internal static DockToolbarPosition Create(DockToolbar bar)
{
if (bar.Floating)
return new FloatingPosition (bar);
else
return new DockedPosition (bar);
}
public void Attach(DockToolbar bar)
{
this.bar = bar;
bar.FloatingDock = this;
Frame f = new Frame ();
f.Shadow = ShadowType.Out;
f.Add (bar);
Add (f);
f.Show ();
bar.Show ();
Show ();
}
void InsertRow(DockToolbar ibar, int offset, int row)
{
MoveBar (ibar, offset, row);
foreach (DockToolbar bar in bars) {
if (ibar != bar && bar.DockRow >= row)
bar.DockRow++;
}
SortBars ();
UpdateRowHeight (row);
}
internal void EndDragBar(DockToolbar bar, uint time)
{
Pointer.Ungrab (time);
if (targetPanel != null) {
targetPanel.DropDragBar (bar);
targetPanel.EndDragBar (bar);
}
dragBar = null;
}
int GetChildRightOffset(DockToolbar bar)
{
return bar.DockOffset + bar.Size;
}
void SetNewRowPlaceholder(DockToolbar bar, int offset, int toprow)
{
if (dropRow != -1)
RestoreShiftedBars (dropRow);
int y = GetRowTop (toprow) - parentFrame.DockMargin;
int h = parentFrame.DockMargin * 2;
ShowPlaceholder (bar, true, offset, y, GetChildWidth (bar), h);
dropOffset = offset;
dropRow = toprow;
dropNewRow = true;
}
void ShowPlaceholder(DockToolbar bar, bool horz, int x, int y, int w, int h)
{
if (orientation != Orientation.Horizontal)
horz = !horz;
PanelToWindow (x, y, w, h, out x, out y, out w, out h);
bool created = false;
if (placeholder == null || horz != currentPlaceholderHorz) {
HidePlaceholder ();
placeholder = new PlaceholderWindow (parentFrame);
placeholderArrow1 = new ArrowWindow (parentFrame, horz ? ArrowWindow.Direction.Right : ArrowWindow.Direction.Down);
placeholderArrow2 = new ArrowWindow (parentFrame, horz ? ArrowWindow.Direction.Left : ArrowWindow.Direction.Up);
currentPlaceholderHorz = horz;
created = true;
}
int sx, sy;
this.GdkWindow.GetOrigin (out sx, out sy);
sx += x;
sy += y;
int mg = -4;
placeholder.Move (sx - mg, sy - mg);
placeholder.Resize (w + mg*2, h + mg * 2);
if (horz) {
placeholderArrow1.Move (sx - placeholderArrow1.Width, sy + (h/2) - placeholderArrow1.Height/2);
placeholderArrow2.Move (sx + w, sy + (h/2) - placeholderArrow1.Height/2);
} else {
int px = sx + w/2 - placeholderArrow1.Width/2;
if (px < 0) px = 0;
placeholderArrow1.Move (px, sy - placeholderArrow1.Height);
placeholderArrow2.Move (px, sy + h);
}
if (created) {
placeholder.Show ();
placeholder.Present ();
if (bar.FloatingDock != null)
bar.FloatingDock.Present ();
placeholderArrow1.Present ();
placeholderArrow2.Present ();
}
}
bool IsSingleBarRow(DockToolbar bar)
{
int row = bar.DockRow;
foreach (DockToolbar b in bars) {
if (bar != b && b.DockRow == row)
return false;
}
return true;
}
void MoveBar(DockToolbar bar, int x, int row, bool setAnchorOffset)
{
int rt = GetRowTop (row);
bar.DockRow = row;
bar.DockOffset = x;
if (bar.Floating) {
FloatingDock win = bar.FloatingDock;
win.Detach ();
win.Destroy ();
InternalAdd (bar);
Put (bar, x, rt);
SortBars ();
ResetAnchorOffsets (row);
} else {
if (setAnchorOffset)
ResetAnchorOffsets (row);
InternalMove (bar, x, rt, true);
}
}
public void AddDockToolbar(DockToolbar bar, int offset, int row)
{
bool ea = EnableAnimation (false);
InternalAdd (bar);
Put (bar, 0, 0);
bar.Orientation = orientation;
MoveBar (bar, offset, row, false);
bar.AnchorOffset = offset;
SortBars ();
PackBars ();
EnableAnimation (ea);
}
public void DropDragBar(DockToolbar bar)
{
if (!IsPlaceHolderVisible) return;
foreach (DockToolbar b in bars) {
if (b.DockRow == dropRow && b.DockShiftOffset != -1) {
b.DockShiftOffset = -1;
b.AnchorOffset = b.DockRow;
}
}
if (dropRow != -1) {
if (dropNewRow)
InsertRow (bar, dropOffset, dropRow);
else {
MoveBar (bar, dropOffset, dropRow);
UpdateRowHeight (dropRow);
}
SortBars ();
dropRow = -1;
}
}
internal override void RestorePosition(DockToolbarFrame frame, DockToolbar bar)
{
frame.DockToolbar (bar, placement, dockOffset, dockRow);
}
public void AddDockToolbar(DockToolbar bar)
{
bool ea = EnableAnimation (false);
Put (bar, 0, 0);
bar.Orientation = orientation;
if (bars.Count > 0 && IsRealized) {
DockToolbar last = (DockToolbar) bars [bars.Count - 1];
int width = bar.DefaultSize;
int lastx = last.DockOffset + last.DefaultSize;
if (lastx + width <= PanelWidth)
MoveBar (bar, lastx, last.DockRow, false);
else
MoveBar (bar, 0, last.DockRow + 1, false);
bar.AnchorOffset = bar.DockOffset;
InternalAdd (bar);
SortBars ();
} else {
MoveBar (bar, 0, 0);
bar.AnchorOffset = bar.DockOffset;
InternalAdd (bar);
}
EnableAnimation (ea);
}
internal DockedPosition(DockToolbar bar)
{
dockOffset = bar.AnchorOffset;
dockRow = bar.DockRow;
placement = ((DockToolbarPanel)bar.Parent).Placement;
}
internal void StartDragBar(DockToolbar bar, int x, int y, uint time)
{
dragBar = bar;
xDragDif = -x;
yDragDif = -y;
Pointer.Grab (this.GdkWindow, false, EventMask.ButtonPressMask | EventMask.ButtonReleaseMask | EventMask.PointerMotionMask, null, new Cursor (CursorType.Hand2), time);
if (!bar.Floating) {
DockToolbarPanel panel = (DockToolbarPanel) dragBar.Parent;
panel.StartDragBar (bar);
}
}
internal void FloatBar(DockToolbar bar, Orientation orientation, int x, int y)
{
FloatingDock fdock = new FloatingDock (this);
fdock.Move (x, y);
bar.ResetSize ();
fdock.Attach (bar);
bar.Orientation = orientation;
}
void InternalAdd(DockToolbar bar)
{
bars.Add (bar);
bar.DefaultSizeChanged += new EventHandler (OnBarSizeChanged);
}
public void EndDragBar(DockToolbar bar)
{
if (IsPlaceHolderVisible) {
HidePlaceholder ();
}
}
void InternalMove(DockToolbar bar, int x, int y, bool animate)
{
if (bar.Animation != null) {
bar.Animation.Cancel ();
bar.Animation = null;
}
if (animate && enableAnimations) {
bar.Animation = new MoveAnimation (this, bar, x, y);
bar.Animation.Start ();
}
else
Move (bar, x, y);
}
public void RemoveBar(DockToolbar bar)
{
if (IsSingleBarRow (bar))
RemoveRow (bar.DockRow);
Remove (bar);
bars.Remove (bar);
bar.DefaultSizeChanged -= new EventHandler (OnBarSizeChanged);
UpdateRowHeight (bar.DockRow);
PackBars ();
}
void MoveBar(DockToolbar bar, int x, int row)
{
MoveBar (bar, x, row, true);
}
public void Reposition(DockToolbar bar, int xcursor, int ycursor, int difx, int dify)
{
if (!bar.CanDockTo (this))
return;
bar.Orientation = orientation;
int x, y;
WindowToPanel (xcursor + difx, ycursor + dify, bar.Allocation.Width, bar.Allocation.Height, out x, out y);
WindowToPanel (xcursor, ycursor, 0, 0, out xcursor, out ycursor);
RepositionInternal (bar, x, y, xcursor, ycursor);
}
void RepositionInternal(DockToolbar bar, int x, int y, int xcursor, int ycursor)
{
int width = GetChildWidth (bar);
ycursor = y + bar.DefaultHeight / 2;
if (bars.Count == 0 && bar.Floating) {
SetNewRowPlaceholder (bar, x, 0);
return;
}
int dx = (x + width) - PanelWidth;
if (dx > parentFrame.DockMargin && !bar.Floating) {
HidePlaceholder ();
FloatBar (bar, x, y);
return;
}
else if (dx > 0)
x -= dx;
else if (x < -parentFrame.DockMargin && !bar.Floating) {
HidePlaceholder ();
FloatBar (bar, x, y);
return;
}
else if (x < 0)
x = 0;
int nx = x;
int row = -1;
// Get the old bar y position
int panelBottom = GetPanelBottom ();
if (ycursor < - parentFrame.DockMargin || ycursor > panelBottom + parentFrame.DockMargin) {
HidePlaceholder ();
FloatBar (bar, x, y);
return;
}
int rtop = 0;
int prevtop = 0;
row = 0;
while (ycursor >= rtop) {
prevtop = rtop;
row++;
if (rtop >= panelBottom) break;
rtop += GetRowSize (row - 1);
}
row--;
int ry = ycursor - prevtop;
if (ry <= parentFrame.DockMargin && ry >= 0) {
SetNewRowPlaceholder (bar, x, row);
FloatBar (bar, x, y);
return;
} else if (ry >= (GetRowSize(row) - parentFrame.DockMargin) || (ry < 0 && -ry < parentFrame.DockMargin)) {
SetNewRowPlaceholder (bar, x, row + 1);
FloatBar (bar, x, y);
return;
}
// Can't create a new row. Try to fit the bar in the current row
// Find the first bar in the row:
int ns = -1;
for (int n=0; n<bars.Count; n++) {
DockToolbar b = (DockToolbar)bars[n];
// Ignore the bar being moved
if (b == bar) continue;
if (b.DockRow == row) {
ns = n;
break;
}
}
if (ns == -1) {
// There are no other bars, no problem then
if (bar.Floating) {
SetPlaceholder (bar, nx, row);
return;
}
if ((nx == bar.DockOffset && row == bar.DockRow) || (row != bar.DockRow)) {
SetPlaceholder (bar, nx, row);
FloatBar (bar, x, y);
return;
}
HidePlaceholder ();
MoveBar (bar, nx, row);
return;
}
// Compute the available space, and find the bars at the
// left and the right of the bar being moved
int gapsTotal = 0;
int lastx = 0;
int leftIndex=-1, rightIndex = -1;
int gapsLeft = 0, gapsRight = 0;
for (int n=ns; n<bars.Count; n++) {
DockToolbar b = (DockToolbar)bars[n];
// Ignore the bar being moved
if (b == bar) continue;
if (b.DockRow != row) break;
int bx = b.DockOffset;
if (bx > x && (rightIndex == -1))
rightIndex = n;
else if (bx <= x)
leftIndex = n;
if (bx < x)
gapsLeft += bx - lastx;
else {
if (lastx < x) {
gapsLeft += x - lastx;
gapsRight += bx - x;
} else
gapsRight += bx - lastx;
}
gapsTotal += bx - lastx;
lastx = GetChildRightOffset (b);
}
if (lastx < x) {
gapsLeft += x - lastx;
gapsRight += PanelWidth - x;
} else {
gapsRight += PanelWidth - lastx;
}
gapsTotal += PanelWidth - lastx;
// Is there room for the bar?
if (gapsTotal < width) {
HidePlaceholder ();
FloatBar (bar, x, y);
return;
}
// Shift the bars at the left and the right
int oversizeLeft = 0;
int oversizeRight = 0;
if (leftIndex != -1) {
int r = GetChildRightOffset ((DockToolbar) bars [leftIndex]);
oversizeLeft = r - nx;
}
if (rightIndex != -1) {
int r = ((DockToolbar) bars [rightIndex]).DockOffset;
oversizeRight = (nx + width) - r;
}
if (oversizeLeft > gapsLeft)
oversizeRight += (oversizeLeft - gapsLeft);
else if (oversizeRight > gapsRight)
oversizeLeft += (oversizeRight - gapsRight);
if (leftIndex != -1 && oversizeLeft > 0) {
ShiftBar (leftIndex, -oversizeLeft);
nx = GetChildRightOffset ((DockToolbar) bars [leftIndex]);
}
if (rightIndex != -1 && oversizeRight > 0) {
ShiftBar (rightIndex, oversizeRight);
nx = ((DockToolbar) bars [rightIndex]).DockOffset - width;
}
if (bar.Floating) {
SetPlaceholder (bar, nx, row);
return;
}
if ((nx == bar.DockOffset && row == bar.DockRow) || (row != bar.DockRow)) {
if (bar.Floating) {
SetPlaceholder (bar, nx, row);
FloatBar (bar, x, y);
}
return;
}
HidePlaceholder ();
MoveBar (bar, nx, row);
}
internal FloatingPosition(DockToolbar bar)
{
orientation = bar.Orientation;
bar.FloatingDock.GetPosition (out x, out y);
}
void SetPlaceholder(DockToolbar bar, int offset, int row)
{
if (dropRow != row && dropRow != -1)
RestoreShiftedBars (dropRow);
ShowPlaceholder (bar, false, offset, GetRowTop (row), GetChildWidth (bar), GetRowSize (row));
dropOffset = offset;
dropRow = row;
dropNewRow = false;
}
public IDockToolbar AddBar(DockToolbar bar, Placement defaultPanel, bool defaultVisible)
{
bar.SetParentFrame (this);
bars.Add (bar);
DockToolbarPosition pos = new DockedPosition (defaultPanel);
DockToolbarStatus s = new DockToolbarStatus (bar.Id, defaultVisible, pos);
bar.DefaultStatus = s;
bar.Status = s;
return bar;
}
public void StartDragBar(DockToolbar bar)
{
}
internal void DockToolbar(DockToolbar bar, Placement placement, int offset, int row)
{
DockToolbarPanel p = GetPanel (placement);
if (row != -1)
p.AddDockToolbar (bar, offset, row);
else
p.AddDockToolbar (bar);
}
internal override void RestorePosition(DockToolbarFrame frame, DockToolbar bar)
{
frame.FloatBar (bar, orientation, x, y);
}
void FloatBar(DockToolbar bar, int x, int y)
{
if (bar.Floating) return;
int wx,wy,w,h;
PanelToWindow (x, y, GetChildWidth (bar), bar.DefaultHeight, out x, out y, out w, out h);
this.GdkWindow.GetOrigin (out wx, out wy);
RemoveBar (bar);
parentFrame.FloatBar (bar, orientation, wx + x, wy + y);
}