// __WXGTK20__
#include <gtk/gtk.h>
+#include "wx/gtk/private/gtk2-compat.h"
static void
gtk_pseudo_window_realized_callback( GtkWidget *m_widget, void *WXUNUSED(win) )
if ((j*16+8)<amount)
region.Union(0, y, disp.x, 1);
}
- gdk_window_shape_combine_region(m_widget->window, region.GetRegion(), 0, 0);
+ gdk_window_shape_combine_region(gtk_widget_get_window(m_widget), region.GetRegion(), 0, 0);
}
}
+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 --
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;
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();
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(),
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));
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();
input.Replace(wxT("\\|"), wxT("\a"));
input.Replace(wxT("\\;"), wxT("\b"));
+ m_has_maximized = false;
while (1)
{
wxAuiPaneInfo pane;
LoadPaneInfo(pane_part, pane);
+ if ( pane.IsMaximized() )
+ m_has_maximized = true;
+
wxAuiPaneInfo& p = GetPane(pane.name);
if (!p.IsOk())
{
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());
}
}
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;
}
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)),
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)),
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)),
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)),
wxAuiPaneInfo& pane = m_panes.Item(i);
if (pane.IsFloating() &&
- pane.frame->IsShown())
+ pane.frame &&
+ pane.frame->IsShown())
{
wxRect rect = pane.frame->GetRect();
#ifdef __WXGTK__
// 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.
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
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);
}
// 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)
{
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);
projects / wxWidgets.git / blobdiff