You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
781 lines
38 KiB
C#
781 lines
38 KiB
C#
using System;
|
|
using System.ComponentModel;
|
|
using System.Windows.Forms;
|
|
using System.Drawing;
|
|
using Mesnac.Docking;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Xml;
|
|
using System.Globalization;
|
|
|
|
namespace Mesnac.Docking
|
|
{
|
|
partial class DockPanel
|
|
{
|
|
private static class Persistor
|
|
{
|
|
private const string ConfigFileVersion = "1.0";
|
|
private static string[] CompatibleConfigFileVersions = new string[] { };
|
|
|
|
private class DummyContent : DockContent
|
|
{
|
|
}
|
|
|
|
private struct DockPanelStruct
|
|
{
|
|
private double m_dockLeftPortion;
|
|
public double DockLeftPortion
|
|
{
|
|
get { return m_dockLeftPortion; }
|
|
set { m_dockLeftPortion = value; }
|
|
}
|
|
|
|
private double m_dockRightPortion;
|
|
public double DockRightPortion
|
|
{
|
|
get { return m_dockRightPortion; }
|
|
set { m_dockRightPortion = value; }
|
|
}
|
|
|
|
private double m_dockTopPortion;
|
|
public double DockTopPortion
|
|
{
|
|
get { return m_dockTopPortion; }
|
|
set { m_dockTopPortion = value; }
|
|
}
|
|
|
|
private double m_dockBottomPortion;
|
|
public double DockBottomPortion
|
|
{
|
|
get { return m_dockBottomPortion; }
|
|
set { m_dockBottomPortion = value; }
|
|
}
|
|
|
|
private int m_indexActiveDocumentPane;
|
|
public int IndexActiveDocumentPane
|
|
{
|
|
get { return m_indexActiveDocumentPane; }
|
|
set { m_indexActiveDocumentPane = value; }
|
|
}
|
|
|
|
private int m_indexActivePane;
|
|
public int IndexActivePane
|
|
{
|
|
get { return m_indexActivePane; }
|
|
set { m_indexActivePane = value; }
|
|
}
|
|
}
|
|
|
|
private struct ContentStruct
|
|
{
|
|
private string m_persistString;
|
|
public string PersistString
|
|
{
|
|
get { return m_persistString; }
|
|
set { m_persistString = value; }
|
|
}
|
|
|
|
private double m_autoHidePortion;
|
|
public double AutoHidePortion
|
|
{
|
|
get { return m_autoHidePortion; }
|
|
set { m_autoHidePortion = value; }
|
|
}
|
|
|
|
private bool m_isHidden;
|
|
public bool IsHidden
|
|
{
|
|
get { return m_isHidden; }
|
|
set { m_isHidden = value; }
|
|
}
|
|
|
|
private bool m_isFloat;
|
|
public bool IsFloat
|
|
{
|
|
get { return m_isFloat; }
|
|
set { m_isFloat = value; }
|
|
}
|
|
}
|
|
|
|
private struct PaneStruct
|
|
{
|
|
private DockState m_dockState;
|
|
public DockState DockState
|
|
{
|
|
get { return m_dockState; }
|
|
set { m_dockState = value; }
|
|
}
|
|
|
|
private int m_indexActiveContent;
|
|
public int IndexActiveContent
|
|
{
|
|
get { return m_indexActiveContent; }
|
|
set { m_indexActiveContent = value; }
|
|
}
|
|
|
|
private int[] m_indexContents;
|
|
public int[] IndexContents
|
|
{
|
|
get { return m_indexContents; }
|
|
set { m_indexContents = value; }
|
|
}
|
|
|
|
private int m_zOrderIndex;
|
|
public int ZOrderIndex
|
|
{
|
|
get { return m_zOrderIndex; }
|
|
set { m_zOrderIndex = value; }
|
|
}
|
|
}
|
|
|
|
private struct NestedPane
|
|
{
|
|
private int m_indexPane;
|
|
public int IndexPane
|
|
{
|
|
get { return m_indexPane; }
|
|
set { m_indexPane = value; }
|
|
}
|
|
|
|
private int m_indexPrevPane;
|
|
public int IndexPrevPane
|
|
{
|
|
get { return m_indexPrevPane; }
|
|
set { m_indexPrevPane = value; }
|
|
}
|
|
|
|
private DockAlignment m_alignment;
|
|
public DockAlignment Alignment
|
|
{
|
|
get { return m_alignment; }
|
|
set { m_alignment = value; }
|
|
}
|
|
|
|
private double m_proportion;
|
|
public double Proportion
|
|
{
|
|
get { return m_proportion; }
|
|
set { m_proportion = value; }
|
|
}
|
|
}
|
|
|
|
private struct DockWindowStruct
|
|
{
|
|
private DockState m_dockState;
|
|
public DockState DockState
|
|
{
|
|
get { return m_dockState; }
|
|
set { m_dockState = value; }
|
|
}
|
|
|
|
private int m_zOrderIndex;
|
|
public int ZOrderIndex
|
|
{
|
|
get { return m_zOrderIndex; }
|
|
set { m_zOrderIndex = value; }
|
|
}
|
|
|
|
private NestedPane[] m_nestedPanes;
|
|
public NestedPane[] NestedPanes
|
|
{
|
|
get { return m_nestedPanes; }
|
|
set { m_nestedPanes = value; }
|
|
}
|
|
}
|
|
|
|
private struct FloatWindowStruct
|
|
{
|
|
private Rectangle m_bounds;
|
|
public Rectangle Bounds
|
|
{
|
|
get { return m_bounds; }
|
|
set { m_bounds = value; }
|
|
}
|
|
|
|
private int m_zOrderIndex;
|
|
public int ZOrderIndex
|
|
{
|
|
get { return m_zOrderIndex; }
|
|
set { m_zOrderIndex = value; }
|
|
}
|
|
|
|
private NestedPane[] m_nestedPanes;
|
|
public NestedPane[] NestedPanes
|
|
{
|
|
get { return m_nestedPanes; }
|
|
set { m_nestedPanes = value; }
|
|
}
|
|
}
|
|
|
|
public static void SaveAsXml(DockPanel dockPanel, string fileName)
|
|
{
|
|
SaveAsXml(dockPanel, fileName, Encoding.Unicode);
|
|
}
|
|
|
|
public static void SaveAsXml(DockPanel dockPanel, string fileName, Encoding encoding)
|
|
{
|
|
FileStream fs = new FileStream(fileName, FileMode.Create);
|
|
try
|
|
{
|
|
SaveAsXml(dockPanel, fs, encoding);
|
|
}
|
|
finally
|
|
{
|
|
fs.Close();
|
|
}
|
|
}
|
|
|
|
public static void SaveAsXml(DockPanel dockPanel, Stream stream, Encoding encoding)
|
|
{
|
|
SaveAsXml(dockPanel, stream, encoding, false);
|
|
}
|
|
|
|
public static void SaveAsXml(DockPanel dockPanel, Stream stream, Encoding encoding, bool upstream)
|
|
{
|
|
XmlTextWriter xmlOut = new XmlTextWriter(stream, encoding);
|
|
|
|
// Use indenting for readability
|
|
xmlOut.Formatting = Formatting.Indented;
|
|
|
|
if (!upstream)
|
|
xmlOut.WriteStartDocument();
|
|
|
|
// Always begin file with identification and warning
|
|
xmlOut.WriteComment(Strings.DockPanel_Persistor_XmlFileComment1);
|
|
xmlOut.WriteComment(Strings.DockPanel_Persistor_XmlFileComment2);
|
|
|
|
// Associate a version number with the root element so that future version of the code
|
|
// will be able to be backwards compatible or at least recognise out of date versions
|
|
xmlOut.WriteStartElement("DockPanel");
|
|
xmlOut.WriteAttributeString("FormatVersion", ConfigFileVersion);
|
|
xmlOut.WriteAttributeString("DockLeftPortion", dockPanel.DockLeftPortion.ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteAttributeString("DockRightPortion", dockPanel.DockRightPortion.ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteAttributeString("DockTopPortion", dockPanel.DockTopPortion.ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteAttributeString("DockBottomPortion", dockPanel.DockBottomPortion.ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteAttributeString("ActiveDocumentPane", dockPanel.Panes.IndexOf(dockPanel.ActiveDocumentPane).ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteAttributeString("ActivePane", dockPanel.Panes.IndexOf(dockPanel.ActivePane).ToString(CultureInfo.InvariantCulture));
|
|
|
|
// Contents
|
|
xmlOut.WriteStartElement("Contents");
|
|
xmlOut.WriteAttributeString("Count", dockPanel.Contents.Count.ToString(CultureInfo.InvariantCulture));
|
|
foreach (IDockContent content in dockPanel.Contents)
|
|
{
|
|
xmlOut.WriteStartElement("Content");
|
|
xmlOut.WriteAttributeString("ID", dockPanel.Contents.IndexOf(content).ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteAttributeString("PersistString", content.DockHandler.PersistString);
|
|
xmlOut.WriteAttributeString("AutoHidePortion", content.DockHandler.AutoHidePortion.ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteAttributeString("IsHidden", content.DockHandler.IsHidden.ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteAttributeString("IsFloat", content.DockHandler.IsFloat.ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteEndElement();
|
|
}
|
|
xmlOut.WriteEndElement();
|
|
|
|
// Panes
|
|
xmlOut.WriteStartElement("Panes");
|
|
xmlOut.WriteAttributeString("Count", dockPanel.Panes.Count.ToString(CultureInfo.InvariantCulture));
|
|
foreach (DockPane pane in dockPanel.Panes)
|
|
{
|
|
xmlOut.WriteStartElement("Pane");
|
|
xmlOut.WriteAttributeString("ID", dockPanel.Panes.IndexOf(pane).ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteAttributeString("DockState", pane.DockState.ToString());
|
|
xmlOut.WriteAttributeString("ActiveContent", dockPanel.Contents.IndexOf(pane.ActiveContent).ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteStartElement("Contents");
|
|
xmlOut.WriteAttributeString("Count", pane.Contents.Count.ToString(CultureInfo.InvariantCulture));
|
|
foreach (IDockContent content in pane.Contents)
|
|
{
|
|
xmlOut.WriteStartElement("Content");
|
|
xmlOut.WriteAttributeString("ID", pane.Contents.IndexOf(content).ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteAttributeString("RefID", dockPanel.Contents.IndexOf(content).ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteEndElement();
|
|
}
|
|
xmlOut.WriteEndElement();
|
|
xmlOut.WriteEndElement();
|
|
}
|
|
xmlOut.WriteEndElement();
|
|
|
|
// DockWindows
|
|
xmlOut.WriteStartElement("DockWindows");
|
|
int dockWindowId = 0;
|
|
foreach (DockWindow dw in dockPanel.DockWindows)
|
|
{
|
|
xmlOut.WriteStartElement("DockWindow");
|
|
xmlOut.WriteAttributeString("ID", dockWindowId.ToString(CultureInfo.InvariantCulture));
|
|
dockWindowId++;
|
|
xmlOut.WriteAttributeString("DockState", dw.DockState.ToString());
|
|
xmlOut.WriteAttributeString("ZOrderIndex", dockPanel.Controls.IndexOf(dw).ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteStartElement("NestedPanes");
|
|
xmlOut.WriteAttributeString("Count", dw.NestedPanes.Count.ToString(CultureInfo.InvariantCulture));
|
|
foreach (DockPane pane in dw.NestedPanes)
|
|
{
|
|
xmlOut.WriteStartElement("Pane");
|
|
xmlOut.WriteAttributeString("ID", dw.NestedPanes.IndexOf(pane).ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteAttributeString("RefID", dockPanel.Panes.IndexOf(pane).ToString(CultureInfo.InvariantCulture));
|
|
NestedDockingStatus status = pane.NestedDockingStatus;
|
|
xmlOut.WriteAttributeString("PrevPane", dockPanel.Panes.IndexOf(status.PreviousPane).ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteAttributeString("Alignment", status.Alignment.ToString());
|
|
xmlOut.WriteAttributeString("Proportion", status.Proportion.ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteEndElement();
|
|
}
|
|
xmlOut.WriteEndElement();
|
|
xmlOut.WriteEndElement();
|
|
}
|
|
xmlOut.WriteEndElement();
|
|
|
|
// FloatWindows
|
|
RectangleConverter rectConverter = new RectangleConverter();
|
|
xmlOut.WriteStartElement("FloatWindows");
|
|
xmlOut.WriteAttributeString("Count", dockPanel.FloatWindows.Count.ToString(CultureInfo.InvariantCulture));
|
|
foreach (FloatWindow fw in dockPanel.FloatWindows)
|
|
{
|
|
xmlOut.WriteStartElement("FloatWindow");
|
|
xmlOut.WriteAttributeString("ID", dockPanel.FloatWindows.IndexOf(fw).ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteAttributeString("Bounds", rectConverter.ConvertToInvariantString(fw.Bounds));
|
|
xmlOut.WriteAttributeString("ZOrderIndex", fw.DockPanel.FloatWindows.IndexOf(fw).ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteStartElement("NestedPanes");
|
|
xmlOut.WriteAttributeString("Count", fw.NestedPanes.Count.ToString(CultureInfo.InvariantCulture));
|
|
foreach (DockPane pane in fw.NestedPanes)
|
|
{
|
|
xmlOut.WriteStartElement("Pane");
|
|
xmlOut.WriteAttributeString("ID", fw.NestedPanes.IndexOf(pane).ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteAttributeString("RefID", dockPanel.Panes.IndexOf(pane).ToString(CultureInfo.InvariantCulture));
|
|
NestedDockingStatus status = pane.NestedDockingStatus;
|
|
xmlOut.WriteAttributeString("PrevPane", dockPanel.Panes.IndexOf(status.PreviousPane).ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteAttributeString("Alignment", status.Alignment.ToString());
|
|
xmlOut.WriteAttributeString("Proportion", status.Proportion.ToString(CultureInfo.InvariantCulture));
|
|
xmlOut.WriteEndElement();
|
|
}
|
|
xmlOut.WriteEndElement();
|
|
xmlOut.WriteEndElement();
|
|
}
|
|
xmlOut.WriteEndElement(); // </FloatWindows>
|
|
|
|
xmlOut.WriteEndElement();
|
|
|
|
if (!upstream)
|
|
{
|
|
xmlOut.WriteEndDocument();
|
|
xmlOut.Close();
|
|
}
|
|
else
|
|
xmlOut.Flush();
|
|
}
|
|
|
|
public static void LoadFromXml(DockPanel dockPanel, string fileName, DeserializeDockContent deserializeContent)
|
|
{
|
|
FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
|
|
try
|
|
{
|
|
LoadFromXml(dockPanel, fs, deserializeContent);
|
|
}
|
|
finally
|
|
{
|
|
fs.Close();
|
|
}
|
|
}
|
|
|
|
public static void LoadFromXml(DockPanel dockPanel, Stream stream, DeserializeDockContent deserializeContent)
|
|
{
|
|
LoadFromXml(dockPanel, stream, deserializeContent, true);
|
|
}
|
|
|
|
private static ContentStruct[] LoadContents(XmlTextReader xmlIn)
|
|
{
|
|
int countOfContents = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
|
|
ContentStruct[] contents = new ContentStruct[countOfContents];
|
|
MoveToNextElement(xmlIn);
|
|
for (int i = 0; i < countOfContents; i++)
|
|
{
|
|
int id = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
|
|
if (xmlIn.Name != "Content" || id != i)
|
|
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
|
|
|
|
contents[i].PersistString = xmlIn.GetAttribute("PersistString");
|
|
contents[i].AutoHidePortion = Convert.ToDouble(xmlIn.GetAttribute("AutoHidePortion"), CultureInfo.InvariantCulture);
|
|
contents[i].IsHidden = Convert.ToBoolean(xmlIn.GetAttribute("IsHidden"), CultureInfo.InvariantCulture);
|
|
contents[i].IsFloat = Convert.ToBoolean(xmlIn.GetAttribute("IsFloat"), CultureInfo.InvariantCulture);
|
|
MoveToNextElement(xmlIn);
|
|
}
|
|
|
|
return contents;
|
|
}
|
|
|
|
private static PaneStruct[] LoadPanes(XmlTextReader xmlIn)
|
|
{
|
|
EnumConverter dockStateConverter = new EnumConverter(typeof(DockState));
|
|
int countOfPanes = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
|
|
PaneStruct[] panes = new PaneStruct[countOfPanes];
|
|
MoveToNextElement(xmlIn);
|
|
for (int i = 0; i < countOfPanes; i++)
|
|
{
|
|
int id = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
|
|
if (xmlIn.Name != "Pane" || id != i)
|
|
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
|
|
|
|
panes[i].DockState = (DockState)dockStateConverter.ConvertFrom(xmlIn.GetAttribute("DockState"));
|
|
panes[i].IndexActiveContent = Convert.ToInt32(xmlIn.GetAttribute("ActiveContent"), CultureInfo.InvariantCulture);
|
|
panes[i].ZOrderIndex = -1;
|
|
|
|
MoveToNextElement(xmlIn);
|
|
if (xmlIn.Name != "Contents")
|
|
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
|
|
int countOfPaneContents = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
|
|
panes[i].IndexContents = new int[countOfPaneContents];
|
|
MoveToNextElement(xmlIn);
|
|
for (int j = 0; j < countOfPaneContents; j++)
|
|
{
|
|
int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
|
|
if (xmlIn.Name != "Content" || id2 != j)
|
|
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
|
|
|
|
panes[i].IndexContents[j] = Convert.ToInt32(xmlIn.GetAttribute("RefID"), CultureInfo.InvariantCulture);
|
|
MoveToNextElement(xmlIn);
|
|
}
|
|
}
|
|
|
|
return panes;
|
|
}
|
|
|
|
private static DockWindowStruct[] LoadDockWindows(XmlTextReader xmlIn, DockPanel dockPanel)
|
|
{
|
|
EnumConverter dockStateConverter = new EnumConverter(typeof(DockState));
|
|
EnumConverter dockAlignmentConverter = new EnumConverter(typeof(DockAlignment));
|
|
int countOfDockWindows = dockPanel.DockWindows.Count;
|
|
DockWindowStruct[] dockWindows = new DockWindowStruct[countOfDockWindows];
|
|
MoveToNextElement(xmlIn);
|
|
for (int i = 0; i < countOfDockWindows; i++)
|
|
{
|
|
int id = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
|
|
if (xmlIn.Name != "DockWindow" || id != i)
|
|
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
|
|
|
|
dockWindows[i].DockState = (DockState)dockStateConverter.ConvertFrom(xmlIn.GetAttribute("DockState"));
|
|
dockWindows[i].ZOrderIndex = Convert.ToInt32(xmlIn.GetAttribute("ZOrderIndex"), CultureInfo.InvariantCulture);
|
|
MoveToNextElement(xmlIn);
|
|
if (xmlIn.Name != "DockList" && xmlIn.Name != "NestedPanes")
|
|
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
|
|
int countOfNestedPanes = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
|
|
dockWindows[i].NestedPanes = new NestedPane[countOfNestedPanes];
|
|
MoveToNextElement(xmlIn);
|
|
for (int j = 0; j < countOfNestedPanes; j++)
|
|
{
|
|
int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
|
|
if (xmlIn.Name != "Pane" || id2 != j)
|
|
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
|
|
dockWindows[i].NestedPanes[j].IndexPane = Convert.ToInt32(xmlIn.GetAttribute("RefID"), CultureInfo.InvariantCulture);
|
|
dockWindows[i].NestedPanes[j].IndexPrevPane = Convert.ToInt32(xmlIn.GetAttribute("PrevPane"), CultureInfo.InvariantCulture);
|
|
dockWindows[i].NestedPanes[j].Alignment = (DockAlignment)dockAlignmentConverter.ConvertFrom(xmlIn.GetAttribute("Alignment"));
|
|
dockWindows[i].NestedPanes[j].Proportion = Convert.ToDouble(xmlIn.GetAttribute("Proportion"), CultureInfo.InvariantCulture);
|
|
MoveToNextElement(xmlIn);
|
|
}
|
|
}
|
|
|
|
return dockWindows;
|
|
}
|
|
|
|
private static FloatWindowStruct[] LoadFloatWindows(XmlTextReader xmlIn)
|
|
{
|
|
EnumConverter dockAlignmentConverter = new EnumConverter(typeof(DockAlignment));
|
|
RectangleConverter rectConverter = new RectangleConverter();
|
|
int countOfFloatWindows = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
|
|
FloatWindowStruct[] floatWindows = new FloatWindowStruct[countOfFloatWindows];
|
|
MoveToNextElement(xmlIn);
|
|
for (int i = 0; i < countOfFloatWindows; i++)
|
|
{
|
|
int id = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
|
|
if (xmlIn.Name != "FloatWindow" || id != i)
|
|
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
|
|
|
|
floatWindows[i].Bounds = (Rectangle)rectConverter.ConvertFromInvariantString(xmlIn.GetAttribute("Bounds"));
|
|
floatWindows[i].ZOrderIndex = Convert.ToInt32(xmlIn.GetAttribute("ZOrderIndex"), CultureInfo.InvariantCulture);
|
|
MoveToNextElement(xmlIn);
|
|
if (xmlIn.Name != "DockList" && xmlIn.Name != "NestedPanes")
|
|
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
|
|
int countOfNestedPanes = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
|
|
floatWindows[i].NestedPanes = new NestedPane[countOfNestedPanes];
|
|
MoveToNextElement(xmlIn);
|
|
for (int j = 0; j < countOfNestedPanes; j++)
|
|
{
|
|
int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
|
|
if (xmlIn.Name != "Pane" || id2 != j)
|
|
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
|
|
floatWindows[i].NestedPanes[j].IndexPane = Convert.ToInt32(xmlIn.GetAttribute("RefID"), CultureInfo.InvariantCulture);
|
|
floatWindows[i].NestedPanes[j].IndexPrevPane = Convert.ToInt32(xmlIn.GetAttribute("PrevPane"), CultureInfo.InvariantCulture);
|
|
floatWindows[i].NestedPanes[j].Alignment = (DockAlignment)dockAlignmentConverter.ConvertFrom(xmlIn.GetAttribute("Alignment"));
|
|
floatWindows[i].NestedPanes[j].Proportion = Convert.ToDouble(xmlIn.GetAttribute("Proportion"), CultureInfo.InvariantCulture);
|
|
MoveToNextElement(xmlIn);
|
|
}
|
|
}
|
|
|
|
return floatWindows;
|
|
}
|
|
|
|
public static void LoadFromXml(DockPanel dockPanel, Stream stream, DeserializeDockContent deserializeContent, bool closeStream)
|
|
{
|
|
|
|
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);
|
|
}
|
|
|
|
private static bool MoveToNextElement(XmlTextReader xmlIn)
|
|
{
|
|
if (!xmlIn.Read())
|
|
return false;
|
|
|
|
while (xmlIn.NodeType == XmlNodeType.EndElement)
|
|
{
|
|
if (!xmlIn.Read())
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static bool IsFormatVersionValid(string formatVersion)
|
|
{
|
|
if (formatVersion == ConfigFileVersion)
|
|
return true;
|
|
|
|
foreach (string s in CompatibleConfigFileVersions)
|
|
if (s == formatVersion)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public void SaveAsXml(string fileName)
|
|
{
|
|
Persistor.SaveAsXml(this, fileName);
|
|
}
|
|
|
|
public void SaveAsXml(string fileName, Encoding encoding)
|
|
{
|
|
Persistor.SaveAsXml(this, fileName, encoding);
|
|
}
|
|
|
|
public void SaveAsXml(Stream stream, Encoding encoding)
|
|
{
|
|
Persistor.SaveAsXml(this, stream, encoding);
|
|
}
|
|
|
|
public void SaveAsXml(Stream stream, Encoding encoding, bool upstream)
|
|
{
|
|
Persistor.SaveAsXml(this, stream, encoding, upstream);
|
|
}
|
|
|
|
public void LoadFromXml(string fileName, DeserializeDockContent deserializeContent)
|
|
{
|
|
Persistor.LoadFromXml(this, fileName, deserializeContent);
|
|
}
|
|
|
|
public void LoadFromXml(Stream stream, DeserializeDockContent deserializeContent)
|
|
{
|
|
Persistor.LoadFromXml(this, stream, deserializeContent);
|
|
}
|
|
|
|
public void LoadFromXml(Stream stream, DeserializeDockContent deserializeContent, bool closeStream)
|
|
{
|
|
Persistor.LoadFromXml(this, stream, deserializeContent, closeStream);
|
|
}
|
|
}
|
|
}
|