public void DockTo(DockPane pane, DockStyle dockStyle, int contentIndex)
{
if (dockStyle == DockStyle.Fill)
{
bool flag = Pane == pane;
if (!flag)
{
Pane = pane;
}
if (contentIndex == -1 || !flag)
{
pane.SetContentIndex(Content, contentIndex);
}
else
{
DockContentCollection contents = pane.Contents;
int num = contents.IndexOf(Content);
int num2 = contentIndex;
if (num < num2)
{
num2++;
if (num2 > contents.Count - 1)
{
num2 = -1;
}
}
pane.SetContentIndex(Content, num2);
}
}
else
{
DockPane dockPane = DockPanel.DockPaneFactory.CreateDockPane(Content, pane.DockState, show: true);
INestedPanesContainer nestedPanesContainer = pane.NestedPanesContainer;
switch (dockStyle)
{
case DockStyle.Left:
dockPane.DockTo(nestedPanesContainer, pane, DockAlignment.Left, 0.5);
break;
case DockStyle.Right:
dockPane.DockTo(nestedPanesContainer, pane, DockAlignment.Right, 0.5);
break;
case DockStyle.Top:
dockPane.DockTo(nestedPanesContainer, pane, DockAlignment.Top, 0.5);
break;
case DockStyle.Bottom:
dockPane.DockTo(nestedPanesContainer, pane, DockAlignment.Bottom, 0.5);
break;
}
dockPane.DockState = pane.DockState;
}
}
public void DockTo(DockPane pane, DockStyle dockStyle, int contentIndex)
{
if (dockStyle == DockStyle.Fill)
{
bool flag = this.Pane == pane;
if (!flag)
{
this.Pane = pane;
}
if (!((contentIndex != -1) && flag))
{
pane.SetContentIndex(this.Content, contentIndex);
}
else
{
DockContentCollection contents = pane.Contents;
int index = contents.IndexOf(this.Content);
int num2 = contentIndex;
if (index < num2)
{
num2++;
if (num2 > (contents.Count - 1))
{
num2 = -1;
}
}
pane.SetContentIndex(this.Content, num2);
}
}
else
{
DockPane pane2 = this.DockPanel.DockPaneFactory.CreateDockPane(this.Content, pane.DockState, true);
INestedPanesContainer nestedPanesContainer = pane.NestedPanesContainer;
if (dockStyle == DockStyle.Left)
{
pane2.DockTo(nestedPanesContainer, pane, DockAlignment.Left, 0.5);
}
else if (dockStyle == DockStyle.Right)
{
pane2.DockTo(nestedPanesContainer, pane, DockAlignment.Right, 0.5);
}
else if (dockStyle == DockStyle.Top)
{
pane2.DockTo(nestedPanesContainer, pane, DockAlignment.Top, 0.5);
}
else if (dockStyle == DockStyle.Bottom)
{
pane2.DockTo(nestedPanesContainer, pane, DockAlignment.Bottom, 0.5);
}
pane2.DockState = pane.DockState;
}
}
private void SetPaneContentIndex(DockPane pane, int contentIndex, bool samePane)
{
if (contentIndex == -1 || !samePane)
{
pane.SetContentIndex(this.Content, contentIndex);
}
else
{
DockContentCollection contents = pane.Contents;
int num = contents.IndexOf(this.Content);
int num2 = contentIndex;
if (num < num2)
{
num2++;
if (num2 > contents.Count - 1)
{
num2 = -1;
}
}
pane.SetContentIndex(this.Content, num2);
}
}
/// <include file='CodeDoc\DockContent.xml' path='//CodeDoc/Class[@name="DockContent"]/Method[@name="Show(DockPane, DockContent)"]/*'/>
public void Show(DockPane pane, DockContent beforeContent)
{
if (pane == null)
{
throw(new ArgumentNullException(ResourceHelper.GetString("DockContent.Show.NullPane")));
}
if (beforeContent != null && pane.Contents.IndexOf(beforeContent) == -1)
{
throw(new ArgumentException(ResourceHelper.GetString("DockContent.Show.InvalidBeforeContent")));
}
DockPanel = pane.DockPanel;
Pane = pane;
pane.SetContentIndex(this, pane.Contents.IndexOf(beforeContent));
Show();
}
public void Show(DockPane pane, IDockContent beforeContent)
{
if (pane == null)
{
throw new ArgumentNullException(Strings.DockContentHandler_Show_NullPane);
}
if (beforeContent != null && pane.Contents.IndexOf(beforeContent) == -1)
{
throw new ArgumentException(Strings.DockContentHandler_Show_InvalidBeforeContent);
}
pane.DockPanel.SuspendLayout(true);
this.DockPanel = pane.DockPanel;
this.Pane = pane;
pane.SetContentIndex(this.Content, pane.Contents.IndexOf(beforeContent));
this.Show();
pane.DockPanel.ResumeLayout(true, true);
}
public void Show(DockPane pane, DockContent beforeContent)
{
if (pane == null)
{
throw new InvalidOperationException("InvalidValue");
}
if (beforeContent != null && pane.Contents.IndexOf(beforeContent) == -1)
{
throw new InvalidOperationException("InvalidValue");
}
DockPanel = pane.DockPanel;
Pane = pane;
pane.SetContentIndex(this, pane.Contents.IndexOf(beforeContent));
Show();
}
public void DockTo(DockPane pane, DockStyle dockStyle, int contentIndex)
{
if (dockStyle == DockStyle.Fill)
{
for (int num = NestedPanes.Count - 1; num >= 0; num--)
{
DockPane dockPane = NestedPanes[num];
for (int num2 = dockPane.Contents.Count - 1; num2 >= 0; num2--)
{
IDockContent dockContent = dockPane.Contents[num2];
dockContent.DockHandler.Pane = pane;
if (contentIndex != -1)
{
pane.SetContentIndex(dockContent, contentIndex);
}
dockContent.DockHandler.Activate();
}
}
}
else
{
DockAlignment alignment = DockAlignment.Left;
switch (dockStyle)
{
case DockStyle.Left:
alignment = DockAlignment.Left;
break;
case DockStyle.Right:
alignment = DockAlignment.Right;
break;
case DockStyle.Top:
alignment = DockAlignment.Top;
break;
case DockStyle.Bottom:
alignment = DockAlignment.Bottom;
break;
}
MergeNestedPanes(VisibleNestedPanes, pane.NestedPanesContainer.NestedPanes, pane, alignment, 0.5);
}
}
public void DockTo(DockPane pane, DockStyle dockStyle, int contentIndex)
{
if (dockStyle == DockStyle.Fill)
{
for (int i = NestedPanes.Count - 1; i >= 0; i--)
{
DockPane paneFrom = NestedPanes[i];
for (int j = paneFrom.Contents.Count - 1; j >= 0; j--)
{
IDockContent c = paneFrom.Contents[j];
c.DockHandler.Pane = pane;
if (contentIndex != -1)
{
pane.SetContentIndex(c, contentIndex);
}
c.DockHandler.Activate();
}
}
}
else
{
DockAlignment alignment = DockAlignment.Left;
if (dockStyle == DockStyle.Left)
{
alignment = DockAlignment.Left;
}
else if (dockStyle == DockStyle.Right)
{
alignment = DockAlignment.Right;
}
else if (dockStyle == DockStyle.Top)
{
alignment = DockAlignment.Top;
}
else if (dockStyle == DockStyle.Bottom)
{
alignment = DockAlignment.Bottom;
}
MergeNestedPanes(VisibleNestedPanes, pane.NestedPanesContainer.NestedPanes, pane, alignment, 0.5);
}
}
public void DockTo(DockPane pane, DockStyle dockStyle, int contentIndex)
{
if (dockStyle == DockStyle.Fill)
{
bool samePane = (Pane == pane);
if (!samePane)
{
Pane = pane;
}
int visiblePanes = 0;
int convertedIndex = 0;
while (visiblePanes <= contentIndex && convertedIndex < Pane.Contents.Count)
{
DockContent window = Pane.Contents[convertedIndex] as DockContent;
if (window != null && !window.IsHidden)
{
++visiblePanes;
}
++convertedIndex;
}
contentIndex = Math.Min(Math.Max(0, convertedIndex - 1), Pane.Contents.Count - 1);
if (contentIndex == -1 || !samePane)
{
pane.SetContentIndex(Content, contentIndex);
}
else
{
DockContentCollection contents = pane.Contents;
int oldIndex = contents.IndexOf(Content);
int newIndex = contentIndex;
if (oldIndex < newIndex)
{
newIndex += 1;
if (newIndex > contents.Count - 1)
{
newIndex = -1;
}
}
pane.SetContentIndex(Content, newIndex);
}
}
else
{
DockPane paneFrom = DockPanel.Theme.Extender.DockPaneFactory.CreateDockPane(Content, pane.DockState, true);
INestedPanesContainer container = pane.NestedPanesContainer;
if (dockStyle == DockStyle.Left)
{
paneFrom.DockTo(container, pane, DockAlignment.Left, 0.5);
}
else if (dockStyle == DockStyle.Right)
{
paneFrom.DockTo(container, pane, DockAlignment.Right, 0.5);
}
else if (dockStyle == DockStyle.Top)
{
paneFrom.DockTo(container, pane, DockAlignment.Top, 0.5);
}
else if (dockStyle == DockStyle.Bottom)
{
paneFrom.DockTo(container, pane, DockAlignment.Bottom, 0.5);
}
paneFrom.DockState = pane.DockState;
}
if (PatchController.EnableActivateOnDockFix == true)
{
Pane.ActiveContent = Content;
}
}
private void Pane_OnEndDrag(bool abort)
{
User32.SetCursor(DragControl.Cursor.Handle);
if (abort)
{
return;
}
DockPane pane = (DockPane)DragControl;
if (DropTarget.DropTo is DockPane)
{
DockPane paneTo = DropTarget.DropTo as DockPane;
if (DropTarget.Dock == DockStyle.Fill)
{
for (int i = pane.Contents.Count - 1; i >= 0; i--)
{
DockContent c = pane.Contents[i];
c.Pane = paneTo;
if (DropTarget.ContentIndex != -1)
{
paneTo.SetContentIndex(c, DropTarget.ContentIndex);
}
c.Activate();
}
}
else
{
if (DropTarget.Dock == DockStyle.Left)
{
pane.AddToDockList(paneTo.DockListContainer, paneTo, DockAlignment.Left, 0.5);
}
else if (DropTarget.Dock == DockStyle.Right)
{
pane.AddToDockList(paneTo.DockListContainer, paneTo, DockAlignment.Right, 0.5);
}
else if (DropTarget.Dock == DockStyle.Top)
{
pane.AddToDockList(paneTo.DockListContainer, paneTo, DockAlignment.Top, 0.5);
}
else if (DropTarget.Dock == DockStyle.Bottom)
{
pane.AddToDockList(paneTo.DockListContainer, paneTo, DockAlignment.Bottom, 0.5);
}
pane.DockState = paneTo.DockState;
pane.Activate();
}
}
else if (DropTarget.DropTo is DockPanel)
{
if (DropTarget.Dock == DockStyle.Top)
{
pane.DockState = DockState.DockTop;
}
else if (DropTarget.Dock == DockStyle.Bottom)
{
pane.DockState = DockState.DockBottom;
}
else if (DropTarget.Dock == DockStyle.Left)
{
pane.DockState = DockState.DockLeft;
}
else if (DropTarget.Dock == DockStyle.Right)
{
pane.DockState = DockState.DockRight;
}
else if (DropTarget.Dock == DockStyle.Fill)
{
pane.DockState = DockState.Document;
}
pane.Activate();
}
else if (IsDockStateValid(DockState.Float))
{
Point ptMouse = Control.MousePosition;
Point location = new Point(ptMouse.X + m_mouseOffset.X, ptMouse.Y + m_mouseOffset.Y);
Size size;
bool createFloatWindow = true;
if (pane.FloatWindow == null)
{
size = FloatWindow.DefaultWindowSize;
}
else if (pane.FloatWindow.DockList.Count == 1)
{
size = pane.FloatWindow.Size;
createFloatWindow = false;
}
else
{
size = FloatWindow.DefaultWindowSize;
}
if (ptMouse.X > location.X + size.Width)
{
location.X += ptMouse.X - (location.X + size.Width) + OutlineBorderWidth;
}
if (createFloatWindow)
{
pane.FloatWindow = pane.DockPanel.FloatWindowFactory.CreateFloatWindow(pane.DockPanel, pane, new Rectangle(location, size));
}
else
{
pane.FloatWindow.Bounds = new Rectangle(location, size);
}
pane.DockState = DockState.Float;
pane.Activate();
}
}
private void Content_OnEndDrag(bool abort)
{
User32.SetCursor(DragControl.Cursor.Handle);
if (abort)
{
return;
}
DockContent content = ((DockPane)DragControl).ActiveContent;
if (DropTarget.DropTo is DockPane)
{
DockPane paneTo = DropTarget.DropTo as DockPane;
if (DropTarget.Dock == DockStyle.Fill)
{
bool samePane = (content.Pane == paneTo);
if (!samePane)
{
content.Pane = paneTo;
}
if (DropTarget.ContentIndex == -1 || !samePane)
{
paneTo.SetContentIndex(content, DropTarget.ContentIndex);
}
else
{
DockContentCollection contents = paneTo.Contents;
int oldIndex = contents.IndexOf(content);
int newIndex = DropTarget.ContentIndex;
if (oldIndex < newIndex)
{
newIndex += 1;
if (newIndex > contents.Count - 1)
{
newIndex = -1;
}
}
paneTo.SetContentIndex(content, newIndex);
}
content.Activate();
}
else
{
DockPane pane = content.DockPanel.DockPaneFactory.CreateDockPane(content, paneTo.DockState, true);
IDockListContainer container = paneTo.DockListContainer;
if (DropTarget.Dock == DockStyle.Left)
{
pane.AddToDockList(container, paneTo, DockAlignment.Left, 0.5);
}
else if (DropTarget.Dock == DockStyle.Right)
{
pane.AddToDockList(container, paneTo, DockAlignment.Right, 0.5);
}
else if (DropTarget.Dock == DockStyle.Top)
{
pane.AddToDockList(container, paneTo, DockAlignment.Top, 0.5);
}
else if (DropTarget.Dock == DockStyle.Bottom)
{
pane.AddToDockList(container, paneTo, DockAlignment.Bottom, 0.5);
}
pane.DockState = paneTo.DockState;
pane.Activate();
}
}
else if (DropTarget.DropTo is DockPanel)
{
DockPane pane;
DockPanel dockPanel = content.DockPanel;
if (DropTarget.Dock == DockStyle.Top)
{
pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockTop, true);
}
else if (DropTarget.Dock == DockStyle.Bottom)
{
pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockBottom, true);
}
else if (DropTarget.Dock == DockStyle.Left)
{
pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockLeft, true);
}
else if (DropTarget.Dock == DockStyle.Right)
{
pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockRight, true);
}
else if (DropTarget.Dock == DockStyle.Fill)
{
pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.Document, true);
}
else
{
return;
}
pane.Activate();
}
else if (IsDockStateValid(DockState.Float))
{
Point ptMouse = Control.MousePosition;
Size size = FloatWindow.DefaultWindowSize;
Point location;
if (content.DockState == DockState.Document)
{
location = new Point(ptMouse.X + m_mouseOffset.X, ptMouse.Y + m_mouseOffset.Y);
}
else
{
location = new Point(ptMouse.X + m_mouseOffset.X, ptMouse.Y + m_mouseOffset.Y - size.Height);
}
if (ptMouse.X > location.X + size.Width)
{
location.X += ptMouse.X - (location.X + size.Width) + OutlineBorderWidth;
}
DockPane pane = content.DockPanel.DockPaneFactory.CreateDockPane(content, new Rectangle(location, size), true);
pane.Activate();
}
}
private void FloatWindow_OnEndDrag(bool abort)
{
if (abort)
{
return;
}
FloatWindow floatWindow = (FloatWindow)DragControl;
if (DropTarget.DropTo == null)
{
Rectangle rect = DragControl.Bounds;
rect.X = Control.MousePosition.X + m_mouseOffset.X;
rect.Y = Control.MousePosition.Y + m_mouseOffset.Y;
DragControl.Bounds = rect;
}
else if (DropTarget.DropTo is DockPane)
{
DockPane paneTo = DropTarget.DropTo as DockPane;
if (DropTarget.Dock == DockStyle.Fill)
{
for (int i = floatWindow.DockList.Count - 1; i >= 0; i--)
{
DockPane pane = floatWindow.DockList[i];
for (int j = pane.Contents.Count - 1; j >= 0; j--)
{
DockContent c = pane.Contents[j];
c.Pane = paneTo;
if (DropTarget.ContentIndex != -1)
{
paneTo.SetContentIndex(c, DropTarget.ContentIndex);
}
c.Activate();
}
}
}
else
{
DockAlignment alignment = DockAlignment.Left;
if (DropTarget.Dock == DockStyle.Left)
{
alignment = DockAlignment.Left;
}
else if (DropTarget.Dock == DockStyle.Right)
{
alignment = DockAlignment.Right;
}
else if (DropTarget.Dock == DockStyle.Top)
{
alignment = DockAlignment.Top;
}
else if (DropTarget.Dock == DockStyle.Bottom)
{
alignment = DockAlignment.Bottom;
}
MergeDockList(floatWindow.DisplayingList, paneTo.DockListContainer.DockList, paneTo, alignment, 0.5);
}
}
else if (DropTarget.DropTo is DockPanel)
{
DockList dockListTo = null;
if (DropTarget.Dock == DockStyle.Top)
{
dockListTo = floatWindow.DockPanel.DockWindows[DockState.DockTop].DockList;
}
else if (DropTarget.Dock == DockStyle.Bottom)
{
dockListTo = floatWindow.DockPanel.DockWindows[DockState.DockBottom].DockList;
}
else if (DropTarget.Dock == DockStyle.Left)
{
dockListTo = floatWindow.DockPanel.DockWindows[DockState.DockLeft].DockList;
}
else if (DropTarget.Dock == DockStyle.Right)
{
dockListTo = floatWindow.DockPanel.DockWindows[DockState.DockRight].DockList;
}
else if (DropTarget.Dock == DockStyle.Fill)
{
dockListTo = floatWindow.DockPanel.DockWindows[DockState.Document].DockList;
}
DockPane prevPane = null;
for (int i = dockListTo.Count - 1; i >= 0; i--)
{
if (dockListTo[i] != floatWindow.DisplayingList[0])
{
prevPane = dockListTo[i];
}
}
MergeDockList(floatWindow.DisplayingList, dockListTo, prevPane, DockAlignment.Left, 0.5);
}
}
