///////////////////////////////////////////////////////////////////////////////
-// 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"
+ #include "wx/toolbar.h"
+ #include "wx/mdi.h"
+ #include "wx/image.h"
#endif
-//#include "wx/dcbuffer.h"
-
-#include "wx/app.h"
-#include "wx/image.h"
WX_CHECK_BUILD_OPTIONS("wxAUI")
#include "wx/arrimpl.cpp"
wxPaneInfo wxNullPaneInfo;
wxDockInfo wxNullDockInfo;
DEFINE_EVENT_TYPE(wxEVT_AUI_PANEBUTTON)
+DEFINE_EVENT_TYPE(wxEVT_AUI_PANECLOSE)
+DEFINE_EVENT_TYPE(wxEVT_AUI_RENDER)
#ifdef __WXMAC__
// a few defines to avoid nameclashes
#include "wx/mac/private.h"
#endif
+IMPLEMENT_DYNAMIC_CLASS(wxFrameManagerEvent, wxEvent)
+
// -- static utility functions --
{
wxBitmap stipple = wxPaneCreateStippleBitmap();
wxBrush brush(stipple);
- dc.SetBrush(brush);
+ dc.SetBrush(brush);
dc.SetPen(*wxTRANSPARENT_PEN);
dc.SetLogicalFunction(wxXOR);
dc.DrawRectangle(rect);
}
-#ifdef __WXMSW__
-// on supported windows systems (Win2000 and greater), this function
+// on supported windows systems (Win2000 and greater, Mac), this function
// will make a frame window transparent by a certain amount
static void MakeWindowTransparent(wxWindow* wnd, int amount)
{
+#if defined(__WXMSW__)
// this API call is not in all SDKs, only the newer ones, so
// we will runtime bind this
typedef DWORD (WINAPI *PSETLAYEREDWINDOWATTR)(HWND, DWORD, BYTE, DWORD);
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");
+ (PSETLAYEREDWINDOWATTR)GetProcAddress(h,
+#ifdef __WXWINCE__
+ wxT("SetLayeredWindowAttributes")
+#else
+ "SetLayeredWindowAttributes"
+#endif
+ );
}
-
+
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*/);
+
+#elif defined(__WXMAC__)
+
+ WindowRef handle = GetControlOwner((OpaqueControlRef*)wnd->GetHandle());
+ SetWindowAlpha(handle, float(amount)/ 255.0);
+#else
+ wxUnusedVar(wnd);
+ wxUnusedVar(amount);
#endif
+}
+
// CopyDocksAndPanes() - this utility function creates copies of
{
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)
{
}
-
+// SetActivePane() sets the active pane, as well as cycles through
+// every other pane and makes sure that all others' active flags
+// are turned off
static void SetActivePane(wxPaneInfoArray& panes, wxWindow* active_pane)
{
int i, pane_count;
BEGIN_EVENT_TABLE(wxFrameManager, wxEvtHandler)
EVT_AUI_PANEBUTTON(wxFrameManager::OnPaneButton)
+ EVT_AUI_RENDER(wxFrameManager::OnRender)
EVT_PAINT(wxFrameManager::OnPaint)
EVT_ERASE_BACKGROUND(wxFrameManager::OnEraseBackground)
EVT_SIZE(wxFrameManager::OnSize)
END_EVENT_TABLE()
-wxFrameManager::wxFrameManager(wxFrame* frame, unsigned int flags)
+wxFrameManager::wxFrameManager(wxWindow* managed_wnd, unsigned int flags)
{
m_action = actionNone;
m_last_mouse_move = wxPoint();
m_hint_wnd = NULL;
m_flags = flags;
- if (frame)
+ if (managed_wnd)
{
- SetFrame(frame);
+ SetManagedWindow(managed_wnd);
}
}
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;
}
}
-// SetFrame() is usually called once when the frame
+// don't use these anymore as they are deprecated
+// use Set/GetManagedFrame() instead
+void wxFrameManager::SetFrame(wxFrame* frame)
+{
+ SetManagedWindow((wxWindow*)frame);
+}
+
+wxFrame* wxFrameManager::GetFrame() const
+{
+ return (wxFrame*)m_frame;
+}
+
+
+
+
+// SetManagedWindow() is usually called once when the frame
// manager class is being initialized. "frame" specifies
// the frame which should be managed by the frame mananger
-void wxFrameManager::SetFrame(wxFrame* frame)
+void wxFrameManager::SetManagedWindow(wxWindow* frame)
{
wxASSERT_MSG(frame, wxT("specified frame must be non-NULL"));
if (frame->IsKindOf(CLASSINFO(wxMDIParentFrame)))
{
wxMDIParentFrame* mdi_frame = (wxMDIParentFrame*)frame;
- wxMDIClientWindow* client_window = mdi_frame->GetClientWindow();
+ wxWindow* client_window = mdi_frame->GetClientWindow();
wxASSERT_MSG(client_window, wxT("Client window is NULL!"));
m_frame->RemoveEventHandler(this);
}
-// GetFrame() returns the frame pointer being managed by wxFrameManager
-wxFrame* wxFrameManager::GetFrame() const
+// GetManagedWindow() returns the window pointer being managed
+wxWindow* wxFrameManager::GetManagedWindow() const
{
return m_frame;
}
// SetArtProvider() instructs wxFrameManager to use the
// specified art provider for all drawing calls. This allows
-// plugable look-and-feel features
+// plugable look-and-feel features. The pointer that is
+// passed to this method subsequently belongs to wxFrameManager,
+// and is deleted in the frame manager destructor
void wxFrameManager::SetArtProvider(wxDockArt* art_provider)
{
// delete the last art provider, if any
delete m_art;
-
+
// assign the new art provider
m_art = art_provider;
}
+
bool wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info)
{
// check if the pane has a valid window
// 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"),
+ pinfo.name.Printf(wxT("%08lx%08x%08x%08lx"),
((unsigned long)pinfo.window) & 0xffffffff,
(unsigned int)time(NULL),
- (unsigned int)clock(), m_panes.GetCount());
+#ifdef __WXWINCE__
+ (unsigned int)GetTickCount(),
+#else
+ (unsigned int)clock(),
+#endif
+ (unsigned long)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 AddPane(window, pane_info);
}
- else
+ else
{
if (pane_info.IsFloating())
{
return true;
}
-
+
+// DetachPane() removes a pane from the frame manager. This
+// method will not destroy the window that is removed.
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;
{
sizer_item = vert_pane_sizer->Add(1, 1, 1, wxEXPAND);
}
- else
+ else
{
sizer_item = vert_pane_sizer->Add(pane.window, 1, wxEXPAND);
+ // Don't do this because it breaks the pane size in floating windows
+ // BIW: Right now commenting this out is causing problems with
+ // an mdi client window as the center pane.
vert_pane_sizer->SetItemMinSize(pane.window, 1, 1);
}
// 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(
part.sizer_item = sizer_item;
uiparts.Add(part);
}
- else
+ else
{
sizer_item = cont->Add(horz_pane_sizer, pane_proportion, wxEXPAND);
}
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);
part.sizer_item = sizer_item;
uiparts.Add(part);
}
- else
+ else
{
for (pane_i = 0; pane_i < pane_count; ++pane_i)
{
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);
// we need to create a frame for this
// pane, which has recently been floated
wxFloatingPane* frame = new wxFloatingPane(m_frame,
- this, -1,
- p.floating_pos,
- p.floating_size);
-
- // on MSW, if the owner desires transparent dragging, and
+ this,
+ p);
+
+ // on MSW and Mac, if the owner desires transparent dragging, and
// the dragging is happening right now, then the floating
- // window should have this style by default
- #ifdef __WXMSW__
+ // window should have this style by default
if (m_action == actionDragFloatingPane &&
(m_flags & wxAUI_MGR_TRANSPARENT_DRAG))
MakeWindowTransparent(frame, 150);
- #endif
-
+
frame->SetPaneWindow(p);
p.frame = frame;
if (p.frame->GetPosition() != p.floating_pos)
{
p.frame->SetSize(p.floating_pos.x, p.floating_pos.y,
- -1, -1, wxSIZE_USE_EXISTING);
+ wxDefaultCoord, wxDefaultCoord,
+ wxSIZE_USE_EXISTING);
//p.frame->Move(p.floating_pos.x, p.floating_pos.y);
}
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);
// if a dock operation is allowed, the new dock position is copied into
// the target info. If the operation was allowed, the function returns true.
-static bool ProcessDockResult(wxPaneInfo& target,
+bool wxFrameManager::ProcessDockResult(wxPaneInfo& target,
const wxPaneInfo& new_pos)
{
bool allowed = false;
// 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).
Position(pt.y - GetDockPixelOffset(drop) - offset.y);
return ProcessDockResult(target, drop);
}
- else if (pt.y < layer_insert_offset &&
- pt.y > layer_insert_offset-auiLayerInsertPixels)
+ else if (pt.y < layer_insert_offset &&
+ pt.y > layer_insert_offset-auiLayerInsertPixels)
{
int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_TOP),
GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
Position(pt.x - GetDockPixelOffset(drop) - offset.x);
return ProcessDockResult(target, drop);
}
- else if (pt.x >= cli_size.x - layer_insert_offset &&
- pt.x < cli_size.x - layer_insert_offset + auiLayerInsertPixels)
+ else if (pt.x >= cli_size.x - layer_insert_offset &&
+ pt.x < cli_size.x - layer_insert_offset + auiLayerInsertPixels)
{
int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_RIGHT),
GetMaxLayer(docks, wxAUI_DOCK_TOP)),
- GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)) + 1;
+ GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)) + 1;
drop.Dock().Right().
Layer(new_layer).
Row(0).
Position(pt.y - GetDockPixelOffset(drop) - offset.y);
return ProcessDockResult(target, drop);
}
- else if (pt.y >= cli_size.y - layer_insert_offset &&
- pt.y < cli_size.y - layer_insert_offset + auiLayerInsertPixels)
+ else if (pt.y >= cli_size.y - layer_insert_offset &&
+ pt.y < cli_size.y - layer_insert_offset + auiLayerInsertPixels)
{
int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_BOTTOM),
GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
{
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)
void wxFrameManager::OnHintFadeTimer(wxTimerEvent& WXUNUSED(event))
{
-#ifdef __WXMSW__
if (!m_hint_wnd || m_hint_fadeamt >= 50)
{
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__
-
+#if defined(__WXMSW__) || defined(__WXMAC__)
// 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_flags & wxAUI_MGR_TRANSPARENT_HINT) != 0
+#ifdef __WXMSW__
+ && os_type == wxWINDOWS_NT && ver_major >= 5
+#endif
+ )
{
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();
wxSize size = rect.GetSize();
+#if defined(__WXMSW__)
m_hint_wnd = new wxFrame(m_frame, -1, wxEmptyString, pt, size,
wxFRAME_TOOL_WINDOW |
wxFRAME_FLOAT_ON_PARENT |
MakeWindowTransparent(m_hint_wnd, initial_fade);
m_hint_wnd->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, -1, wxEmptyString, pt, size,
+ wxFRAME_FLOAT_ON_PARENT
+ | wxFRAME_TOOL_WINDOW
+ | wxCAPTION );
+
+ // Can't set the bg colour of a Frame in wxMac
+ wxPanel* p = new wxPanel(m_hint_wnd);
+
+ // The default wxSYS_COLOUR_ACTIVECAPTION colour is a light silver
+ // color that is really hard to see, especially transparent.
+ // Until a better system color is decided upon we'll just use
+ // blue.
+ p->SetBackgroundColour(*wxBLUE);
+#endif
m_hint_wnd->Show();
// if we are dragging a floating pane, set the focus
m_action_window->SetFocus();
}
- else
+ else
{
- wxPoint pt = rect.GetPosition();
- wxSize size = rect.GetSize();
MakeWindowTransparent(m_hint_wnd, initial_fade);
- m_hint_wnd->SetSize(pt.x, pt.y, rect.width, rect.height);
+ m_hint_wnd->SetSize(rect);
+ m_hint_wnd->Raise();
}
-
+
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)
{
// remove the last hint rectangle
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__
+{
+ // hides a transparent window hint, if there is one
if (m_hint_wnd)
{
MakeWindowTransparent(m_hint_wnd, 0);
m_last_hint = wxRect();
return;
}
- #endif
-
+
// hides a painted hint by redrawing the frame window
if (!m_last_hint.IsEmpty())
{
wxDockUIPartArray uiparts;
wxPaneInfo hint = GetPane(pane_window);
hint.name = wxT("__HINT__");
+ hint.Show();
if (!hint.IsOk())
return;
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__
+
if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
MakeWindowTransparent(pane.frame, 150);
- #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;
}
-void wxFrameManager::OnFloatingPaneClosed(wxWindow* wnd)
+
+void wxFrameManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt)
{
// try to find the pane
wxPaneInfo& pane = GetPane(wnd);
wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
- // reparent the pane window back to us and
- // prepare the frame window for destruction
- pane.window->Show(false);
- pane.window->Reparent(m_frame);
- pane.frame = NULL;
- pane.Hide();
+
+ // fire pane close event
+ wxFrameManagerEvent e(wxEVT_AUI_PANECLOSE);
+ e.SetPane(&pane);
+ e.SetCanVeto(evt.CanVeto());
+ ProcessMgrEvent(e);
+
+ if (e.GetVeto())
+ {
+ evt.Veto();
+ return;
+ }
+ else
+ {
+ // reparent the pane window back to us and
+ // prepare the frame window for destruction
+ pane.window->Show(false);
+ pane.window->Reparent(m_frame);
+ pane.frame = NULL;
+ pane.Hide();
+ }
}
+
+
void wxFrameManager::OnFloatingPaneActivated(wxWindow* wnd)
{
if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
{
// try to find the pane
- wxPaneInfo& pane = GetPane(wnd);
- wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
+ wxASSERT_MSG(GetPane(wnd).IsOk(), wxT("Pane window not found"));
SetActivePane(m_panes, wnd);
Repaint();
}
}
-// Render() draws all of the pane captions, sashes,
+// OnRender() draws all of the pane captions, sashes,
// backgrounds, captions, grippers, pane borders and buttons.
// It renders the entire user interface.
-void wxFrameManager::Render(wxDC* dc)
+void wxFrameManager::OnRender(wxFrameManagerEvent& evt)
{
+ wxDC* dc = evt.GetDC();
+
#ifdef __WXMAC__
dc->Clear() ;
#endif
// 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;
}
}
+
+// Render() fire a render event, which is normally handled by
+// wxFrameManager::OnRender(). This allows the render function to
+// be overridden via the render event. This can be useful for paintin
+// custom graphics in the main window. Default behavior can be
+// invoked in the overridden function by calling OnRender()
+
+void wxFrameManager::Render(wxDC* dc)
+{
+ wxFrameManagerEvent e(wxEVT_AUI_RENDER);
+ e.SetDC(dc);
+ ProcessMgrEvent(e);
+}
+
void wxFrameManager::Repaint(wxDC* dc)
{
#ifdef __WXMAC__
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())
else
state = wxAUI_BUTTON_STATE_HOVER;
}
- else
+ else
{
if (event.LeftDown())
state = wxAUI_BUTTON_STATE_HOVER;
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)
+ 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);
ProcessMgrEvent(e);
}
}
- else if (m_action == actionClickCaption)
+ else if (m_action == actionClickCaption)
{
m_frame->ReleaseMouse();
}
- else if (m_action == actionDragFloatingPane)
+ else if (m_action == actionDragFloatingPane)
{
m_frame->ReleaseMouse();
}
- else if (m_action == actionDragToolbarPane)
+ else if (m_action == actionDragToolbarPane)
{
m_frame->ReleaseMouse();
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();
}
- else
+ else
{
event.Skip();
}
// 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();
DrawResizeHint(dc, rect);
m_action_hintrect = rect;
}
- else if (m_action == actionClickCaption)
+ else if (m_action == actionClickCaption)
{
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
}
}
}
- else if (m_action == actionDragFloatingPane)
+ else if (m_action == actionDragFloatingPane)
{
wxPoint pt = m_frame->ClientToScreen(event.GetPosition());
m_action_window->Move(pt.x - m_action_offset.x,
pt.y - m_action_offset.y);
}
- else if (m_action == actionDragToolbarPane)
+ else if (m_action == actionDragToolbarPane)
{
wxPaneInfo& pane = GetPane(m_action_window);
wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
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)
{
// OnPaneButton() is an event handler that is called
// when a pane button has been pressed.
-void wxFrameManager::OnPaneButton(wxFrameManagerEvent& event)
+void wxFrameManager::OnPaneButton(wxFrameManagerEvent& evt)
{
- wxPaneInfo& pane = *(event.pane);
-
- if (event.button == wxPaneInfo::buttonClose)
+ wxASSERT_MSG(evt.pane, wxT("Pane Info passed to wxFrameManager::OnPaneButton must be non-null"));
+
+ wxPaneInfo& pane = *(evt.pane);
+
+ if (evt.button == wxPaneInfo::buttonClose)
{
- pane.Hide();
- Update();
+ // fire pane close event
+ wxFrameManagerEvent e(wxEVT_AUI_PANECLOSE);
+ e.SetPane(evt.pane);
+ ProcessMgrEvent(e);
+
+ if (!e.GetVeto())
+ {
+ pane.Hide();
+ Update();
+ }
}
- else if (event.button == wxPaneInfo::buttonPin)
+ else if (evt.button == wxPaneInfo::buttonPin)
{
if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) &&
pane.IsFloatable())
projects / wxWidgets.git / blobdiff