public IDockingPanel InsertPanel(int index)
{
if (_panels.Count > index)
{
DockControlContainer existingContainer = _panels[index] as DockControlContainer;
if (existingContainer.DockedControlList.Count == 0)
{
return(existingContainer);
}
}
DockControlContainer container = new DockControlContainer();
container.MenuStrip = _menuStrip;
container.Dock = _dockStyle;
container.Parent = _manager;
_panels.Insert(index, container);
container.Visible = true;
_manager.PerformLayout();
container.Visible = false;
_manager.PerformLayout();
return(container);
}
public void DockControl(int panelIndex, int index, DockingType direction)
{
if (direction == DockingType.Floating)
{
throw new ArgumentException("Can't dock to a docking type of floating");
}
else
{
bool autoHide = this.AutoHide;
bool cancelled = this.Cancelled;
if (this.AutoHide)
{
this.AutoHide = false;
}
this.Cancelled = false;
DockControlContainerCollection panels = DockControlContainerCollectionHelpers.GetCollection(_manager, direction);
DockControlContainer container = panels[panelIndex] as DockControlContainer;
container.DockControl(this, container.DockedControlList.Count, index);
RemoveFloatingForm();
this.AutoHide = autoHide;
this.Cancelled = cancelled;
}
}
public AutoResizeControl(DockingControl control, DockControlContainer container)
{
InitializeComponent();
this.Width = control.Width;
this.Height = control.Height;
_animator = new ControlResizeAnimator(this, control.Width);
_inner = control;
_container = container;
_inner.Parent = this;
_inner.Dock = DockStyle.Fill;
DragHandler dragHandler = new DragHandler(this, new DragHandlerHitTester(HitTestSizeArea));
_dragHandler = new SplitterDragHandler(dragHandler, SplitterDragHandlerDirection.EastWest);
_dragHandler.EndSplitterDrag += new SplitterDragEndHandler(_dragHandler_EndSplitterDrag);
_autoHideHandler = new AutoHideControlHandler(this);
_autoHideHandler.Hide += new Darwen.Windows.Forms.General.AutoHideHandler(_autoHideHandler_Hide);
_paddingDrawHandler = new PaddingDrawHandler(this);
}
private void LayoutControls(DockControlContainerCollection container)
{
for (int index = 0; index < container.Count; index += 1)
{
DockControlContainer control = container[index] as DockControlContainer;
control.SendToBack();
}
}
internal DockControlContainer GetContainerAtPoint(Point point)
{
DockControlContainer container = null;
container = GetContainerAtPoint(_leftDockControlContainers, point);
container = (container == null) ? GetContainerAtPoint(_rightDockControlContainers, point) : container;
container = (container == null) ? GetContainerAtPoint(_topDockControlContainers, point) : container;
container = (container == null) ? GetContainerAtPoint(_bottomDockControlContainers, point) : container;
return(container);
}
public TabbedDockControlContainerHandler(DockControlContainer container)
{
_container = container;
_dockingControlToPageMap = new Dictionary <DockingControl, TabPage>();
_tabControl = new TabControl();
_tabControl.Dock = DockStyle.Fill;
_tabControl.Alignment = TabAlignment.Bottom;
_tabControl.Parent = _container;
_tabControl.SelectedIndexChanged += new EventHandler(_tabControl_SelectedIndexChanged);
}
private static DockingControl GetControlBefore(DockControlContainer container, int index)
{
DockingControl controlBefore = null;
for (int indexBefore = index - 1; controlBefore == null && indexBefore >= 0; indexBefore -= 1)
{
controlBefore = container.DockedControlList[indexBefore];
if (controlBefore.AutoHide || controlBefore.Cancelled)
{
controlBefore = null;
}
}
return(controlBefore);
}
public void DockControl(DockingControl control, int dockAtIndex, int dimension)
{
using (RedrawStopper stopRedraws = new RedrawStopper(this))
{
DockControlContainer oldContainer = ControlHelpers.FindParentControl <DockControlContainer>(control);
if (oldContainer != null && oldContainer != this)
{
oldContainer.RemoveControl(control);
}
AddControl(control, dockAtIndex, dimension);
}
Invalidate(true);
}
private static DockingControl GetControlAfter(DockControlContainer container, int index)
{
DockingControl controlAfter = null;
for (int indexAfter = index + 1; controlAfter == null && indexAfter < container.DockedControlList.Count; indexAfter += 1)
{
controlAfter = container.DockedControlList[indexAfter];
if (controlAfter.AutoHide || controlAfter.Cancelled)
{
controlAfter = null;
}
}
return(controlAfter);
}
private Rectangle GetContainerDragDrawRectangle(DockControlContainer container, Point pointInScreen)
{
Point pointInControl = container.PointToClient(pointInScreen);
Rectangle clientRectangle = container.ClientRectangle;
Rectangle rectangleToDraw = Rectangle.Empty;
Rectangle containerRectangle = container.RectangleToScreen(container.ClientRectangle);
switch (container.Dock)
{
case DockStyle.Top:
case DockStyle.Bottom:
if (pointInControl.Y > clientRectangle.Y && pointInControl.Y < clientRectangle.Y + DockingBarSize)
{
rectangleToDraw = containerRectangle;
rectangleToDraw.Height = DockingBarSize;
}
else if (pointInControl.Y < clientRectangle.Bottom && pointInControl.Y > clientRectangle.Bottom - DockingBarSize)
{
rectangleToDraw = containerRectangle;
rectangleToDraw.Y = containerRectangle.Bottom - DockingBarSize;
rectangleToDraw.Height = DockingBarSize;
}
break;
case DockStyle.Left:
case DockStyle.Right:
if (pointInControl.X > clientRectangle.X && pointInControl.X < clientRectangle.X + DockingBarSize)
{
rectangleToDraw = containerRectangle;
rectangleToDraw.Width = DockingBarSize;
}
else if (pointInControl.X < clientRectangle.Right && pointInControl.X > clientRectangle.Right - DockingBarSize)
{
rectangleToDraw = containerRectangle;
rectangleToDraw.X = containerRectangle.Right - DockingBarSize;
rectangleToDraw.Width = DockingBarSize;
}
break;
default:
break;
}
return(rectangleToDraw);
}
private void DockControl(Point dropPoint, DockControlContainer container, int dimension)
{
Point containerLocalDropPoint = container.PointToClient(PointToScreen(dropPoint));
int index = 0;
DockedControlCollection controls = container.DockedControls as DockedControlCollection;
foreach (DockingControl child in controls)
{
Rectangle bounds = child.Bounds;
switch (container.Dock)
{
case DockStyle.Top:
case DockStyle.Bottom:
if (bounds.Right >= containerLocalDropPoint.X)
{
if (containerLocalDropPoint.X < (bounds.Left + bounds.Right) / 2)
{
container.DockControl(this, index, dimension);
return;
}
}
break;
case DockStyle.Left:
case DockStyle.Right:
if (bounds.Bottom >= containerLocalDropPoint.Y)
{
if (containerLocalDropPoint.Y < (bounds.Top + bounds.Bottom) / 2)
{
container.DockControl(this, index, dimension);
return;
}
}
break;
}
index += 1;
}
container.DockControl(this, container.DockedControlList.Count, dimension);
}
private void _toolStripCaption_CaptionDrag(object sender, MouseEventArgs e)
{
Point pointInScreen = this.PointToScreen(e.Location);
DockControlContainer container = _manager.GetContainerAtPoint(_manager.PointToClient(pointInScreen));
if (container == null)
{
Rectangle dragRectangle = DockControlHelpers.GetDropXorDragRect(_manager, pointInScreen, DockingBarSize);
if (!dragRectangle.IsEmpty)
{
_dragger.SetRectangle(_manager.RectangleToScreen(dragRectangle));
return;
}
}
else
{
Rectangle rectangleToDraw = GetContainerDragDrawRectangle(container, pointInScreen);
if (!rectangleToDraw.IsEmpty)
{
_dragger.SetRectangle(rectangleToDraw);
return;
}
if (container.Tabbed)
{
_dragger.SetRectangle(container.RectangleToScreen(container.ClientRectangle));
return;
}
else
{
DockingControl control = container.GetDockingControlAtPoint(container.PointToClient(pointInScreen));
if (control != null)
{
Point pointInControl = control.PointToClient(pointInScreen);
rectangleToDraw = GetContolDragDrawRectangle(container, control, pointInControl);
_dragger.SetRectangle(control.RectangleToScreen(rectangleToDraw));
return;
}
}
}
_dragger.MoveTo(e.Location);
}
static public DockControlContainer GetDropContainer(DockingManagerControl manager, Point screenDropPoint, int dockingBarSize)
{
Point managerLocalDropPoint = manager.PointToClient(screenDropPoint);
DockControlContainer container = manager.GetContainerAtPoint(managerLocalDropPoint);
if (container == null)
{
Rectangle managerClientBounds = manager.DockingBounds;
if (!HasVisibleContainer(manager.Panels[DockingType.Left]))
{
if (managerLocalDropPoint.X < managerClientBounds.Left + dockingBarSize)
{
container = manager.Panels[DockingType.Left][0] as DockControlContainer;
}
}
if (!HasVisibleContainer(manager.Panels[DockingType.Right]))
{
if (managerLocalDropPoint.X > managerClientBounds.Right - dockingBarSize)
{
container = manager.Panels[DockingType.Right][0] as DockControlContainer;
}
}
if (!HasVisibleContainer(manager.Panels[DockingType.Top]))
{
if (managerLocalDropPoint.Y < managerClientBounds.Top + dockingBarSize)
{
container = manager.Panels[DockingType.Top][0] as DockControlContainer;
}
}
if (!HasVisibleContainer(manager.Panels[DockingType.Bottom]))
{
if (managerLocalDropPoint.Y > managerClientBounds.Bottom - dockingBarSize)
{
container = manager.Panels[DockingType.Bottom][0] as DockControlContainer;
}
}
}
return(container);
}
public void Remove(DockControlContainer container)
{
if (_panels.Count == 1)
{
throw new InvalidOperationException("You must have at least one panel in each direction");
}
else
{
if (container.DockedControlList.Count > 0)
{
throw new InvalidOperationException("Can only remove empty panels");
}
else
{
_panels.Remove(container);
container.Dispose();
}
}
}
public void FloatControl(Rectangle bounds)
{
using (RedrawStopper redrawStopper = new RedrawStopper(_manager.ParentForm, true))
{
if (this.AutoHide)
{
this.AutoHide = false;
}
DockControlContainer oldContainer = _container;
Form parentForm = this.ParentForm;
if (oldContainer != null)
{
oldContainer.RemoveControl(this);
}
if (_floatingForm == null || parentForm != _floatingForm)
{
_floatingForm = new FloatingForm(this, _manager);
_autoHidetoolStripButton.Visible = false;
_tabsToolStripButton.Visible = false;
}
_floatingForm.Bounds = bounds;
if (_floatingForm.Visible)
{
_floatingForm.Invalidate();
}
else if (_floatingForm.Loaded)
{
_floatingForm.Visible = !this.Cancelled;
}
else if (!this.Cancelled)
{
_floatingForm.Show(parentForm);
}
}
}
protected virtual void OnEndCaptionDrag(Point dropPoint, Rectangle endDragBounds)
{
using (RedrawStopper stopRedraws = new RedrawStopper(_manager, true))
{
DockControlContainer container = GetDropContainer(dropPoint);
if (container == null)
{
endDragBounds.X -= FloatingForm.PaddingSize;
endDragBounds.Y -= FloatingForm.PaddingSize;
endDragBounds.Width += 2 * FloatingForm.PaddingSize;
endDragBounds.Height += 2 * FloatingForm.PaddingSize;
FloatControl(endDragBounds);
}
else
{
int dimension = DockControlHelpers.GetDockedDimension(this, container.Dock);
container = DockControlHelpers.CreateNewContainerIfNecessary(_manager, container, PointToScreen(dropPoint), DockingBarSize);
DockControl(dropPoint, container, dimension);
RemoveFloatingForm();
}
}
}
public int IndexOf(DockControlContainer panel)
{
return(_panels.IndexOf(panel));
}
public SplitterDockControlContainerHandler(DockControlContainer container)
{
_container = container;
_splitters = new List <Splitter>();
}
static private DockControlContainerCollection GetDockControlContainerCollection(DockingManagerControl manager, DockControlContainer container)
{
return(DockControlContainerCollectionHelpers.GetCollection(manager, container.Dock));
}
static public DockControlContainer CreateNewContainerIfNecessary(DockingManagerControl manager, DockControlContainer container, Point screenDropPoint, int dockingBarSize)
{
DockControlContainer result = container;
if (container.Visible)
{
Point managerLocalDropPoint = manager.PointToClient(screenDropPoint);
DockControlContainerCollection containerCollection = GetDockControlContainerCollection(manager, container);
int index = containerCollection.IndexOf(container);
switch (container.Dock)
{
case DockStyle.Top:
if (managerLocalDropPoint.Y < container.Top + dockingBarSize)
{
result = containerCollection.InsertPanel(index + 1) as DockControlContainer;
}
else if (managerLocalDropPoint.Y > container.Bottom - dockingBarSize)
{
result = containerCollection.InsertPanel(index) as DockControlContainer;
}
break;
case DockStyle.Bottom:
if (managerLocalDropPoint.Y < container.Top + dockingBarSize)
{
result = containerCollection.InsertPanel(index) as DockControlContainer;
}
else if (managerLocalDropPoint.Y > container.Bottom - dockingBarSize)
{
result = containerCollection.InsertPanel(index + 1) as DockControlContainer;
}
break;
case DockStyle.Left:
if (managerLocalDropPoint.X < container.Left + dockingBarSize)
{
result = containerCollection.InsertPanel(index + 1) as DockControlContainer;
}
else if (managerLocalDropPoint.X > container.Right - dockingBarSize)
{
result = containerCollection.InsertPanel(index) as DockControlContainer;
}
break;
case DockStyle.Right:
if (managerLocalDropPoint.X < container.Left + dockingBarSize)
{
result = containerCollection.InsertPanel(index) as DockControlContainer;
}
else if (managerLocalDropPoint.X > container.Right - dockingBarSize)
{
result = containerCollection.InsertPanel(index + 1) as DockControlContainer;
}
break;
default:
throw new InvalidOperationException("Invalid dock style");
}
}
return(result);
}
public DockedControlCollection(DockControlContainer container)
{
_container = container;
_dockedControls = new List <DockingControl>();
_iDockedControls = new List <IDockingControl>();
}
private Rectangle GetContolDragDrawRectangle(DockControlContainer container, DockingControl control, Point pointInControl)
{
Rectangle rectangleToDraw = Rectangle.Empty;
Rectangle containerRectangle = control.RectangleToClient(container.RectangleToScreen(container.ClientRectangle));
Rectangle clientRectangle = control.ClientRectangle;
int index = container.DockedControlList.IndexOf(control);
DockingControl controlBefore = GetControlBefore(container, index);
DockingControl controlAfter = GetControlAfter(container, index);
Rectangle bounds = control.Bounds;
Rectangle beforeBounds = (controlBefore == null) ? Rectangle.Empty : controlBefore.Bounds;
Rectangle afterBounds = (controlAfter == null) ? Rectangle.Empty : controlAfter.Bounds;
switch (container.Dock)
{
case DockStyle.Left:
case DockStyle.Right:
if (container.Tabbed)
{
rectangleToDraw = clientRectangle;
}
else if (pointInControl.Y < clientRectangle.Y + (clientRectangle.Height / 2))
{
if (controlBefore == null)
{
rectangleToDraw = clientRectangle;
rectangleToDraw.Height /= 2;
}
else
{
rectangleToDraw = new Rectangle(
beforeBounds.Left, beforeBounds.Top + (beforeBounds.Height / 2),
beforeBounds.Right, (bounds.Top + (bounds.Height / 2)) - (beforeBounds.Top + (beforeBounds.Height / 2)));
rectangleToDraw = control.RectangleToClient(container.RectangleToScreen(rectangleToDraw));
}
}
else
{
if (controlAfter == null)
{
rectangleToDraw = clientRectangle;
rectangleToDraw.Y = clientRectangle.Bottom - (clientRectangle.Height / 2);
rectangleToDraw.Height /= 2;
}
else
{
rectangleToDraw = new Rectangle(
bounds.Left, bounds.Top + (bounds.Height / 2),
bounds.Right, (afterBounds.Top + (afterBounds.Height / 2)) - (bounds.Top + (bounds.Height / 2)));
rectangleToDraw = control.RectangleToClient(container.RectangleToScreen(rectangleToDraw));
}
}
break;
case DockStyle.Bottom:
case DockStyle.Top:
if (container.Tabbed)
{
rectangleToDraw = clientRectangle;
}
else if (pointInControl.X < clientRectangle.X + (clientRectangle.Width / 2))
{
if (controlBefore == null)
{
rectangleToDraw = clientRectangle;
rectangleToDraw.Width /= 2;
}
else
{
rectangleToDraw = new Rectangle(
beforeBounds.Left + (beforeBounds.Width / 2), beforeBounds.Top,
(bounds.Left + (bounds.Width / 2)) - (beforeBounds.Left + (beforeBounds.Width / 2)), beforeBounds.Height);
rectangleToDraw = control.RectangleToClient(container.RectangleToScreen(rectangleToDraw));
}
}
else
{
if (controlAfter == null)
{
rectangleToDraw = clientRectangle;
rectangleToDraw.X = clientRectangle.Right - (clientRectangle.Width / 2);
rectangleToDraw.Width /= 2;
}
else
{
rectangleToDraw = new Rectangle(
bounds.Left + (bounds.Width / 2), bounds.Top,
(afterBounds.Left + (afterBounds.Width / 2)) - (bounds.Left + (bounds.Width / 2)), bounds.Height);
rectangleToDraw = control.RectangleToClient(container.RectangleToScreen(rectangleToDraw));
}
}
break;
default:
break;
}
return(rectangleToDraw);
}
public bool Contains(DockControlContainer panel)
{
return(_panels.Contains(panel));
}
