///////////////////////////////////////////////////////////////////////////////
-// Name: framemanager.cpp
+// Name: src/aui/framemanager.cpp
// Purpose: wxaui: wx advanced user interface - docking window manager
// Author: Benjamin I. Williams
// Modified by:
// Created: 2005-05-17
-// RCS-ID:
+// RCS-ID: $Id$
// Copyright: (C) Copyright 2005-2006, Kirix Corporation, All Rights Reserved
// Licence: wxWindows Library Licence, Version 3.1
///////////////////////////////////////////////////////////////////////////////
#include "wx/aui/floatpane.h"
#ifndef WX_PRECOMP
-// #include "wx/log.h"
+ #include "wx/settings.h"
+ #include "wx/app.h"
+ #include "wx/dcclient.h"
+ #include "wx/dcscreen.h"
#endif
//#include "wx/dcbuffer.h"
-#include "wx/dcclient.h"
-#include "wx/dcscreen.h"
-#include "wx/app.h"
#include "wx/image.h"
-#include "wx/settings.h"
#include "wx/toolbar.h"
#if wxUSE_MDI
-#include "wx/mdi.h"
+ #include "wx/mdi.h"
#endif
WX_CHECK_BUILD_OPTIONS("wxAUI")
{
wxBitmap stipple = wxPaneCreateStippleBitmap();
wxBrush brush(stipple);
- dc.SetBrush(brush);
+ dc.SetBrush(brush);
dc.SetPen(*wxTRANSPARENT_PEN);
dc.SetLogicalFunction(wxXOR);
static PSETLAYEREDWINDOWATTR pSetLayeredWindowAttributes = NULL;
static HMODULE h = NULL;
HWND hwnd = (HWND)wnd->GetHWND();
-
+
if (!h)
h = LoadLibrary(_T("user32"));
-
+
if (!pSetLayeredWindowAttributes)
{
pSetLayeredWindowAttributes =
(PSETLAYEREDWINDOWATTR)GetProcAddress(h,"SetLayeredWindowAttributes");
}
-
+
if (pSetLayeredWindowAttributes == NULL)
return;
-
+
LONG exstyle = GetWindowLong(hwnd, GWL_EXSTYLE);
if (0 == (exstyle & 0x80000) /*WS_EX_LAYERED*/)
- SetWindowLong(hwnd, GWL_EXSTYLE, exstyle | 0x80000 /*WS_EX_LAYERED*/);
-
- pSetLayeredWindowAttributes(hwnd, 0, amount, 2 /*LWA_ALPHA*/);
+ SetWindowLong(hwnd, GWL_EXSTYLE, exstyle | 0x80000 /*WS_EX_LAYERED*/);
+
+ pSetLayeredWindowAttributes(hwnd, 0, (BYTE)amount, 2 /*LWA_ALPHA*/);
}
#endif
{
wxPaneInfo& pane = panes.Item(i);
if (pane.dock_direction == direction &&
- pane.dock_layer == layer &&
+ pane.dock_layer == layer &&
pane.dock_row > max_row)
max_row = pane.dock_row;
}
}
}
-// DoInsertDockLayer() is an internal function that inserts a space for
+// DoInsertDockLayer() is an internal function that inserts a space for
// another dock pane by incrementing all existing dock row values by one
static void DoInsertPane(wxPaneInfoArray& panes,
int dock_direction,
max_row = wxMax(max_row, docks.Item(i).dock_row);
max_layer = wxMax(max_layer, docks.Item(i).dock_layer);
}
-
+
// if no dock layer was specified, search all dock layers
if (dock_layer == -1)
{
begin_layer = 0;
end_layer = max_layer;
}
-
+
// if no dock row was specified, search all dock row
if (dock_row == -1)
{
for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
{
wxDockUIPart* item = &m_uiparts.Item(i);
-
- // we are not interested in typeDock, because this space
+
+ // we are not interested in typeDock, because this space
// isn't used to draw anything, just for measurements;
// besides, the entire dock area is covered with other
// rectangles, which we are interested in.
if (item->type == wxDockUIPart::typeDock)
continue;
-
+
// if we already have a hit on a more specific item, we are not
// interested in a pane hit. If, however, we don't already have
// a hit, returning a pane hit is necessary for some operations
if ((item->type == wxDockUIPart::typePane ||
item->type == wxDockUIPart::typePaneBorder) && result)
continue;
-
+
// if the point is inside the rectangle, we have a hit
if (item->rect.Inside(x,y))
result = item;
}
-
+
return result;
}
{
// delete the last art provider, if any
delete m_art;
-
+
// assign the new art provider
m_art = art_provider;
}
// set the pane window
pinfo.window = window;
-
+
// if the pane's name identifier is blank, create a random string
- if (pinfo.name.IsEmpty())
+ if (pinfo.name.empty())
{
pinfo.name.Printf(wxT("%08x%08x%08x%08x"),
((unsigned long)pinfo.window) & 0xffffffff,
(unsigned int)time(NULL),
(unsigned int)clock(), m_panes.GetCount());
}
-
+
// set initial proportion (if not already set)
if (pinfo.dock_proportion == 0)
pinfo.dock_proportion = 100000;
button.button_id = wxPaneInfo::buttonClose;
pinfo.buttons.Add(button);
}
-
+
if (pinfo.best_size == wxDefaultSize &&
pinfo.window)
{
// 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
// correct?
pinfo.best_size.y++;
}
-
+
if (pinfo.min_size != wxDefaultSize)
{
if (pinfo.best_size.x < pinfo.min_size.x)
pane_info.dock_layer);
break;
}
-
+
// if the window already exists, we are basically just moving/inserting the
// existing window. If it doesn't exist, we need to add it and insert it
wxPaneInfo& existing_pane = GetPane(window);
return true;
}
-
+
bool wxFrameManager::DetachPane(wxWindow* window)
{
int i, count;
for (i = 0, count = m_panes.GetCount(); i < count; ++i)
{
- wxPaneInfo& p = m_panes.Item(i);
+ wxPaneInfo& p = m_panes.Item(i);
if (p.window == window)
{
if (p.frame)
static wxString EscapeDelimiters(const wxString& s)
{
wxString result;
- result.Alloc(s.Length());
+ result.Alloc(s.length());
const wxChar* ch = s.c_str();
while (*ch)
{
for (pane_i = 0; pane_i < pane_count; ++pane_i)
{
wxPaneInfo& pane = m_panes.Item(pane_i);
-
+
result += wxT("name=");
result += EscapeDelimiters(pane.name);
result += wxT(";");
-
+
result += wxT("caption=");
result += EscapeDelimiters(pane.caption);
result += wxT(";");
-
+
result += wxString::Format(wxT("state=%u;"), pane.state);
result += wxString::Format(wxT("dir=%d;"), pane.dock_direction);
result += wxString::Format(wxT("layer=%d;"), pane.dock_layer);
result += wxString::Format(wxT("floath=%d"), pane.floating_size.y);
result += wxT("|");
}
-
+
int dock_i, dock_count = m_docks.GetCount();
for (dock_i = 0; dock_i < dock_count; ++dock_i)
{
wxDockInfo& dock = m_docks.Item(dock_i);
-
+
result += wxString::Format(wxT("dock_size(%d,%d,%d)=%d|"),
dock.dock_direction, dock.dock_layer,
dock.dock_row, dock.size);
}
-
+
return result;
}
{
wxString input = layout;
wxString part;
-
+
// check layout string version
part = input.BeforeFirst(wxT('|'));
input = input.AfterFirst(wxT('|'));
part.Trim(false);
if (part != wxT("layout1"))
return false;
-
-
+
+
// mark all panes currently managed as docked and hidden
int pane_i, pane_count = m_panes.GetCount();
for (pane_i = 0; pane_i < pane_count; ++pane_i)
// clear out the dock array; this will be reconstructed
m_docks.Clear();
-
+
// replace escaped characters so we can
// split up the string easily
input.Replace(wxT("\\|"), wxT("\a"));
input.Replace(wxT("\\;"), wxT("\b"));
-
+
while (1)
{
wxPaneInfo pane;
pane_part.Trim(true);
// if the string is empty, we're done parsing
- if (pane_part.IsEmpty())
+ if (pane_part.empty())
break;
{
wxString val_name = pane_part.BeforeFirst(wxT('='));
wxString value = pane_part.AfterFirst(wxT('='));
-
+
long dir, layer, row, size;
wxString piece = val_name.AfterFirst(wxT('('));
piece = piece.BeforeLast(wxT(')'));
piece.BeforeFirst(wxT(',')).ToLong(&layer);
piece.AfterFirst(wxT(',')).ToLong(&row);
value.ToLong(&size);
-
+
wxDockInfo dock;
dock.dock_direction = dir;
dock.dock_layer = layer;
val_name.Trim(false);
value.Trim(true);
value.Trim(false);
-
- if (val_name.IsEmpty())
+
+ if (val_name.empty())
break;
if (val_name == wxT("name"))
wxFAIL_MSG(wxT("Bad Perspective String"));
}
}
-
+
// replace escaped characters so we can
// split up the string easily
pane.name.Replace(wxT("\a"), wxT("|"));
pane.name.Replace(wxT("\b"), wxT(";"));
pane.caption.Replace(wxT("\a"), wxT("|"));
pane.caption.Replace(wxT("\b"), wxT(";"));
-
+
wxPaneInfo& p = GetPane(pane.name);
if (!p.IsOk())
{
// in the existing layout
return false;
}
-
+
pane.window = p.window;
pane.frame = p.frame;
pane.buttons = p.buttons;
p = pane;
}
-
+
if (update)
Update();
action_pane = pane_i;
}
}
-
+
// set up each panes default position, and
// determine the size (width or height, depending
// on the dock's orientation) of each pane
wxPaneInfo& pane = *(dock.panes.Item(pane_i));
positions.Add(pane.dock_pos);
int size = 0;
-
+
if (pane.HasBorder())
size += (pane_border_size*2);
-
+
if (dock.IsHorizontal())
{
if (pane.HasGripper() && !pane.HasGripperTop())
size += gripper_size;
if (pane.HasCaption())
- size += caption_size;
+ size += caption_size;
size += pane.best_size.y;
}
-
+
sizes.Add(size);
}
offset += sizes[pane_i];
}
-
+
// if the dock mode is fixed, make sure none of the panes
// overlap; we will bump panes that overlap
offset = 0;
wxPaneInfo& pane,
wxDockUIPartArray& uiparts,
bool spacer_only)
-{
+{
wxDockUIPart part;
wxSizerItem* sizer_item;
{
if (pane.HasGripperTop())
sizer_item = vert_pane_sizer ->Add(1, gripper_size, 0, wxEXPAND);
- else
+ else
sizer_item = horz_pane_sizer ->Add(gripper_size, 1, 0, wxEXPAND);
part.type = wxDockUIPart::typeGripper;
// determine if the pane should have a minimum size; if the pane is
// non-resizable (fixed) then we must set a minimum size. Alternitavely,
// if the pane.min_size is set, we must use that value as well
-
+
wxSize min_size = pane.min_size;
if (pane.IsFixed())
{
pane_proportion = 0;
}
}
-
+
if (min_size != wxDefaultSize)
{
vert_pane_sizer->SetItemMinSize(
if (dock.fixed)
{
wxArrayInt pane_positions, pane_sizes;
-
+
// figure out the real pane positions we will
// use, without modifying the each pane's pane_pos member
GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);
int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE);
wxSize cli_size = m_frame->GetClientSize();
int i, dock_count, pane_count;
-
+
// empty all docks out
for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
docks.Item(i).panes.Empty();
-
+
// iterate through all known panes, filing each
// of them into the appropriate dock. If the
// pane does not exist in the dock, add it
RemovePaneFromDocks(docks, p, dock);
// pane needs to be added to the dock,
- // if it doesn't already exist
+ // if it doesn't already exist
if (!FindPaneInDock(*dock, p.window))
dock->panes.Add(&p);
}
{
wxDockInfo& dock = docks.Item(i);
int j, dock_pane_count = dock.panes.GetCount();
-
+
// sort the dock pane array by the pane's
// dock position (dock_pos), in ascending order
dock.panes.Sort(PaneSortFunc);
pane_size = pane.min_size;
if (pane_size == wxDefaultSize)
pane_size = pane.window->GetSize();
-
+
if (dock.IsHorizontal())
size = wxMax(pane_size.y, size);
else
size = wxMax(pane_size.x, size);
}
-
+
// add space for the border (two times), but only
// if at least one pane inside the dock has a pane border
for (j = 0; j < dock_pane_count; ++j)
}
}
}
-
+
if (plus_border)
dock_min_size += (pane_border_size*2);
if (plus_caption && dock.IsHorizontal())
dock_min_size += (caption_size);
-
+
dock.min_size = dock_min_size;
-
-
+
+
// if the pane's current size is less than it's
// minimum, increase the dock's size to it's minimum
if (dock.size < dock.min_size)
{
wxArrayInt pane_positions, pane_sizes;
GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);
-
+
int offset = 0;
for (j = 0; j < dock_pane_count; ++j)
{
}
}
}
-
+
// discover the maximum dock layer
int max_layer = 0;
for (i = 0; i < dock_count; ++i)
max_layer = wxMax(max_layer, docks.Item(i).dock_layer);
-
+
// clear out uiparts
uiparts.Empty();
LayoutAddDock(cont, *arr.Item(row), uiparts, spacer_only);
}
-
+
// fill out the middle layer (which consists
// of left docks, content area and right docks)
-
+
middle = new wxBoxSizer(wxHORIZONTAL);
// find any left docks in this layer
{
// because the pane is no longer in a floating, we need to
// reparent it to m_frame and destroy the floating frame
-
+
// reduce flicker
p.window->SetSize(1,1);
p.frame->Show(false);
-
+
// reparent to m_frame and destroy the pane
p.window->Reparent(m_frame);
p.frame->SetSizer(NULL);
this, -1,
p.floating_pos,
p.floating_size);
-
+
// on MSW, if the owner desires transparent dragging, and
// the dragging is happening right now, then the floating
- // window should have this style by default
- #ifdef __WXMSW__
+ // window should have this style by default
+#ifdef __WXMSW__
if (m_action == actionDragFloatingPane &&
(m_flags & wxAUI_MGR_TRANSPARENT_DRAG))
MakeWindowTransparent(frame, 150);
- #endif
-
+#endif
+
frame->SetPaneWindow(p);
p.frame = frame;
Repaint();
-
+
// set frame's minimum size
-
+
/*
// N.B. More work needs to be done on frame minimum sizes;
// this is some intresting code that imposes the minimum size,
wxSize minframe_size(min_size.x+frame_size.x-client_size.x,
min_size.y+frame_size.y-client_size.y );
-
+
m_frame->SetMinSize(minframe_size);
-
+
if (frame_size.x < minframe_size.x ||
frame_size.y < minframe_size.y)
sizer->Fit(m_frame);
void wxFrameManager::DoFrameLayout()
{
m_frame->Layout();
-
+
int i, part_count;
for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
{
// part.rect = wxRect(part.sizer_item->GetPosition(),
// part.sizer_item->GetSize());
// this worked quite well, with one exception: the mdi
- // client window had a "deferred" size variable
+ // client window had a "deferred" size variable
// that returned the wrong size. It looks like
// a bug in wx, because the former size of the window
// was being returned. So, we will retrieve the part's
{
// the only way to accurately calculate the dock's
// offset is to actually run a theoretical layout
-
+
int i, part_count, dock_count;
wxDockInfoArray docks;
wxPaneInfoArray panes;
if (part.type == wxDockUIPart::typeDock)
part.dock->rect = part.rect;
}
-
+
delete sizer;
-
+
for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
{
wxDockInfo& dock = docks.Item(i);
// The result should always be shown
drop.Show();
-
+
// Check to see if the pane has been dragged outside of the window
// (or near to the outside of the window), if so, dock it along the edge
int layer_insert_offset = auiLayerInsertOffset;
if (target.IsToolbar())
layer_insert_offset = 0;
-
+
if (pt.x < layer_insert_offset &&
pt.x > layer_insert_offset-auiLayerInsertPixels)
{
int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_LEFT),
GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)),
- GetMaxLayer(docks, wxAUI_DOCK_TOP)) + 1;
+ GetMaxLayer(docks, wxAUI_DOCK_TOP)) + 1;
drop.Dock().Left().
Layer(new_layer).
Row(0).
{
int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_RIGHT),
GetMaxLayer(docks, wxAUI_DOCK_TOP)),
- GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)) + 1;
+ GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)) + 1;
drop.Dock().Right().
Layer(new_layer).
Row(0).
{
if (!part || !part->dock)
return false;
-
+
// calculate the offset from where the dock begins
// to the point where the user dropped the pane
{
drop.Float();
}
-
+
return ProcessDockResult(target, drop);
}
-
+
drop.Dock().
Direction(part->dock->dock_direction).
Layer(part->dock->dock_layer).
part->dock->dock_row);
drop.dock_row = row;
}
-
+
if ((
((pt.y > part->dock->rect.y + part->dock->rect.height - 2 ) && part->dock->IsHorizontal()) ||
((pt.x > part->dock->rect.x + part->dock->rect.width - 2 ) && part->dock->IsVertical())
-
+
if (!part)
return false;
part = GetPanePart(part->pane->window);
if (!part)
return false;
-
+
bool insert_dock_row = false;
int insert_row = part->pane->dock_row;
int insert_dir = part->pane->dock_direction;
int insert_layer = part->pane->dock_layer;
-
+
switch (part->pane->dock_direction)
{
case wxAUI_DOCK_TOP:
if (new_row_pixels_y > (part->rect.height*20)/100)
new_row_pixels_y = (part->rect.height*20)/100;
-
+
// determine if the mouse pointer is in a location that
// will cause a new row to be inserted. The hot spot positions
// are along the borders of the center pane
}
if (insert_dock_row)
- {
+ {
DoInsertDockRow(panes, insert_dir, insert_layer, insert_row);
drop.Dock().Direction(insert_dir).
Layer(insert_layer).
Position(0);
return ProcessDockResult(target, drop);
}
-
+
// determine the mouse offset and the pane size, both in the
// direction of the dock itself, and perpendicular to the dock
-
+
int offset, size;
-
+
if (part->orientation == wxVERTICAL)
{
offset = pt.y - part->rect.y;
- size = part->rect.GetHeight();
+ size = part->rect.GetHeight();
}
else
{
offset = pt.x - part->rect.x;
size = part->rect.GetWidth();
}
-
+
int drop_position = part->pane->dock_pos;
-
+
// if we are in the top/left part of the pane,
// insert the pane before the pane being hovered over
if (offset <= size/2)
m_hint_fadetimer.Stop();
return;
}
-
+
m_hint_fadeamt += 5;
MakeWindowTransparent(m_hint_wnd, m_hint_fadeamt);
#endif
void wxFrameManager::ShowHint(const wxRect& rect)
{
- #ifdef __WXMSW__
-
+#ifdef __WXMSW__
+
// First, determine if the operating system can handle transparency.
// Transparency is available on Win2000 and above
-
+
static int os_type = -1;
static int ver_major = -1;
-
+
if (os_type == -1)
os_type = ::wxGetOsVersion(&ver_major);
// If the transparent flag is set, and the OS supports it,
// go ahead and use a transparent hint
-
+
if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) != 0 &&
os_type == wxWINDOWS_NT && ver_major >= 5)
{
if (m_last_hint == rect)
return;
m_last_hint = rect;
-
+
int initial_fade = 50;
if (m_flags & wxAUI_MGR_TRANSPARENT_HINT_FADE)
initial_fade = 0;
-
+
if (m_hint_wnd == NULL)
{
wxPoint pt = rect.GetPosition();
MakeWindowTransparent(m_hint_wnd, initial_fade);
m_hint_wnd->SetSize(pt.x, pt.y, rect.width, rect.height);
}
-
+
if (m_flags & wxAUI_MGR_TRANSPARENT_HINT_FADE)
{
// start fade in timer
m_hint_fadetimer.SetOwner(this, 101);
m_hint_fadetimer.Start(5);
}
-
+
return;
}
- #endif
+#endif
if (m_last_hint != rect)
{
m_frame->Refresh();
m_frame->Update();
}
-
+
wxScreenDC screendc;
wxRegion clip(1, 1, 10000, 10000);
}
void wxFrameManager::HideHint()
-{
+{
// hides a transparent window hint (currently wxMSW only)
- #ifdef __WXMSW__
+#ifdef __WXMSW__
if (m_hint_wnd)
{
MakeWindowTransparent(m_hint_wnd, 0);
m_last_hint = wxRect();
return;
}
- #endif
-
+#endif
+
// hides a painted hint by redrawing the frame window
if (!m_last_hint.IsEmpty())
{
break;
}
}
-
+
delete sizer;
if (rect.IsEmpty())
// try to find the pane
wxPaneInfo& pane = GetPane(wnd);
wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
-
- #ifdef __WXMSW__
+
+#ifdef __WXMSW__
if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
MakeWindowTransparent(pane.frame, 150);
- #endif
+#endif
}
void wxFrameManager::OnFloatingPaneMoving(wxWindow* wnd)
// try to find the pane
wxPaneInfo& pane = GetPane(wnd);
wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
-
+
wxPoint pt = ::wxGetMousePosition();
wxPoint client_pt = m_frame->ScreenToClient(pt);
-
+
// calculate the offset from the upper left-hand corner
// of the frame to the mouse pointer
wxPoint frame_pos = pane.frame->GetPosition();
wxPaneInfoArray panes;
wxDockUIPartArray uiparts;
wxPaneInfo hint = pane;
-
+
CopyDocksAndPanes(docks, panes, m_docks, m_panes);
// find out where the new pane would be
return;
if (hint.IsFloating())
return;
-
+
pane = hint;
m_action = actionDragToolbarPane;
m_action_window = pane.window;
-
+
Update();
}
-
+
return;
}
DrawHintRect(wnd, client_pt, action_offset);
- #ifdef __WXGTK__
+#ifdef __WXGTK__
// this cleans up some screen artifacts that are caused on GTK because
// we aren't getting the exact size of the window (see comment
// in DrawHintRect)
//Refresh();
- #endif
-
-
+#endif
+
+
// reduces flicker
m_frame->Update();
}
// try to find the pane
wxPaneInfo& pane = GetPane(wnd);
wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
-
+
wxPoint pt = ::wxGetMousePosition();
wxPoint client_pt = m_frame->ScreenToClient(pt);
-
+
// calculate the offset from the upper left-hand corner
// of the frame to the mouse pointer
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 (pane.IsFloating())
{
pane.floating_pos = pane.frame->GetPosition();
-
+
#ifdef __WXMSW__
if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
MakeWindowTransparent(pane.frame, 255);
#endif
}
-
+
Update();
-
+
HideHint();
}
// try to find the pane
wxPaneInfo& pane = GetPane(wnd);
wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
-
+
pane.floating_size = size;
}
// don't draw hidden pane items
if (part.sizer_item && !part.sizer_item->IsShown())
continue;
-
+
switch (part.type)
{
case wxDockUIPart::typeDockSizer:
break;
case wxDockUIPart::typeGripper:
m_art->DrawGripper(*dc, part.rect, *part.pane);
- break;
+ break;
case wxDockUIPart::typePaneBorder:
m_art->DrawBorder(*dc, part.rect, *part.pane);
break;
cursor = wxCursor(wxCURSOR_SIZING);
}
}
-
+
event.SetCursor(cursor);
}
wxDockUIPart* hit_test = HitTest(event.GetX(), event.GetY());
int state = wxAUI_BUTTON_STATE_NORMAL;
-
+
if (hit_test == button_ui_part)
{
if (event.LeftDown())
wxPaneInfo& p = *dock.panes.Item(i);
if (p.window == pane.window)
pane_position = i;
-
+
// while we're at it, subtract the pane sash
// width from the dock width, because this would
// skew our proportion calculations
if (i > 0)
dock_pixels -= sash_size;
-
+
// also, the whole size (including decorations) of
// all fixed panes must also be subtracted, because they
// are not part of the proportion calculation
total_proportion += p.dock_proportion;
}
}
-
+
// 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
break;
}
}
-
-
+
+
// 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)
{
// calculate the new proportion of the pane
int new_proportion = (new_pixsize*total_proportion)/dock_pixels;
-
+
// 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,
if (pane.min_size.IsFullySpecified())
{
min_size = 0;
-
+
if (pane.HasBorder())
min_size += (pane_border_size*2);
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
min_size++;
int min_proportion = (min_size*total_proportion)/dock_pixels;
-
+
if (new_proportion < min_proportion)
new_proportion = min_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;
-
+
// repaint
Update();
Repaint(NULL);
else if (m_action == actionClickButton)
{
m_hover_button = NULL;
- m_frame->ReleaseMouse();
+ 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()))
- {
+ {
// fire button-click event
wxFrameManagerEvent e(wxEVT_AUI_PANEBUTTON);
e.SetPane(m_action_part->pane);
wxPaneInfo& pane = GetPane(m_action_window);
wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
-
+
// save the new positions
wxDockInfoPtrArray docks;
FindDocks(m_docks, pane.dock_direction,
if (docks.GetCount() == 1)
{
wxDockInfo& dock = *docks.Item(0);
-
+
wxArrayInt pane_positions, pane_sizes;
GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);
-
+
int i, dock_pane_count = dock.panes.GetCount();
for (i = 0; i < dock_pane_count; ++i)
dock.panes.Item(i)->dock_pos = pane_positions[i];
}
-
+
pane.state &= ~wxPaneInfo::actionPane;
Update();
}
// sure that only real mouse moves will get anywhere in this method;
// this appears to be a bug somewhere, and I don't know where the
// mouse move event is being generated. only verified on MSW
-
+
wxPoint mouse_pos = event.GetPosition();
if (m_last_mouse_move == mouse_pos)
return;
m_last_mouse_move = mouse_pos;
-
+
if (m_action == actionResize)
{
wxPoint pos = m_action_part->rect.GetPosition();
{
int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);
-
+
// 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)
+ abs(event.m_y - m_action_start.y) > drag_y_threshold)
{
wxPaneInfo* pane_info = m_action_part->pane;
if (!pane_info->IsToolbar())
{
if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) &&
- pane_info->IsFloatable())
+ pane_info->IsFloatable())
{
m_action = actionDragFloatingPane;
Update();
m_action_window = pane_info->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
wxPoint pt = event.GetPosition();
DoDrop(m_docks, m_panes, pane, pt, m_action_offset);
-
+
// if DoDrop() decided to float the pane, set up
// the floating pane's initial position
if (pane.IsFloating())
pane.floating_pos = wxPoint(pt.x - m_action_offset.x,
pt.y - m_action_offset.y);
}
-
+
// this will do the actiual move operation;
// in the case that the pane has been floated,
// this call will create the floating pane
// and do the reparenting
Update();
-
+
// if the pane has been floated, change the mouse
// action actionDragFloatingPane so that subsequent
// EVT_MOTION() events will move the floating pane
m_action = actionDragFloatingPane;
m_action_window = pane.frame;
}
- }
- else
+ }
+ else
{
wxDockUIPart* part = HitTest(event.GetX(), event.GetY());
if (part && part->type == wxDockUIPart::typePaneButton)
void wxFrameManager::OnChildFocus(wxChildFocusEvent& event)
{
- // when a child pane has it's focus set, we should change the
- // pane's active state to reflect this. (this is only true if
+ // when a child pane has it's focus set, we should change the
+ // pane's active state to reflect this. (this is only true if
// active panes are allowed by the owner)
if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
{
void wxFrameManager::OnPaneButton(wxFrameManagerEvent& event)
{
wxPaneInfo& pane = *(event.pane);
-
+
if (event.button == wxPaneInfo::buttonClose)
{
pane.Hide();
projects / wxWidgets.git / commitdiff
