X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/479574aab29e0eaad7dea401fcf0792effd32e01..67afffcd05e53e20503b7b64215b6c272ac75e47:/src/aui/framemanager.cpp diff --git a/src/aui/framemanager.cpp b/src/aui/framemanager.cpp index 6009b040d8..20e654791a 100644 --- a/src/aui/framemanager.cpp +++ b/src/aui/framemanager.cpp @@ -4,7 +4,6 @@ // Author: Benjamin I. Williams // Modified by: // Created: 2005-05-17 -// RCS-ID: $Id$ // Copyright: (C) Copyright 2005-2006, Kirix Corporation, All Rights Reserved // Licence: wxWindows Library Licence, Version 3.1 /////////////////////////////////////////////////////////////////////////////// @@ -29,6 +28,8 @@ #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" @@ -37,8 +38,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") @@ -53,18 +54,25 @@ WX_DEFINE_OBJARRAY(wxAuiPaneInfoArray) wxAuiPaneInfo wxAuiNullPaneInfo; wxAuiDockInfo wxAuiNullDockInfo; -DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_BUTTON) -DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_CLOSE) -DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_MAXIMIZE) -DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_RESTORE) -DEFINE_EVENT_TYPE(wxEVT_AUI_RENDER) -DEFINE_EVENT_TYPE(wxEVT_AUI_FIND_MANAGER) +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_PANE_ACTIVATED, 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(wxAuiManagerEvent, wxEvent) @@ -74,6 +82,8 @@ IMPLEMENT_CLASS(wxAuiManager, wxEvtHandler) const int auiToolBarLayer = 10; +#ifndef __WXGTK20__ + class wxPseudoTransparentFrame : public wxFrame { @@ -88,44 +98,44 @@ public: : wxFrame(parent, id, title, pos, size, style | wxFRAME_SHAPED, name) { SetBackgroundStyle(wxBG_STYLE_CUSTOM); - m_Amount=0; - m_MaxWidth=0; - m_MaxHeight=0; + m_amount=0; + m_maxWidth=0; + m_maxHeight=0; m_lastWidth=0; m_lastHeight=0; #ifdef __WXGTK__ - m_CanSetShape = false; // have to wait for window create event on GTK + m_canSetShape = false; // have to wait for window create event on GTK #else - m_CanSetShape = true; + m_canSetShape = true; #endif - m_Region = wxRegion(0, 0, 0, 0); + m_region = wxRegion(0, 0, 0, 0); SetTransparent(0); } virtual bool SetTransparent(wxByte alpha) { - if (m_CanSetShape) + if (m_canSetShape) { int w=100; // some defaults int h=100; GetClientSize(&w, &h); - m_MaxWidth = w; - m_MaxHeight = h; - m_Amount = alpha; - m_Region.Clear(); -// m_Region.Union(0, 0, 1, m_MaxWidth); - if (m_Amount) + m_maxWidth = w; + m_maxHeight = h; + m_amount = alpha; + m_region.Clear(); +// m_region.Union(0, 0, 1, m_maxWidth); + if (m_amount) { - for (int y=0; y +#include "wx/gtk/private/gtk2-compat.h" + +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; yAddChild(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() @@ -223,10 +313,15 @@ 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 } @@ -430,34 +525,53 @@ static void RemovePaneFromDocks(wxAuiDockInfoArray& docks, } } +/* +// 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(wxAuiDockInfoPtrArray& docks) { - int i, dock_count, j, pane_count; + int i, dock_count; for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++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(wxAuiPaneInfoArray& panes, wxWindow* active_pane) +void wxAuiManager::SetActivePane(wxWindow* active_pane) { int i, pane_count; - for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i) + wxAuiPaneInfo* active_paneinfo = NULL; + for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) { - wxAuiPaneInfo& pane = panes.Item(i); + wxAuiPaneInfo& pane = m_panes.Item(i); pane.state &= ~wxAuiPaneInfo::optionActive; if (pane.window == active_pane) + { pane.state |= wxAuiPaneInfo::optionActive; + active_paneinfo = &pane; + } + } + + // send the 'activated' event after all panes have been updated + if ( active_paneinfo ) + { + wxAuiManagerEvent evt(wxEVT_AUI_PANE_ACTIVATED); + evt.SetManager(this); + evt.SetPane(active_paneinfo); + ProcessMgrEvent(evt); } } @@ -469,6 +583,15 @@ static int PaneSortFunc(wxAuiPaneInfo** p1, wxAuiPaneInfo** p2) } +bool wxAuiPaneInfo::IsValid() const +{ + // Should this RTTI and function call be rewritten as + // sending a new event type to allow other window types + // to check the pane settings? + wxAuiToolBar* toolbar = wxDynamicCast(window, wxAuiToolBar); + return !toolbar || toolbar->IsPaneValid(*this); +} + // -- wxAuiManager class implementation -- @@ -483,26 +606,28 @@ BEGIN_EVENT_TABLE(wxAuiManager, wxEvtHandler) 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) - EVT_TIMER(101, wxAuiManager::OnHintFadeTimer) END_EVENT_TABLE() wxAuiManager::wxAuiManager(wxWindow* managed_wnd, unsigned int flags) { m_action = actionNone; - m_last_mouse_move = wxPoint(); - m_hover_button = NULL; + m_actionWindow = NULL; + m_lastMouseMove = wxPoint(); + m_hoverButton = NULL; m_art = new wxAuiDefaultDockArt; - m_hint_wnd = NULL; + m_hintWnd = NULL; m_flags = flags; m_skipping = false; - m_has_maximized = false; + m_hasMaximized = false; m_frame = NULL; - m_dock_constraint_x = 0.3; - m_dock_constraint_y = 0.3; + m_dockConstraintX = 0.3; + m_dockConstraintY = 0.3; m_reserved = NULL; + m_currentDragItem = -1; if (managed_wnd) { @@ -512,21 +637,34 @@ wxAuiManager::wxAuiManager(wxWindow* managed_wnd, unsigned int flags) 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 wxAuiFloatingFrame* wxAuiManager::CreateFloatingFrame(wxWindow* parent, - const wxAuiPaneInfo& pane_info) + const wxAuiPaneInfo& paneInfo) +{ + return new wxAuiFloatingFrame(parent, this, paneInfo); +} + +bool wxAuiManager::CanDockPanel(const wxAuiPaneInfo & WXUNUSED(p)) { - return new wxAuiFloatingFrame(parent, this, pane_info); + // 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 wxAuiPaneInfo structure based @@ -578,9 +716,9 @@ wxAuiDockUIPart* wxAuiManager::HitTest(int x, int y) wxAuiDockUIPart* result = NULL; int i, part_count; - for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i) + for (i = 0, part_count = m_uiParts.GetCount(); i < part_count; ++i) { - wxAuiDockUIPart* 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; @@ -632,6 +770,18 @@ 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 @@ -656,7 +806,7 @@ wxAuiManager* wxAuiManager::GetManager(wxWindow* window) wxAuiManagerEvent evt(wxEVT_AUI_FIND_MANAGER); evt.SetManager(NULL); evt.ResumePropagation(wxEVENT_PROPAGATE_MAX); - if (!window->ProcessEvent(evt)) + if (!window->GetEventHandler()->ProcessEvent(evt)) return NULL; return evt.GetManager(); @@ -665,16 +815,17 @@ wxAuiManager* wxAuiManager::GetManager(wxWindow* window) void wxAuiManager::UpdateHintWindowConfig() { - // find out if the the system can do transparent frames + // find out if the system can do transparent frames bool can_do_transparent = false; wxWindow* w = m_frame; while (w) { - if (w->IsKindOf(CLASSINFO(wxFrame))) + if (wxDynamicCast(w, wxFrame)) { wxFrame* f = static_cast(w); can_do_transparent = f->CanSetTransparent(); + break; } @@ -682,37 +833,39 @@ void wxAuiManager::UpdateHintWindowConfig() } // if there is an existing hint window, delete it - if (m_hint_wnd) + if (m_hintWnd) { - m_hint_wnd->Destroy(); - m_hint_wnd = NULL; + m_hintWnd->Destroy(); + m_hintWnd = NULL; } - m_hint_fademax = 50; - m_hint_wnd = NULL; + m_hintFadeMax = 50; + m_hintWnd = 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, + m_hintWnd = new wxFrame(m_frame, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(1,1), wxFRAME_TOOL_WINDOW | wxFRAME_FLOAT_ON_PARENT | wxFRAME_NO_TASKBAR | wxNO_BORDER); - m_hint_wnd->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_ACTIVECAPTION)); + m_hintWnd->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_ACTIVECAPTION)); #elif defined(__WXMAC__) // Using a miniframe with float and tool styles keeps the parent // frame activated and highlighted as such... - m_hint_wnd = new wxMiniFrame(m_frame, wxID_ANY, wxEmptyString, + m_hintWnd = new wxMiniFrame(m_frame, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(1,1), wxFRAME_FLOAT_ON_PARENT | wxFRAME_TOOL_WINDOW ); + m_hintWnd->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); + wxPanel* p = new wxPanel(m_hintWnd); // The default wxSYS_COLOUR_ACTIVECAPTION colour is a light silver // color that is really hard to see, especially transparent. @@ -729,7 +882,7 @@ void wxAuiManager::UpdateHintWindowConfig() { // system can't support transparent fade, or the venetian // blinds effect was explicitly requested - m_hint_wnd = new wxPseudoTransparentFrame(m_frame, + m_hintWnd = new wxPseudoTransparentFrame(m_frame, wxID_ANY, wxEmptyString, wxDefaultPosition, @@ -738,7 +891,7 @@ void wxAuiManager::UpdateHintWindowConfig() wxFRAME_FLOAT_ON_PARENT | wxFRAME_NO_TASKBAR | wxNO_BORDER); - m_hint_fademax = 128; + m_hintFadeMax = 128; } } } @@ -759,7 +912,7 @@ void wxAuiManager::SetManagedWindow(wxWindow* wnd) // we need to add the MDI client window as the default // center pane - if (m_frame->IsKindOf(CLASSINFO(wxMDIParentFrame))) + if (wxDynamicCast(m_frame, wxMDIParentFrame)) { wxMDIParentFrame* mdi_frame = (wxMDIParentFrame*)m_frame; wxWindow* client_window = mdi_frame->GetClientWindow(); @@ -770,7 +923,7 @@ void wxAuiManager::SetManagedWindow(wxWindow* wnd) wxAuiPaneInfo().Name(wxT("mdiclient")). CenterPane().PaneBorder(false)); } - else if (m_frame->IsKindOf(CLASSINFO(wxAuiMDIParentFrame))) + else if (wxDynamicCast(m_frame, wxAuiMDIParentFrame)) { wxAuiMDIParentFrame* mdi_frame = (wxAuiMDIParentFrame*)m_frame; wxAuiMDIClientWindow* client_window = mdi_frame->GetClientWindow(); @@ -814,7 +967,7 @@ 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; } @@ -836,30 +989,65 @@ void wxAuiManager::SetArtProvider(wxAuiDockArt* art_provider) } -bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info) +bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& paneInfo) { + 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 window is already managed by us - if (GetPane(pane_info.window).IsOk()) + if (GetPane(paneInfo.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()) + if (!paneInfo.name.empty() && GetPane(paneInfo.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()) + if (paneInfo.IsDocked()) RestoreMaximizedPane(); - m_panes.Add(pane_info); + // special case: wxAuiToolBar style interacts with docking flags + wxAuiPaneInfo test(paneInfo); + wxAuiToolBar* toolbar = wxDynamicCast(window, wxAuiToolBar); + if (toolbar) + { + // if pane has default docking flags + const unsigned int dockMask = wxAuiPaneInfo::optionLeftDockable | + wxAuiPaneInfo::optionRightDockable | + wxAuiPaneInfo::optionTopDockable | + wxAuiPaneInfo::optionBottomDockable; + const unsigned int defaultDock = wxAuiPaneInfo(). + DefaultPane().state & dockMask; + if ((test.state & dockMask) == defaultDock) + { + // set docking flags based on toolbar style + if (toolbar->GetWindowStyleFlag() & wxAUI_TB_VERTICAL) + { + test.TopDockable(false).BottomDockable(false); + } + else if (toolbar->GetWindowStyleFlag() & wxAUI_TB_HORIZONTAL) + { + test.LeftDockable(false).RightDockable(false); + } + } + else + { + // see whether non-default docking flags are valid + test.window = window; + wxCHECK_MSG(test.IsValid(), false, + "toolbar style and pane docking flags are incompatible"); + } + } + + m_panes.Add(test); wxAuiPaneInfo& pinfo = m_panes.Last(); @@ -871,7 +1059,7 @@ bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info) if (pinfo.name.empty() || already_exists) { pinfo.name.Printf(wxT("%08lx%08x%08x%08lx"), - ((unsigned long)pinfo.window) & 0xffffffff, + (unsigned long)(wxPtrToUInt(pinfo.window) & 0xffffffff), (unsigned int)time(NULL), #ifdef __WXWINCE__ (unsigned int)GetTickCount(), @@ -906,25 +1094,36 @@ bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info) pinfo.buttons.Add(button); } + if (pinfo.HasGripper()) + { + if (wxDynamicCast(pinfo.window, 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 (pinfo.window->IsKindOf(CLASSINFO(wxToolBar))) +#if wxUSE_TOOLBAR + if (wxDynamicCast(pinfo.window, 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) { @@ -935,6 +1134,8 @@ bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info) } } + + return true; } @@ -956,10 +1157,10 @@ bool wxAuiManager::AddPane(wxWindow* window, } bool wxAuiManager::AddPane(wxWindow* window, - const wxAuiPaneInfo& pane_info, + const wxAuiPaneInfo& paneInfo, const wxPoint& drop_pos) { - if (!AddPane(window, pane_info)) + if (!AddPane(window, paneInfo)) return false; wxAuiPaneInfo& pane = GetPane(window); @@ -969,29 +1170,31 @@ bool wxAuiManager::AddPane(wxWindow* window, return true; } -bool wxAuiManager::InsertPane(wxWindow* window, const wxAuiPaneInfo& pane_info, +bool wxAuiManager::InsertPane(wxWindow* window, const wxAuiPaneInfo& paneInfo, 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) { case wxAUI_INSERT_PANE: DoInsertPane(m_panes, - pane_info.dock_direction, - pane_info.dock_layer, - pane_info.dock_row, - pane_info.dock_pos); + paneInfo.dock_direction, + paneInfo.dock_layer, + paneInfo.dock_row, + paneInfo.dock_pos); break; case wxAUI_INSERT_ROW: DoInsertDockRow(m_panes, - pane_info.dock_direction, - pane_info.dock_layer, - pane_info.dock_row); + paneInfo.dock_direction, + paneInfo.dock_layer, + paneInfo.dock_row); break; case wxAUI_INSERT_DOCK: DoInsertDockLayer(m_panes, - pane_info.dock_direction, - pane_info.dock_layer); + paneInfo.dock_direction, + paneInfo.dock_layer); break; } @@ -1000,27 +1203,27 @@ bool wxAuiManager::InsertPane(wxWindow* window, const wxAuiPaneInfo& pane_info, wxAuiPaneInfo& existing_pane = GetPane(window); if (!existing_pane.IsOk()) { - return AddPane(window, pane_info); + return AddPane(window, paneInfo); } else { - if (pane_info.IsFloating()) + if (paneInfo.IsFloating()) { existing_pane.Float(); - if (pane_info.floating_pos != wxDefaultPosition) - existing_pane.FloatingPosition(pane_info.floating_pos); - if (pane_info.floating_size != wxDefaultSize) - existing_pane.FloatingSize(pane_info.floating_size); + if (paneInfo.floating_pos != wxDefaultPosition) + existing_pane.FloatingPosition(paneInfo.floating_pos); + if (paneInfo.floating_size != wxDefaultSize) + existing_pane.FloatingSize(paneInfo.floating_size); } 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); - existing_pane.Position(pane_info.dock_pos); + existing_pane.Direction(paneInfo.dock_direction); + existing_pane.Layer(paneInfo.dock_layer); + existing_pane.Row(paneInfo.dock_row); + existing_pane.Position(paneInfo.dock_pos); } } @@ -1032,6 +1235,8 @@ bool wxAuiManager::InsertPane(wxWindow* window, const wxAuiPaneInfo& pane_info, // method will not destroy the window that is removed. 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) { @@ -1050,9 +1255,9 @@ bool wxAuiManager::DetachPane(wxWindow* window) p.frame->Show(false); // reparent to m_frame and destroy the pane - if (m_action_window == p.frame) + if (m_actionWindow == p.frame) { - m_action_window = NULL; + m_actionWindow = NULL; } p.window->Reparent(m_frame); @@ -1066,12 +1271,12 @@ bool wxAuiManager::DetachPane(wxWindow* window) // the DetachPane() call. This prevets obscure crashes which would // happen at window repaint if the caller forgets to call Update() int pi, part_count; - for (pi = 0, part_count = (int)m_uiparts.GetCount(); pi < part_count; ++pi) + for (pi = 0, part_count = (int)m_uiParts.GetCount(); pi < part_count; ++pi) { - wxAuiDockUIPart& part = m_uiparts.Item(pi); + wxAuiDockUIPart& part = m_uiParts.Item(pi); if (part.pane == &p) { - m_uiparts.RemoveAt(pi); + m_uiParts.RemoveAt(pi); part_count--; pi--; continue; @@ -1085,39 +1290,38 @@ bool wxAuiManager::DetachPane(wxWindow* window) return false; } -// ClosePane() destroys or hides the pane depending on its -// flags -void wxAuiManager::ClosePane(wxAuiPaneInfo& pane_info) +// ClosePane() destroys or hides the pane depending on its flags +void wxAuiManager::ClosePane(wxAuiPaneInfo& paneInfo) { // if we were maximized, restore - if (pane_info.IsMaximized()) + if (paneInfo.IsMaximized()) { - RestorePane(pane_info); + RestorePane(paneInfo); } // first, hide the window - if (pane_info.window && pane_info.window->IsShown()) + if (paneInfo.window && paneInfo.window->IsShown()) { - pane_info.window->Show(false); + paneInfo.window->Show(false); } // make sure that we are the parent of this window - if (pane_info.window && pane_info.window->GetParent() != m_frame) + if (paneInfo.window && paneInfo.window->GetParent() != m_frame) { - pane_info.window->Reparent(m_frame); + paneInfo.window->Reparent(m_frame); } // if we have a frame, destroy it - if (pane_info.frame) + if (paneInfo.frame) { - pane_info.frame->Destroy(); - pane_info.frame = NULL; + paneInfo.frame->Destroy(); + paneInfo.frame = NULL; } // now we need to either destroy or hide the pane - if (pane_info.IsDestroyOnClose()) + if (paneInfo.IsDestroyOnClose()) { - wxWindow * window = pane_info.window; + wxWindow * window = paneInfo.window; DetachPane(window); if (window) { @@ -1126,11 +1330,11 @@ void wxAuiManager::ClosePane(wxAuiPaneInfo& pane_info) } else { - pane_info.Hide(); + paneInfo.Hide(); } } -void wxAuiManager::MaximizePane(wxAuiPaneInfo& pane_info) +void wxAuiManager::MaximizePane(wxAuiPaneInfo& paneInfo) { int i, pane_count; @@ -1138,7 +1342,7 @@ void wxAuiManager::MaximizePane(wxAuiPaneInfo& pane_info) for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) { wxAuiPaneInfo& p = m_panes.Item(i); - if (!p.IsToolbar()) + if (!p.IsToolbar() && !p.IsFloating()) { p.Restore(); @@ -1153,18 +1357,18 @@ void wxAuiManager::MaximizePane(wxAuiPaneInfo& pane_info) } // mark ourselves maximized - pane_info.Maximize(); - pane_info.Show(); - m_has_maximized = true; + paneInfo.Maximize(); + paneInfo.Show(); + m_hasMaximized = true; // last, show the window - if (pane_info.window && !pane_info.window->IsShown()) + if (paneInfo.window && !paneInfo.window->IsShown()) { - pane_info.window->Show(true); + paneInfo.window->Show(true); } } -void wxAuiManager::RestorePane(wxAuiPaneInfo& pane_info) +void wxAuiManager::RestorePane(wxAuiPaneInfo& paneInfo) { int i, pane_count; @@ -1172,7 +1376,7 @@ void wxAuiManager::RestorePane(wxAuiPaneInfo& pane_info) for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) { wxAuiPaneInfo& p = m_panes.Item(i); - if (!p.IsToolbar()) + if (!p.IsToolbar() && !p.IsFloating()) { p.SetFlag(wxAuiPaneInfo::optionHidden, p.HasFlag(wxAuiPaneInfo::savedHiddenState)); @@ -1180,13 +1384,13 @@ void wxAuiManager::RestorePane(wxAuiPaneInfo& pane_info) } // mark ourselves non-maximized - pane_info.Restore(); - m_has_maximized = false; + paneInfo.Restore(); + m_hasMaximized = false; // last, show the window - if (pane_info.window && !pane_info.window->IsShown()) + if (paneInfo.window && !paneInfo.window->IsShown()) { - pane_info.window->Show(true); + paneInfo.window->Show(true); } } @@ -1380,10 +1584,15 @@ bool wxAuiManager::LoadPerspective(const wxString& layout, bool update) if (part != wxT("layout2")) return false; - // mark all panes currently managed as docked and hidden + // Mark all panes currently managed as hidden. Also, dock all panes that are dockable. int pane_i, pane_count = m_panes.GetCount(); for (pane_i = 0; pane_i < pane_count; ++pane_i) - m_panes.Item(pane_i).Dock().Hide(); + { + wxAuiPaneInfo& p = m_panes.Item(pane_i); + if(p.IsDockable()) + p.Dock(); + p.Hide(); + } // clear out the dock array; this will be reconstructed m_docks.Clear(); @@ -1393,6 +1602,7 @@ bool wxAuiManager::LoadPerspective(const wxString& layout, bool update) input.Replace(wxT("\\|"), wxT("\a")); input.Replace(wxT("\\;"), wxT("\b")); + m_hasMaximized = false; while (1) { wxAuiPaneInfo pane; @@ -1435,16 +1645,18 @@ bool wxAuiManager::LoadPerspective(const wxString& layout, bool update) LoadPaneInfo(pane_part, pane); + if ( pane.IsMaximized() ) + m_hasMaximized = true; + 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) @@ -1458,8 +1670,8 @@ void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock, wxArrayInt& sizes) { 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); + int pane_borderSize = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE); + int gripperSize = m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE); positions.Empty(); sizes.Empty(); @@ -1472,7 +1684,7 @@ void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock, { wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i)); - if (pane.state & wxAuiPaneInfo::actionPane) + if (pane.HasFlag(wxAuiPaneInfo::actionPane)) { wxASSERT_MSG(action_pane==-1, wxT("Too many fixed action panes")); action_pane = pane_i; @@ -1489,18 +1701,18 @@ void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock, int size = 0; if (pane.HasBorder()) - size += (pane_border_size*2); + size += (pane_borderSize*2); if (dock.IsHorizontal()) { if (pane.HasGripper() && !pane.HasGripperTop()) - size += gripper_size; + size += gripperSize; size += pane.best_size.x; } else { if (pane.HasGripper() && pane.HasGripperTop()) - size += gripper_size; + size += gripperSize; if (pane.HasCaption()) size += caption_size; @@ -1554,8 +1766,8 @@ void wxAuiManager::LayoutAddPane(wxSizer* cont, wxSizerItem* sizer_item; 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 gripperSize = m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE); + int pane_borderSize = 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 @@ -1576,9 +1788,9 @@ void wxAuiManager::LayoutAddPane(wxSizer* cont, if (pane.HasGripper()) { if (pane.HasGripperTop()) - sizer_item = vert_pane_sizer ->Add(1, gripper_size, 0, wxEXPAND); + sizer_item = vert_pane_sizer ->Add(1, gripperSize, 0, wxEXPAND); else - sizer_item = horz_pane_sizer ->Add(gripper_size, 1, 0, wxEXPAND); + sizer_item = horz_pane_sizer ->Add(gripperSize, 1, 0, wxEXPAND); part.type = wxAuiDockUIPart::typeGripper; part.dock = &dock; @@ -1697,7 +1909,7 @@ void wxAuiManager::LayoutAddPane(wxSizer* cont, { // allowing space for the pane's border sizer_item = cont->Add(horz_pane_sizer, pane_proportion, - wxEXPAND | wxALL, pane_border_size); + wxEXPAND | wxALL, pane_borderSize); part.type = wxAuiDockUIPart::typePaneBorder; part.dock = &dock; @@ -1722,14 +1934,14 @@ void wxAuiManager::LayoutAddDock(wxSizer* cont, wxSizerItem* sizer_item; wxAuiDockUIPart part; - int sash_size = m_art->GetMetric(wxAUI_DOCKART_SASH_SIZE); + int sashSize = m_art->GetMetric(wxAUI_DOCKART_SASH_SIZE); int orientation = dock.IsHorizontal() ? wxHORIZONTAL : wxVERTICAL; // resizable bottom and right docks have a sash before them - if (!m_has_maximized && !dock.fixed && (dock.dock_direction == wxAUI_DOCK_BOTTOM || + if (!m_hasMaximized && !dock.fixed && (dock.dock_direction == wxAUI_DOCK_BOTTOM || dock.dock_direction == wxAUI_DOCK_RIGHT)) { - sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND); + sizer_item = cont->Add(sashSize, sashSize, 0, wxEXPAND); part.type = wxAuiDockUIPart::typeDockSizer; part.orientation = orientation; @@ -1814,9 +2026,9 @@ void wxAuiManager::LayoutAddDock(wxSizer* cont, // if this is not the first pane being added, // we need to add a pane sizer - if (!m_has_maximized && pane_i > 0) + if (!m_hasMaximized && pane_i > 0) { - sizer_item = dock_sizer->Add(sash_size, sash_size, 0, wxEXPAND); + sizer_item = dock_sizer->Add(sashSize, sashSize, 0, wxEXPAND); part.type = wxAuiDockUIPart::typePaneSizer; part.dock = &dock; @@ -1852,12 +2064,12 @@ void wxAuiManager::LayoutAddDock(wxSizer* cont, cont->SetItemMinSize(dock_sizer, dock.size, 0); // top and left docks have a sash after them - if (!m_has_maximized && + if (!m_hasMaximized && !dock.fixed && (dock.dock_direction == wxAUI_DOCK_TOP || dock.dock_direction == wxAUI_DOCK_LEFT)) { - sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND); + sizer_item = cont->Add(sashSize, sashSize, 0, wxEXPAND); part.type = wxAuiDockUIPart::typeDockSizer; part.dock = &dock; @@ -1877,7 +2089,7 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes, { wxBoxSizer* container = new wxBoxSizer(wxVERTICAL); - int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE); + int pane_borderSize = 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; @@ -1991,7 +2203,7 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes, { if (dock.panes.Item(j)->HasBorder()) { - size += (pane_border_size*2); + size += (pane_borderSize*2); break; } } @@ -2014,8 +2226,8 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes, // 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)); + int max_dock_x_size = (int)(m_dockConstraintX * ((double)cli_size.x)); + int max_dock_y_size = (int)(m_dockConstraintY * ((double)cli_size.y)); if (dock.IsHorizontal()) size = wxMin(size, max_dock_y_size); @@ -2057,7 +2269,7 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes, } if (plus_border) - dock_min_size += (pane_border_size*2); + dock_min_size += (pane_borderSize*2); if (plus_caption && dock.IsHorizontal()) dock_min_size += (caption_size); @@ -2082,7 +2294,9 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes, dock.fixed = false; if (!pane.IsToolbar()) dock.toolbar = false; - if (pane.state & wxAuiPaneInfo::actionPane) + if (pane.HasFlag(wxAuiPaneInfo::optionDockFixed)) + dock.fixed = true; + if (pane.HasFlag(wxAuiPaneInfo::actionPane)) action_pane_marked = true; } @@ -2161,7 +2375,6 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes, // 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) @@ -2176,7 +2389,6 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes, // 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) @@ -2194,7 +2406,7 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes, for (row = 0,row_count = arr.GetCount(); rowAdd(1,1, 1, wxEXPAND); @@ -2215,20 +2427,21 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes, // 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) @@ -2264,17 +2477,17 @@ wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes, 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)); + m_dockConstraintX = wxMax(0.0, wxMin(1.0, width_pct)); + m_dockConstraintY = 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; + *width_pct = m_dockConstraintX; if (height_pct) - *height_pct = m_dock_constraint_y; + *height_pct = m_dockConstraintY; } @@ -2285,6 +2498,9 @@ void wxAuiManager::GetDockSizeConstraint(double* width_pct, double* height_pct) void wxAuiManager::Update() { + m_hoverButton = NULL; + m_actionPart = NULL; + wxSizer* sizer; int i, pane_count = m_panes.GetCount(); @@ -2304,28 +2520,28 @@ void wxAuiManager::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_actionWindow == p.frame) + { + if (wxWindow::GetCapture() == m_frame) m_frame->ReleaseMouse(); m_action = actionNone; - m_action_window = NULL; - } + m_actionWindow = 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) + if (m_actionWindow == p.frame) { - m_action_window = NULL; + m_actionWindow = NULL; } p.window->Reparent(m_frame); @@ -2340,7 +2556,7 @@ void wxAuiManager::Update() m_frame->SetSizer(NULL); // create a layout for all of the panes - sizer = LayoutAll(m_panes, m_docks, m_uiparts, false); + sizer = LayoutAll(m_panes, m_docks, m_uiParts, false); // hide or show panes as necessary, // and float panes as necessary @@ -2373,7 +2589,7 @@ void wxAuiManager::Update() { // frame already exists, make sure it's position // and size reflect the information in wxAuiPaneInfo - if (p.frame->GetPosition() != p.floating_pos) + 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, @@ -2386,6 +2602,17 @@ void wxAuiManager::Update() */ } + // update whether the pane is resizable or not + long style = p.frame->GetWindowStyleFlag(); + if (p.IsFixed()) + style &= ~wxRESIZE_BORDER; + else + style |= wxRESIZE_BORDER; + p.frame->SetWindowStyleFlag(style); + + if (p.frame->GetLabel() != p.caption) + p.frame->SetLabel(p.caption); + if (p.frame->IsShown() != p.IsShown()) p.frame->Show(p.IsShown()); } @@ -2482,9 +2709,9 @@ void wxAuiManager::DoFrameLayout() m_frame->Layout(); int i, part_count; - for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i) + for (i = 0, part_count = m_uiParts.GetCount(); i < part_count; ++i) { - wxAuiDockUIPart& part = m_uiparts.Item(i); + wxAuiDockUIPart& part = m_uiParts.Item(i); // get the rectangle of the UI part // originally, this code looked like this: @@ -2532,16 +2759,16 @@ void wxAuiManager::DoFrameLayout() wxAuiDockUIPart* wxAuiManager::GetPanePart(wxWindow* wnd) { int i, part_count; - for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i) + for (i = 0, part_count = m_uiParts.GetCount(); i < part_count; ++i) { - wxAuiDockUIPart& part = m_uiparts.Item(i); + 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) + for (i = 0, part_count = m_uiParts.GetCount(); i < part_count; ++i) { - wxAuiDockUIPart& part = m_uiparts.Item(i); + wxAuiDockUIPart& part = m_uiParts.Item(i); if (part.type == wxAuiDockUIPart::typePane && part.pane && part.pane->window == wnd) return ∂ @@ -2620,7 +2847,22 @@ bool wxAuiManager::ProcessDockResult(wxAuiPaneInfo& target, } if (allowed) + { target = new_pos; + // Should this RTTI and function call be rewritten as + // sending a new event type to allow other window types + // to vary size based on dock location? + wxAuiToolBar* toolbar = wxDynamicCast(target.window, wxAuiToolBar); + if (toolbar) + { + wxSize hintSize = toolbar->GetHintSize(target.dock_direction); + if (target.best_size != hintSize) + { + target.best_size = hintSize; + target.floating_size = wxDefaultSize; + } + } + } return allowed; } @@ -2664,7 +2906,9 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks, if (pt.x < layer_insert_offset && - pt.x > layer_insert_offset-auiLayerInsertPixels) + pt.x > layer_insert_offset-auiLayerInsertPixels && + pt.y > 0 && + pt.y < cli_size.y) { int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_LEFT), GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)), @@ -2680,7 +2924,9 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks, return ProcessDockResult(target, drop); } else if (pt.y < layer_insert_offset && - pt.y > layer_insert_offset-auiLayerInsertPixels) + pt.y > layer_insert_offset-auiLayerInsertPixels && + pt.x > 0 && + pt.x < cli_size.x) { int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_TOP), GetMaxLayer(docks, wxAUI_DOCK_LEFT)), @@ -2696,7 +2942,9 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks, return ProcessDockResult(target, drop); } else if (pt.x >= cli_size.x - layer_insert_offset && - pt.x < cli_size.x - layer_insert_offset + auiLayerInsertPixels) + pt.x < cli_size.x - layer_insert_offset + auiLayerInsertPixels && + pt.y > 0 && + pt.y < cli_size.y) { int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_RIGHT), GetMaxLayer(docks, wxAUI_DOCK_TOP)), @@ -2712,7 +2960,9 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks, return ProcessDockResult(target, drop); } else if (pt.y >= cli_size.y - layer_insert_offset && - pt.y < cli_size.y - layer_insert_offset + auiLayerInsertPixels) + pt.y < cli_size.y - layer_insert_offset + auiLayerInsertPixels && + pt.x > 0 && + pt.x < cli_size.x) { int new_layer = wxMax( wxMax( GetMaxLayer(docks, wxAUI_DOCK_BOTTOM), GetMaxLayer(docks, wxAUI_DOCK_LEFT)), @@ -2749,18 +2999,16 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks, // 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 )) + if (m_lastRect.IsEmpty() || m_lastRect.Contains(pt.x, pt.y )) { m_skipping = true; } 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(); } @@ -2774,16 +3022,11 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& 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_lastRect = part->dock->rect; + m_lastRect.Inflate( 15, 15 ); drop.Dock(). Direction(part->dock->dock_direction). @@ -2992,16 +3235,16 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks, // determine the mouse offset and the pane size, both in the // direction of the dock itself, and perpendicular to the dock - int offset, size; + int mouseOffset, size; if (part->orientation == wxVERTICAL) { - offset = pt.y - part->rect.y; + mouseOffset = pt.y - part->rect.y; size = part->rect.GetHeight(); } else { - offset = pt.x - part->rect.x; + mouseOffset = pt.x - part->rect.x; size = part->rect.GetWidth(); } @@ -3009,7 +3252,7 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks, // if we are in the top/left part of the pane, // insert the pane before the pane being hovered over - if (offset <= size/2) + if (mouseOffset <= size/2) { drop_position = part->pane->dock_pos; DoInsertPane(panes, @@ -3021,7 +3264,7 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks, // if we are in the bottom/right part of the pane, // insert the pane before the pane being hovered over - if (offset > size/2) + if (mouseOffset > size/2) { drop_position = part->pane->dock_pos+1; DoInsertPane(panes, @@ -3045,52 +3288,56 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks, void wxAuiManager::OnHintFadeTimer(wxTimerEvent& WXUNUSED(event)) { - if (!m_hint_wnd || m_hint_fadeamt >= m_hint_fademax) + if (!m_hintWnd || m_hintFadeAmt >= m_hintFadeMax) { - m_hint_fadetimer.Stop(); + m_hintFadeTimer.Stop(); + Disconnect(m_hintFadeTimer.GetId(), wxEVT_TIMER, + wxTimerEventHandler(wxAuiManager::OnHintFadeTimer)); return; } - m_hint_fadeamt += 4; - m_hint_wnd->SetTransparent(m_hint_fadeamt); + m_hintFadeAmt += 4; + m_hintWnd->SetTransparent(m_hintFadeAmt); } void wxAuiManager::ShowHint(const wxRect& rect) { - if (m_hint_wnd) + if (m_hintWnd) { // if the hint rect is the same as last time, don't do anything - if (m_last_hint == rect) + if (m_lastHint == rect) return; - m_last_hint = rect; + m_lastHint = rect; - m_hint_fadeamt = m_hint_fademax; + m_hintFadeAmt = m_hintFadeMax; if ((m_flags & wxAUI_MGR_HINT_FADE) - && !((m_hint_wnd->IsKindOf(CLASSINFO(wxPseudoTransparentFrame))) && + && !((wxDynamicCast(m_hintWnd, wxPseudoTransparentFrame)) && (m_flags & wxAUI_MGR_NO_VENETIAN_BLINDS_FADE)) ) - m_hint_fadeamt = 0; + m_hintFadeAmt = 0; - m_hint_wnd->SetSize(rect); - m_hint_wnd->SetTransparent(m_hint_fadeamt); + m_hintWnd->SetSize(rect); + m_hintWnd->SetTransparent(m_hintFadeAmt); - if (!m_hint_wnd->IsShown()) - m_hint_wnd->Show(); + if (!m_hintWnd->IsShown()) + m_hintWnd->Show(); // if we are dragging a floating pane, set the focus // back to that floating pane (otherwise it becomes unfocused) - if (m_action == actionDragFloatingPane && m_action_window) - m_action_window->SetFocus(); + if (m_action == actionDragFloatingPane && m_actionWindow) + m_actionWindow->SetFocus(); - m_hint_wnd->Raise(); + m_hintWnd->Raise(); - if (m_hint_fadeamt != m_hint_fademax) // Only fade if we need to + if (m_hintFadeAmt != m_hintFadeMax) // Only fade if we need to { // start fade in timer - m_hint_fadetimer.SetOwner(this, 101); - m_hint_fadetimer.Start(5); + m_hintFadeTimer.SetOwner(this); + m_hintFadeTimer.Start(5); + Connect(m_hintFadeTimer.GetId(), wxEVT_TIMER, + wxTimerEventHandler(wxAuiManager::OnHintFadeTimer)); } } else // Not using a transparent hint window... @@ -3098,10 +3345,10 @@ void wxAuiManager::ShowHint(const wxRect& rect) if (!(m_flags & wxAUI_MGR_RECTANGLE_HINT)) return; - if (m_last_hint != rect) + if (m_lastHint != rect) { // remove the last hint rectangle - m_last_hint = rect; + m_lastHint = rect; m_frame->Refresh(); m_frame->Update(); } @@ -3116,17 +3363,18 @@ void wxAuiManager::ShowHint(const wxRect& rect) wxAuiPaneInfo& pane = m_panes.Item(i); if (pane.IsFloating() && - pane.frame->IsShown()) + pane.frame && + pane.frame->IsShown()) { - wxRect rect = pane.frame->GetRect(); + wxRect r = pane.frame->GetRect(); #ifdef __WXGTK__ // wxGTK returns the client size, not the whole frame size - rect.width += 15; - rect.height += 35; - rect.Inflate(5); + r.width += 15; + r.height += 35; + r.Inflate(5); #endif - clip.Subtract(rect); + clip.Subtract(r); } } @@ -3135,7 +3383,7 @@ void wxAuiManager::ShowHint(const wxRect& rect) // nasty redrawn problems. clip.Intersect(m_frame->GetRect()); - screendc.SetClippingRegion(clip); + screendc.SetDeviceClippingRegion(clip); wxBitmap stipple = wxPaneCreateStippleBitmap(); wxBrush brush(stipple); @@ -3152,25 +3400,40 @@ void wxAuiManager::ShowHint(const wxRect& rect) 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); - m_hint_wnd->SetTransparent(0); - m_hint_fadetimer.Stop(); - m_last_hint = wxRect(); + if (m_hintWnd) + { + if (m_hintWnd->IsShown()) + m_hintWnd->Show(false); + m_hintWnd->SetTransparent(0); + m_hintFadeTimer.Stop(); + // In case this is called while a hint fade is going, we need to + // disconnect the event handler. + Disconnect(m_hintFadeTimer.GetId(), wxEVT_TIMER, + wxTimerEventHandler(wxAuiManager::OnHintFadeTimer)); + m_lastHint = wxRect(); return; } // hides a painted hint by redrawing the frame window - if (!m_last_hint.IsEmpty()) + if (!m_lastHint.IsEmpty()) { m_frame->Refresh(); m_frame->Update(); - m_last_hint = wxRect(); + m_lastHint = wxRect(); } } +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 behaviour 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, @@ -3189,16 +3452,25 @@ void wxAuiManager::StartPaneDrag(wxWindow* pane_window, m_action = actionDragFloatingPane; } - m_action_window = pane_window; - m_action_offset = offset; + m_actionWindow = pane_window; + m_actionOffset = offset; m_frame->CaptureMouse(); + + if (pane.frame) + { + wxRect window_rect = pane.frame->GetRect(); + wxRect client_rect = pane.frame->GetClientRect(); + wxPoint client_pt = pane.frame->ClientToScreen(client_rect.GetTopLeft()); + wxPoint origin_pt = client_pt - window_rect.GetTopLeft(); + m_actionOffset += origin_pt; + } } // 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 +// specified drop point, 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 @@ -3313,6 +3585,9 @@ void wxAuiManager::OnFloatingPaneMoveStart(wxWindow* wnd) wxAuiPaneInfo& pane = GetPane(wnd); wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); + if(!pane.frame) + return; + if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG) pane.frame->SetTransparent(150); } @@ -3323,6 +3598,9 @@ void wxAuiManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir) wxAuiPaneInfo& pane = GetPane(wnd); wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); + if(!pane.frame) + return; + wxPoint pt = ::wxGetMousePosition(); #if 0 @@ -3371,27 +3649,24 @@ void wxAuiManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir) // no hint for toolbar floating windows if (pane.IsToolbar() && m_action == actionDragFloatingPane) { - if (m_action == actionDragFloatingPane) - { - wxAuiDockInfoArray docks; - wxAuiPaneInfoArray panes; - wxAuiDockUIPartArray uiparts; - wxAuiPaneInfo 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_actionWindow = pane.window; - Update(); - } + Update(); return; } @@ -3399,7 +3674,7 @@ void wxAuiManager::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; @@ -3426,6 +3701,9 @@ void wxAuiManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir) wxAuiPaneInfo& pane = GetPane(wnd); wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); + if(!pane.frame) + return; + wxPoint pt = ::wxGetMousePosition(); #if 0 @@ -3471,10 +3749,9 @@ void wxAuiManager::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); @@ -3489,7 +3766,7 @@ void wxAuiManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir) if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG) pane.frame->SetTransparent(255); } - else if (m_has_maximized) + else if (m_hasMaximized) { RestoreMaximizedPane(); } @@ -3499,13 +3776,16 @@ void wxAuiManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir) HideHint(); } -void wxAuiManager::OnFloatingPaneResized(wxWindow* wnd, const wxSize& size) +void wxAuiManager::OnFloatingPaneResized(wxWindow* wnd, const wxRect& rect) { // try to find the pane wxAuiPaneInfo& pane = GetPane(wnd); wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); - pane.floating_size = size; + pane.FloatingSize(rect.GetWidth(), rect.GetHeight()); + + // the top-left position may change as well as the size + pane.FloatingPosition(rect.x, rect.y); } @@ -3529,7 +3809,15 @@ void wxAuiManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt) } 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); + } } } @@ -3537,12 +3825,9 @@ void wxAuiManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt) 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); + SetActivePane(wnd); Repaint(); } } @@ -3555,21 +3840,21 @@ void wxAuiManager::OnRender(wxAuiManagerEvent& evt) { // if the frame is about to be deleted, don't bother if (!m_frame || wxPendingDelete.Member(m_frame)) - return; - + return; + wxDC* dc = evt.GetDC(); #ifdef __WXMAC__ dc->Clear() ; #endif int i, part_count; - for (i = 0, part_count = m_uiparts.GetCount(); + for (i = 0, part_count = m_uiParts.GetCount(); i < part_count; ++i) { - wxAuiDockUIPart& 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) @@ -3602,7 +3887,7 @@ void wxAuiManager::OnRender(wxAuiManagerEvent& evt) // Render() fire a render event, which is normally handled by // 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 +// custom graphics in the main window. Default behaviour can be // invoked in the overridden function by calling OnRender() void wxAuiManager::Render(wxDC* dc) @@ -3615,7 +3900,7 @@ void wxAuiManager::Render(wxDC* dc) void wxAuiManager::Repaint(wxDC* dc) { -#ifdef __WXMAC__ +#ifdef __WXMAC__ if ( dc == NULL ) { m_frame->Refresh() ; @@ -3673,7 +3958,7 @@ void wxAuiManager::OnSize(wxSizeEvent& event) Repaint(); #if wxUSE_MDI - if (m_frame->IsKindOf(CLASSINFO(wxMDIParentFrame))) + if (wxDynamicCast(m_frame, wxMDIParentFrame)) { // for MDI parent frames, this event must not // be "skipped". In other words, the parent frame @@ -3697,7 +3982,7 @@ void wxAuiManager::OnFindManager(wxAuiManagerEvent& evt) } // if we are managing a child frame, get the 'real' manager - if (window->IsKindOf(CLASSINFO(wxAuiFloatingFrame))) + if (wxDynamicCast(window, wxAuiFloatingFrame)) { wxAuiFloatingFrame* float_frame = static_cast(window); evt.SetManager(float_frame->GetOwnerManager()); @@ -3789,14 +4074,17 @@ void wxAuiManager::UpdateButtonOnScreen(wxAuiDockUIPart* button_ui_part, void wxAuiManager::OnLeftDown(wxMouseEvent& event) { + m_currentDragItem = -1; + wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY()); if (part) { if (part->type == wxAuiDockUIPart::typeDockSizer || part->type == wxAuiDockUIPart::typePaneSizer) { - if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER) - return; + // 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 @@ -3810,18 +4098,18 @@ void wxAuiManager::OnLeftDown(wxMouseEvent& event) return; m_action = actionResize; - m_action_part = part; - m_action_hintrect = wxRect(); - m_action_start = wxPoint(event.m_x, event.m_y); - m_action_offset = wxPoint(event.m_x - part->rect.x, + m_actionPart = part; + m_actionHintRect = wxRect(); + m_actionStart = wxPoint(event.m_x, event.m_y); + m_actionOffset = wxPoint(event.m_x - part->rect.x, event.m_y - part->rect.y); m_frame->CaptureMouse(); } else if (part->type == wxAuiDockUIPart::typePaneButton) { m_action = actionClickButton; - m_action_part = part; - m_action_start = wxPoint(event.m_x, event.m_y); + m_actionPart = part; + m_actionStart = wxPoint(event.m_x, event.m_y); m_frame->CaptureMouse(); UpdateButtonOnScreen(part, event); @@ -3837,7 +4125,7 @@ void wxAuiManager::OnLeftDown(wxMouseEvent& event) if (part->pane && part->pane->window && managed_wnd && - managed_wnd->IsKindOf(CLASSINFO(wxAuiFloatingFrame))) + wxDynamicCast(managed_wnd, wxAuiFloatingFrame)) { wxAuiFloatingFrame* floating_frame = (wxAuiFloatingFrame*)managed_wnd; wxAuiManager* owner_mgr = floating_frame->GetOwnerManager(); @@ -3849,20 +4137,20 @@ void wxAuiManager::OnLeftDown(wxMouseEvent& event) - if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER) - return; - if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE) { // set the caption as active - SetActivePane(m_panes, part->pane->window); + SetActivePane(part->pane->window); 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); - m_action_offset = wxPoint(event.m_x - part->rect.x, + m_actionPart = part; + m_actionStart = wxPoint(event.m_x, event.m_y); + m_actionOffset = wxPoint(event.m_x - part->rect.x, event.m_y - part->rect.y); m_frame->CaptureMouse(); } @@ -3883,212 +4171,310 @@ void wxAuiManager::OnLeftDown(wxMouseEvent& event) #endif } - -void wxAuiManager::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_actionPart && m_actionPart->type==wxAuiDockUIPart::typeDockSizer) { - m_frame->ReleaseMouse(); + // first, we must calculate the maximum size the dock may be + int sashSize = 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==wxAuiDockUIPart::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 += sashSize; + } + + + 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 (wxDynamicCast(m_frame, 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 == wxAuiDockUIPart::typePaneSizer) +#endif + + wxRect& rect = m_actionPart->dock->rect; + + wxPoint new_pos(event.m_x - m_actionOffset.x, + event.m_y - m_actionOffset.y); + int new_size, old_size = m_actionPart->dock->size; + + switch (m_actionPart->dock->dock_direction) { - wxAuiDockInfo& dock = *m_action_part->dock; - wxAuiPaneInfo& 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_actionPart->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_actionPart->dock->size = new_size; + break; + case wxAUI_DOCK_RIGHT: + new_size = rect.x + rect.width - new_pos.x - + m_actionPart->rect.GetWidth(); + if (new_size-old_size > available_width) + new_size = old_size+available_width; + m_actionPart->dock->size = new_size; + break; + case wxAUI_DOCK_BOTTOM: + new_size = rect.y + rect.height - + new_pos.y - m_actionPart->rect.GetHeight(); + if (new_size-old_size > available_height) + new_size = old_size+available_height; + m_actionPart->dock->size = new_size; + break; + } - int total_proportion = 0; - int dock_pixels = 0; - int new_pixsize = 0; + Update(); + Repaint(NULL); + } + else if (m_actionPart && + m_actionPart->type == wxAuiDockUIPart::typePaneSizer) + { + wxAuiDockInfo& dock = *m_actionPart->dock; + wxAuiPaneInfo& pane = *m_actionPart->pane; - 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); + 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_borderSize = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE); + int sashSize = m_art->GetMetric(wxAUI_DOCKART_SASH_SIZE); - // 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")); + wxPoint new_pos(event.m_x - m_actionOffset.x, + event.m_y - m_actionOffset.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 -= sashSize; + + // 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()) { - 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()) - { - if (dock.IsHorizontal()) - dock_pixels -= p.best_size.x; - else - dock_pixels -= p.best_size.y; - } + if (dock.IsHorizontal()) + dock_pixels -= p.best_size.x; else - { - total_proportion += p.dock_proportion; - } + 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 { - wxAuiPaneInfo& 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_borderSize*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_actionHintRect); + } + if (m_currentDragItem != -1 && wxAuiManager_HasLiveResize(*this)) + m_actionPart = & (m_uiParts.Item(m_currentDragItem)); + + DoEndResizeAction(event); + + m_currentDragItem = -1; + } else if (m_action == actionClickButton) { - m_hover_button = NULL; + m_hoverButton = 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_actionPart) { - // 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); + UpdateButtonOnScreen(m_actionPart, event); + + // make sure we're still over the item that was originally clicked + if (m_actionPart == HitTest(event.GetX(), event.GetY())) + { + // fire button-click event + wxAuiManagerEvent e(wxEVT_AUI_PANE_BUTTON); + e.SetManager(this); + e.SetPane(m_actionPart->pane); + e.SetButton(m_actionPart->button->button_id); + ProcessMgrEvent(e); + } } } else if (m_action == actionClickCaption) @@ -4103,7 +4489,7 @@ void wxAuiManager::OnLeftUp(wxMouseEvent& event) { m_frame->ReleaseMouse(); - wxAuiPaneInfo& pane = GetPane(m_action_window); + wxAuiPaneInfo& pane = GetPane(m_actionWindow); wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); // save the new positions @@ -4131,7 +4517,7 @@ void wxAuiManager::OnLeftUp(wxMouseEvent& event) } m_action = actionNone; - m_last_mouse_move = wxPoint(); // see comment in OnMotion() + m_lastMouseMove = wxPoint(); // see comment in OnMotion() } @@ -4144,27 +4530,56 @@ void wxAuiManager::OnMotion(wxMouseEvent& event) // mouse move event is being generated. only verified on MSW wxPoint mouse_pos = event.GetPosition(); - if (m_last_mouse_move == mouse_pos) + if (m_lastMouseMove == mouse_pos) return; - m_last_mouse_move = mouse_pos; + m_lastMouseMove = mouse_pos; 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); + // It's necessary to reset m_actionPart since it destroyed + // by the Update within DoEndResizeAction. + if (m_currentDragItem != -1) + m_actionPart = & (m_uiParts.Item(m_currentDragItem)); else - pos.x = wxMax(0, event.m_x - m_action_offset.x); + m_currentDragItem = m_uiParts.Index(* m_actionPart); - wxRect rect(m_frame->ClientToScreen(pos), - m_action_part->rect.GetSize()); + if (m_actionPart) + { + wxPoint pos = m_actionPart->rect.GetPosition(); + if (m_actionPart->orientation == wxHORIZONTAL) + pos.y = wxMax(0, event.m_y - m_actionOffset.y); + else + pos.x = wxMax(0, event.m_x - m_actionOffset.x); + + if (wxAuiManager_HasLiveResize(*this)) + { + m_frame->ReleaseMouse(); + DoEndResizeAction(event); + m_frame->CaptureMouse(); + } + else + { + wxRect rect(m_frame->ClientToScreen(pos), + m_actionPart->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_actionHintRect.IsEmpty()) + { + // remove old resize hint + DrawResizeHint(dc, m_actionHintRect); + m_actionHintRect = wxRect(); + } + + // draw new resize hint, if it's inside the managed frame + wxRect frameScreenRect = m_frame->GetScreenRect(); + if (frameScreenRect.Contains(rect)) + { + DrawResizeHint(dc, rect); + m_actionHintRect = rect; + } + } + } } else if (m_action == actionClickCaption) { @@ -4174,74 +4589,84 @@ void wxAuiManager::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_actionPart && + (abs(event.m_x - m_actionStart.x) > drag_x_threshold || + abs(event.m_y - m_actionStart.y) > drag_y_threshold)) { - wxAuiPaneInfo* pane_info = m_action_part->pane; + wxAuiPaneInfo* paneInfo = m_actionPart->pane; - if (!pane_info->IsToolbar()) + if (!paneInfo->IsToolbar()) { if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) && - pane_info->IsFloatable()) + paneInfo->IsFloatable()) { m_action = actionDragFloatingPane; // set initial float position wxPoint pt = m_frame->ClientToScreen(event.GetPosition()); - pane_info->floating_pos = wxPoint(pt.x - m_action_offset.x, - pt.y - m_action_offset.y); + paneInfo->floating_pos = wxPoint(pt.x - m_actionOffset.x, + pt.y - m_actionOffset.y); // float the window - if (pane_info->IsMaximized()) - RestorePane(*pane_info); - pane_info->Float(); + if (paneInfo->IsMaximized()) + RestorePane(*paneInfo); + paneInfo->Float(); Update(); - m_action_window = pane_info->frame; + m_actionWindow = paneInfo->frame; // action offset is used here to make it feel "natural" to the user // to drag a docked pane and suddenly have it become a floating frame. // Sometimes, however, the offset where the user clicked on the docked // caption is bigger than the width of the floating frame itself, so // in that case we need to set the action offset to a sensible value - wxSize frame_size = m_action_window->GetSize(); - if (frame_size.x <= m_action_offset.x) - m_action_offset.x = 30; + wxSize frame_size = m_actionWindow->GetSize(); + if (frame_size.x <= m_actionOffset.x) + m_actionOffset.x = 30; } } else { m_action = actionDragToolbarPane; - m_action_window = pane_info->window; + m_actionWindow = paneInfo->window; } } } else if (m_action == actionDragFloatingPane) { - if (m_action_window) + if (m_actionWindow) { + // We can't move the child window so we need to get the frame that + // we want to be really moving. This is probably not the best place + // to do this but at least it fixes the bug (#13177) for now. + if (!wxDynamicCast(m_actionWindow, wxAuiFloatingFrame)) + { + wxAuiPaneInfo& pane = GetPane(m_actionWindow); + m_actionWindow = pane.frame; + } + wxPoint pt = m_frame->ClientToScreen(event.GetPosition()); - m_action_window->Move(pt.x - m_action_offset.x, - pt.y - m_action_offset.y); + m_actionWindow->Move(pt.x - m_actionOffset.x, + pt.y - m_actionOffset.y); } } else if (m_action == actionDragToolbarPane) { - wxAuiPaneInfo& pane = GetPane(m_action_window); + wxAuiPaneInfo& pane = GetPane(m_actionWindow); wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); - pane.state |= wxAuiPaneInfo::actionPane; + pane.SetFlag(wxAuiPaneInfo::actionPane, true); - wxPoint pt = event.GetPosition(); - DoDrop(m_docks, m_panes, pane, pt, m_action_offset); + wxPoint point = event.GetPosition(); + DoDrop(m_docks, m_panes, pane, point, m_actionOffset); // if DoDrop() decided to float the pane, set up // the floating pane's initial position if (pane.IsFloating()) { wxPoint pt = m_frame->ClientToScreen(event.GetPosition()); - pane.floating_pos = wxPoint(pt.x - m_action_offset.x, - pt.y - m_action_offset.y); + pane.floating_pos = wxPoint(pt.x - m_actionOffset.x, + pt.y - m_actionOffset.y); } // this will do the actiual move operation; @@ -4257,7 +4682,7 @@ void wxAuiManager::OnMotion(wxMouseEvent& event) { pane.state &= ~wxAuiPaneInfo::actionPane; m_action = actionDragFloatingPane; - m_action_window = pane.frame; + m_actionWindow = pane.frame; } } else @@ -4265,27 +4690,27 @@ void wxAuiManager::OnMotion(wxMouseEvent& event) wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY()); if (part && part->type == wxAuiDockUIPart::typePaneButton) { - if (part != m_hover_button) + if (part != m_hoverButton) { // make the old button normal - if (m_hover_button) + if (m_hoverButton) { - UpdateButtonOnScreen(m_hover_button, event); + UpdateButtonOnScreen(m_hoverButton, event); Repaint(); } // mouse is over a button, so repaint the // button in hover mode UpdateButtonOnScreen(part, event); - m_hover_button = part; + m_hoverButton = part; } } else { - if (m_hover_button) + if (m_hoverButton) { - m_hover_button = NULL; + m_hoverButton = NULL; Repaint(); } else @@ -4298,13 +4723,23 @@ void wxAuiManager::OnMotion(wxMouseEvent& event) void wxAuiManager::OnLeaveWindow(wxMouseEvent& WXUNUSED(event)) { - if (m_hover_button) + if (m_hoverButton) { - m_hover_button = NULL; + m_hoverButton = NULL; Repaint(); } } +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 @@ -4312,9 +4747,10 @@ void wxAuiManager::OnChildFocus(wxChildFocusEvent& event) // 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()); + SetActivePane(event.GetWindow()); m_frame->Refresh(); } } @@ -4341,13 +4777,22 @@ void wxAuiManager::OnPaneButton(wxAuiManagerEvent& evt) 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 + // fire pane maximize event wxAuiManagerEvent e(wxEVT_AUI_PANE_MAXIMIZE); e.SetManager(this); e.SetPane(evt.pane); @@ -4361,7 +4806,7 @@ void wxAuiManager::OnPaneButton(wxAuiManagerEvent& evt) } else if (evt.button == wxAUI_BUTTON_MAXIMIZE_RESTORE && pane.IsMaximized()) { - // fire pane close event + // fire pane restore event wxAuiManagerEvent e(wxEVT_AUI_PANE_RESTORE); e.SetManager(this); e.SetPane(evt.pane); @@ -4373,11 +4818,29 @@ void wxAuiManager::OnPaneButton(wxAuiManagerEvent& evt) Update(); } } - else if (evt.button == wxAUI_BUTTON_PIN) + else if (evt.button == wxAUI_BUTTON_PIN && + (m_flags & wxAUI_MGR_ALLOW_FLOATING) && pane.IsFloatable()) { - if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) && - pane.IsFloatable()) - pane.Float(); + if (pane.IsMaximized()) + { + // If the pane is maximized, the original state must be restored + // before trying to float the pane, otherwise the other panels + // wouldn't appear correctly when it becomes floating. + wxAuiManagerEvent e(wxEVT_AUI_PANE_RESTORE); + e.SetManager(this); + e.SetPane(evt.pane); + ProcessMgrEvent(e); + + if (e.GetVeto()) + { + // If it can't be restored, it can't be floated neither. + return; + } + + RestorePane(pane); + } + + pane.Float(); Update(); } }