X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/68030cae69b096c6a07d634b098a053f0823a8b5..7198c3368055d88249a338eb33b21f051f674806:/src/aui/framemanager.cpp?ds=sidebyside diff --git a/src/aui/framemanager.cpp b/src/aui/framemanager.cpp index dc539a2078..bdb37e182c 100644 --- a/src/aui/framemanager.cpp +++ b/src/aui/framemanager.cpp @@ -30,6 +30,7 @@ #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" @@ -38,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") @@ -54,12 +55,12 @@ 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_RENDER, wxAuiManagerEvent ); +wxDEFINE_EVENT( wxEVT_AUI_FIND_MANAGER, wxAuiManagerEvent ); #ifdef __WXMAC__ // a few defines to avoid nameclashes @@ -222,6 +223,7 @@ END_EVENT_TABLE() // __WXGTK20__ #include +#include "wx/gtk/private/gtk2-compat.h" static void gtk_pseudo_window_realized_callback( GtkWidget *m_widget, void *WXUNUSED(win) ) @@ -236,7 +238,7 @@ gtk_pseudo_window_realized_callback( GtkWidget *m_widget, void *WXUNUSED(win) ) if ((j*16+8)window, region.GetRegion(), 0, 0); + gdk_window_shape_combine_region(gtk_widget_get_window(m_widget), region.GetRegion(), 0, 0); } @@ -276,6 +278,16 @@ public: 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) }; @@ -558,6 +570,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 -- @@ -575,13 +596,13 @@ BEGIN_EVENT_TABLE(wxAuiManager, wxEvtHandler) 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_action_window = NULL; m_last_mouse_move = wxPoint(); m_hover_button = NULL; m_art = new wxAuiDefaultDockArt; @@ -742,6 +763,7 @@ 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; @@ -771,7 +793,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(); @@ -780,7 +802,7 @@ 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; @@ -932,7 +954,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; } @@ -979,7 +1001,40 @@ bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info) if (pane_info.IsDocked()) RestoreMaximizedPane(); - m_panes.Add(pane_info); + // special case: wxAuiToolBar style interacts with docking flags + wxAuiPaneInfo test(pane_info); + 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(); @@ -991,7 +1046,7 @@ bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info) if (pinfo.name.empty() || already_exists) { pinfo.name.Printf(wxT("%08lx%08x%08x%08lx"), - wxPtrToUInt(pinfo.window) & 0xffffffff, + (unsigned long)(wxPtrToUInt(pinfo.window) & 0xffffffff), (unsigned int)time(NULL), #ifdef __WXWINCE__ (unsigned int)GetTickCount(), @@ -1047,21 +1102,15 @@ bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info) { 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? - // commented out by JACS 2007-9-08 after having added a pixel in wxMSW's wxToolBar::DoGetBestSize() - // pinfo.best_size.y++; } +#endif // wxUSE_TOOLBAR if (pinfo.min_size != wxDefaultSize) { @@ -1280,7 +1329,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(); @@ -1314,7 +1363,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)); @@ -1522,10 +1571,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(); @@ -1535,6 +1589,7 @@ bool wxAuiManager::LoadPerspective(const wxString& layout, bool update) input.Replace(wxT("\\|"), wxT("\a")); input.Replace(wxT("\\;"), wxT("\b")); + m_has_maximized = false; while (1) { wxAuiPaneInfo pane; @@ -1577,6 +1632,9 @@ bool wxAuiManager::LoadPerspective(const wxString& layout, bool update) LoadPaneInfo(pane_part, pane); + if ( pane.IsMaximized() ) + m_has_maximized = true; + wxAuiPaneInfo& p = GetPane(pane.name); if (!p.IsOk()) { @@ -2531,6 +2589,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()); } @@ -2765,7 +2834,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; } @@ -2809,7 +2893,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)), @@ -2825,7 +2911,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)), @@ -2841,7 +2929,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)), @@ -2857,7 +2947,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)), @@ -2894,7 +2986,8 @@ 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 )) { @@ -2902,13 +2995,9 @@ bool wxAuiManager::DoDrop(wxAuiDockInfoArray& 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()) { - if (drop.IsFloatable()) - drop.Float(); + drop.Float(); } m_skipping = false; @@ -3189,6 +3278,8 @@ 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; } @@ -3230,8 +3321,10 @@ void wxAuiManager::ShowHint(const wxRect& rect) 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... @@ -3257,7 +3350,8 @@ 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(); #ifdef __WXGTK__ @@ -3299,6 +3393,10 @@ void wxAuiManager::HideHint() m_hint_wnd->Show(false); m_hint_wnd->SetTransparent(0); 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; } @@ -3317,7 +3415,7 @@ 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 + // 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. @@ -3344,13 +3442,22 @@ void wxAuiManager::StartPaneDrag(wxWindow* pane_window, m_action_window = pane_window; m_action_offset = 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_action_offset += 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 @@ -3465,6 +3572,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); } @@ -3475,6 +3585,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 @@ -3575,6 +3688,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 @@ -3647,13 +3763,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); } @@ -3755,7 +3874,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) @@ -4045,26 +4164,84 @@ bool wxAuiManager::DoEndResizeAction(wxMouseEvent& event) // resize the dock or the pane if (m_action_part && m_action_part->type==wxAuiDockUIPart::typeDockSizer) { + // 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; + + wxSize client_size = m_frame->GetClientSize(); + + size_t dock_i, dock_count = m_docks.GetCount(); + for (dock_i = 0; dock_i < dock_count; ++dock_i) + { + 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; + + +#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) + { + wxSize status_client_size = status->GetClientSize(); + available_height -= status_client_size.GetHeight(); + } + } +#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) { case wxAUI_DOCK_LEFT: - m_action_part->dock->size = new_pos.x - rect.x; + 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: - m_action_part->dock->size = new_pos.y - rect.y; + 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: - m_action_part->dock->size = rect.x + rect.width - - new_pos.x - m_action_part->rect.GetWidth(); + 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: - m_action_part->dock->size = rect.y + rect.height - + 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; } @@ -4139,6 +4316,11 @@ bool wxAuiManager::DoEndResizeAction(wxMouseEvent& event) } } + // new size can never be more than the number of dock pixels + if (new_pixsize > dock_pixels) + new_pixsize = dock_pixels; + + // 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 @@ -4213,10 +4395,26 @@ bool wxAuiManager::DoEndResizeAction(wxMouseEvent& event) 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; + // 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; + + 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); @@ -4354,9 +4552,19 @@ void wxAuiManager::OnMotion(wxMouseEvent& event) wxScreenDC dc; if (!m_action_hintrect.IsEmpty()) + { + // remove old resize hint DrawResizeHint(dc, m_action_hintrect); - DrawResizeHint(dc, rect); - m_action_hintrect = rect; + 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; + } } } } @@ -4415,6 +4623,15 @@ void wxAuiManager::OnMotion(wxMouseEvent& event) { if (m_action_window) { + // 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 (!m_action_window->IsKindOf(CLASSINFO(wxAuiFloatingFrame))) + { + wxAuiPaneInfo& pane = GetPane(m_action_window); + m_action_window = 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);