protected internal DockPane(IDockContent content, DockPane previousPane, DockAlignment alignment, double proportion,
bool show)
{
if (previousPane == null)
throw (new ArgumentNullException("previousPane"));
InternalConstruct(content, previousPane.DockState, false, Rectangle.Empty, previousPane, alignment, proportion, show);
}
void InternalConstruct(DockPanel dockPanel, DockPane pane, bool boundsSpecified, Rectangle bounds)
{
if (dockPanel == null)
throw (new ArgumentNullException(Strings.FloatWindow_Constructor_NullDockPanel));
m_nestedPanes = new NestedPaneCollection(this);
FormBorderStyle = FormBorderStyle.SizableToolWindow;
ShowInTaskbar = false;
if (dockPanel.RightToLeft != RightToLeft)
RightToLeft = dockPanel.RightToLeft;
if (RightToLeftLayout != dockPanel.RightToLeftLayout)
RightToLeftLayout = dockPanel.RightToLeftLayout;
SuspendLayout();
if (boundsSpecified)
{
Bounds = bounds;
StartPosition = FormStartPosition.Manual;
}
else
{
StartPosition = FormStartPosition.WindowsDefaultLocation;
Size = dockPanel.DefaultFloatWindowSize;
}
m_dockPanel = dockPanel;
Owner = DockPanel.FindForm();
DockPanel.AddFloatWindow(this);
if (pane != null)
pane.FloatWindow = this;
ResumeLayout();
}
protected internal DockPaneCaptionBase(DockPane pane)
{
m_dockPane = pane;
SetStyle(
ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw | ControlStyles.UserPaint |
ControlStyles.AllPaintingInWmPaint, true);
SetStyle(ControlStyles.Selectable, false);
}
public VS2005DockPaneCaption(DockPane pane) : base(pane)
{
SuspendLayout();
m_components = new Container();
m_toolTip = new ToolTip(Components);
ResumeLayout();
}
public VS2005DockPaneStrip(DockPane pane) : base(pane)
{
SetStyle(
ControlStyles.ResizeRedraw | ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint |
ControlStyles.OptimizedDoubleBuffer, true);
SuspendLayout();
m_components = new Container();
m_toolTip = new ToolTip(Components);
m_selectMenu = new ContextMenuStrip(Components);
ResumeLayout();
}
public void Show(DockPane pane, DockStyle dock)
{
SaveOldValues();
SetValues(Rectangle.Empty, pane, dock, -1);
TestChange();
}
public void Show(DockPane pane, IDockContent beforeContent)
{
DockHandler.Show(pane, beforeContent);
}
protected internal FloatWindow(DockPanel dockPanel, DockPane pane, Rectangle bounds)
{
InternalConstruct(dockPanel, pane, true, bounds);
}
protected internal FloatWindow(DockPanel dockPanel, DockPane pane, Rectangle bounds)
{
InternalConstruct(dockPanel, pane, true, bounds);
}
public void SetPaneIndex(DockPane pane, int index)
{
var oldIndex = Panes.IndexOf(pane);
if (oldIndex == -1)
throw (new ArgumentException(Strings.DockPanel_SetPaneIndex_InvalidPane));
if (index < 0 || index > Panes.Count - 1)
{
if (index != -1)
throw (new ArgumentOutOfRangeException(Strings.DockPanel_SetPaneIndex_InvalidIndex));
}
if (oldIndex == index)
return;
if (oldIndex == Panes.Count - 1 && index == -1)
return;
Panes.Remove(pane);
if (index == -1)
Panes.Add(pane);
else if (oldIndex < index)
Panes.AddAt(pane, index - 1);
else
Panes.AddAt(pane, index);
}
internal void AddPane(DockPane pane)
{
if (Panes.Contains(pane))
return;
Panes.Add(pane);
}
protected void ShowTabPageContextMenu(Point position)
{
DockPane.ShowTabPageContextMenu(this, position);
}
public DockPaneStripBase CreateDockPaneStrip(DockPane pane)
{
return(new VS2005DockPaneStrip(pane));
}
public DockPaneCaptionBase CreateDockPaneCaption(DockPane pane)
{
return(new VS2005DockPaneCaption(pane));
}
public FloatWindow CreateFloatWindow(DockPanel dockPanel, DockPane pane, Rectangle bounds)
{
return(new FloatWindow(dockPanel, pane, bounds));
}
public FloatWindow CreateFloatWindow(DockPanel dockPanel, DockPane pane)
{
return(new FloatWindow(dockPanel, pane));
}
public DockPane CreateDockPane(IDockContent content, DockPane prevPane, DockAlignment alignment, double proportion,
bool show)
{
return(new DockPane(content, prevPane, alignment, proportion, show));
}
void SetVisibleContentsToPane(DockPane pane)
{
SetVisibleContentsToPane(pane, ActiveContent);
}
void SetActiveDocumentPane()
{
DockPane value = null;
if (ActivePane != null && ActivePane.DockState == DockState.Document)
value = ActivePane;
if (value == null && DockPanel.DockWindows != null)
{
if (ActiveDocumentPane == null)
value = DockPanel.DockWindows[DockState.Document].DefaultPane;
else if (ActiveDocumentPane.DockPanel != DockPanel || ActiveDocumentPane.DockState != DockState.Document)
value = DockPanel.DockWindows[DockState.Document].DefaultPane;
else
value = ActiveDocumentPane;
}
if (m_activeDocumentPane == value)
return;
if (m_activeDocumentPane != null)
m_activeDocumentPane.SetIsActiveDocumentPane(false);
m_activeDocumentPane = value;
if (m_activeDocumentPane != null)
m_activeDocumentPane.SetIsActiveDocumentPane(true);
}
public SplitterControl(DockPane pane)
{
SetStyle(ControlStyles.Selectable, false);
m_pane = pane;
}
public void DockTo(DockPane pane, DockStyle dockStyle, int contentIndex)
{
if (dockStyle == DockStyle.Fill)
{
for (var i = NestedPanes.Count - 1; i >= 0; i--)
{
var paneFrom = NestedPanes[i];
for (var j = paneFrom.Contents.Count - 1; j >= 0; j--)
{
var c = paneFrom.Contents[j];
c.DockHandler.Pane = pane;
if (contentIndex != -1)
pane.SetContentIndex(c, contentIndex);
c.DockHandler.Activate();
}
}
}
else
{
var 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);
}
}
internal void RemovePane(DockPane pane)
{
if (!Panes.Contains(pane))
return;
Panes.Remove(pane);
}
static void MergeNestedPanes(VisibleNestedPaneCollection nestedPanesFrom, NestedPaneCollection nestedPanesTo,
DockPane prevPane, DockAlignment alignment, double proportion)
{
if (nestedPanesFrom.Count == 0)
return;
var count = nestedPanesFrom.Count;
var panes = new DockPane[count];
var prevPanes = new DockPane[count];
var alignments = new DockAlignment[count];
var proportions = new double[count];
for (var i = 0; i < count; i++)
{
panes[i] = nestedPanesFrom[i];
prevPanes[i] = nestedPanesFrom[i].NestedDockingStatus.PreviousPane;
alignments[i] = nestedPanesFrom[i].NestedDockingStatus.Alignment;
proportions[i] = nestedPanesFrom[i].NestedDockingStatus.Proportion;
}
var pane = panes[0].DockTo(nestedPanesTo.Container, prevPane, alignment, proportion);
panes[0].DockState = nestedPanesTo.DockState;
for (var i = 1; i < count; i++)
{
for (var j = i; j < count; j++)
{
if (prevPanes[j] == panes[i - 1])
prevPanes[j] = pane;
}
pane = panes[i].DockTo(nestedPanesTo.Container, prevPanes[i], alignments[i], proportions[i]);
panes[i].DockState = nestedPanesTo.DockState;
}
}
protected internal FloatWindow(DockPanel dockPanel, DockPane pane)
{
InternalConstruct(dockPanel, pane, false, Rectangle.Empty);
}
void SetActivePane()
{
var value = (ActiveContent == null ? null : ActiveContent.DockHandler.Pane);
if (value == m_activePane)
return;
m_activePane = value;
}
bool IDockDragSource.CanDockTo(DockPane pane)
{
if (!IsDockStateValid(pane.DockState))
return false;
if (pane.FloatWindow == this)
return false;
return true;
}
protected internal FloatWindow(DockPanel dockPanel, DockPane pane)
{
InternalConstruct(dockPanel, pane, false, Rectangle.Empty);
}
void ResumeSetDockState(bool isHidden, DockState visibleState, DockPane oldPane)
{
ResumeSetDockState();
SetDockState(isHidden, visibleState, oldPane);
}
internal void SetDockState(bool isHidden, DockState visibleState, DockPane oldPane)
{
if (IsSuspendSetDockState)
return;
if (DockPanel == null && visibleState != DockState.Unknown)
throw new InvalidOperationException(Strings.DockContentHandler_SetDockState_NullPanel);
if (visibleState == DockState.Hidden || (visibleState != DockState.Unknown && !IsDockStateValid(visibleState)))
throw new InvalidOperationException(Strings.DockContentHandler_SetDockState_InvalidState);
var dockPanel = DockPanel;
if (dockPanel != null)
dockPanel.SuspendLayout(true);
SuspendSetDockState();
var oldDockState = DockState;
if (m_isHidden != isHidden || oldDockState == DockState.Unknown)
m_isHidden = isHidden;
m_visibleState = visibleState;
m_dockState = isHidden ? DockState.Hidden : visibleState;
if (visibleState == DockState.Unknown)
Pane = null;
else
{
m_isFloat = (m_visibleState == DockState.Float);
if (Pane == null)
Pane = DockPanel.DockPaneFactory.CreateDockPane(Content, visibleState, true);
else if (Pane.DockState != visibleState)
{
if (Pane.Contents.Count == 1)
Pane.SetDockState(visibleState);
else
Pane = DockPanel.DockPaneFactory.CreateDockPane(Content, visibleState, true);
}
}
if (Form.ContainsFocus)
{
if (DockPanel != null && (DockState == DockState.Hidden || DockState == DockState.Unknown))
DockPanel.ContentFocusManager.GiveUpFocus(Content);
}
SetPaneAndVisible(Pane);
if (oldPane != null && !oldPane.IsDisposed && oldDockState == oldPane.DockState)
RefreshDockPane(oldPane);
if (Pane != null && DockState == Pane.DockState)
{
if ((Pane != oldPane) || (Pane == oldPane && oldDockState != oldPane.DockState))
{
// Avoid early refresh of hidden AutoHide panes
if ((Pane.DockWindow == null || Pane.DockWindow.Visible || Pane.IsHidden) && !Pane.IsAutoHide)
RefreshDockPane(Pane);
}
}
if (oldDockState != DockState)
{
if (DockPanel != null)
{
if (DockState == DockState.Hidden || DockState == DockState.Unknown ||
DockHelper.IsDockStateAutoHide(DockState))
DockPanel.ContentFocusManager.RemoveFromList(Content);
else
DockPanel.ContentFocusManager.AddToList(Content);
}
OnDockStateChanged(EventArgs.Empty);
}
ResumeSetDockState();
if (dockPanel != null)
dockPanel.ResumeLayout(true, true);
}
public SplitterControl(DockPane pane)
{
SetStyle(ControlStyles.Selectable, false);
m_pane = pane;
}
void SetPane(DockPane pane)
{
if (pane != null && pane.DockState == DockState.Document && DockPanel.DocumentStyle == DocumentStyle.DockingMdi)
{
if (Form.Parent is DockPane)
SetParent(null);
if (Form.MdiParent != DockPanel.ParentForm)
{
FlagClipWindow = true;
Form.MdiParent = DockPanel.ParentForm;
}
}
else
{
FlagClipWindow = true;
if (Form.MdiParent != null)
Form.MdiParent = null;
if (Form.TopLevel)
Form.TopLevel = false;
SetParent(pane);
}
}
void SetOutline(DockPane pane, DockStyle dock, int contentIndex)
{
if (dock != DockStyle.Fill)
{
var rect = pane.DisplayingRectangle;
if (dock == DockStyle.Right)
rect.X += rect.Width / 2;
if (dock == DockStyle.Bottom)
rect.Y += rect.Height / 2;
if (dock == DockStyle.Left || dock == DockStyle.Right)
rect.Width -= rect.Width / 2;
if (dock == DockStyle.Top || dock == DockStyle.Bottom)
rect.Height -= rect.Height / 2;
rect.Location = pane.PointToScreen(rect.Location);
SetDragForm(rect);
}
else if (contentIndex == -1)
{
var rect = pane.DisplayingRectangle;
rect.Location = pane.PointToScreen(rect.Location);
SetDragForm(rect);
}
else
{
using (var path = pane.TabStripControl.GetOutline(contentIndex))
{
var rectF = path.GetBounds();
var rect = new Rectangle((int)rectF.X, (int)rectF.Y, (int)rectF.Width, (int)rectF.Height);
using (
var matrix = new Matrix(rect,
new Point[] { new Point(0, 0), new Point(rect.Width, 0), new Point(0, rect.Height) }))
{
path.Transform(matrix);
}
var region = new Region(path);
SetDragForm(rect, region);
}
}
}
internal void SetPaneAndVisible(DockPane pane)
{
SetPane(pane);
SetVisible();
}
public void DockTo(DockPane paneTo, DockStyle dockStyle, int contentIndex)
{
DockHandler.DockTo(paneTo, dockStyle, contentIndex);
}
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);
DockPanel = pane.DockPanel;
Pane = pane;
pane.SetContentIndex(Content, pane.Contents.IndexOf(beforeContent));
Show();
pane.DockPanel.ResumeLayout(true, true);
}
public void Show(DockPane previousPane, DockAlignment alignment, double proportion)
{
DockHandler.Show(previousPane, alignment, proportion);
}
public void Show(DockPane previousPane, DockAlignment alignment, double proportion)
{
if (previousPane == null)
throw (new ArgumentException(Strings.DockContentHandler_Show_InvalidPrevPane));
if (DockHelper.IsDockStateAutoHide(previousPane.DockState))
throw (new ArgumentException(Strings.DockContentHandler_Show_InvalidPrevPane));
previousPane.DockPanel.SuspendLayout(true);
DockPanel = previousPane.DockPanel;
DockPanel.DockPaneFactory.CreateDockPane(Content, previousPane, alignment, proportion, true);
Show();
previousPane.DockPanel.ResumeLayout(true, true);
}
public void Show(DockPane pane, int contentIndex)
{
SaveOldValues();
SetValues(Rectangle.Empty, pane, DockStyle.Fill, contentIndex);
TestChange();
}
bool IDockDragSource.CanDockTo(DockPane pane)
{
if (!IsDockStateValid(pane.DockState))
return false;
if (Pane == pane && pane.DisplayingContents.Count == 1)
return false;
return true;
}
void SetActivePane()
{
var value = GetPaneFromHandle(NativeMethods.GetFocus());
if (m_activePane == value)
return;
if (m_activePane != null)
m_activePane.SetIsActivated(false);
m_activePane = value;
if (m_activePane != null)
m_activePane.SetIsActivated(true);
}
public static void LoadFromXml(DockPanel dockPanel, Stream stream, DeserializeDockContent deserializeContent,
bool closeStream)
{
if (dockPanel.Contents.Count != 0)
{
throw new InvalidOperationException(Strings.DockPanel_LoadFromXml_AlreadyInitialized);
}
var xmlIn = new XmlTextReader(stream);
xmlIn.WhitespaceHandling = WhitespaceHandling.None;
xmlIn.MoveToContent();
while (!xmlIn.Name.Equals("DockPanel"))
{
if (!MoveToNextElement(xmlIn))
{
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
}
}
var formatVersion = xmlIn.GetAttribute("FormatVersion");
if (!IsFormatVersionValid(formatVersion))
{
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidFormatVersion);
}
var dockPanelStruct = new DockPanelStruct();
dockPanelStruct.DockLeftPortion = Convert.ToDouble(xmlIn.GetAttribute("DockLeftPortion"),
CultureInfo.InvariantCulture);
dockPanelStruct.DockRightPortion = Convert.ToDouble(xmlIn.GetAttribute("DockRightPortion"),
CultureInfo.InvariantCulture);
dockPanelStruct.DockTopPortion = Convert.ToDouble(xmlIn.GetAttribute("DockTopPortion"),
CultureInfo.InvariantCulture);
dockPanelStruct.DockBottomPortion = Convert.ToDouble(xmlIn.GetAttribute("DockBottomPortion"),
CultureInfo.InvariantCulture);
dockPanelStruct.IndexActiveDocumentPane = Convert.ToInt32(xmlIn.GetAttribute("ActiveDocumentPane"),
CultureInfo.InvariantCulture);
dockPanelStruct.IndexActivePane = Convert.ToInt32(xmlIn.GetAttribute("ActivePane"), CultureInfo.InvariantCulture);
// Load Contents
MoveToNextElement(xmlIn);
if (xmlIn.Name != "Contents")
{
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
}
var contents = LoadContents(xmlIn);
// Load Panes
if (xmlIn.Name != "Panes")
{
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
}
var panes = LoadPanes(xmlIn);
// Load DockWindows
if (xmlIn.Name != "DockWindows")
{
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
}
var dockWindows = LoadDockWindows(xmlIn, dockPanel);
// Load FloatWindows
if (xmlIn.Name != "FloatWindows")
{
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
}
var floatWindows = LoadFloatWindows(xmlIn);
if (closeStream)
{
xmlIn.Close();
}
dockPanel.SuspendLayout(true);
dockPanel.DockLeftPortion = dockPanelStruct.DockLeftPortion;
dockPanel.DockRightPortion = dockPanelStruct.DockRightPortion;
dockPanel.DockTopPortion = dockPanelStruct.DockTopPortion;
dockPanel.DockBottomPortion = dockPanelStruct.DockBottomPortion;
// Set DockWindow ZOrders
var prevMaxDockWindowZOrder = int.MaxValue;
for (var i = 0; i < dockWindows.Length; i++)
{
var maxDockWindowZOrder = -1;
var index = -1;
for (var j = 0; j < dockWindows.Length; j++)
{
if (dockWindows[j].ZOrderIndex > maxDockWindowZOrder &&
dockWindows[j].ZOrderIndex < prevMaxDockWindowZOrder)
{
maxDockWindowZOrder = dockWindows[j].ZOrderIndex;
index = j;
}
}
dockPanel.DockWindows[dockWindows[index].DockState].BringToFront();
prevMaxDockWindowZOrder = maxDockWindowZOrder;
}
// Create Contents
for (var i = 0; i < contents.Length; i++)
{
var content = deserializeContent(contents[i].PersistString);
if (content == null)
{
content = new DummyContent();
}
content.DockHandler.DockPanel = dockPanel;
content.DockHandler.AutoHidePortion = contents[i].AutoHidePortion;
content.DockHandler.IsHidden = true;
content.DockHandler.IsFloat = contents[i].IsFloat;
}
// Create panes
for (var i = 0; i < panes.Length; i++)
{
DockPane pane = null;
for (var j = 0; j < panes[i].IndexContents.Length; j++)
{
var content = dockPanel.Contents[panes[i].IndexContents[j]];
if (j == 0)
{
pane = dockPanel.DockPaneFactory.CreateDockPane(content, panes[i].DockState, false);
}
else if (panes[i].DockState == DockState.Float)
{
content.DockHandler.FloatPane = pane;
}
else
{
content.DockHandler.PanelPane = pane;
}
}
}
// Assign Panes to DockWindows
for (var i = 0; i < dockWindows.Length; i++)
{
for (var j = 0; j < dockWindows[i].NestedPanes.Length; j++)
{
var dw = dockPanel.DockWindows[dockWindows[i].DockState];
var indexPane = dockWindows[i].NestedPanes[j].IndexPane;
var pane = dockPanel.Panes[indexPane];
var indexPrevPane = dockWindows[i].NestedPanes[j].IndexPrevPane;
var prevPane = (indexPrevPane == -1)
? dw.NestedPanes.GetDefaultPreviousPane(pane) : dockPanel.Panes[indexPrevPane];
var alignment = dockWindows[i].NestedPanes[j].Alignment;
var proportion = dockWindows[i].NestedPanes[j].Proportion;
pane.DockTo(dw, prevPane, alignment, proportion);
if (panes[indexPane].DockState == dw.DockState)
{
panes[indexPane].ZOrderIndex = dockWindows[i].ZOrderIndex;
}
}
}
// Create float windows
for (var i = 0; i < floatWindows.Length; i++)
{
FloatWindow fw = null;
for (var j = 0; j < floatWindows[i].NestedPanes.Length; j++)
{
var indexPane = floatWindows[i].NestedPanes[j].IndexPane;
var pane = dockPanel.Panes[indexPane];
if (j == 0)
{
fw = dockPanel.FloatWindowFactory.CreateFloatWindow(dockPanel, pane, floatWindows[i].Bounds);
}
else
{
var indexPrevPane = floatWindows[i].NestedPanes[j].IndexPrevPane;
var prevPane = indexPrevPane == -1 ? null : dockPanel.Panes[indexPrevPane];
var alignment = floatWindows[i].NestedPanes[j].Alignment;
var proportion = floatWindows[i].NestedPanes[j].Proportion;
pane.DockTo(fw, prevPane, alignment, proportion);
}
if (panes[indexPane].DockState == fw.DockState)
{
panes[indexPane].ZOrderIndex = floatWindows[i].ZOrderIndex;
}
}
}
// sort IDockContent by its Pane's ZOrder
int[] sortedContents = null;
if (contents.Length > 0)
{
sortedContents = new int[contents.Length];
for (var i = 0; i < contents.Length; i++)
{
sortedContents[i] = i;
}
var lastDocument = contents.Length;
for (var i = 0; i < contents.Length - 1; i++)
{
for (var j = i + 1; j < contents.Length; j++)
{
var pane1 = dockPanel.Contents[sortedContents[i]].DockHandler.Pane;
var ZOrderIndex1 = pane1 == null ? 0 : panes[dockPanel.Panes.IndexOf(pane1)].ZOrderIndex;
var pane2 = dockPanel.Contents[sortedContents[j]].DockHandler.Pane;
var ZOrderIndex2 = pane2 == null ? 0 : panes[dockPanel.Panes.IndexOf(pane2)].ZOrderIndex;
if (ZOrderIndex1 > ZOrderIndex2)
{
var temp = sortedContents[i];
sortedContents[i] = sortedContents[j];
sortedContents[j] = temp;
}
}
}
}
// show non-document IDockContent first to avoid screen flickers
for (var i = 0; i < contents.Length; i++)
{
var content = dockPanel.Contents[sortedContents[i]];
if (content.DockHandler.Pane != null && content.DockHandler.Pane.DockState != DockState.Document)
{
content.DockHandler.IsHidden = contents[sortedContents[i]].IsHidden;
}
}
// after all non-document IDockContent, show document IDockContent
for (var i = 0; i < contents.Length; i++)
{
var content = dockPanel.Contents[sortedContents[i]];
if (content.DockHandler.Pane != null && content.DockHandler.Pane.DockState == DockState.Document)
{
content.DockHandler.IsHidden = contents[sortedContents[i]].IsHidden;
}
}
for (var i = 0; i < panes.Length; i++)
{
dockPanel.Panes[i].ActiveContent = panes[i].IndexActiveContent == -1
? null : dockPanel.Contents[panes[i].IndexActiveContent];
}
if (dockPanelStruct.IndexActiveDocumentPane != -1)
{
dockPanel.Panes[dockPanelStruct.IndexActiveDocumentPane].Activate();
}
if (dockPanelStruct.IndexActivePane != -1)
{
dockPanel.Panes[dockPanelStruct.IndexActivePane].Activate();
}
for (var i = dockPanel.Contents.Count - 1; i >= 0; i--)
{
if (dockPanel.Contents[i] is DummyContent)
{
dockPanel.Contents[i].DockHandler.Form.Close();
}
}
dockPanel.ResumeLayout(true, true);
}
