public DockPane Float()
{
DockPanel.SuspendLayout(true);
IDockContent activeContent = ActiveContent;
DockPane floatPane = GetFloatPaneFromContents();
if (floatPane == null)
{
IDockContent firstContent = GetFirstContent(DockState.Float);
if (firstContent == null)
{
DockPanel.ResumeLayout(true, true);
return(null);
}
floatPane = DockPanel.DockPaneFactory.CreateDockPane(firstContent, DockState.Float, true);
}
SetVisibleContentsToPane(floatPane, activeContent);
DockPanel.ResumeLayout(true, true);
return(floatPane);
}
public void Show(DockPanel dockPanel, Rectangle floatWindowBounds)
{
if (dockPanel == null)
{
throw(new ArgumentNullException(Strings.DockContentHandler_Show_NullDockPanel));
}
dockPanel.SuspendLayout(true);
DockPanel = dockPanel;
if (FloatPane == null)
{
IsHidden = true; // to reduce the screen flicker
FloatPane = DockPanel.DockPaneFactory.CreateDockPane(Content, DockState.Float, false);
FloatPane.FloatWindow.StartPosition = FormStartPosition.Manual;
}
FloatPane.FloatWindow.Bounds = floatWindowBounds;
Show(dockPanel, DockState.Float);
Activate();
dockPanel.ResumeLayout(true, true);
}
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);
}
DockPanel dockPanel = DockPanel;
if (dockPanel != null)
{
dockPanel.SuspendLayout(true);
}
SuspendSetDockState();
DockState 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 (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 (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);
}
}
protected override void WndProc(ref Message m)
{
if (m.Msg == (int)Msgs.WM_NCLBUTTONDOWN)
{
if (IsDisposed)
{
return;
}
uint result = NativeMethods.SendMessage(this.Handle, (int)Msgs.WM_NCHITTEST, 0, (uint)m.LParam);
if (result == 2 && DockPanel.AllowEndUserDocking && this.AllowEndUserDocking) // HITTEST_CAPTION
{
Activate();
m_dockPanel.BeginDrag(this);
}
else
{
base.WndProc(ref m);
}
return;
}
else if (m.Msg == (int)Msgs.WM_NCRBUTTONDOWN)
{
uint result = NativeMethods.SendMessage(this.Handle, (int)Msgs.WM_NCHITTEST, 0, (uint)m.LParam);
if (result == 2) // HITTEST_CAPTION
{
DockPane theOnlyPane = (VisibleNestedPanes.Count == 1) ? VisibleNestedPanes[0] : null;
if (theOnlyPane != null && theOnlyPane.ActiveContent != null)
{
theOnlyPane.ShowTabPageContextMenu(this, PointToClient(Control.MousePosition));
return;
}
}
base.WndProc(ref m);
return;
}
else if (m.Msg == (int)Msgs.WM_CLOSE)
{
if (NestedPanes.Count == 0)
{
base.WndProc(ref m);
return;
}
for (int i = NestedPanes.Count - 1; i >= 0; i--)
{
DockContentCollection contents = NestedPanes[i].Contents;
for (int j = contents.Count - 1; j >= 0; j--)
{
IDockContent content = contents[j];
if (content.DockHandler.DockState != DockState.Float)
{
continue;
}
if (!content.DockHandler.CloseButton)
{
continue;
}
if (content.DockHandler.HideOnClose)
{
content.DockHandler.Hide();
}
else
{
content.DockHandler.Close();
}
}
}
return;
}
else if (m.Msg == (int)Msgs.WM_NCLBUTTONDBLCLK)
{
uint result = NativeMethods.SendMessage(this.Handle, (int)Msgs.WM_NCHITTEST, 0, (uint)m.LParam);
if (result != 2) // HITTEST_CAPTION
{
base.WndProc(ref m);
return;
}
DockPanel.SuspendLayout(true);
// Restore to panel
foreach (DockPane pane in NestedPanes)
{
if (pane.DockState != DockState.Float)
{
continue;
}
pane.RestoreToPanel();
}
DockPanel.ResumeLayout(true, true);
return;
}
else if (m.Msg == WM_CHECKDISPOSE)
{
if (NestedPanes.Count == 0)
{
Dispose();
}
return;
}
base.WndProc(ref m);
}
private void InternalConstruct(IDockContent content, DockState dockState, bool flagBounds, Rectangle floatWindowBounds, DockPane prevPane, DockAlignment alignment, double proportion, bool show)
{
if (dockState == DockState.Hidden || dockState == DockState.Unknown)
{
throw new ArgumentException(Strings.DockPane_SetDockState_InvalidState);
}
if (content == null)
{
throw new ArgumentNullException(Strings.DockPane_Constructor_NullContent);
}
if (content.DockHandler.DockPanel == null)
{
throw new ArgumentException(Strings.DockPane_Constructor_NullDockPanel);
}
SuspendLayout();
SetStyle(ControlStyles.Selectable, false);
m_isFloat = (dockState == DockState.Float);
m_contents = new DockContentCollection();
m_displayingContents = new DockContentCollection(this);
m_dockPanel = content.DockHandler.DockPanel;
m_dockPanel.AddPane(this);
m_splitter = new SplitterControl(this);
m_nestedDockingStatus = new NestedDockingStatus(this);
m_captionControl = DockPanel.DockPaneCaptionFactory.CreateDockPaneCaption(this);
m_tabStripControl = DockPanel.DockPaneStripFactory.CreateDockPaneStrip(this);
Controls.AddRange(new Control[] { m_captionControl, m_tabStripControl });
DockPanel.SuspendLayout(true);
if (flagBounds)
{
FloatWindow = DockPanel.FloatWindowFactory.CreateFloatWindow(DockPanel, this, floatWindowBounds);
}
else if (prevPane != null)
{
DockTo(prevPane.NestedPanesContainer, prevPane, alignment, proportion);
}
SetDockState(dockState);
if (show)
{
content.DockHandler.Pane = this;
}
else if (this.IsFloat)
{
content.DockHandler.FloatPane = this;
}
else
{
content.DockHandler.PanelPane = this;
}
ResumeLayout();
DockPanel.ResumeLayout(true, true);
}
private void RefreshStateChange(INestedPanesContainer oldContainer, DockState oldDockState)
{
lock (this)
{
if (IsRefreshStateChangeSuspended)
{
return;
}
SuspendRefreshStateChange();
}
DockPanel.SuspendLayout(true);
IDockContent contentFocused = GetFocusedContent();
if (contentFocused != null)
{
DockPanel.SaveFocus();
}
SetParent();
if (ActiveContent != null)
{
ActiveContent.DockHandler.SetDockState(ActiveContent.DockHandler.IsHidden, DockState, ActiveContent.DockHandler.Pane);
}
foreach (IDockContent content in Contents)
{
if (content.DockHandler.Pane == this)
{
content.DockHandler.SetDockState(content.DockHandler.IsHidden, DockState, content.DockHandler.Pane);
}
}
if (oldContainer != null)
{
Control oldContainerControl = (Control)oldContainer;
if (oldContainer.DockState == oldDockState && !oldContainerControl.IsDisposed)
{
oldContainerControl.PerformLayout();
}
}
if (DockHelper.IsDockStateAutoHide(oldDockState))
{
DockPanel.RefreshActiveAutoHideContent();
}
if (NestedPanesContainer.DockState == DockState)
{
((Control)NestedPanesContainer).PerformLayout();
}
if (DockHelper.IsDockStateAutoHide(DockState))
{
DockPanel.RefreshActiveAutoHideContent();
}
if (DockHelper.IsDockStateAutoHide(oldDockState) ||
DockHelper.IsDockStateAutoHide(DockState))
{
DockPanel.RefreshAutoHideStrip();
DockPanel.PerformLayout();
}
ResumeRefreshStateChange();
if (contentFocused != null)
{
contentFocused.DockHandler.Activate();
}
DockPanel.ResumeLayout(true, true);
if (oldDockState != DockState)
{
OnDockStateChanged(EventArgs.Empty);
}
}
private void ResumeRefreshStateChange()
{
m_countRefreshStateChange--;
System.Diagnostics.Debug.Assert(m_countRefreshStateChange >= 0);
DockPanel.ResumeLayout(true, true);
}
public static void LoadFromXml(DockPanel dockPanel, Stream stream, DeserializeDockContent deserializeContent, bool closeStream)
{
try
{
if (dockPanel.Contents.Count != 0)
{
throw new InvalidOperationException(Strings.DockPanel_LoadFromXml_AlreadyInitialized);
}
XmlTextReader 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);
}
}
string formatVersion = xmlIn.GetAttribute("FormatVersion");
if (!IsFormatVersionValid(formatVersion))
{
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidFormatVersion);
}
DockPanelStruct 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);
}
ContentStruct[] contents = LoadContents(xmlIn);
// Load Panes
if (xmlIn.Name != "Panes")
{
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
}
PaneStruct[] panes = LoadPanes(xmlIn);
// Load DockWindows
if (xmlIn.Name != "DockWindows")
{
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
}
DockWindowStruct[] dockWindows = LoadDockWindows(xmlIn, dockPanel);
// Load FloatWindows
if (xmlIn.Name != "FloatWindows")
{
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
}
FloatWindowStruct[] 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
int prevMaxDockWindowZOrder = int.MaxValue;
for (int i = 0; i < dockWindows.Length; i++)
{
int maxDockWindowZOrder = -1;
int index = -1;
for (int 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 (int i = 0; i < contents.Length; i++)
{
IDockContent 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 (int i = 0; i < panes.Length; i++)
{
DockPane pane = null;
for (int j = 0; j < panes[i].IndexContents.Length; j++)
{
IDockContent 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 (int i = 0; i < dockWindows.Length; i++)
{
for (int j = 0; j < dockWindows[i].NestedPanes.Length; j++)
{
DockWindow dw = dockPanel.DockWindows[dockWindows[i].DockState];
int indexPane = dockWindows[i].NestedPanes[j].IndexPane;
DockPane pane = dockPanel.Panes[indexPane];
int indexPrevPane = dockWindows[i].NestedPanes[j].IndexPrevPane;
DockPane prevPane = (indexPrevPane == -1) ? dw.NestedPanes.GetDefaultPreviousPane(pane) : dockPanel.Panes[indexPrevPane];
DockAlignment alignment = dockWindows[i].NestedPanes[j].Alignment;
double 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 (int i = 0; i < floatWindows.Length; i++)
{
FloatWindow fw = null;
for (int j = 0; j < floatWindows[i].NestedPanes.Length; j++)
{
int indexPane = floatWindows[i].NestedPanes[j].IndexPane;
DockPane pane = dockPanel.Panes[indexPane];
if (j == 0)
{
fw = dockPanel.FloatWindowFactory.CreateFloatWindow(dockPanel, pane, floatWindows[i].Bounds);
}
else
{
int indexPrevPane = floatWindows[i].NestedPanes[j].IndexPrevPane;
DockPane prevPane = indexPrevPane == -1 ? null : dockPanel.Panes[indexPrevPane];
DockAlignment alignment = floatWindows[i].NestedPanes[j].Alignment;
double 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 (int i = 0; i < contents.Length; i++)
{
sortedContents[i] = i;
}
int lastDocument = contents.Length;
for (int i = 0; i < contents.Length - 1; i++)
{
for (int j = i + 1; j < contents.Length; j++)
{
DockPane pane1 = dockPanel.Contents[sortedContents[i]].DockHandler.Pane;
int ZOrderIndex1 = pane1 == null ? 0 : panes[dockPanel.Panes.IndexOf(pane1)].ZOrderIndex;
DockPane pane2 = dockPanel.Contents[sortedContents[j]].DockHandler.Pane;
int ZOrderIndex2 = pane2 == null ? 0 : panes[dockPanel.Panes.IndexOf(pane2)].ZOrderIndex;
if (ZOrderIndex1 > ZOrderIndex2)
{
int temp = sortedContents[i];
sortedContents[i] = sortedContents[j];
sortedContents[j] = temp;
}
}
}
}
// show non-document IDockContent first to avoid screen flickers
for (int i = 0; i < contents.Length; i++)
{
IDockContent 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 (int i = 0; i < contents.Length; i++)
{
IDockContent content = dockPanel.Contents[sortedContents[i]];
if (content.DockHandler.Pane != null && content.DockHandler.Pane.DockState == DockState.Document)
{
content.DockHandler.IsHidden = contents[sortedContents[i]].IsHidden;
}
}
for (int 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 (int i = dockPanel.Contents.Count - 1; i >= 0; i--)
{
if (dockPanel.Contents[i] is DummyContent)
{
dockPanel.Contents[i].DockHandler.Form.Close();
}
}
dockPanel.ResumeLayout(true, true);
}
catch
{
}
}