X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/4f6459a3dd75bafc3913d67d74467a72fbe33fbd..e75390d4aa51b46b9217dc4699267c1345893054:/src/aui/framemanager.cpp diff --git a/src/aui/framemanager.cpp b/src/aui/framemanager.cpp index 2d245c525f..cd0eebc4f9 100644 --- a/src/aui/framemanager.cpp +++ b/src/aui/framemanager.cpp @@ -28,6 +28,9 @@ #include "wx/aui/framemanager.h" #include "wx/aui/dockart.h" #include "wx/aui/floatpane.h" +#include "wx/aui/tabmdi.h" +#include "wx/aui/auibar.h" +#include "wx/mdi.h" #ifndef WX_PRECOMP #include "wx/panel.h" @@ -36,8 +39,8 @@ #include "wx/dcclient.h" #include "wx/dcscreen.h" #include "wx/toolbar.h" - #include "wx/mdi.h" #include "wx/image.h" + #include "wx/statusbr.h" #endif WX_CHECK_BUILD_OPTIONS("wxAUI") @@ -45,25 +48,42 @@ WX_CHECK_BUILD_OPTIONS("wxAUI") #include "wx/arrimpl.cpp" WX_DECLARE_OBJARRAY(wxRect, wxAuiRectArray); WX_DEFINE_OBJARRAY(wxAuiRectArray) -WX_DEFINE_OBJARRAY(wxDockUIPartArray) -WX_DEFINE_OBJARRAY(wxDockInfoArray) -WX_DEFINE_OBJARRAY(wxPaneButtonArray) -WX_DEFINE_OBJARRAY(wxPaneInfoArray) - -wxPaneInfo wxNullPaneInfo; -wxDockInfo wxNullDockInfo; -DEFINE_EVENT_TYPE(wxEVT_AUI_PANEBUTTON) -DEFINE_EVENT_TYPE(wxEVT_AUI_PANECLOSE) -DEFINE_EVENT_TYPE(wxEVT_AUI_RENDER) +WX_DEFINE_OBJARRAY(wxAuiDockUIPartArray) +WX_DEFINE_OBJARRAY(wxAuiDockInfoArray) +WX_DEFINE_OBJARRAY(wxAuiPaneButtonArray) +WX_DEFINE_OBJARRAY(wxAuiPaneInfoArray) + +wxAuiPaneInfo wxAuiNullPaneInfo; +wxAuiDockInfo wxAuiNullDockInfo; +wxDEFINE_EVENT( wxEVT_AUI_PANE_BUTTON, wxAuiManagerEvent ); +wxDEFINE_EVENT( wxEVT_AUI_PANE_CLOSE, wxAuiManagerEvent ); +wxDEFINE_EVENT( wxEVT_AUI_PANE_MAXIMIZE, wxAuiManagerEvent ); +wxDEFINE_EVENT( wxEVT_AUI_PANE_RESTORE, wxAuiManagerEvent ); +wxDEFINE_EVENT( wxEVT_AUI_RENDER, wxAuiManagerEvent ); +wxDEFINE_EVENT( wxEVT_AUI_FIND_MANAGER, wxAuiManagerEvent ); #ifdef __WXMAC__ // a few defines to avoid nameclashes #define __MAC_OS_X_MEMORY_MANAGER_CLEAN__ 1 #define __AIFF__ - #include "wx/mac/private.h" + #include "wx/osx/private.h" +#endif + +#ifdef __WXMSW__ + #include "wx/msw/wrapwin.h" + #include "wx/msw/private.h" + #include "wx/msw/dc.h" #endif -IMPLEMENT_DYNAMIC_CLASS(wxFrameManagerEvent, wxEvent) +IMPLEMENT_DYNAMIC_CLASS(wxAuiManagerEvent, wxEvent) +IMPLEMENT_CLASS(wxAuiManager, wxEvtHandler) + + + +const int auiToolBarLayer = 10; + +#ifndef __WXGTK20__ + class wxPseudoTransparentFrame : public wxFrame { @@ -142,7 +162,7 @@ public: wxRect rect(upd.GetRect()); dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height); - upd++; + ++upd; } } @@ -199,6 +219,85 @@ BEGIN_EVENT_TABLE(wxPseudoTransparentFrame, wxFrame) END_EVENT_TABLE() +#else + // __WXGTK20__ + +#include + +static void +gtk_pseudo_window_realized_callback( GtkWidget *m_widget, void *WXUNUSED(win) ) +{ + wxSize disp = wxGetDisplaySize(); + int amount = 128; + wxRegion region; + for (int y=0; ywindow, region.GetRegion(), 0, 0); +} + + +class wxPseudoTransparentFrame: public wxFrame +{ +public: + wxPseudoTransparentFrame(wxWindow* parent = NULL, + wxWindowID id = wxID_ANY, + const wxString& title = wxEmptyString, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxDEFAULT_FRAME_STYLE, + const wxString &name = wxT("frame")) + { + if (!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) + return; + + m_title = title; + + m_widget = gtk_window_new( GTK_WINDOW_POPUP ); + g_object_ref(m_widget); + + if (parent) parent->AddChild(this); + + g_signal_connect( m_widget, "realize", + G_CALLBACK (gtk_pseudo_window_realized_callback), this ); + + GdkColor col; + col.red = 128 * 256; + col.green = 192 * 256; + col.blue = 255 * 256; + gtk_widget_modify_bg( m_widget, GTK_STATE_NORMAL, &col ); + } + + bool SetTransparent(wxByte WXUNUSED(alpha)) + { + return true; + } + +protected: + virtual void DoSetSizeHints( int minW, int minH, + int maxW, int maxH, + int incW, int incH) + { + // the real wxFrame method doesn't work for us because we're not really + // a top level window so skip it + wxWindow::DoSetSizeHints(minW, minH, maxW, maxH, incW, incH); + } + +private: + DECLARE_DYNAMIC_CLASS(wxPseudoTransparentFrame) +}; + +IMPLEMENT_DYNAMIC_CLASS(wxPseudoTransparentFrame, wxFrame) + +#endif + // __WXGTK20__ + + + // -- static utility functions -- static wxBitmap wxPaneCreateStippleBitmap() @@ -213,30 +312,35 @@ static void DrawResizeHint(wxDC& dc, const wxRect& rect) wxBitmap stipple = wxPaneCreateStippleBitmap(); wxBrush brush(stipple); dc.SetBrush(brush); +#ifdef __WXMSW__ + wxMSWDCImpl *impl = (wxMSWDCImpl*) dc.GetImpl(); + PatBlt(GetHdcOf(*impl), rect.GetX(), rect.GetY(), rect.GetWidth(), rect.GetHeight(), PATINVERT); +#else dc.SetPen(*wxTRANSPARENT_PEN); dc.SetLogicalFunction(wxXOR); dc.DrawRectangle(rect); +#endif } // CopyDocksAndPanes() - this utility function creates copies of -// the dock and pane info. wxDockInfo's usually contain pointers -// to wxPaneInfo classes, thus this function is necessary to reliably +// the dock and pane info. wxAuiDockInfo's usually contain pointers +// to wxAuiPaneInfo classes, thus this function is necessary to reliably // reconstruct that relationship in the new dock info and pane info arrays -static void CopyDocksAndPanes(wxDockInfoArray& dest_docks, - wxPaneInfoArray& dest_panes, - const wxDockInfoArray& src_docks, - const wxPaneInfoArray& src_panes) +static void CopyDocksAndPanes(wxAuiDockInfoArray& dest_docks, + wxAuiPaneInfoArray& dest_panes, + const wxAuiDockInfoArray& src_docks, + const wxAuiPaneInfoArray& src_panes) { dest_docks = src_docks; dest_panes = src_panes; int i, j, k, dock_count, pc1, pc2; for (i = 0, dock_count = dest_docks.GetCount(); i < dock_count; ++i) { - wxDockInfo& dock = dest_docks.Item(i); + wxAuiDockInfo& dock = dest_docks.Item(i); for (j = 0, pc1 = dock.panes.GetCount(); j < pc1; ++j) for (k = 0, pc2 = src_panes.GetCount(); k < pc2; ++k) if (dock.panes.Item(j) == &src_panes.Item(k)) @@ -246,12 +350,13 @@ static void CopyDocksAndPanes(wxDockInfoArray& dest_docks, // GetMaxLayer() is an internal function which returns // the highest layer inside the specified dock -static int GetMaxLayer(const wxDockInfoArray& docks, int dock_direction) +static int GetMaxLayer(const wxAuiDockInfoArray& docks, + int dock_direction) { int i, dock_count, max_layer = 0; for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i) { - wxDockInfo& dock = docks.Item(i); + wxAuiDockInfo& dock = docks.Item(i); if (dock.dock_direction == dock_direction && dock.dock_layer > max_layer && !dock.fixed) max_layer = dock.dock_layer; @@ -262,12 +367,12 @@ static int GetMaxLayer(const wxDockInfoArray& docks, int dock_direction) // GetMaxRow() is an internal function which returns // the highest layer inside the specified dock -static int GetMaxRow(const wxPaneInfoArray& panes, int direction, int layer) +static int GetMaxRow(const wxAuiPaneInfoArray& panes, int direction, int layer) { int i, pane_count, max_row = 0; for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i) { - wxPaneInfo& pane = panes.Item(i); + wxAuiPaneInfo& pane = panes.Item(i); if (pane.dock_direction == direction && pane.dock_layer == layer && pane.dock_row > max_row) @@ -280,14 +385,14 @@ static int GetMaxRow(const wxPaneInfoArray& panes, int direction, int layer) // DoInsertDockLayer() is an internal function that inserts a new dock // layer by incrementing all existing dock layer values by one -static void DoInsertDockLayer(wxPaneInfoArray& panes, +static void DoInsertDockLayer(wxAuiPaneInfoArray& panes, int dock_direction, int dock_layer) { int i, pane_count; for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i) { - wxPaneInfo& pane = panes.Item(i); + wxAuiPaneInfo& pane = panes.Item(i); if (!pane.IsFloating() && pane.dock_direction == dock_direction && pane.dock_layer >= dock_layer) @@ -297,7 +402,7 @@ static void DoInsertDockLayer(wxPaneInfoArray& panes, // DoInsertDockLayer() is an internal function that inserts a new dock // row by incrementing all existing dock row values by one -static void DoInsertDockRow(wxPaneInfoArray& panes, +static void DoInsertDockRow(wxAuiPaneInfoArray& panes, int dock_direction, int dock_layer, int dock_row) @@ -305,7 +410,7 @@ static void DoInsertDockRow(wxPaneInfoArray& panes, int i, pane_count; for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i) { - wxPaneInfo& pane = panes.Item(i); + wxAuiPaneInfo& pane = panes.Item(i); if (!pane.IsFloating() && pane.dock_direction == dock_direction && pane.dock_layer == dock_layer && @@ -316,7 +421,7 @@ static void DoInsertDockRow(wxPaneInfoArray& panes, // DoInsertDockLayer() is an internal function that inserts a space for // another dock pane by incrementing all existing dock row values by one -static void DoInsertPane(wxPaneInfoArray& panes, +static void DoInsertPane(wxAuiPaneInfoArray& panes, int dock_direction, int dock_layer, int dock_row, @@ -325,7 +430,7 @@ static void DoInsertPane(wxPaneInfoArray& panes, int i, pane_count; for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i) { - wxPaneInfo& pane = panes.Item(i); + wxAuiPaneInfo& pane = panes.Item(i); if (!pane.IsFloating() && pane.dock_direction == dock_direction && pane.dock_layer == dock_layer && @@ -338,11 +443,11 @@ static void DoInsertPane(wxPaneInfoArray& panes, // FindDocks() is an internal function that returns a list of docks which meet // the specified conditions in the parameters and returns a sorted array // (sorted by layer and then row) -static void FindDocks(wxDockInfoArray& docks, +static void FindDocks(wxAuiDockInfoArray& docks, int dock_direction, int dock_layer, int dock_row, - wxDockInfoPtrArray& arr) + wxAuiDockInfoPtrArray& arr) { int begin_layer = dock_layer; int end_layer = dock_layer; @@ -378,7 +483,7 @@ static void FindDocks(wxDockInfoArray& docks, for (row = begin_row; row <= end_row; ++row) for (i = 0; i < dock_count; ++i) { - wxDockInfo& d = docks.Item(i); + wxAuiDockInfo& d = docks.Item(i); if (dock_direction == -1 || dock_direction == d.dock_direction) { if (d.dock_layer == layer && d.dock_row == row) @@ -388,13 +493,13 @@ static void FindDocks(wxDockInfoArray& docks, } // FindPaneInDock() looks up a specified window pointer inside a dock. -// If found, the corresponding wxPaneInfo pointer is returned, otherwise NULL. -static wxPaneInfo* FindPaneInDock(const wxDockInfo& dock, wxWindow* window) +// If found, the corresponding wxAuiPaneInfo pointer is returned, otherwise NULL. +static wxAuiPaneInfo* FindPaneInDock(const wxAuiDockInfo& dock, wxWindow* window) { int i, count = dock.panes.GetCount(); for (i = 0; i < count; ++i) { - wxPaneInfo* p = dock.panes.Item(i); + wxAuiPaneInfo* p = dock.panes.Item(i); if (p->window == window) return p; } @@ -403,145 +508,309 @@ static wxPaneInfo* FindPaneInDock(const wxDockInfo& dock, wxWindow* window) // RemovePaneFromDocks() removes a pane window from all docks // with a possible exception specified by parameter "ex_cept" -static void RemovePaneFromDocks(wxDockInfoArray& docks, - wxPaneInfo& pane, - wxDockInfo* ex_cept = NULL ) +static void RemovePaneFromDocks(wxAuiDockInfoArray& docks, + wxAuiPaneInfo& pane, + wxAuiDockInfo* ex_cept = NULL ) { int i, dock_count; for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i) { - wxDockInfo& d = docks.Item(i); + wxAuiDockInfo& d = docks.Item(i); if (&d == ex_cept) continue; - wxPaneInfo* pi = FindPaneInDock(d, pane.window); + wxAuiPaneInfo* pi = FindPaneInDock(d, pane.window); if (pi) d.panes.Remove(pi); } } +/* +// This function works fine, and may be used in the future + // RenumberDockRows() takes a dock and assigns sequential numbers // to existing rows. Basically it takes out the gaps; so if a // dock has rows with numbers 0,2,5, they will become 0,1,2 -static void RenumberDockRows(wxDockInfoPtrArray& docks) +static void RenumberDockRows(wxAuiDockInfoPtrArray& docks) { - int i, dock_count, j, pane_count; + int i, dock_count; for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i) { - wxDockInfo& dock = *docks.Item(i); + wxAuiDockInfo& dock = *docks.Item(i); dock.dock_row = i; + + int j, pane_count; for (j = 0, pane_count = dock.panes.GetCount(); j < pane_count; ++j) dock.panes.Item(j)->dock_row = i; } } +*/ // SetActivePane() sets the active pane, as well as cycles through // every other pane and makes sure that all others' active flags // are turned off -static void SetActivePane(wxPaneInfoArray& panes, wxWindow* active_pane) +static void SetActivePane(wxAuiPaneInfoArray& panes, wxWindow* active_pane) { int i, pane_count; for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i) { - wxPaneInfo& pane = panes.Item(i); - pane.state &= ~wxPaneInfo::optionActive; + wxAuiPaneInfo& pane = panes.Item(i); + pane.state &= ~wxAuiPaneInfo::optionActive; if (pane.window == active_pane) - pane.state |= wxPaneInfo::optionActive; + pane.state |= wxAuiPaneInfo::optionActive; } } // this function is used to sort panes by dock position -static int PaneSortFunc(wxPaneInfo** p1, wxPaneInfo** p2) +static int PaneSortFunc(wxAuiPaneInfo** p1, wxAuiPaneInfo** p2) { return ((*p1)->dock_pos < (*p2)->dock_pos) ? -1 : 1; } -// -- wxFrameManager class implementation -- -BEGIN_EVENT_TABLE(wxFrameManager, wxEvtHandler) - EVT_AUI_PANEBUTTON(wxFrameManager::OnPaneButton) - EVT_AUI_RENDER(wxFrameManager::OnRender) - EVT_PAINT(wxFrameManager::OnPaint) - EVT_ERASE_BACKGROUND(wxFrameManager::OnEraseBackground) - EVT_SIZE(wxFrameManager::OnSize) - EVT_SET_CURSOR(wxFrameManager::OnSetCursor) - EVT_LEFT_DOWN(wxFrameManager::OnLeftDown) - EVT_LEFT_UP(wxFrameManager::OnLeftUp) - EVT_MOTION(wxFrameManager::OnMotion) - EVT_LEAVE_WINDOW(wxFrameManager::OnLeaveWindow) - EVT_CHILD_FOCUS(wxFrameManager::OnChildFocus) - EVT_TIMER(101, wxFrameManager::OnHintFadeTimer) +// this utility class implements a proportional sizer +// as it existed in wxWidgets 2.8 and before. + +class wxAuiProportionalBoxSizer : public wxBoxSizer +{ +public: + wxAuiProportionalBoxSizer(int orientation) : wxBoxSizer(orientation) { } + + void RecalcSizes() + { + if (m_children.GetCount() == 0) + return; + + int fixed_height = 0; + int fixed_width = 0; + int stretchable = 0; + wxSizerItemList::compatibility_iterator node; + + // find fixed width and height, as well + // as the total stretchable proportions + node = m_children.GetFirst(); + while (node) + { + wxSizerItem *item = node->GetData(); + + if (item->IsShown()) + { + stretchable += item->GetProportion(); + + wxSize size(item->GetMinSizeWithBorder()); + if (item->GetProportion() == 0) + { + if (m_orient == wxVERTICAL) + { + fixed_height += size.y; + fixed_width = wxMax(fixed_width, size.x); + } + else + { + fixed_width += size.x; + fixed_height = wxMax(fixed_height, size.y); + } + } + } + + node = node->GetNext(); + } + + + // delta specifies the total amount to be allocated to stretch spaces + int delta = 0; + if (stretchable) + { + if (m_orient == wxHORIZONTAL) + delta = m_size.x - fixed_width; + else + delta = m_size.y - fixed_height; + } + + // go through each item and assign sizes + wxPoint pt(m_position); + node = m_children.GetFirst(); + while (node) + { + wxSizerItem* item = node->GetData(); + + if (item->IsShown()) + { + wxSize size(item->GetMinSizeWithBorder()); + + if (m_orient == wxVERTICAL) + { + wxCoord height = size.y; + if (item->GetProportion()) + { + height = (delta * item->GetProportion()) / stretchable; + delta -= height; + stretchable -= item->GetProportion(); + } + + wxPoint child_pos(pt); + wxSize child_size(size.x, height); + + if (item->GetFlag() & (wxEXPAND | wxSHAPED)) + child_size.x = m_size.x; + else if (item->GetFlag() & wxALIGN_RIGHT) + child_pos.x += m_size.x - size.x; + else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_HORIZONTAL)) + child_pos.x += (m_size.x - size.x) / 2; + + item->SetDimension(child_pos, child_size); + + pt.y += height; + } + else + { + wxCoord width = size.x; + if (item->GetProportion()) + { + width = (delta * item->GetProportion()) / stretchable; + delta -= width; + stretchable -= item->GetProportion(); + } + + wxPoint child_pos(pt); + wxSize child_size(width, size.y); + + if (item->GetFlag() & (wxEXPAND | wxSHAPED)) + child_size.y = m_size.y; + else if (item->GetFlag() & wxALIGN_BOTTOM) + child_pos.y += m_size.y - size.y; + else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_VERTICAL)) + child_pos.y += (m_size.y - size.y) / 2; + + item->SetDimension(child_pos, child_size); + + pt.x += width; + } + } + + node = node->GetNext(); + } + } +}; + + + + +// -- wxAuiManager class implementation -- + + +BEGIN_EVENT_TABLE(wxAuiManager, wxEvtHandler) + EVT_AUI_PANE_BUTTON(wxAuiManager::OnPaneButton) + EVT_AUI_RENDER(wxAuiManager::OnRender) + EVT_PAINT(wxAuiManager::OnPaint) + EVT_ERASE_BACKGROUND(wxAuiManager::OnEraseBackground) + EVT_SIZE(wxAuiManager::OnSize) + EVT_SET_CURSOR(wxAuiManager::OnSetCursor) + EVT_LEFT_DOWN(wxAuiManager::OnLeftDown) + EVT_LEFT_UP(wxAuiManager::OnLeftUp) + EVT_MOTION(wxAuiManager::OnMotion) + EVT_LEAVE_WINDOW(wxAuiManager::OnLeaveWindow) + EVT_MOUSE_CAPTURE_LOST(wxAuiManager::OnCaptureLost) + EVT_CHILD_FOCUS(wxAuiManager::OnChildFocus) + EVT_AUI_FIND_MANAGER(wxAuiManager::OnFindManager) END_EVENT_TABLE() -wxFrameManager::wxFrameManager(wxWindow* managed_wnd, unsigned int flags) +wxAuiManager::wxAuiManager(wxWindow* managed_wnd, unsigned int flags) { m_action = actionNone; + m_action_window = NULL; m_last_mouse_move = wxPoint(); m_hover_button = NULL; - m_art = new wxDefaultDockArt; + m_art = new wxAuiDefaultDockArt; m_hint_wnd = NULL; m_flags = flags; m_skipping = false; + m_has_maximized = false; m_frame = NULL; - + m_dock_constraint_x = 0.3; + m_dock_constraint_y = 0.3; + m_reserved = NULL; + m_currentDragItem = -1; + if (managed_wnd) { SetManagedWindow(managed_wnd); } } -wxFrameManager::~wxFrameManager() +wxAuiManager::~wxAuiManager() { + // NOTE: It's possible that the windows have already been destroyed by the + // time this dtor is called, so this loop can result in memory access via + // invalid pointers, resulting in a crash. So it will be disabled while + // waiting for a better solution. +#if 0 + for ( size_t i = 0; i < m_panes.size(); i++ ) + { + wxAuiPaneInfo& pinfo = m_panes[i]; + if (pinfo.window && !pinfo.window->GetParent()) + delete pinfo.window; + } +#endif + delete m_art; } -// Creates a floating frame for the windows -wxFloatingPane * wxFrameManager::CreateFloatingFrame(wxWindow* parent, const wxPaneInfo& p) +// creates a floating frame for the windows +wxAuiFloatingFrame* wxAuiManager::CreateFloatingFrame(wxWindow* parent, + const wxAuiPaneInfo& pane_info) +{ + return new wxAuiFloatingFrame(parent, this, pane_info); +} + +bool wxAuiManager::CanDockPanel(const wxAuiPaneInfo & WXUNUSED(p)) { - return new wxFloatingPane(parent, this, p); + // if a key modifier is pressed while dragging the frame, + // don't dock the window + return !(wxGetKeyState(WXK_CONTROL) || wxGetKeyState(WXK_ALT)); } -// GetPane() looks up a wxPaneInfo structure based +// GetPane() looks up a wxAuiPaneInfo structure based // on the supplied window pointer. Upon failure, GetPane() -// returns an empty wxPaneInfo, a condition which can be checked -// by calling wxPaneInfo::IsOk(). +// returns an empty wxAuiPaneInfo, a condition which can be checked +// by calling wxAuiPaneInfo::IsOk(). // // The pane info's structure may then be modified. Once a pane's -// info is modified, wxFrameManager::Update() must be called to +// info is modified, wxAuiManager::Update() must be called to // realize the changes in the UI. -wxPaneInfo& wxFrameManager::GetPane(wxWindow* window) +wxAuiPaneInfo& wxAuiManager::GetPane(wxWindow* window) { int i, pane_count; for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) { - wxPaneInfo& p = m_panes.Item(i); + wxAuiPaneInfo& p = m_panes.Item(i); if (p.window == window) return p; } - return wxNullPaneInfo; + return wxAuiNullPaneInfo; } // this version of GetPane() looks up a pane based on a // 'pane name', see above comment for more info -wxPaneInfo& wxFrameManager::GetPane(const wxString& name) +wxAuiPaneInfo& wxAuiManager::GetPane(const wxString& name) { int i, pane_count; for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) { - wxPaneInfo& p = m_panes.Item(i); + wxAuiPaneInfo& p = m_panes.Item(i); if (p.name == name) return p; } - return wxNullPaneInfo; + return wxAuiNullPaneInfo; } // GetAllPanes() returns a reference to all the pane info structures -wxPaneInfoArray& wxFrameManager::GetAllPanes() +wxAuiPaneInfoArray& wxAuiManager::GetAllPanes() { return m_panes; } @@ -549,27 +818,27 @@ wxPaneInfoArray& wxFrameManager::GetAllPanes() // HitTest() is an internal function which determines // which UI item the specified coordinates are over // (x,y) specify a position in client coordinates -wxDockUIPart* wxFrameManager::HitTest(int x, int y) +wxAuiDockUIPart* wxAuiManager::HitTest(int x, int y) { - wxDockUIPart* result = NULL; + wxAuiDockUIPart* result = NULL; int i, part_count; for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i) { - wxDockUIPart* item = &m_uiparts.Item(i); + wxAuiDockUIPart* item = &m_uiparts.Item(i); // we are not interested in typeDock, because this space // isn't used to draw anything, just for measurements; // besides, the entire dock area is covered with other // rectangles, which we are interested in. - if (item->type == wxDockUIPart::typeDock) + if (item->type == wxAuiDockUIPart::typeDock) continue; // if we already have a hit on a more specific item, we are not // interested in a pane hit. If, however, we don't already have // a hit, returning a pane hit is necessary for some operations - if ((item->type == wxDockUIPart::typePane || - item->type == wxDockUIPart::typePaneBorder) && result) + if ((item->type == wxAuiDockUIPart::typePane || + item->type == wxAuiDockUIPart::typePaneBorder) && result) continue; // if the point is inside the rectangle, we have a hit @@ -582,8 +851,8 @@ wxDockUIPart* wxFrameManager::HitTest(int x, int y) // SetFlags() and GetFlags() allow the owner to set various -// options which are global to wxFrameManager -void wxFrameManager::SetFlags(unsigned int flags) +// options which are global to wxAuiManager +void wxAuiManager::SetFlags(unsigned int flags) { // find out if we have to call UpdateHintWindowConfig() bool update_hint_wnd = false; @@ -596,52 +865,80 @@ void wxFrameManager::SetFlags(unsigned int flags) // set the new flags m_flags = flags; - + if (update_hint_wnd) { UpdateHintWindowConfig(); } } -unsigned int wxFrameManager::GetFlags() const +unsigned int wxAuiManager::GetFlags() const { return m_flags; } +// Convenience function +bool wxAuiManager_HasLiveResize(wxAuiManager& manager) +{ + // With Core Graphics on Mac, it's not possible to show sash feedback, + // so we'll always use live update instead. +#if defined(__WXMAC__) + wxUnusedVar(manager); + return true; +#else + return (manager.GetFlags() & wxAUI_MGR_LIVE_RESIZE) == wxAUI_MGR_LIVE_RESIZE; +#endif +} // don't use these anymore as they are deprecated // use Set/GetManagedFrame() instead -void wxFrameManager::SetFrame(wxFrame* frame) +void wxAuiManager::SetFrame(wxFrame* frame) { SetManagedWindow((wxWindow*)frame); } -wxFrame* wxFrameManager::GetFrame() const +wxFrame* wxAuiManager::GetFrame() const { return (wxFrame*)m_frame; } -void wxFrameManager::UpdateHintWindowConfig() +// this function will return the aui manager for a given +// window. The |window| parameter should be any child window +// or grand-child window (and so on) of the frame/window +// managed by wxAuiManager. The |window| parameter does not +// need to be managed by the manager itself. +wxAuiManager* wxAuiManager::GetManager(wxWindow* window) +{ + wxAuiManagerEvent evt(wxEVT_AUI_FIND_MANAGER); + evt.SetManager(NULL); + evt.ResumePropagation(wxEVENT_PROPAGATE_MAX); + if (!window->GetEventHandler()->ProcessEvent(evt)) + return NULL; + + return evt.GetManager(); +} + + +void wxAuiManager::UpdateHintWindowConfig() { // find out if the the system can do transparent frames bool can_do_transparent = false; - + wxWindow* w = m_frame; while (w) { if (w->IsKindOf(CLASSINFO(wxFrame))) { wxFrame* f = static_cast(w); - #if wxCHECK_VERSION(2,7,0) can_do_transparent = f->CanSetTransparent(); - #endif + break; } - + w = w->GetParent(); } - + // if there is an existing hint window, delete it if (m_hint_wnd) { @@ -651,9 +948,9 @@ void wxFrameManager::UpdateHintWindowConfig() m_hint_fademax = 50; m_hint_wnd = NULL; - + if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) && can_do_transparent) - { + { // Make a window to use for a transparent hint #if defined(__WXMSW__) || defined(__WXGTK__) m_hint_wnd = new wxFrame(m_frame, wxID_ANY, wxEmptyString, @@ -671,6 +968,8 @@ void wxFrameManager::UpdateHintWindowConfig() wxDefaultPosition, wxSize(1,1), wxFRAME_FLOAT_ON_PARENT | wxFRAME_TOOL_WINDOW ); + m_hint_wnd->Connect(wxEVT_ACTIVATE, + wxActivateEventHandler(wxAuiManager::OnHintActivate), NULL, this); // Can't set the bg colour of a Frame in wxMac wxPanel* p = new wxPanel(m_hint_wnd); @@ -681,9 +980,9 @@ void wxFrameManager::UpdateHintWindowConfig() // blue. p->SetBackgroundColour(*wxBLUE); #endif - + } - else + else { if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) != 0 || (m_flags & wxAUI_MGR_VENETIAN_BLINDS_HINT) != 0) @@ -708,7 +1007,7 @@ void wxFrameManager::UpdateHintWindowConfig() // SetManagedWindow() is usually called once when the frame // manager class is being initialized. "frame" specifies // the frame which should be managed by the frame mananger -void wxFrameManager::SetManagedWindow(wxWindow* wnd) +void wxAuiManager::SetManagedWindow(wxWindow* wnd) { wxASSERT_MSG(wnd, wxT("specified window must be non-NULL")); @@ -728,9 +1027,20 @@ void wxFrameManager::SetManagedWindow(wxWindow* wnd) wxASSERT_MSG(client_window, wxT("Client window is NULL!")); AddPane(client_window, - wxPaneInfo().Name(wxT("mdiclient")). + wxAuiPaneInfo().Name(wxT("mdiclient")). + CenterPane().PaneBorder(false)); + } + else if (m_frame->IsKindOf(CLASSINFO(wxAuiMDIParentFrame))) + { + wxAuiMDIParentFrame* mdi_frame = (wxAuiMDIParentFrame*)m_frame; + wxAuiMDIClientWindow* client_window = mdi_frame->GetClientWindow(); + wxASSERT_MSG(client_window, wxT("Client window is NULL!")); + + AddPane(client_window, + wxAuiPaneInfo().Name(wxT("mdiclient")). CenterPane().PaneBorder(false)); } + #endif UpdateHintWindowConfig(); @@ -740,7 +1050,7 @@ void wxFrameManager::SetManagedWindow(wxWindow* wnd) // UnInit() must be called, usually in the destructor // of the frame class. If it is not called, usually this // will result in a crash upon program exit -void wxFrameManager::UnInit() +void wxAuiManager::UnInit() { if (m_frame) { @@ -749,34 +1059,34 @@ void wxFrameManager::UnInit() } // GetManagedWindow() returns the window pointer being managed -wxWindow* wxFrameManager::GetManagedWindow() const +wxWindow* wxAuiManager::GetManagedWindow() const { return m_frame; } -wxDockArt* wxFrameManager::GetArtProvider() const +wxAuiDockArt* wxAuiManager::GetArtProvider() const { return m_art; } -void wxFrameManager::ProcessMgrEvent(wxFrameManagerEvent& event) +void wxAuiManager::ProcessMgrEvent(wxAuiManagerEvent& event) { // first, give the owner frame a chance to override if (m_frame) { - if (m_frame->ProcessEvent(event)) + if (m_frame->GetEventHandler()->ProcessEvent(event)) return; } ProcessEvent(event); } -// SetArtProvider() instructs wxFrameManager to use the +// SetArtProvider() instructs wxAuiManager to use the // specified art provider for all drawing calls. This allows // plugable look-and-feel features. The pointer that is -// passed to this method subsequently belongs to wxFrameManager, +// passed to this method subsequently belongs to wxAuiManager, // and is deleted in the frame manager destructor -void wxFrameManager::SetArtProvider(wxDockArt* art_provider) +void wxAuiManager::SetArtProvider(wxAuiDockArt* art_provider) { // delete the last art provider, if any delete m_art; @@ -786,28 +1096,44 @@ void wxFrameManager::SetArtProvider(wxDockArt* art_provider) } -bool wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info) +bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info) { + wxASSERT_MSG(window, wxT("NULL window ptrs are not allowed")); + // check if the pane has a valid window if (!window) return false; - // check if the pane already exists + // check if the window is already managed by us if (GetPane(pane_info.window).IsOk()) return false; + // check if the pane name already exists, this could reveal a + // bug in the library user's application + bool already_exists = false; + if (!pane_info.name.empty() && GetPane(pane_info.name).IsOk()) + { + wxFAIL_MSG(wxT("A pane with that name already exists in the manager!")); + already_exists = true; + } + + // if the new pane is docked then we should undo maximize + if (pane_info.IsDocked()) + RestoreMaximizedPane(); + m_panes.Add(pane_info); - wxPaneInfo& pinfo = m_panes.Last(); + 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()) + if (pinfo.name.empty() || already_exists) { pinfo.name.Printf(wxT("%08lx%08x%08x%08lx"), - ((unsigned long)pinfo.window) & 0xffffffff, + wxPtrToUInt(pinfo.window) & 0xffffffff, (unsigned int)time(NULL), #ifdef __WXWINCE__ (unsigned int)GetTickCount(), @@ -821,33 +1147,57 @@ bool wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info) if (pinfo.dock_proportion == 0) pinfo.dock_proportion = 100000; - if (pinfo.HasCloseButton() && - pinfo.buttons.size() == 0) + if (pinfo.HasMaximizeButton()) + { + wxAuiPaneButton button; + button.button_id = wxAUI_BUTTON_MAXIMIZE_RESTORE; + pinfo.buttons.Add(button); + } + + if (pinfo.HasPinButton()) { - wxPaneButton button; + wxAuiPaneButton button; + button.button_id = wxAUI_BUTTON_PIN; + pinfo.buttons.Add(button); + } + + if (pinfo.HasCloseButton()) + { + wxAuiPaneButton button; button.button_id = wxAUI_BUTTON_CLOSE; pinfo.buttons.Add(button); } + if (pinfo.HasGripper()) + { + if (pinfo.window->IsKindOf(CLASSINFO(wxAuiToolBar))) + { + // prevent duplicate gripper -- both wxAuiManager and wxAuiToolBar + // have a gripper control. The toolbar's built-in gripper + // meshes better with the look and feel of the control than ours, + // so turn wxAuiManager's gripper off, and the toolbar's on. + + wxAuiToolBar* tb = static_cast(pinfo.window); + pinfo.SetFlag(wxAuiPaneInfo::optionGripper, false); + tb->SetGripperVisible(true); + } + } + + if (pinfo.best_size == wxDefaultSize && pinfo.window) { pinfo.best_size = pinfo.window->GetClientSize(); +#if wxUSE_TOOLBAR 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++; } +#endif // wxUSE_TOOLBAR if (pinfo.min_size != wxDefaultSize) { @@ -858,14 +1208,16 @@ bool wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info) } } + + return true; } -bool wxFrameManager::AddPane(wxWindow* window, - int direction, - const wxString& caption) +bool wxAuiManager::AddPane(wxWindow* window, + int direction, + const wxString& caption) { - wxPaneInfo pinfo; + wxAuiPaneInfo pinfo; pinfo.Caption(caption); switch (direction) { @@ -878,23 +1230,25 @@ bool wxFrameManager::AddPane(wxWindow* window, return AddPane(window, pinfo); } -bool wxFrameManager::AddPane(wxWindow* window, - const wxPaneInfo& pane_info, - const wxPoint& drop_pos) +bool wxAuiManager::AddPane(wxWindow* window, + const wxAuiPaneInfo& pane_info, + const wxPoint& drop_pos) { if (!AddPane(window, pane_info)) return false; - wxPaneInfo& pane = GetPane(window); + wxAuiPaneInfo& pane = GetPane(window); DoDrop(m_docks, m_panes, pane, drop_pos, wxPoint(0,0)); return true; } -bool wxFrameManager::InsertPane(wxWindow* window, const wxPaneInfo& pane_info, +bool wxAuiManager::InsertPane(wxWindow* window, const wxAuiPaneInfo& pane_info, int insert_level) { + wxASSERT_MSG(window, wxT("NULL window ptrs are not allowed")); + // shift the panes around, depending on the insert level switch (insert_level) { @@ -920,12 +1274,12 @@ bool wxFrameManager::InsertPane(wxWindow* window, const wxPaneInfo& pane_info, // if the window already exists, we are basically just moving/inserting the // existing window. If it doesn't exist, we need to add it and insert it - wxPaneInfo& existing_pane = GetPane(window); + wxAuiPaneInfo& existing_pane = GetPane(window); if (!existing_pane.IsOk()) { return AddPane(window, pane_info); } - else + else { if (pane_info.IsFloating()) { @@ -935,8 +1289,11 @@ bool wxFrameManager::InsertPane(wxWindow* window, const wxPaneInfo& pane_info, if (pane_info.floating_size != wxDefaultSize) existing_pane.FloatingSize(pane_info.floating_size); } - else + else { + // if the new pane is docked then we should undo maximize + RestoreMaximizedPane(); + existing_pane.Direction(pane_info.dock_direction); existing_pane.Layer(pane_info.dock_layer); existing_pane.Row(pane_info.dock_row); @@ -950,12 +1307,14 @@ bool wxFrameManager::InsertPane(wxWindow* window, const wxPaneInfo& pane_info, // DetachPane() removes a pane from the frame manager. This // method will not destroy the window that is removed. -bool wxFrameManager::DetachPane(wxWindow* window) +bool wxAuiManager::DetachPane(wxWindow* window) { + wxASSERT_MSG(window, wxT("NULL window ptrs are not allowed")); + int i, count; for (i = 0, count = m_panes.GetCount(); i < count; ++i) { - wxPaneInfo& p = m_panes.Item(i); + wxAuiPaneInfo& p = m_panes.Item(i); if (p.window == window) { if (p.frame) @@ -970,6 +1329,11 @@ bool wxFrameManager::DetachPane(wxWindow* window) p.frame->Show(false); // reparent to m_frame and destroy the pane + if (m_action_window == p.frame) + { + m_action_window = NULL; + } + p.window->Reparent(m_frame); p.frame->SetSizer(NULL); p.frame->Destroy(); @@ -983,7 +1347,7 @@ bool wxFrameManager::DetachPane(wxWindow* window) int pi, part_count; for (pi = 0, part_count = (int)m_uiparts.GetCount(); pi < part_count; ++pi) { - wxDockUIPart& part = m_uiparts.Item(pi); + wxAuiDockUIPart& part = m_uiparts.Item(pi); if (part.pane == &p) { m_uiparts.RemoveAt(pi); @@ -1000,41 +1364,126 @@ bool wxFrameManager::DetachPane(wxWindow* window) return false; } -// ClosePane() destroys or hides the pane depending on its -// flags -void wxFrameManager::ClosePane(wxPaneInfo& pane_info) +// ClosePane() destroys or hides the pane depending on its flags +void wxAuiManager::ClosePane(wxAuiPaneInfo& pane_info) { + // if we were maximized, restore + if (pane_info.IsMaximized()) + { + RestorePane(pane_info); + } + // first, hide the window - if (pane_info.window && pane_info.window->IsShown()) { + if (pane_info.window && pane_info.window->IsShown()) + { pane_info.window->Show(false); } // make sure that we are the parent of this window - if(pane_info.window && pane_info.window->GetParent() != m_frame) { + if (pane_info.window && pane_info.window->GetParent() != m_frame) + { pane_info.window->Reparent(m_frame); } // if we have a frame, destroy it - if(pane_info.frame) { + if (pane_info.frame) + { pane_info.frame->Destroy(); pane_info.frame = NULL; } // now we need to either destroy or hide the pane - if(pane_info.IsDestroyOnClose()) + if (pane_info.IsDestroyOnClose()) { wxWindow * window = pane_info.window; DetachPane(window); - if(window) { + if (window) + { window->Destroy(); } - } - else + } + else { pane_info.Hide(); } } +void wxAuiManager::MaximizePane(wxAuiPaneInfo& pane_info) +{ + int i, pane_count; + + // un-maximize and hide all other panes + for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) + { + wxAuiPaneInfo& p = m_panes.Item(i); + if (!p.IsToolbar() && !p.IsFloating()) + { + p.Restore(); + + // save hidden state + p.SetFlag(wxAuiPaneInfo::savedHiddenState, + p.HasFlag(wxAuiPaneInfo::optionHidden)); + + // hide the pane, because only the newly + // maximized pane should show + p.Hide(); + } + } + + // mark ourselves maximized + pane_info.Maximize(); + pane_info.Show(); + m_has_maximized = true; + + // last, show the window + if (pane_info.window && !pane_info.window->IsShown()) + { + pane_info.window->Show(true); + } +} + +void wxAuiManager::RestorePane(wxAuiPaneInfo& pane_info) +{ + int i, pane_count; + + // restore all the panes + for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) + { + wxAuiPaneInfo& p = m_panes.Item(i); + if (!p.IsToolbar()) + { + p.SetFlag(wxAuiPaneInfo::optionHidden, + p.HasFlag(wxAuiPaneInfo::savedHiddenState)); + } + } + + // mark ourselves non-maximized + pane_info.Restore(); + m_has_maximized = false; + + // last, show the window + if (pane_info.window && !pane_info.window->IsShown()) + { + pane_info.window->Show(true); + } +} + +void wxAuiManager::RestoreMaximizedPane() +{ + int i, pane_count; + + // restore all the panes + for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) + { + wxAuiPaneInfo& p = m_panes.Item(i); + if (p.IsMaximized()) + { + RestorePane(p); + break; + } + } +} + // EscapeDelimiters() changes ";" into "\;" and "|" into "\|" // in the input string. This is an internal functions which is // used for saving perspectives @@ -1053,7 +1502,7 @@ static wxString EscapeDelimiters(const wxString& s) return result; } -wxString wxFrameManager::SavePaneInfo(wxPaneInfo& pane) +wxString wxAuiManager::SavePaneInfo(wxAuiPaneInfo& pane) { wxString result = wxT("name="); result += EscapeDelimiters(pane.name); @@ -1084,7 +1533,7 @@ wxString wxFrameManager::SavePaneInfo(wxPaneInfo& pane) } // Load a "pane" with the pane infor settings in pane_part -void wxFrameManager::LoadPaneInfo(wxString pane_part, wxPaneInfo &pane) +void wxAuiManager::LoadPaneInfo(wxString pane_part, wxAuiPaneInfo &pane) { // replace escaped characters so we can // split up the string easily @@ -1165,23 +1614,23 @@ void wxFrameManager::LoadPaneInfo(wxString pane_part, wxPaneInfo &pane) // all pane settings. This save and load mechanism allows an // exact pane configuration to be saved and restored at a later time -wxString wxFrameManager::SavePerspective() +wxString wxAuiManager::SavePerspective() { wxString result; result.Alloc(500); - result = wxT("layout1|"); + result = wxT("layout2|"); int pane_i, pane_count = m_panes.GetCount(); for (pane_i = 0; pane_i < pane_count; ++pane_i) { - wxPaneInfo& pane = m_panes.Item(pane_i); + wxAuiPaneInfo& pane = m_panes.Item(pane_i); result += SavePaneInfo(pane)+wxT("|"); } int dock_i, dock_count = m_docks.GetCount(); for (dock_i = 0; dock_i < dock_count; ++dock_i) { - wxDockInfo& dock = m_docks.Item(dock_i); + wxAuiDockInfo& dock = m_docks.Item(dock_i); result += wxString::Format(wxT("dock_size(%d,%d,%d)=%d|"), dock.dock_direction, dock.dock_layer, @@ -1194,17 +1643,19 @@ wxString wxFrameManager::SavePerspective() // LoadPerspective() loads a layout which was saved with SavePerspective() // If the "update" flag parameter is true, the GUI will immediately be updated -bool wxFrameManager::LoadPerspective(const wxString& layout, bool update) +bool wxAuiManager::LoadPerspective(const wxString& layout, bool update) { wxString input = layout; wxString part; // check layout string version + // 'layout1' = wxAUI 0.9.0 - wxAUI 0.9.2 + // 'layout2' = wxAUI 0.9.2 (wxWidgets 2.8) part = input.BeforeFirst(wxT('|')); input = input.AfterFirst(wxT('|')); part.Trim(true); part.Trim(false); - if (part != wxT("layout1")) + if (part != wxT("layout2")) return false; // mark all panes currently managed as docked and hidden @@ -1222,7 +1673,7 @@ bool wxFrameManager::LoadPerspective(const wxString& layout, bool update) while (1) { - wxPaneInfo pane; + wxAuiPaneInfo pane; wxString pane_part = input.BeforeFirst(wxT('|')); input = input.AfterFirst(wxT('|')); @@ -1246,7 +1697,7 @@ bool wxFrameManager::LoadPerspective(const wxString& layout, bool update) piece.AfterFirst(wxT(',')).ToLong(&row); value.ToLong(&size); - wxDockInfo dock; + wxAuiDockInfo dock; dock.dock_direction = dir; dock.dock_layer = layer; dock.dock_row = row; @@ -1262,16 +1713,15 @@ bool wxFrameManager::LoadPerspective(const wxString& layout, bool update) LoadPaneInfo(pane_part, pane); - wxPaneInfo& p = GetPane(pane.name); + wxAuiPaneInfo& p = GetPane(pane.name); if (!p.IsOk()) { // the pane window couldn't be found - // in the existing layout - return false; + // in the existing layout -- skip it + continue; } p.SafeSet(pane); - } if (update) @@ -1280,13 +1730,13 @@ bool wxFrameManager::LoadPerspective(const wxString& layout, bool update) return true; } -void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo& dock, - wxArrayInt& positions, - wxArrayInt& sizes) +void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock, + wxArrayInt& positions, + wxArrayInt& sizes) { - 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); + int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE); + int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE); + int gripper_size = m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE); positions.Empty(); sizes.Empty(); @@ -1297,9 +1747,9 @@ void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo& dock, // find the pane marked as our action pane for (pane_i = 0; pane_i < pane_count; ++pane_i) { - wxPaneInfo& pane = *(dock.panes.Item(pane_i)); + wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i)); - if (pane.state & wxPaneInfo::actionPane) + if (pane.HasFlag(wxAuiPaneInfo::actionPane)) { wxASSERT_MSG(action_pane==-1, wxT("Too many fixed action panes")); action_pane = pane_i; @@ -1311,7 +1761,7 @@ void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo& dock, // on the dock's orientation) of each pane for (pane_i = 0; pane_i < pane_count; ++pane_i) { - wxPaneInfo& pane = *(dock.panes.Item(pane_i)); + wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i)); positions.Add(pane.dock_pos); int size = 0; @@ -1324,7 +1774,7 @@ void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo& dock, size += gripper_size; size += pane.best_size.x; } - else + else { if (pane.HasGripper() && pane.HasGripperTop()) size += gripper_size; @@ -1349,7 +1799,7 @@ void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo& dock, if (amount >= 0) offset += amount; - else + else positions[pane_i] -= -amount; offset += sizes[pane_i]; @@ -1363,7 +1813,7 @@ void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo& dock, int amount = positions[pane_i] - offset; if (amount >= 0) offset += amount; - else + else positions[pane_i] += -amount; offset += sizes[pane_i]; @@ -1371,34 +1821,34 @@ void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo& dock, } -void wxFrameManager::LayoutAddPane(wxSizer* cont, - wxDockInfo& dock, - wxPaneInfo& pane, - wxDockUIPartArray& uiparts, - bool spacer_only) +void wxAuiManager::LayoutAddPane(wxSizer* cont, + wxAuiDockInfo& dock, + wxAuiPaneInfo& pane, + wxAuiDockUIPartArray& uiparts, + bool spacer_only) { - wxDockUIPart part; + wxAuiDockUIPart part; wxSizerItem* sizer_item; - int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE); - int gripper_size = m_art->GetMetric(wxAUI_ART_GRIPPER_SIZE); - int pane_border_size = m_art->GetMetric(wxAUI_ART_PANE_BORDER_SIZE); - int pane_button_size = m_art->GetMetric(wxAUI_ART_PANE_BUTTON_SIZE); + int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE); + int gripper_size = m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE); + int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE); + int pane_button_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BUTTON_SIZE); // find out the orientation of the item (orientation for panes // is the same as the dock's orientation) int orientation; if (dock.IsHorizontal()) orientation = wxHORIZONTAL; - else + else orientation = wxVERTICAL; // this variable will store the proportion // value that the pane will receive int pane_proportion = pane.dock_proportion; - wxBoxSizer* horz_pane_sizer = new wxBoxSizer(wxHORIZONTAL); - wxBoxSizer* vert_pane_sizer = new wxBoxSizer(wxVERTICAL); + wxAuiProportionalBoxSizer* horz_pane_sizer = new wxAuiProportionalBoxSizer(wxHORIZONTAL); + wxAuiProportionalBoxSizer* vert_pane_sizer = new wxAuiProportionalBoxSizer(wxVERTICAL); if (pane.HasGripper()) { @@ -1407,7 +1857,7 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont, else sizer_item = horz_pane_sizer ->Add(gripper_size, 1, 0, wxEXPAND); - part.type = wxDockUIPart::typeGripper; + part.type = wxAuiDockUIPart::typeGripper; part.dock = &dock; part.pane = &pane; part.button = NULL; @@ -1420,11 +1870,11 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont, if (pane.HasCaption()) { // create the caption sizer - wxBoxSizer* caption_sizer = new wxBoxSizer(wxHORIZONTAL); + wxAuiProportionalBoxSizer* caption_sizer = new wxAuiProportionalBoxSizer(wxHORIZONTAL); sizer_item = caption_sizer->Add(1, caption_size, 1, wxEXPAND); - part.type = wxDockUIPart::typeCaption; + part.type = wxAuiDockUIPart::typeCaption; part.dock = &dock; part.pane = &pane; part.button = NULL; @@ -1439,13 +1889,13 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont, for (i = 0, button_count = pane.buttons.GetCount(); i < button_count; ++i) { - wxPaneButton& button = pane.buttons.Item(i); + wxAuiPaneButton& button = pane.buttons.Item(i); sizer_item = caption_sizer->Add(pane_button_size, caption_size, 0, wxEXPAND); - part.type = wxDockUIPart::typePaneButton; + part.type = wxAuiDockUIPart::typePaneButton; part.dock = &dock; part.pane = &pane; part.button = &button; @@ -1455,6 +1905,13 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont, uiparts.Add(part); } + // if we have buttons, add a little space to the right + // of them to ease visual crowding + if (button_count >= 1) + { + caption_sizer->Add(3,1); + } + // add the caption sizer sizer_item = vert_pane_sizer->Add(caption_sizer, 0, wxEXPAND); @@ -1475,7 +1932,7 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont, vert_pane_sizer->SetItemMinSize(pane.window, 1, 1); } - part.type = wxDockUIPart::typePane; + part.type = wxAuiDockUIPart::typePane; part.dock = &dock; part.pane = &pane; part.button = NULL; @@ -1486,7 +1943,7 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont, // determine if the pane should have a minimum size; if the pane is - // non-resizable (fixed) then we must set a minimum size. Alternitavely, + // non-resizable (fixed) then we must set a minimum size. Alternatively, // if the pane.min_size is set, we must use that value as well wxSize min_size = pane.min_size; @@ -1519,7 +1976,7 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont, sizer_item = cont->Add(horz_pane_sizer, pane_proportion, wxEXPAND | wxALL, pane_border_size); - part.type = wxDockUIPart::typePaneBorder; + part.type = wxAuiDockUIPart::typePaneBorder; part.dock = &dock; part.pane = &pane; part.button = NULL; @@ -1534,24 +1991,24 @@ void wxFrameManager::LayoutAddPane(wxSizer* cont, } } -void wxFrameManager::LayoutAddDock(wxSizer* cont, - wxDockInfo& dock, - wxDockUIPartArray& uiparts, - bool spacer_only) +void wxAuiManager::LayoutAddDock(wxSizer* cont, + wxAuiDockInfo& dock, + wxAuiDockUIPartArray& uiparts, + bool spacer_only) { wxSizerItem* sizer_item; - wxDockUIPart part; + wxAuiDockUIPart part; - int sash_size = m_art->GetMetric(wxAUI_ART_SASH_SIZE); + int sash_size = m_art->GetMetric(wxAUI_DOCKART_SASH_SIZE); int orientation = dock.IsHorizontal() ? wxHORIZONTAL : wxVERTICAL; // resizable bottom and right docks have a sash before them - if (!dock.fixed && (dock.dock_direction == wxAUI_DOCK_BOTTOM || + if (!m_has_maximized && !dock.fixed && (dock.dock_direction == wxAUI_DOCK_BOTTOM || dock.dock_direction == wxAUI_DOCK_RIGHT)) { sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND); - part.type = wxDockUIPart::typeDockSizer; + part.type = wxAuiDockUIPart::typeDockSizer; part.orientation = orientation; part.dock = &dock; part.pane = NULL; @@ -1562,9 +2019,10 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont, } // create the sizer for the dock - wxSizer* dock_sizer = new wxBoxSizer(orientation); + wxSizer* dock_sizer = new wxAuiProportionalBoxSizer(orientation); // add each pane to the dock + bool has_maximized_pane = false; int pane_i, pane_count = dock.panes.GetCount(); if (dock.fixed) @@ -1578,18 +2036,22 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont, int offset = 0; for (pane_i = 0; pane_i < pane_count; ++pane_i) { - wxPaneInfo& pane = *(dock.panes.Item(pane_i)); + wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i)); int pane_pos = pane_positions.Item(pane_i); + if (pane.IsMaximized()) + has_maximized_pane = true; + + int amount = pane_pos - offset; if (amount > 0) { if (dock.IsVertical()) sizer_item = dock_sizer->Add(1, amount, 0, wxEXPAND); - else + else sizer_item = dock_sizer->Add(amount, 1, 0, wxEXPAND); - part.type = wxDockUIPart::typeBackground; + part.type = wxAuiDockUIPart::typeBackground; part.dock = &dock; part.pane = NULL; part.button = NULL; @@ -1607,9 +2069,9 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont, } // at the end add a very small stretchable background area - sizer_item = dock_sizer->Add(1,1, 1, wxEXPAND); + sizer_item = dock_sizer->Add(0,0, 1, wxEXPAND); - part.type = wxDockUIPart::typeBackground; + part.type = wxAuiDockUIPart::typeBackground; part.dock = &dock; part.pane = NULL; part.button = NULL; @@ -1622,15 +2084,18 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont, { for (pane_i = 0; pane_i < pane_count; ++pane_i) { - wxPaneInfo& pane = *(dock.panes.Item(pane_i)); + wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i)); + + if (pane.IsMaximized()) + has_maximized_pane = true; // if this is not the first pane being added, // we need to add a pane sizer - if (pane_i > 0) + if (!m_has_maximized && pane_i > 0) { sizer_item = dock_sizer->Add(sash_size, sash_size, 0, wxEXPAND); - part.type = wxDockUIPart::typePaneSizer; + part.type = wxAuiDockUIPart::typePaneSizer; part.dock = &dock; part.pane = dock.panes.Item(pane_i-1); part.button = NULL; @@ -1644,12 +2109,12 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont, } } - if (dock.dock_direction == wxAUI_DOCK_CENTER) + if (dock.dock_direction == wxAUI_DOCK_CENTER || has_maximized_pane) sizer_item = cont->Add(dock_sizer, 1, wxEXPAND); - else + else sizer_item = cont->Add(dock_sizer, 0, wxEXPAND); - part.type = wxDockUIPart::typeDock; + part.type = wxAuiDockUIPart::typeDock; part.dock = &dock; part.pane = NULL; part.button = NULL; @@ -1660,16 +2125,18 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont, if (dock.IsHorizontal()) cont->SetItemMinSize(dock_sizer, 0, dock.size); - else + else cont->SetItemMinSize(dock_sizer, dock.size, 0); // top and left docks have a sash after them - if (!dock.fixed && (dock.dock_direction == wxAUI_DOCK_TOP || - dock.dock_direction == wxAUI_DOCK_LEFT)) + if (!m_has_maximized && + !dock.fixed && + (dock.dock_direction == wxAUI_DOCK_TOP || + dock.dock_direction == wxAUI_DOCK_LEFT)) { sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND); - part.type = wxDockUIPart::typeDockSizer; + part.type = wxAuiDockUIPart::typeDockSizer; part.dock = &dock; part.pane = NULL; part.button = NULL; @@ -1680,43 +2147,58 @@ void wxFrameManager::LayoutAddDock(wxSizer* cont, } } -wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, - wxDockInfoArray& docks, - wxDockUIPartArray& uiparts, - bool spacer_only) +wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes, + wxAuiDockInfoArray& docks, + wxAuiDockUIPartArray& uiparts, + bool spacer_only) { - wxBoxSizer* container = new wxBoxSizer(wxVERTICAL); + wxAuiProportionalBoxSizer* container = new wxAuiProportionalBoxSizer(wxVERTICAL); - int pane_border_size = m_art->GetMetric(wxAUI_ART_PANE_BORDER_SIZE); - int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE); + int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE); + int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE); wxSize cli_size = m_frame->GetClientSize(); int i, dock_count, pane_count; // empty all docks out for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i) - docks.Item(i).panes.Empty(); + { + wxAuiDockInfo& dock = docks.Item(i); + + // empty out all panes, as they will be readded below + dock.panes.Empty(); + + if (dock.fixed) + { + // always reset fixed docks' sizes, because + // the contained windows may have been resized + dock.size = 0; + } + } + // iterate through all known panes, filing each // of them into the appropriate dock. If the // pane does not exist in the dock, add it for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i) { - wxPaneInfo& p = panes.Item(i); + wxAuiPaneInfo& p = panes.Item(i); - // find any docks in this layer - wxDockInfo* dock; - wxDockInfoPtrArray arr; + // find any docks with the same dock direction, dock layer, and + // dock row as the pane we are working on + wxAuiDockInfo* dock; + wxAuiDockInfoPtrArray arr; FindDocks(docks, p.dock_direction, p.dock_layer, p.dock_row, arr); if (arr.GetCount() > 0) { + // found the right dock dock = arr.Item(0); } - else + else { // dock was not found, so we need to create a new one - wxDockInfo d; + wxAuiDockInfo d; d.dock_direction = p.dock_direction; d.dock_layer = p.dock_layer; d.dock_row = p.dock_row; @@ -1735,7 +2217,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, if (!FindPaneInDock(*dock, p.window)) dock->panes.Add(&p); } - else + else { // remove the pane from any existing docks RemovePaneFromDocks(docks, p); @@ -1753,7 +2235,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, // configure the docks further for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i) { - wxDockInfo& dock = docks.Item(i); + wxAuiDockInfo& dock = docks.Item(i); int j, dock_pane_count = dock.panes.GetCount(); // sort the dock pane array by the pane's @@ -1767,7 +2249,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, for (j = 0; j < dock_pane_count; ++j) { - wxPaneInfo& pane = *dock.panes.Item(j); + wxAuiPaneInfo& pane = *dock.panes.Item(j); wxSize pane_size = pane.best_size; if (pane_size == wxDefaultSize) pane_size = pane.min_size; @@ -1776,7 +2258,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, if (dock.IsHorizontal()) size = wxMax(pane_size.y, size); - else + else size = wxMax(pane_size.x, size); } @@ -1805,14 +2287,22 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, } } - // new dock's size may not be more than 1/3 of the frame size + + // new dock's size may not be more than the dock constraint + // parameter specifies. See SetDockSizeConstraint() + + int max_dock_x_size = (int)(m_dock_constraint_x * ((double)cli_size.x)); + int max_dock_y_size = (int)(m_dock_constraint_y * ((double)cli_size.y)); + if (dock.IsHorizontal()) - size = wxMin(size, cli_size.y/3); - else - size = wxMin(size, cli_size.x/3); + size = wxMin(size, max_dock_y_size); + else + size = wxMin(size, max_dock_x_size); + // absolute minimum size for a dock is 10 pixels if (size < 10) size = 10; + dock.size = size; } @@ -1823,7 +2313,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, int dock_min_size = 0; for (j = 0; j < dock_pane_count; ++j) { - wxPaneInfo& pane = *dock.panes.Item(j); + wxAuiPaneInfo& pane = *dock.panes.Item(j); if (pane.min_size != wxDefaultSize) { if (pane.HasBorder()) @@ -1835,7 +2325,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, if (pane.min_size.y > dock_min_size) dock_min_size = pane.min_size.y; } - else + else { if (pane.min_size.x > dock_min_size) dock_min_size = pane.min_size.x; @@ -1864,12 +2354,14 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, dock.toolbar = true; for (j = 0; j < dock_pane_count; ++j) { - wxPaneInfo& pane = *dock.panes.Item(j); + wxAuiPaneInfo& pane = *dock.panes.Item(j); if (!pane.IsFixed()) dock.fixed = false; if (!pane.IsToolbar()) dock.toolbar = false; - if (pane.state & wxPaneInfo::actionPane) + if (pane.HasFlag(wxAuiPaneInfo::optionDockFixed)) + dock.fixed = true; + if (pane.HasFlag(wxAuiPaneInfo::actionPane)) action_pane_marked = true; } @@ -1881,7 +2373,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, { for (j = 0; j < dock_pane_count; ++j) { - wxPaneInfo& pane = *dock.panes.Item(j); + wxAuiPaneInfo& pane = *dock.panes.Item(j); pane.dock_pos = j; } } @@ -1889,7 +2381,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, // if the dock mode is fixed, and none of the panes // are being moved right now, make sure the panes // do not overlap each other. If they do, we will - // adjust the panes' positions + // adjust the positions of the panes if (dock.fixed && !action_pane_marked) { wxArrayInt pane_positions, pane_sizes; @@ -1898,13 +2390,13 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, int offset = 0; for (j = 0; j < dock_pane_count; ++j) { - wxPaneInfo& pane = *(dock.panes.Item(j)); + wxAuiPaneInfo& pane = *(dock.panes.Item(j)); pane.dock_pos = pane_positions[j]; int amount = pane.dock_pos - offset; if (amount >= 0) offset += amount; - else + else pane.dock_pos += -amount; offset += pane_sizes[j]; @@ -1930,7 +2422,7 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, for (layer = 0; layer <= max_layer; ++layer) { - wxDockInfoPtrArray arr; + wxAuiDockInfoPtrArray arr; // find any docks in this layer FindDocks(docks, -1, layer, -1, arr); @@ -1943,12 +2435,11 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, // create a container which will hold this layer's // docks (top, bottom, left, right) - cont = new wxBoxSizer(wxVERTICAL); + cont = new wxAuiProportionalBoxSizer(wxVERTICAL); // find any top docks in this layer FindDocks(docks, wxAUI_DOCK_TOP, layer, -1, arr); - RenumberDockRows(arr); if (!arr.IsEmpty()) { for (row = 0, row_count = arr.GetCount(); row < row_count; ++row) @@ -1959,11 +2450,10 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, // fill out the middle layer (which consists // of left docks, content area and right docks) - middle = new wxBoxSizer(wxHORIZONTAL); + middle = new wxAuiProportionalBoxSizer(wxHORIZONTAL); // find any left docks in this layer FindDocks(docks, wxAUI_DOCK_LEFT, layer, -1, arr); - RenumberDockRows(arr); if (!arr.IsEmpty()) { for (row = 0, row_count = arr.GetCount(); row < row_count; ++row) @@ -1981,12 +2471,12 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, for (row = 0,row_count = arr.GetCount(); rowAdd(1,1, 1, wxEXPAND); - wxDockUIPart part; - part.type = wxDockUIPart::typeBackground; + wxAuiDockUIPart part; + part.type = wxAuiDockUIPart::typeBackground; part.pane = NULL; part.dock = NULL; part.button = NULL; @@ -1995,27 +2485,28 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, uiparts.Add(part); } } - else + else { middle->Add(old_cont, 1, wxEXPAND); } // find any right docks in this layer FindDocks(docks, wxAUI_DOCK_RIGHT, layer, -1, arr); - RenumberDockRows(arr); if (!arr.IsEmpty()) { for (row = arr.GetCount()-1; row >= 0; --row) LayoutAddDock(middle, *arr.Item(row), uiparts, spacer_only); } - cont->Add(middle, 1, wxEXPAND); + if (middle->GetChildren().GetCount() > 0) + cont->Add(middle, 1, wxEXPAND); + else + delete middle; // find any bottom docks in this layer FindDocks(docks, wxAUI_DOCK_BOTTOM, layer, -1, arr); - RenumberDockRows(arr); if (!arr.IsEmpty()) { for (row = arr.GetCount()-1; row >= 0; --row) @@ -2028,10 +2519,10 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, { // no sizer available, because there are no docks, // therefore we will create a simple background area - cont = new wxBoxSizer(wxVERTICAL); + cont = new wxAuiProportionalBoxSizer(wxVERTICAL); wxSizerItem* sizer_item = cont->Add(1,1, 1, wxEXPAND); - wxDockUIPart part; - part.type = wxDockUIPart::typeBackground; + wxAuiDockUIPart part; + part.type = wxAuiDockUIPart::typeBackground; part.pane = NULL; part.dock = NULL; part.button = NULL; @@ -2045,23 +2536,45 @@ wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes, } +// SetDockSizeConstraint() allows the dock constraints to be set. For example, +// specifying values of 0.5, 0.5 will mean that upon dock creation, a dock may +// not be larger than half of the window's size + +void wxAuiManager::SetDockSizeConstraint(double width_pct, double height_pct) +{ + m_dock_constraint_x = wxMax(0.0, wxMin(1.0, width_pct)); + m_dock_constraint_y = wxMax(0.0, wxMin(1.0, height_pct)); +} + +void wxAuiManager::GetDockSizeConstraint(double* width_pct, double* height_pct) const +{ + if (width_pct) + *width_pct = m_dock_constraint_x; + + if (height_pct) + *height_pct = m_dock_constraint_y; +} + + + // Update() updates the layout. Whenever changes are made to // one or more panes, this function should be called. It is the // external entry point for running the layout engine. -void wxFrameManager::Update() +void wxAuiManager::Update() { + m_hover_button = NULL; + m_action_part = NULL; + wxSizer* sizer; int i, pane_count = m_panes.GetCount(); - // delete old sizer first - m_frame->SetSizer(NULL); // destroy floating panes which have been // redocked or are becoming non-floating for (i = 0; i < pane_count; ++i) { - wxPaneInfo& p = m_panes.Item(i); + wxAuiPaneInfo& p = m_panes.Item(i); if (!p.IsFloating() && p.frame) { @@ -2072,25 +2585,30 @@ void wxFrameManager::Update() p.window->SetSize(1,1); - // the following block is a workaround for bug #1531361 - // (see wxWidgets sourceforge page). On wxGTK (only), when - // a frame is shown/hidden, a move event unfortunately - // also gets fired. Because we may be dragging around - // a pane, we need to cancel that action here to prevent - // a spurious crash. - if (m_action_window == p.frame) - { - if (wxWindow::GetCapture() == m_frame) + // the following block is a workaround for bug #1531361 + // (see wxWidgets sourceforge page). On wxGTK (only), when + // a frame is shown/hidden, a move event unfortunately + // also gets fired. Because we may be dragging around + // a pane, we need to cancel that action here to prevent + // a spurious crash. + if (m_action_window == p.frame) + { + if (wxWindow::GetCapture() == m_frame) m_frame->ReleaseMouse(); m_action = actionNone; - m_action_window = NULL; - } + m_action_window = NULL; + } - // hide the frame + // hide the frame if (p.frame->IsShown()) p.frame->Show(false); // reparent to m_frame and destroy the pane + if (m_action_window == p.frame) + { + m_action_window = NULL; + } + p.window->Reparent(m_frame); p.frame->SetSizer(NULL); p.frame->Destroy(); @@ -2099,6 +2617,9 @@ void wxFrameManager::Update() } + // delete old sizer first + m_frame->SetSizer(NULL); + // create a layout for all of the panes sizer = LayoutAll(m_panes, m_docks, m_uiparts, false); @@ -2106,7 +2627,7 @@ void wxFrameManager::Update() // and float panes as necessary for (i = 0; i < pane_count; ++i) { - wxPaneInfo& p = m_panes.Item(i); + wxAuiPaneInfo& p = m_panes.Item(i); if (p.IsFloating()) { @@ -2114,16 +2635,14 @@ void wxFrameManager::Update() { // we need to create a frame for this // pane, which has recently been floated - wxFloatingPane* frame = CreateFloatingFrame(m_frame, p); + wxAuiFloatingFrame* frame = CreateFloatingFrame(m_frame, p); -#if wxCHECK_VERSION(2,7,0) // on MSW and Mac, if the owner desires transparent dragging, and // the dragging is happening right now, then the floating // window should have this style by default if (m_action == actionDragFloatingPane && (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)) frame->SetTransparent(150); -#endif frame->SetPaneWindow(p); p.frame = frame; @@ -2131,23 +2650,28 @@ void wxFrameManager::Update() if (p.IsShown() && !frame->IsShown()) frame->Show(); } - else + else { // frame already exists, make sure it's position - // and size reflect the information in wxPaneInfo - if (p.frame->GetPosition() != p.floating_pos) + // and size reflect the information in wxAuiPaneInfo + if ((p.frame->GetPosition() != p.floating_pos) || (p.frame->GetSize() != p.floating_size)) { + p.frame->SetSize(p.floating_pos.x, p.floating_pos.y, + p.floating_size.x, p.floating_size.y, + wxSIZE_USE_EXISTING); + /* p.frame->SetSize(p.floating_pos.x, p.floating_pos.y, wxDefaultCoord, wxDefaultCoord, wxSIZE_USE_EXISTING); //p.frame->Move(p.floating_pos.x, p.floating_pos.y); + */ } if (p.frame->IsShown() != p.IsShown()) p.frame->Show(p.IsShown()); } } - else + else { if (p.window->IsShown() != p.IsShown()) p.window->Show(p.IsShown()); @@ -2157,7 +2681,7 @@ void wxFrameManager::Update() // any optionActive values from the pane states if ((m_flags & wxAUI_MGR_ALLOW_ACTIVE_PANE) == 0) { - p.state &= ~wxPaneInfo::optionActive; + p.state &= ~wxAuiPaneInfo::optionActive; } } @@ -2168,7 +2692,7 @@ void wxFrameManager::Update() for (i = 0; i < pane_count; ++i) { wxRect r; - wxPaneInfo& p = m_panes.Item(i); + wxAuiPaneInfo& p = m_panes.Item(i); if (p.window && p.IsShown() && p.IsDocked()) r = p.rect; @@ -2192,7 +2716,7 @@ void wxFrameManager::Update() // changed, the corresponding panes must also be updated for (i = 0; i < pane_count; ++i) { - wxPaneInfo& p = m_panes.Item(i); + wxAuiPaneInfo& p = m_panes.Item(i); if (p.window && p.window->IsShown() && p.IsDocked()) { if (p.rect != old_pane_rects[i]) @@ -2234,14 +2758,14 @@ void wxFrameManager::Update() // and updates their internal rectangles. This should always be called // instead of calling m_frame->Layout() directly -void wxFrameManager::DoFrameLayout() +void wxAuiManager::DoFrameLayout() { m_frame->Layout(); int i, part_count; for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i) { - wxDockUIPart& part = m_uiparts.Item(i); + wxAuiDockUIPart& part = m_uiparts.Item(i); // get the rectangle of the UI part // originally, this code looked like this: @@ -2274,9 +2798,9 @@ void wxFrameManager::DoFrameLayout() part.rect.width += border; - if (part.type == wxDockUIPart::typeDock) + if (part.type == wxAuiDockUIPart::typeDock) part.dock->rect = part.rect; - if (part.type == wxDockUIPart::typePane) + if (part.type == wxAuiDockUIPart::typePane) part.pane->rect = part.rect; } } @@ -2286,20 +2810,20 @@ void wxFrameManager::DoFrameLayout() // rectangle of the pane in question, including decorations like // caption and border (if any). -wxDockUIPart* wxFrameManager::GetPanePart(wxWindow* wnd) +wxAuiDockUIPart* wxAuiManager::GetPanePart(wxWindow* wnd) { int i, part_count; for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i) { - wxDockUIPart& part = m_uiparts.Item(i); - if (part.type == wxDockUIPart::typePaneBorder && + wxAuiDockUIPart& part = m_uiparts.Item(i); + if (part.type == wxAuiDockUIPart::typePaneBorder && part.pane && part.pane->window == wnd) return ∂ } for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i) { - wxDockUIPart& part = m_uiparts.Item(i); - if (part.type == wxDockUIPart::typePane && + wxAuiDockUIPart& part = m_uiparts.Item(i); + if (part.type == wxAuiDockUIPart::typePane && part.pane && part.pane->window == wnd) return ∂ } @@ -2314,15 +2838,15 @@ wxDockUIPart* wxFrameManager::GetPanePart(wxWindow* wnd) // vertical docks). This value is necessary for calculating // fixel-pane/toolbar offsets when they are dragged. -int wxFrameManager::GetDockPixelOffset(wxPaneInfo& test) +int wxAuiManager::GetDockPixelOffset(wxAuiPaneInfo& test) { // the only way to accurately calculate the dock's // offset is to actually run a theoretical layout int i, part_count, dock_count; - wxDockInfoArray docks; - wxPaneInfoArray panes; - wxDockUIPartArray uiparts; + wxAuiDockInfoArray docks; + wxAuiPaneInfoArray panes; + wxAuiDockUIPartArray uiparts; CopyDocksAndPanes(docks, panes, m_docks, m_panes); panes.Add(test); @@ -2333,10 +2857,10 @@ int wxFrameManager::GetDockPixelOffset(wxPaneInfo& test) for (i = 0, part_count = uiparts.GetCount(); i < part_count; ++i) { - wxDockUIPart& part = uiparts.Item(i); + wxAuiDockUIPart& part = uiparts.Item(i); part.rect = wxRect(part.sizer_item->GetPosition(), part.sizer_item->GetSize()); - if (part.type == wxDockUIPart::typeDock) + if (part.type == wxAuiDockUIPart::typeDock) part.dock->rect = part.rect; } @@ -2344,13 +2868,13 @@ int wxFrameManager::GetDockPixelOffset(wxPaneInfo& test) for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i) { - wxDockInfo& dock = docks.Item(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 + else return dock.rect.x; } } @@ -2364,8 +2888,8 @@ int wxFrameManager::GetDockPixelOffset(wxPaneInfo& test) // if a dock operation is allowed, the new dock position is copied into // the target info. If the operation was allowed, the function returns true. -bool wxFrameManager::ProcessDockResult(wxPaneInfo& target, - const wxPaneInfo& new_pos) +bool wxAuiManager::ProcessDockResult(wxAuiPaneInfo& target, + const wxAuiPaneInfo& new_pos) { bool allowed = false; switch (new_pos.dock_direction) @@ -2388,7 +2912,7 @@ bool wxFrameManager::ProcessDockResult(wxPaneInfo& target, // dropped, it performs the drop operation using the specified dock and pane // arrays. By specifying copied dock and pane arrays when calling, a "what-if" // scenario can be performed, giving precise coordinates for drop hints. -// If, however, wxFrameManager:m_docks and wxFrameManager::m_panes are specified +// If, however, wxAuiManager:m_docks and wxAuiManager::m_panes are specified // as parameters, the changes will be made to the main state arrays const int auiInsertRowPixels = 10; @@ -2396,15 +2920,15 @@ const int auiNewRowPixels = 40; const int auiLayerInsertPixels = 40; const int auiLayerInsertOffset = 5; -bool wxFrameManager::DoDrop(wxDockInfoArray& docks, - wxPaneInfoArray& panes, - wxPaneInfo& target, - const wxPoint& pt, - const wxPoint& offset) +bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks, + wxAuiPaneInfoArray& panes, + wxAuiPaneInfo& target, + const wxPoint& pt, + const wxPoint& offset) { wxSize cli_size = m_frame->GetClientSize(); - wxPaneInfo drop = target; + wxAuiPaneInfo drop = target; // The result should always be shown @@ -2416,13 +2940,22 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks, int layer_insert_offset = auiLayerInsertOffset; - if (target.IsToolbar()) + if (drop.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; + + if (drop.IsToolbar()) + new_layer = auiToolBarLayer; + drop.Dock().Left(). + Layer(new_layer). Row(0). Position(pt.y - GetDockPixelOffset(drop) - offset.y); return ProcessDockResult(target, drop); @@ -2430,7 +2963,15 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks, 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; + + if (drop.IsToolbar()) + new_layer = auiToolBarLayer; + drop.Dock().Top(). + Layer(new_layer). Row(0). Position(pt.x - GetDockPixelOffset(drop) - offset.x); return ProcessDockResult(target, drop); @@ -2438,7 +2979,15 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks, 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; + + if (drop.IsToolbar()) + new_layer = auiToolBarLayer; + drop.Dock().Right(). + Layer(new_layer). Row(0). Position(pt.y - GetDockPixelOffset(drop) - offset.y); return ProcessDockResult(target, drop); @@ -2450,6 +2999,9 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks, GetMaxLayer(docks, wxAUI_DOCK_LEFT)), GetMaxLayer(docks, wxAUI_DOCK_RIGHT)) + 1; + if (drop.IsToolbar()) + new_layer = auiToolBarLayer; + drop.Dock().Bottom(). Layer(new_layer). Row(0). @@ -2457,7 +3009,8 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks, return ProcessDockResult(target, drop); } - wxDockUIPart* part = HitTest(pt.x, pt.y); + + wxAuiDockUIPart* part = HitTest(pt.x, pt.y); if (drop.IsToolbar()) @@ -2470,14 +3023,15 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks, int dock_drop_offset = 0; if (part->dock->IsHorizontal()) dock_drop_offset = pt.x - part->dock->rect.x - offset.x; - else + 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 (!part->dock->fixed || part->dock->dock_direction == wxAUI_DOCK_CENTER || + pt.x >= cli_size.x || pt.x <= 0 || pt.y >= cli_size.y || pt.y <= 0) { if (m_last_rect.IsEmpty() || m_last_rect.Contains(pt.x, pt.y )) { @@ -2485,10 +3039,7 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks, } else { - if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) && - (drop.IsFloatable() || - (part->dock->dock_direction != wxAUI_DOCK_CENTER && - part->dock->dock_direction != wxAUI_DOCK_NONE))) + if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) && drop.IsFloatable()) { drop.Float(); } @@ -2502,16 +3053,11 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks, return ProcessDockResult(target, drop); } - else - { - m_skipping = false; - } - if (!m_skipping) - { - m_last_rect = part->dock->rect; - m_last_rect.Inflate( 15, 15 ); - } + m_skipping = false; + + m_last_rect = part->dock->rect; + m_last_rect.Inflate( 15, 15 ); drop.Dock(). Direction(part->dock->dock_direction). @@ -2574,16 +3120,16 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks, if (!part) return false; - if (part->type == wxDockUIPart::typePaneBorder || - part->type == wxDockUIPart::typeCaption || - part->type == wxDockUIPart::typeGripper || - part->type == wxDockUIPart::typePaneButton || - part->type == wxDockUIPart::typePane || - part->type == wxDockUIPart::typePaneSizer || - part->type == wxDockUIPart::typeDockSizer || - part->type == wxDockUIPart::typeBackground) + 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 == wxDockUIPart::typeDockSizer) + if (part->type == wxAuiDockUIPart::typeDockSizer) { if (part->dock->panes.GetCount() != 1) return false; @@ -2689,23 +3235,19 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks, 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; + const wxRect& pr = part->rect; + if (pt.x >= pr.x && pt.x < pr.x + new_row_pixels_x) + insert_dir = wxAUI_DOCK_LEFT; + else if (pt.y >= pr.y && pt.y < pr.y + new_row_pixels_y) + insert_dir = wxAUI_DOCK_TOP; + else if (pt.x >= pr.x + pr.width - new_row_pixels_x && + pt.x < pr.x + pr.width) + insert_dir = wxAUI_DOCK_RIGHT; + else if (pt.y >= pr.y+ pr.height - new_row_pixels_y && + pt.y < pr.y + pr.height) + insert_dir = wxAUI_DOCK_BOTTOM; + else + return false; insert_row = GetMaxRow(panes, insert_dir, insert_layer) + 1; } @@ -2731,7 +3273,7 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks, offset = pt.y - part->rect.y; size = part->rect.GetHeight(); } - else + else { offset = pt.x - part->rect.x; size = part->rect.GetWidth(); @@ -2775,24 +3317,21 @@ bool wxFrameManager::DoDrop(wxDockInfoArray& docks, } -void wxFrameManager::OnHintFadeTimer(wxTimerEvent& WXUNUSED(event)) +void wxAuiManager::OnHintFadeTimer(wxTimerEvent& WXUNUSED(event)) { if (!m_hint_wnd || m_hint_fadeamt >= m_hint_fademax) { m_hint_fadetimer.Stop(); + Disconnect(m_hint_fadetimer.GetId(), wxEVT_TIMER, + wxTimerEventHandler(wxAuiManager::OnHintFadeTimer)); return; } m_hint_fadeamt += 4; -#if wxCHECK_VERSION(2,7,0) m_hint_wnd->SetTransparent(m_hint_fadeamt); -#else - if (m_hint_wnd->IsKindOf(CLASSINFO(wxPseudoTransparentFrame))) - ((wxPseudoTransparentFrame *)m_hint_wnd)->SetTransparent(m_hint_fadeamt); -#endif } -void wxFrameManager::ShowHint(const wxRect& rect) +void wxAuiManager::ShowHint(const wxRect& rect) { if (m_hint_wnd) { @@ -2802,7 +3341,7 @@ void wxFrameManager::ShowHint(const wxRect& rect) m_last_hint = rect; m_hint_fadeamt = m_hint_fademax; - + if ((m_flags & wxAUI_MGR_HINT_FADE) && !((m_hint_wnd->IsKindOf(CLASSINFO(wxPseudoTransparentFrame))) && (m_flags & wxAUI_MGR_NO_VENETIAN_BLINDS_FADE)) @@ -2810,6 +3349,7 @@ void wxFrameManager::ShowHint(const wxRect& rect) m_hint_fadeamt = 0; m_hint_wnd->SetSize(rect); + m_hint_wnd->SetTransparent(m_hint_fadeamt); if (!m_hint_wnd->IsShown()) m_hint_wnd->Show(); @@ -2819,27 +3359,23 @@ void wxFrameManager::ShowHint(const wxRect& rect) if (m_action == actionDragFloatingPane && m_action_window) m_action_window->SetFocus(); -#if wxCHECK_VERSION(2,7,0) - m_hint_wnd->SetTransparent(m_hint_fadeamt); -#else - if (m_hint_wnd->IsKindOf(CLASSINFO(wxPseudoTransparentFrame))) - ((wxPseudoTransparentFrame*)m_hint_wnd)->SetTransparent(m_hint_fadeamt); -#endif m_hint_wnd->Raise(); if (m_hint_fadeamt != m_hint_fademax) // Only fade if we need to { // start fade in timer - m_hint_fadetimer.SetOwner(this, 101); + m_hint_fadetimer.SetOwner(this); m_hint_fadetimer.Start(5); + Connect(m_hint_fadetimer.GetId(), wxEVT_TIMER, + wxTimerEventHandler(wxAuiManager::OnHintFadeTimer)); } } - else // Not using a transparent hint window... + else // Not using a transparent hint window... { if (!(m_flags & wxAUI_MGR_RECTANGLE_HINT)) return; - + if (m_last_hint != rect) { // remove the last hint rectangle @@ -2855,7 +3391,7 @@ void wxFrameManager::ShowHint(const wxRect& rect) int i, pane_count; for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) { - wxPaneInfo& pane = m_panes.Item(i); + wxAuiPaneInfo& pane = m_panes.Item(i); if (pane.IsFloating() && pane.frame->IsShown()) @@ -2877,7 +3413,7 @@ void wxFrameManager::ShowHint(const wxRect& rect) // nasty redrawn problems. clip.Intersect(m_frame->GetRect()); - screendc.SetClippingRegion(clip); + screendc.SetDeviceClippingRegion(clip); wxBitmap stipple = wxPaneCreateStippleBitmap(); wxBrush brush(stipple); @@ -2891,20 +3427,19 @@ void wxFrameManager::ShowHint(const wxRect& rect) } } -void wxFrameManager::HideHint() +void wxAuiManager::HideHint() { // hides a transparent window hint, if there is one if (m_hint_wnd) { if (m_hint_wnd->IsShown()) m_hint_wnd->Show(false); -#if wxCHECK_VERSION(2,7,0) m_hint_wnd->SetTransparent(0); -#else - if (m_hint_wnd->IsKindOf(CLASSINFO(wxPseudoTransparentFrame))) - ((wxPseudoTransparentFrame *)m_hint_wnd)->SetTransparent(0); -#endif m_hint_fadetimer.Stop(); + // In case this is called while a hint fade is going, we need to + // disconnect the event handler. + Disconnect(m_hint_fadetimer.GetId(), wxEVT_TIMER, + wxTimerEventHandler(wxAuiManager::OnHintFadeTimer)); m_last_hint = wxRect(); return; } @@ -2918,17 +3453,53 @@ void wxFrameManager::HideHint() } } +void wxAuiManager::OnHintActivate(wxActivateEvent& WXUNUSED(event)) +{ + // Do nothing so this event isn't handled in the base handlers. + + // Letting the hint window activate without this handler can lead to + // weird behavior on Mac where the menu is switched out to the top + // window's menu in MDI applications when it shouldn't be. So since + // we don't want user interaction with the hint window anyway, we just + // prevent it from activating here. +} + + + +void wxAuiManager::StartPaneDrag(wxWindow* pane_window, + const wxPoint& offset) +{ + wxAuiPaneInfo& pane = GetPane(pane_window); + if (!pane.IsOk()) + return; + + if (pane.IsToolbar()) + { + m_action = actionDragToolbarPane; + } + else + { + m_action = actionDragFloatingPane; + } + + m_action_window = pane_window; + m_action_offset = offset; + m_frame->CaptureMouse(); +} + +// CalculateHintRect() calculates the drop hint rectangle. The method +// first calls DoDrop() to determine the exact position the pane would +// be at were if dropped. If the pane would indeed become docked at the +// specified drop point, the the rectangle hint will be returned in +// screen coordinates. Otherwise, an empty rectangle is returned. +// |pane_window| is the window pointer of the pane being dragged, |pt| is +// the mouse position, in client coordinates. |offset| describes the offset +// that the mouse is from the upper-left corner of the item being dragged -// DrawHintRect() draws a drop hint rectangle. First calls DoDrop() to -// determine the exact position the pane would be at were if dropped. If -// the pame would indeed become docked at the specified drop point, -// DrawHintRect() then calls ShowHint() to indicate this drop rectangle. -// "pane_window" is the window pointer of the pane being dragged, pt is -// the mouse position, in client coordinates -void wxFrameManager::DrawHintRect(wxWindow* pane_window, - const wxPoint& pt, - const wxPoint& offset) +wxRect wxAuiManager::CalculateHintRect(wxWindow* pane_window, + const wxPoint& pt, + const wxPoint& offset) { wxRect rect; @@ -2938,15 +3509,16 @@ void wxFrameManager::DrawHintRect(wxWindow* pane_window, // so that we don't modify the real thing on screen int i, pane_count, part_count; - wxDockInfoArray docks; - wxPaneInfoArray panes; - wxDockUIPartArray uiparts; - wxPaneInfo hint = GetPane(pane_window); + wxAuiDockInfoArray docks; + wxAuiPaneInfoArray panes; + wxAuiDockUIPartArray uiparts; + wxAuiPaneInfo hint = GetPane(pane_window); hint.name = wxT("__HINT__"); + hint.PaneBorder(true); hint.Show(); if (!hint.IsOk()) - return; + return rect; CopyDocksAndPanes(docks, panes, m_docks, m_panes); @@ -2965,8 +3537,7 @@ void wxFrameManager::DrawHintRect(wxWindow* pane_window, // find out where the new pane would be if (!DoDrop(docks, panes, hint, pt, offset)) { - HideHint(); - return; + return rect; } panes.Add(hint); @@ -2979,9 +3550,9 @@ void wxFrameManager::DrawHintRect(wxWindow* pane_window, for (i = 0, part_count = uiparts.GetCount(); i < part_count; ++i) { - wxDockUIPart& part = uiparts.Item(i); + wxAuiDockUIPart& part = uiparts.Item(i); - if (part.type == wxDockUIPart::typePaneBorder && + if (part.type == wxAuiDockUIPart::typePaneBorder && part.pane && part.pane->name == wxT("__HINT__")) { rect = wxRect(part.sizer_item->GetPosition(), @@ -2994,33 +3565,63 @@ void wxFrameManager::DrawHintRect(wxWindow* pane_window, if (rect.IsEmpty()) { - HideHint(); - return; + return rect; } // actually show the hint rectangle on the screen m_frame->ClientToScreen(&rect.x, &rect.y); - ShowHint(rect); + + if ( m_frame->GetLayoutDirection() == wxLayout_RightToLeft ) + { + // Mirror rectangle in RTL mode + rect.x -= rect.GetWidth(); + } + + return rect; +} + +// DrawHintRect() calculates the hint rectangle by calling +// CalculateHintRect(). If there is a rectangle, it shows it +// by calling ShowHint(), otherwise it hides any hint +// rectangle currently shown +void wxAuiManager::DrawHintRect(wxWindow* pane_window, + const wxPoint& pt, + const wxPoint& offset) +{ + wxRect rect = CalculateHintRect(pane_window, pt, offset); + + if (rect.IsEmpty()) + { + HideHint(); + } + else + { + ShowHint(rect); + } } -void wxFrameManager::OnFloatingPaneMoveStart(wxWindow* wnd) +void wxAuiManager::OnFloatingPaneMoveStart(wxWindow* wnd) { // try to find the pane - wxPaneInfo& pane = GetPane(wnd); + wxAuiPaneInfo& pane = GetPane(wnd); wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); -#if wxCHECK_VERSION(2,7,0) + if(!pane.frame) + return; + if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG) pane.frame->SetTransparent(150); -#endif } -void wxFrameManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir) +void wxAuiManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir) { // try to find the pane - wxPaneInfo& pane = GetPane(wnd); + wxAuiPaneInfo& pane = GetPane(wnd); wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); + if(!pane.frame) + return; + wxPoint pt = ::wxGetMousePosition(); #if 0 @@ -3033,22 +3634,22 @@ void wxFrameManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir) pt.y = pos.y; // and some more pixels for the title bar pt.y -= 5; - } else - if (dir == wxWEST) + } + else if (dir == wxWEST) { // move to pane's left border wxPoint pos( 0,0 ); pos = wnd->ClientToScreen( pos ); pt.x = pos.x; - } else - if (dir == wxEAST) + } + else if (dir == wxEAST) { // move to pane's right border wxPoint pos( wnd->GetSize().x, 0 ); pos = wnd->ClientToScreen( pos ); pt.x = pos.x; - } else - if (dir == wxSOUTH) + } + else if (dir == wxSOUTH) { // move to pane's bottom border wxPoint pos( 0, wnd->GetSize().y ); @@ -3069,27 +3670,24 @@ void wxFrameManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir) // no hint for toolbar floating windows if (pane.IsToolbar() && m_action == actionDragFloatingPane) { - if (m_action == actionDragFloatingPane) - { - wxDockInfoArray docks; - wxPaneInfoArray panes; - wxDockUIPartArray uiparts; - wxPaneInfo hint = pane; + wxAuiDockInfoArray docks; + wxAuiPaneInfoArray panes; + wxAuiDockUIPartArray uiparts; + wxAuiPaneInfo hint = pane; - CopyDocksAndPanes(docks, panes, m_docks, m_panes); + CopyDocksAndPanes(docks, panes, m_docks, m_panes); - // find out where the new pane would be - if (!DoDrop(docks, panes, hint, client_pt)) - return; - if (hint.IsFloating()) - return; + // find out where the new pane would be + if (!DoDrop(docks, panes, hint, client_pt)) + return; + if (hint.IsFloating()) + return; - pane = hint; - m_action = actionDragToolbarPane; - m_action_window = pane.window; + pane = hint; + m_action = actionDragToolbarPane; + m_action_window = pane.window; - Update(); - } + Update(); return; } @@ -3097,7 +3695,7 @@ void wxFrameManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir) // if a key modifier is pressed while dragging the frame, // don't dock the window - if (wxGetKeyState(WXK_CONTROL) || wxGetKeyState(WXK_ALT)) + if (!CanDockPanel(pane)) { HideHint(); return; @@ -3118,12 +3716,15 @@ void wxFrameManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir) m_frame->Update(); } -void wxFrameManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir) +void wxAuiManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir) { // try to find the pane - wxPaneInfo& pane = GetPane(wnd); + wxAuiPaneInfo& pane = GetPane(wnd); wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); + if(!pane.frame) + return; + wxPoint pt = ::wxGetMousePosition(); #if 0 @@ -3136,22 +3737,22 @@ void wxFrameManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir) pt.y = pos.y; // and some more pixels for the title bar pt.y -= 10; - } else - if (dir == wxWEST) + } + else if (dir == wxWEST) { // move to pane's left border wxPoint pos( 0,0 ); pos = wnd->ClientToScreen( pos ); pt.x = pos.x; - } else - if (dir == wxEAST) + } + else if (dir == wxEAST) { // move to pane's right border wxPoint pos( wnd->GetSize().x, 0 ); pos = wnd->ClientToScreen( pos ); pt.x = pos.x; - } else - if (dir == wxSOUTH) + } + else if (dir == wxSOUTH) { // move to pane's bottom border wxPoint pos( 0, wnd->GetSize().y ); @@ -3169,10 +3770,9 @@ void wxFrameManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir) wxPoint frame_pos = pane.frame->GetPosition(); wxPoint action_offset(pt.x-frame_pos.x, pt.y-frame_pos.y); - // if a key modifier is pressed while dragging the frame, // don't dock the window - if (!wxGetKeyState(WXK_CONTROL) && !wxGetKeyState(WXK_ALT)) + if (CanDockPanel(pane)) { // do the drop calculation DoDrop(m_docks, m_panes, pane, client_pt, action_offset); @@ -3184,10 +3784,12 @@ void wxFrameManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir) { pane.floating_pos = pane.frame->GetPosition(); -#if wxCHECK_VERSION(2,7,0) if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG) pane.frame->SetTransparent(255); -#endif + } + else if (m_has_maximized) + { + RestoreMaximizedPane(); } Update(); @@ -3195,25 +3797,25 @@ void wxFrameManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir) HideHint(); } -void wxFrameManager::OnFloatingPaneResized(wxWindow* wnd, const wxSize& size) +void wxAuiManager::OnFloatingPaneResized(wxWindow* wnd, const wxSize& size) { // try to find the pane - wxPaneInfo& pane = GetPane(wnd); + wxAuiPaneInfo& pane = GetPane(wnd); wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); pane.floating_size = size; } -void wxFrameManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt) +void wxAuiManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt) { // try to find the pane - wxPaneInfo& pane = GetPane(wnd); + wxAuiPaneInfo& pane = GetPane(wnd); wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); // fire pane close event - wxFrameManagerEvent e(wxEVT_AUI_PANECLOSE); + wxAuiManagerEvent e(wxEVT_AUI_PANE_CLOSE); e.SetPane(&pane); e.SetCanVeto(evt.CanVeto()); ProcessMgrEvent(e); @@ -3223,21 +3825,26 @@ void wxFrameManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt) evt.Veto(); return; } - else + else { - ClosePane(pane); + // close the pane, but check that it + // still exists in our pane array first + // (the event handler above might have removed it) + + wxAuiPaneInfo& check = GetPane(wnd); + if (check.IsOk()) + { + ClosePane(pane); + } } } -void wxFrameManager::OnFloatingPaneActivated(wxWindow* wnd) +void wxAuiManager::OnFloatingPaneActivated(wxWindow* wnd) { - if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE) + if ((GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE) && GetPane(wnd).IsOk()) { - // try to find the pane - wxASSERT_MSG(GetPane(wnd).IsOk(), wxT("Pane window not found")); - SetActivePane(m_panes, wnd); Repaint(); } @@ -3247,8 +3854,12 @@ void wxFrameManager::OnFloatingPaneActivated(wxWindow* wnd) // backgrounds, captions, grippers, pane borders and buttons. // It renders the entire user interface. -void wxFrameManager::OnRender(wxFrameManagerEvent& evt) +void wxAuiManager::OnRender(wxAuiManagerEvent& evt) { + // if the frame is about to be deleted, don't bother + if (!m_frame || wxPendingDelete.Member(m_frame)) + return; + wxDC* dc = evt.GetDC(); #ifdef __WXMAC__ @@ -3258,31 +3869,31 @@ void wxFrameManager::OnRender(wxFrameManagerEvent& evt) for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i) { - wxDockUIPart& part = m_uiparts.Item(i); + wxAuiDockUIPart& part = m_uiparts.Item(i); - // don't draw hidden pane items - if (part.sizer_item && !part.sizer_item->IsShown()) + // don't draw hidden pane items or items that aren't windows + if (part.sizer_item && ((!part.sizer_item->IsWindow() && !part.sizer_item->IsSpacer() && !part.sizer_item->IsSizer()) || !part.sizer_item->IsShown())) continue; switch (part.type) { - case wxDockUIPart::typeDockSizer: - case wxDockUIPart::typePaneSizer: + case wxAuiDockUIPart::typeDockSizer: + case wxAuiDockUIPart::typePaneSizer: m_art->DrawSash(*dc, m_frame, part.orientation, part.rect); break; - case wxDockUIPart::typeBackground: + case wxAuiDockUIPart::typeBackground: m_art->DrawBackground(*dc, m_frame, part.orientation, part.rect); break; - case wxDockUIPart::typeCaption: + case wxAuiDockUIPart::typeCaption: m_art->DrawCaption(*dc, m_frame, part.pane->caption, part.rect, *part.pane); break; - case wxDockUIPart::typeGripper: + case wxAuiDockUIPart::typeGripper: m_art->DrawGripper(*dc, m_frame, part.rect, *part.pane); break; - case wxDockUIPart::typePaneBorder: + case wxAuiDockUIPart::typePaneBorder: m_art->DrawBorder(*dc, m_frame, part.rect, *part.pane); break; - case wxDockUIPart::typePaneButton: + case wxAuiDockUIPart::typePaneButton: m_art->DrawPaneButton(*dc, m_frame, part.button->button_id, wxAUI_BUTTON_STATE_NORMAL, part.rect, *part.pane); break; @@ -3292,19 +3903,20 @@ void wxFrameManager::OnRender(wxFrameManagerEvent& evt) // Render() fire a render event, which is normally handled by -// wxFrameManager::OnRender(). This allows the render function to +// wxAuiManager::OnRender(). This allows the render function to // be overridden via the render event. This can be useful for paintin // custom graphics in the main window. Default behavior can be // invoked in the overridden function by calling OnRender() -void wxFrameManager::Render(wxDC* dc) +void wxAuiManager::Render(wxDC* dc) { - wxFrameManagerEvent e(wxEVT_AUI_RENDER); + wxAuiManagerEvent e(wxEVT_AUI_RENDER); + e.SetManager(this); e.SetDC(dc); ProcessMgrEvent(e); } -void wxFrameManager::Repaint(wxDC* dc) +void wxAuiManager::Repaint(wxDC* dc) { #ifdef __WXMAC__ if ( dc == NULL ) @@ -3341,13 +3953,13 @@ void wxFrameManager::Repaint(wxDC* dc) delete client_dc; } -void wxFrameManager::OnPaint(wxPaintEvent& WXUNUSED(event)) +void wxAuiManager::OnPaint(wxPaintEvent& WXUNUSED(event)) { wxPaintDC dc(m_frame); Repaint(&dc); } -void wxFrameManager::OnEraseBackground(wxEraseEvent& event) +void wxAuiManager::OnEraseBackground(wxEraseEvent& event) { #ifdef __WXMAC__ event.Skip() ; @@ -3356,31 +3968,63 @@ void wxFrameManager::OnEraseBackground(wxEraseEvent& event) #endif } -void wxFrameManager::OnSize(wxSizeEvent& event) +void wxAuiManager::OnSize(wxSizeEvent& event) { if (m_frame) { DoFrameLayout(); Repaint(); + +#if wxUSE_MDI + if (m_frame->IsKindOf(CLASSINFO(wxMDIParentFrame))) + { + // for MDI parent frames, this event must not + // be "skipped". In other words, the parent frame + // must not be allowed to resize the client window + // after we are finished processing sizing changes + return; + } +#endif } event.Skip(); } +void wxAuiManager::OnFindManager(wxAuiManagerEvent& evt) +{ + // get the window we are managing, if none, return NULL + wxWindow* window = GetManagedWindow(); + if (!window) + { + evt.SetManager(NULL); + return; + } + + // if we are managing a child frame, get the 'real' manager + if (window->IsKindOf(CLASSINFO(wxAuiFloatingFrame))) + { + wxAuiFloatingFrame* float_frame = static_cast(window); + evt.SetManager(float_frame->GetOwnerManager()); + return; + } + + // return pointer to ourself + evt.SetManager(this); +} -void wxFrameManager::OnSetCursor(wxSetCursorEvent& event) +void wxAuiManager::OnSetCursor(wxSetCursorEvent& event) { // determine cursor - wxDockUIPart* part = HitTest(event.GetX(), event.GetY()); + wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY()); wxCursor cursor = wxNullCursor; if (part) { - if (part->type == wxDockUIPart::typeDockSizer || - part->type == wxDockUIPart::typePaneSizer) + if (part->type == wxAuiDockUIPart::typeDockSizer || + part->type == wxAuiDockUIPart::typePaneSizer) { // a dock may not be resized if it has a single // pane which is not resizable - if (part->type == wxDockUIPart::typeDockSizer && part->dock && + if (part->type == wxAuiDockUIPart::typeDockSizer && part->dock && part->dock->panes.GetCount() == 1 && part->dock->panes.Item(0)->IsFixed()) return; @@ -3391,10 +4035,10 @@ void wxFrameManager::OnSetCursor(wxSetCursorEvent& event) if (part->orientation == wxVERTICAL) cursor = wxCursor(wxCURSOR_SIZEWE); - else + else cursor = wxCursor(wxCURSOR_SIZENS); } - else if (part->type == wxDockUIPart::typeGripper) + else if (part->type == wxAuiDockUIPart::typeGripper) { cursor = wxCursor(wxCURSOR_SIZING); } @@ -3405,10 +4049,12 @@ void wxFrameManager::OnSetCursor(wxSetCursorEvent& event) -void wxFrameManager::UpdateButtonOnScreen(wxDockUIPart* button_ui_part, - const wxMouseEvent& event) +void wxAuiManager::UpdateButtonOnScreen(wxAuiDockUIPart* button_ui_part, + const wxMouseEvent& event) { - wxDockUIPart* hit_test = HitTest(event.GetX(), event.GetY()); + wxAuiDockUIPart* hit_test = HitTest(event.GetX(), event.GetY()); + if (!hit_test || !button_ui_part) + return; int state = wxAUI_BUTTON_STATE_NORMAL; @@ -3416,7 +4062,7 @@ void wxFrameManager::UpdateButtonOnScreen(wxDockUIPart* button_ui_part, { if (event.LeftDown()) state = wxAUI_BUTTON_STATE_PRESSED; - else + else state = wxAUI_BUTTON_STATE_HOVER; } else @@ -3434,27 +4080,33 @@ void wxFrameManager::UpdateButtonOnScreen(wxDockUIPart* button_ui_part, if (pt.x != 0 || pt.y != 0) cdc.SetDeviceOrigin(pt.x, pt.y); - m_art->DrawPaneButton(cdc, m_frame, - button_ui_part->button->button_id, - state, - button_ui_part->rect, - *hit_test->pane); + if (hit_test->pane) + { + m_art->DrawPaneButton(cdc, m_frame, + button_ui_part->button->button_id, + state, + button_ui_part->rect, + *hit_test->pane); + } } -void wxFrameManager::OnLeftDown(wxMouseEvent& event) +void wxAuiManager::OnLeftDown(wxMouseEvent& event) { - wxDockUIPart* part = HitTest(event.GetX(), event.GetY()); + m_currentDragItem = -1; + + wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY()); if (part) { - if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER) - return; - - if (part->type == wxDockUIPart::typeDockSizer || - part->type == wxDockUIPart::typePaneSizer) + if (part->type == wxAuiDockUIPart::typeDockSizer || + part->type == wxAuiDockUIPart::typePaneSizer) { + // Removing this restriction so that a centre pane can be resized + //if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER) + // return; + // a dock may not be resized if it has a single // pane which is not resizable - if (part->type == wxDockUIPart::typeDockSizer && part->dock && + if (part->type == wxAuiDockUIPart::typeDockSizer && part->dock && part->dock->panes.GetCount() == 1 && part->dock->panes.Item(0)->IsFixed()) return; @@ -3471,7 +4123,7 @@ void wxFrameManager::OnLeftDown(wxMouseEvent& event) event.m_y - part->rect.y); m_frame->CaptureMouse(); } - else if (part->type == wxDockUIPart::typePaneButton) + else if (part->type == wxAuiDockUIPart::typePaneButton) { m_action = actionClickButton; m_action_part = part; @@ -3480,9 +4132,29 @@ void wxFrameManager::OnLeftDown(wxMouseEvent& event) UpdateButtonOnScreen(part, event); } - else if (part->type == wxDockUIPart::typeCaption || - part->type == wxDockUIPart::typeGripper) + else if (part->type == wxAuiDockUIPart::typeCaption || + part->type == wxAuiDockUIPart::typeGripper) { + // if we are managing a wxAuiFloatingFrame window, then + // we are an embedded wxAuiManager inside the wxAuiFloatingFrame. + // We want to initiate a toolbar drag in our owner manager + wxWindow* managed_wnd = GetManagedWindow(); + + if (part->pane && + part->pane->window && + managed_wnd && + managed_wnd->IsKindOf(CLASSINFO(wxAuiFloatingFrame))) + { + wxAuiFloatingFrame* floating_frame = (wxAuiFloatingFrame*)managed_wnd; + wxAuiManager* owner_mgr = floating_frame->GetOwnerManager(); + owner_mgr->StartPaneDrag(part->pane->window, + wxPoint(event.m_x - part->rect.x, + event.m_y - part->rect.y)); + return; + } + + + if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE) { // set the caption as active @@ -3490,6 +4162,9 @@ void wxFrameManager::OnLeftDown(wxMouseEvent& event) Repaint(); } + if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER) + return; + m_action = actionClickCaption; m_action_part = part; m_action_start = wxPoint(event.m_x, event.m_y); @@ -3514,211 +4189,310 @@ void wxFrameManager::OnLeftDown(wxMouseEvent& event) #endif } - -void wxFrameManager::OnLeftUp(wxMouseEvent& event) +/// Ends a resize action, or for live update, resizes the sash +bool wxAuiManager::DoEndResizeAction(wxMouseEvent& event) { - if (m_action == actionResize) + // resize the dock or the pane + if (m_action_part && m_action_part->type==wxAuiDockUIPart::typeDockSizer) { - m_frame->ReleaseMouse(); + // first, we must calculate the maximum size the dock may be + int sash_size = m_art->GetMetric(wxAUI_DOCKART_SASH_SIZE); + + int used_width = 0, used_height = 0; - // get rid of the hint rectangle - wxScreenDC dc; - DrawResizeHint(dc, m_action_hintrect); + wxSize client_size = m_frame->GetClientSize(); - // resize the dock or the pane - if (m_action_part && m_action_part->type==wxDockUIPart::typeDockSizer) + size_t dock_i, dock_count = m_docks.GetCount(); + for (dock_i = 0; dock_i < dock_count; ++dock_i) { - wxRect& rect = m_action_part->dock->rect; + wxAuiDockInfo& dock = m_docks.Item(dock_i); + if (dock.dock_direction == wxAUI_DOCK_TOP || + dock.dock_direction == wxAUI_DOCK_BOTTOM) + { + used_height += dock.size; + } + if (dock.dock_direction == wxAUI_DOCK_LEFT || + dock.dock_direction == wxAUI_DOCK_RIGHT) + { + used_width += dock.size; + } + if (dock.resizable) + used_width += sash_size; + } + + + int available_width = client_size.GetWidth() - used_width; + int available_height = client_size.GetHeight() - used_height; - wxPoint new_pos(event.m_x - m_action_offset.x, - event.m_y - m_action_offset.y); - switch (m_action_part->dock->dock_direction) +#if wxUSE_STATUSBAR + // if there's a status control, the available + // height decreases accordingly + if (m_frame && m_frame->IsKindOf(CLASSINFO(wxFrame))) + { + wxFrame* frame = static_cast(m_frame); + wxStatusBar* status = frame->GetStatusBar(); + if (status) { - case wxAUI_DOCK_LEFT: - m_action_part->dock->size = new_pos.x - rect.x; - break; - case wxAUI_DOCK_TOP: - m_action_part->dock->size = new_pos.y - rect.y; - break; - case wxAUI_DOCK_RIGHT: - m_action_part->dock->size = rect.x + rect.width - - new_pos.x - m_action_part->rect.GetWidth(); - break; - case wxAUI_DOCK_BOTTOM: - m_action_part->dock->size = rect.y + rect.height - - new_pos.y - m_action_part->rect.GetHeight(); - break; + wxSize status_client_size = status->GetClientSize(); + available_height -= status_client_size.GetHeight(); } - - Update(); - Repaint(NULL); } - else if (m_action_part && - m_action_part->type == wxDockUIPart::typePaneSizer) +#endif + + wxRect& rect = m_action_part->dock->rect; + + wxPoint new_pos(event.m_x - m_action_offset.x, + event.m_y - m_action_offset.y); + int new_size, old_size = m_action_part->dock->size; + + switch (m_action_part->dock->dock_direction) { - wxDockInfo& dock = *m_action_part->dock; - wxPaneInfo& pane = *m_action_part->pane; + case wxAUI_DOCK_LEFT: + new_size = new_pos.x - rect.x; + if (new_size-old_size > available_width) + new_size = old_size+available_width; + m_action_part->dock->size = new_size; + break; + case wxAUI_DOCK_TOP: + new_size = new_pos.y - rect.y; + if (new_size-old_size > available_height) + new_size = old_size+available_height; + m_action_part->dock->size = new_size; + break; + case wxAUI_DOCK_RIGHT: + new_size = rect.x + rect.width - new_pos.x - + m_action_part->rect.GetWidth(); + if (new_size-old_size > available_width) + new_size = old_size+available_width; + m_action_part->dock->size = new_size; + break; + case wxAUI_DOCK_BOTTOM: + new_size = rect.y + rect.height - + new_pos.y - m_action_part->rect.GetHeight(); + if (new_size-old_size > available_height) + new_size = old_size+available_height; + m_action_part->dock->size = new_size; + break; + } - int total_proportion = 0; - int dock_pixels = 0; - int new_pixsize = 0; + Update(); + Repaint(NULL); + } + else if (m_action_part && + m_action_part->type == wxAuiDockUIPart::typePaneSizer) + { + wxAuiDockInfo& dock = *m_action_part->dock; + wxAuiPaneInfo& pane = *m_action_part->pane; - int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE); - int pane_border_size = m_art->GetMetric(wxAUI_ART_PANE_BORDER_SIZE); - int sash_size = m_art->GetMetric(wxAUI_ART_SASH_SIZE); + int total_proportion = 0; + int dock_pixels = 0; + int new_pixsize = 0; - wxPoint new_pos(event.m_x - m_action_offset.x, - event.m_y - m_action_offset.y); + int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE); + int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE); + int sash_size = m_art->GetMetric(wxAUI_DOCKART_SASH_SIZE); - // determine the pane rectangle by getting the pane part - wxDockUIPart* pane_part = GetPanePart(pane.window); - wxASSERT_MSG(pane_part, - wxT("Pane border part not found -- shouldn't happen")); + wxPoint new_pos(event.m_x - m_action_offset.x, + event.m_y - m_action_offset.y); - // determine the new pixel size that the user wants; - // this will help us recalculate the pane's proportion - if (dock.IsHorizontal()) - new_pixsize = new_pos.x - pane_part->rect.x; - else - new_pixsize = new_pos.y - pane_part->rect.y; + // determine the pane rectangle by getting the pane part + wxAuiDockUIPart* pane_part = GetPanePart(pane.window); + wxASSERT_MSG(pane_part, + wxT("Pane border part not found -- shouldn't happen")); - // determine the size of the dock, based on orientation - if (dock.IsHorizontal()) - dock_pixels = dock.rect.GetWidth(); - else - dock_pixels = dock.rect.GetHeight(); + // determine the new pixel size that the user wants; + // this will help us recalculate the pane's proportion + if (dock.IsHorizontal()) + new_pixsize = new_pos.x - pane_part->rect.x; + else + new_pixsize = new_pos.y - pane_part->rect.y; - // determine the total proportion of all resizable panes, - // and the total size of the dock minus the size of all - // the fixed panes - int i, dock_pane_count = dock.panes.GetCount(); - int pane_position = -1; - for (i = 0; i < dock_pane_count; ++i) + // determine the size of the dock, based on orientation + if (dock.IsHorizontal()) + dock_pixels = dock.rect.GetWidth(); + else + dock_pixels = dock.rect.GetHeight(); + + // determine the total proportion of all resizable panes, + // and the total size of the dock minus the size of all + // the fixed panes + int i, dock_pane_count = dock.panes.GetCount(); + int pane_position = -1; + for (i = 0; i < dock_pane_count; ++i) + { + wxAuiPaneInfo& p = *dock.panes.Item(i); + if (p.window == pane.window) + pane_position = i; + + // while we're at it, subtract the pane sash + // width from the dock width, because this would + // skew our proportion calculations + if (i > 0) + dock_pixels -= sash_size; + + // also, the whole size (including decorations) of + // all fixed panes must also be subtracted, because they + // are not part of the proportion calculation + if (p.IsFixed()) { - wxPaneInfo& p = *dock.panes.Item(i); - if (p.window == pane.window) - pane_position = i; - - // while we're at it, subtract the pane sash - // width from the dock width, because this would - // skew our proportion calculations - if (i > 0) - dock_pixels -= sash_size; - - // also, the whole size (including decorations) of - // all fixed panes must also be subtracted, because they - // are not part of the proportion calculation - if (p.IsFixed()) - { - if (dock.IsHorizontal()) - dock_pixels -= p.best_size.x; - else - dock_pixels -= p.best_size.y; - } - else - { - total_proportion += p.dock_proportion; - } + if (dock.IsHorizontal()) + dock_pixels -= p.best_size.x; + else + dock_pixels -= p.best_size.y; } - - // find a pane in our dock to 'steal' space from or to 'give' - // space to -- this is essentially what is done when a pane is - // resized; the pane should usually be the first non-fixed pane - // to the right of the action pane - int borrow_pane = -1; - for (i = pane_position+1; i < dock_pane_count; ++i) + else { - wxPaneInfo& p = *dock.panes.Item(i); - if (!p.IsFixed()) - { - borrow_pane = i; - break; - } + total_proportion += p.dock_proportion; } + } + // new size can never be more than the number of dock pixels + if (new_pixsize > dock_pixels) + new_pixsize = dock_pixels; - // demand that the pane being resized is found in this dock - // (this assert really never should be raised) - wxASSERT_MSG(pane_position != -1, wxT("Pane not found in dock")); - // prevent division by zero - if (dock_pixels == 0 || total_proportion == 0 || borrow_pane == -1) + // find a pane in our dock to 'steal' space from or to 'give' + // space to -- this is essentially what is done when a pane is + // resized; the pane should usually be the first non-fixed pane + // to the right of the action pane + int borrow_pane = -1; + for (i = pane_position+1; i < dock_pane_count; ++i) + { + wxAuiPaneInfo& p = *dock.panes.Item(i); + if (!p.IsFixed()) { - m_action = actionNone; - return; + borrow_pane = i; + break; } + } - // calculate the new proportion of the pane - int new_proportion = (new_pixsize*total_proportion)/dock_pixels; - // default minimum size - int min_size = 0; + // demand that the pane being resized is found in this dock + // (this assert really never should be raised) + wxASSERT_MSG(pane_position != -1, wxT("Pane not found in dock")); - // check against the pane's minimum size, if specified. please note - // that this is not enough to ensure that the minimum size will - // not be violated, because the whole frame might later be shrunk, - // causing the size of the pane to violate it's minimum size - if (pane.min_size.IsFullySpecified()) - { - min_size = 0; + // prevent division by zero + if (dock_pixels == 0 || total_proportion == 0 || borrow_pane == -1) + { + m_action = actionNone; + return false; + } - if (pane.HasBorder()) - min_size += (pane_border_size*2); + // calculate the new proportion of the pane + int new_proportion = (new_pixsize*total_proportion)/dock_pixels; - // calculate minimum size with decorations (border,caption) - if (pane_part->orientation == wxVERTICAL) - { - min_size += pane.min_size.y; - if (pane.HasCaption()) - min_size += caption_size; - } - else - { - min_size += pane.min_size.x; - } + // default minimum size + int min_size = 0; + + // check against the pane's minimum size, if specified. please note + // that this is not enough to ensure that the minimum size will + // not be violated, because the whole frame might later be shrunk, + // causing the size of the pane to violate it's minimum size + if (pane.min_size.IsFullySpecified()) + { + min_size = 0; + + if (pane.HasBorder()) + min_size += (pane_border_size*2); + + // calculate minimum size with decorations (border,caption) + if (pane_part->orientation == wxVERTICAL) + { + min_size += pane.min_size.y; + if (pane.HasCaption()) + min_size += caption_size; + } + else + { + min_size += pane.min_size.x; } + } - // for some reason, an arithmatic error somewhere is causing - // the proportion calculations to always be off by 1 pixel; - // for now we will add the 1 pixel on, but we really should - // determine what's causing this. - min_size++; + // for some reason, an arithmatic error somewhere is causing + // the proportion calculations to always be off by 1 pixel; + // for now we will add the 1 pixel on, but we really should + // determine what's causing this. + min_size++; - int min_proportion = (min_size*total_proportion)/dock_pixels; + int min_proportion = (min_size*total_proportion)/dock_pixels; - if (new_proportion < min_proportion) - new_proportion = min_proportion; + if (new_proportion < min_proportion) + new_proportion = min_proportion; - int prop_diff = new_proportion - pane.dock_proportion; + int prop_diff = new_proportion - pane.dock_proportion; - // borrow the space from our neighbor pane to the - // right or bottom (depending on orientation) - dock.panes.Item(borrow_pane)->dock_proportion -= prop_diff; - pane.dock_proportion = new_proportion; + // borrow the space from our neighbor pane to the + // right or bottom (depending on orientation); + // also make sure we don't make the neighbor too small + int prop_borrow = dock.panes.Item(borrow_pane)->dock_proportion; - // repaint - Update(); - Repaint(NULL); + if (prop_borrow - prop_diff < 0) + { + // borrowing from other pane would make it too small, + // so cancel the resize operation + prop_borrow = min_proportion; + } + else + { + prop_borrow -= prop_diff; + } + + + dock.panes.Item(borrow_pane)->dock_proportion = prop_borrow; + pane.dock_proportion = new_proportion; + + + // repaint + Update(); + Repaint(NULL); + } + + return true; +} + +void wxAuiManager::OnLeftUp(wxMouseEvent& event) +{ + if (m_action == actionResize) + { + m_frame->ReleaseMouse(); + + if (!wxAuiManager_HasLiveResize(*this)) + { + // get rid of the hint rectangle + wxScreenDC dc; + DrawResizeHint(dc, m_action_hintrect); } + if (m_currentDragItem != -1 && wxAuiManager_HasLiveResize(*this)) + m_action_part = & (m_uiparts.Item(m_currentDragItem)); + + DoEndResizeAction(event); + + m_currentDragItem = -1; + } else if (m_action == actionClickButton) { m_hover_button = NULL; m_frame->ReleaseMouse(); - UpdateButtonOnScreen(m_action_part, event); - // make sure we're still over the item that was originally clicked - if (m_action_part == HitTest(event.GetX(), event.GetY())) + if (m_action_part) { - // fire button-click event - wxFrameManagerEvent e(wxEVT_AUI_PANEBUTTON); - e.SetPane(m_action_part->pane); - e.SetButton(m_action_part->button->button_id); - ProcessMgrEvent(e); + UpdateButtonOnScreen(m_action_part, event); + + // make sure we're still over the item that was originally clicked + if (m_action_part == HitTest(event.GetX(), event.GetY())) + { + // fire button-click event + wxAuiManagerEvent e(wxEVT_AUI_PANE_BUTTON); + e.SetManager(this); + e.SetPane(m_action_part->pane); + e.SetButton(m_action_part->button->button_id); + ProcessMgrEvent(e); + } } } else if (m_action == actionClickCaption) @@ -3733,16 +4507,16 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event) { m_frame->ReleaseMouse(); - wxPaneInfo& pane = GetPane(m_action_window); + wxAuiPaneInfo& pane = GetPane(m_action_window); wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); // save the new positions - wxDockInfoPtrArray docks; + wxAuiDockInfoPtrArray docks; FindDocks(m_docks, pane.dock_direction, pane.dock_layer, pane.dock_row, docks); if (docks.GetCount() == 1) { - wxDockInfo& dock = *docks.Item(0); + wxAuiDockInfo& dock = *docks.Item(0); wxArrayInt pane_positions, pane_sizes; GetPanePositionsAndSizes(dock, pane_positions, pane_sizes); @@ -3752,7 +4526,7 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event) dock.panes.Item(i)->dock_pos = pane_positions[i]; } - pane.state &= ~wxPaneInfo::actionPane; + pane.state &= ~wxAuiPaneInfo::actionPane; Update(); } else @@ -3765,7 +4539,7 @@ void wxFrameManager::OnLeftUp(wxMouseEvent& event) } -void wxFrameManager::OnMotion(wxMouseEvent& event) +void wxAuiManager::OnMotion(wxMouseEvent& event) { // sometimes when Update() is called from inside this method, // a spurious mouse move event is generated; this check will make @@ -3781,20 +4555,49 @@ void wxFrameManager::OnMotion(wxMouseEvent& event) if (m_action == actionResize) { - wxPoint pos = m_action_part->rect.GetPosition(); - if (m_action_part->orientation == wxHORIZONTAL) - pos.y = wxMax(0, event.m_y - m_action_offset.y); - else - pos.x = wxMax(0, event.m_x - m_action_offset.x); + // It's necessary to reset m_action_part since it destroyed + // by the Update within DoEndResizeAction. + if (m_currentDragItem != -1) + m_action_part = & (m_uiparts.Item(m_currentDragItem)); + else + m_currentDragItem = m_uiparts.Index(* m_action_part); - wxRect rect(m_frame->ClientToScreen(pos), + if (m_action_part) + { + wxPoint pos = m_action_part->rect.GetPosition(); + if (m_action_part->orientation == wxHORIZONTAL) + pos.y = wxMax(0, event.m_y - m_action_offset.y); + else + pos.x = wxMax(0, event.m_x - m_action_offset.x); + + if (wxAuiManager_HasLiveResize(*this)) + { + m_frame->ReleaseMouse(); + DoEndResizeAction(event); + m_frame->CaptureMouse(); + } + else + { + wxRect rect(m_frame->ClientToScreen(pos), m_action_part->rect.GetSize()); + wxScreenDC dc; - wxScreenDC dc; - if (!m_action_hintrect.IsEmpty()) - DrawResizeHint(dc, m_action_hintrect); - DrawResizeHint(dc, rect); - m_action_hintrect = rect; + if (!m_action_hintrect.IsEmpty()) + { + // remove old resize hint + DrawResizeHint(dc, m_action_hintrect); + m_action_hintrect = wxRect(); + } + + // draw new resize hint, if it's inside the managed frame + wxRect frame_screen_rect = m_frame->GetScreenRect(); + if (frame_screen_rect.Contains(rect)) + { + DrawResizeHint(dc, rect); + m_action_hintrect = rect; + } + } + } } else if (m_action == actionClickCaption) { @@ -3804,10 +4607,11 @@ void wxFrameManager::OnMotion(wxMouseEvent& event) // caption has been clicked. we need to check if the mouse // is now being dragged. if it is, we need to change the // mouse action to 'drag' - if (abs(event.m_x - m_action_start.x) > drag_x_threshold || - abs(event.m_y - m_action_start.y) > drag_y_threshold) + if (m_action_part && + (abs(event.m_x - m_action_start.x) > drag_x_threshold || + abs(event.m_y - m_action_start.y) > drag_y_threshold)) { - wxPaneInfo* pane_info = m_action_part->pane; + wxAuiPaneInfo* pane_info = m_action_part->pane; if (!pane_info->IsToolbar()) { @@ -3820,7 +4624,10 @@ void wxFrameManager::OnMotion(wxMouseEvent& event) wxPoint pt = m_frame->ClientToScreen(event.GetPosition()); pane_info->floating_pos = wxPoint(pt.x - m_action_offset.x, pt.y - m_action_offset.y); + // float the window + if (pane_info->IsMaximized()) + RestorePane(*pane_info); pane_info->Float(); Update(); @@ -3836,7 +4643,7 @@ void wxFrameManager::OnMotion(wxMouseEvent& event) m_action_offset.x = 30; } } - else + else { m_action = actionDragToolbarPane; m_action_window = pane_info->window; @@ -3845,16 +4652,19 @@ void wxFrameManager::OnMotion(wxMouseEvent& event) } else if (m_action == actionDragFloatingPane) { - wxPoint pt = m_frame->ClientToScreen(event.GetPosition()); - m_action_window->Move(pt.x - m_action_offset.x, - pt.y - m_action_offset.y); + if (m_action_window) + { + wxPoint pt = m_frame->ClientToScreen(event.GetPosition()); + m_action_window->Move(pt.x - m_action_offset.x, + pt.y - m_action_offset.y); + } } else if (m_action == actionDragToolbarPane) { - wxPaneInfo& pane = GetPane(m_action_window); + wxAuiPaneInfo& pane = GetPane(m_action_window); wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); - pane.state |= wxPaneInfo::actionPane; + pane.SetFlag(wxAuiPaneInfo::actionPane, true); wxPoint pt = event.GetPosition(); DoDrop(m_docks, m_panes, pane, pt, m_action_offset); @@ -3879,36 +4689,40 @@ void wxFrameManager::OnMotion(wxMouseEvent& event) // EVT_MOTION() events will move the floating pane if (pane.IsFloating()) { - pane.state &= ~wxPaneInfo::actionPane; + pane.state &= ~wxAuiPaneInfo::actionPane; m_action = actionDragFloatingPane; m_action_window = pane.frame; } } else { - wxDockUIPart* part = HitTest(event.GetX(), event.GetY()); - if (part && part->type == wxDockUIPart::typePaneButton) + wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY()); + if (part && part->type == wxAuiDockUIPart::typePaneButton) { if (part != m_hover_button) { // make the old button normal if (m_hover_button) + { UpdateButtonOnScreen(m_hover_button, event); + Repaint(); + } // mouse is over a button, so repaint the // button in hover mode UpdateButtonOnScreen(part, event); m_hover_button = part; + } } - else + else { if (m_hover_button) { m_hover_button = NULL; Repaint(); } - else + else { event.Skip(); } @@ -3916,7 +4730,7 @@ void wxFrameManager::OnMotion(wxMouseEvent& event) } } -void wxFrameManager::OnLeaveWindow(wxMouseEvent& WXUNUSED(event)) +void wxAuiManager::OnLeaveWindow(wxMouseEvent& WXUNUSED(event)) { if (m_hover_button) { @@ -3925,14 +4739,25 @@ void wxFrameManager::OnLeaveWindow(wxMouseEvent& WXUNUSED(event)) } } -void wxFrameManager::OnChildFocus(wxChildFocusEvent& event) +void wxAuiManager::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event)) +{ + // cancel the operation in progress, if any + if ( m_action != actionNone ) + { + m_action = actionNone; + HideHint(); + } +} + +void wxAuiManager::OnChildFocus(wxChildFocusEvent& event) { // when a child pane has it's focus set, we should change the // pane's active state to reflect this. (this is only true if // active panes are allowed by the owner) if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE) { - if (GetPane(event.GetWindow()).IsOk()) + wxAuiPaneInfo& pane = GetPane(event.GetWindow()); + if (pane.IsOk() && (pane.state & wxAuiPaneInfo::optionActive) == 0) { SetActivePane(m_panes, event.GetWindow()); m_frame->Refresh(); @@ -3945,26 +4770,64 @@ void wxFrameManager::OnChildFocus(wxChildFocusEvent& event) // OnPaneButton() is an event handler that is called // when a pane button has been pressed. -void wxFrameManager::OnPaneButton(wxFrameManagerEvent& evt) +void wxAuiManager::OnPaneButton(wxAuiManagerEvent& evt) { - wxASSERT_MSG(evt.pane, wxT("Pane Info passed to wxFrameManager::OnPaneButton must be non-null")); + wxASSERT_MSG(evt.pane, wxT("Pane Info passed to wxAuiManager::OnPaneButton must be non-null")); - wxPaneInfo& pane = *(evt.pane); + wxAuiPaneInfo& pane = *(evt.pane); if (evt.button == wxAUI_BUTTON_CLOSE) { // fire pane close event - wxFrameManagerEvent e(wxEVT_AUI_PANECLOSE); + wxAuiManagerEvent e(wxEVT_AUI_PANE_CLOSE); + e.SetManager(this); e.SetPane(evt.pane); ProcessMgrEvent(e); if (!e.GetVeto()) { - ClosePane(pane); + // close the pane, but check that it + // still exists in our pane array first + // (the event handler above might have removed it) + + wxAuiPaneInfo& check = GetPane(pane.window); + if (check.IsOk()) + { + ClosePane(pane); + } + + Update(); + } + } + else if (evt.button == wxAUI_BUTTON_MAXIMIZE_RESTORE && !pane.IsMaximized()) + { + // fire pane close event + wxAuiManagerEvent e(wxEVT_AUI_PANE_MAXIMIZE); + e.SetManager(this); + e.SetPane(evt.pane); + ProcessMgrEvent(e); + + if (!e.GetVeto()) + { + MaximizePane(pane); + Update(); + } + } + else if (evt.button == wxAUI_BUTTON_MAXIMIZE_RESTORE && pane.IsMaximized()) + { + // fire pane close event + wxAuiManagerEvent e(wxEVT_AUI_PANE_RESTORE); + e.SetManager(this); + e.SetPane(evt.pane); + ProcessMgrEvent(e); + + if (!e.GetVeto()) + { + RestorePane(pane); Update(); } } - else if (evt.button == wxAUI_BUTTON_PIN) + else if (evt.button == wxAUI_BUTTON_PIN) { if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) && pane.IsFloatable())