internal static void WriteInstance(XmlDocument xmlDoc, XmlElement pluginNode)
{
if (instance == null)
{
//This can occur if a logbook could not be loaded, then ST is closed
instance = new Settings();
}
XmlElement user = xmlDoc.CreateElement("User");
XmlAttribute username = xmlDoc.CreateAttribute("username");
username.Value = instance.User.Username;
user.Attributes.Append(username);
XmlAttribute password = xmlDoc.CreateAttribute("password");
password.Value = instance.User.Password;
user.Attributes.Append(password);
XmlNode existing = pluginNode.SelectSingleNode(user.Name);
if (existing == null)
pluginNode.AppendChild(user);
else
pluginNode.ReplaceChild(user, existing);
XmlElement login = xmlDoc.CreateElement("Login");
XmlAttribute loginId = xmlDoc.CreateAttribute("loginId");
loginId.Value = instance.User.LoginId;
login.Attributes.Append(loginId);
XmlAttribute loginSecret = xmlDoc.CreateAttribute("loginSecret");
loginSecret.Value = instance.User.LoginSecret;
login.Attributes.Append(loginSecret);
existing = pluginNode.SelectSingleNode(login.Name);
if (existing == null)
pluginNode.AppendChild(login);
else
pluginNode.ReplaceChild(login, existing);
XmlElement ExportNameInComment = xmlDoc.CreateElement("ExportNameInComment");
XmlAttribute export = xmlDoc.CreateAttribute("export");
export.Value = instance.boExportNameInComment.ToString();
ExportNameInComment.Attributes.Append(export);
existing = pluginNode.SelectSingleNode(ExportNameInComment.Name);
if (existing == null)
pluginNode.AppendChild(ExportNameInComment);
else
pluginNode.ReplaceChild(ExportNameInComment, existing);
XmlElement RoutePrivacyElement = xmlDoc.CreateElement("RoutePrivacy");
RoutePrivacyElement.SetAttribute("RoutePrivacyIndex", instance.RoutePrivacyIndex.ToString());
existing = pluginNode.SelectSingleNode(RoutePrivacyElement.Name);
if (existing == null)
pluginNode.AppendChild(RoutePrivacyElement);
else
pluginNode.ReplaceChild(RoutePrivacyElement, existing);
// Save activity type mappings
XmlElement mappings = xmlDoc.CreateElement("Mappings"); //Remains called only Mappings for compatibility reasons
foreach (ActivityTypeMapping atm in instance.ActivityTypeMappings)
{
if (atm.Funbeat != 51) // 51 is default, only save mappings that differ
{
XmlElement mapping = xmlDoc.CreateElement("Mapping");
XmlAttribute funbeat = xmlDoc.CreateAttribute("funbeat");
XmlAttribute st2 = xmlDoc.CreateAttribute("st2");
funbeat.Value = atm.Funbeat.ToString();
st2.Value = atm.SportTracks;
mapping.Attributes.Append(funbeat);
mapping.Attributes.Append(st2);
mappings.AppendChild(mapping);
}
}
existing = pluginNode.SelectSingleNode(mappings.Name);
if (existing == null)
pluginNode.AppendChild(mappings);
else
pluginNode.ReplaceChild(mappings, existing);
// Save equipment mappings
XmlElement eqMappings = xmlDoc.CreateElement("EquipmentMappings");
foreach (EquipmentTypeMapping etm in instance.EquipmentTypeMappings)
{
if (etm.Funbeat != "") // Only save mappings that are used
{
XmlElement mapping = xmlDoc.CreateElement("Mapping");
XmlAttribute funbeat = xmlDoc.CreateAttribute("funbeat");
XmlAttribute st2 = xmlDoc.CreateAttribute("st2");
funbeat.Value = etm.Funbeat;
st2.Value = etm.SportTracks;
mapping.Attributes.Append(funbeat);
mapping.Attributes.Append(st2);
eqMappings.AppendChild(mapping);
}
}
existing = pluginNode.SelectSingleNode(eqMappings.Name);
if (existing == null)
pluginNode.AppendChild(eqMappings);
else
pluginNode.ReplaceChild(eqMappings, existing);
}
// TODO: Take the word save off front of this method when XmlNode.ReplaceChild() is implemented.
public void saveTestReplaceChildAffectOnEnumeration ()
{
document.LoadXml ("<foo><child1/><child2/></foo>");
element = document.DocumentElement;
node = document.CreateElement("child3");
enumerator = element.GetEnumerator();
Assert.AreEqual (enumerator.MoveNext(), true, "MoveNext should have succeeded.");
element.ReplaceChild(node, element.LastChild);
enumerator.MoveNext();
Assert.AreEqual (((XmlElement)enumerator.Current).LocalName, "child3", "Expected child3 element.");
Assert.AreEqual (enumerator.MoveNext(), false, "MoveNext should have failed.");
}
void mergeNodes(XmlElement oldroot,XmlElement newroot,string nd,string idattr)
{
string[] atr = idattr.Split('|');
foreach (XmlElement e in newroot)
if (e.Name == nd)
{
string vl = "";
for (int i=0;i<atr.Length;i++)
{
if (i != 0) vl += "|";
vl += e.Attributes[atr[i]].Value;
}
XmlElement e2 = findNode(oldroot, nd, idattr, vl);
if (e2 == null)
oldroot.AppendChild(doc.ImportNode(e,true));
else
{
bool same = true;
if (e2.Attributes.Count != e.Attributes.Count)
same = false;
else
for (int i = 0; i < e2.Attributes.Count;i++ )
{
string nm = e2.Attributes[i].Name;
if (e.Attributes[nm] == null || e.Attributes[nm].Value != e2.Attributes[nm].Value)
same = false;
}
if (!same)
{
if (new MergeChanges(e2,e).ShowDialog() == DialogResult.OK)
oldroot.ReplaceChild(doc.ImportNode(e,true), e2);
}
}
}
}
IEnumerable<XmlNode> GetNormalizedChildNodes(XmlElement element)
{
XmlNode node = element.FirstChild;
while (node != null) {
XmlText text = node as XmlText;
XmlCDataSection cData = node as XmlCDataSection;
if (node.NodeType == XmlNodeType.SignificantWhitespace) {
text = element.OwnerDocument.CreateTextNode(node.Value);
element.ReplaceChild(text, node);
node = text;
}
if (text != null || cData != null) {
node = node.NextSibling;
while (node != null
&& (node.NodeType == XmlNodeType.Text
|| node.NodeType == XmlNodeType.CDATA
|| node.NodeType == XmlNodeType.SignificantWhitespace)) {
if (text != null) text.Value += node.Value;
else cData.Value += node.Value;
XmlNode nodeToDelete = node;
node = node.NextSibling;
element.RemoveChild(nodeToDelete);
}
if (text != null) yield return text;
else yield return cData;
} else {
yield return node;
node = node.NextSibling;
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Creates the entries for the type library and all classes defined in this type
/// library. We can get the necessary information for the file element (file name and
/// size) directly from the file. We get the information for the type library from
/// the type library itself.
/// </summary>
/// <param name="parent">The parent node.</param>
/// <param name="fileName">Name (and path) of the file.</param>
/// ------------------------------------------------------------------------------------
public void ProcessTypeLibrary(XmlElement parent, string fileName)
{
m_BaseDirectory = Path.GetDirectoryName(fileName);
m_FileName = fileName.ToLower();
try
{
XmlNode oldChild;
ITypeLib typeLib = LoadTypeLib(m_FileName);
IntPtr pLibAttr;
typeLib.GetLibAttr(out pLibAttr);
var libAttr = (TYPELIBATTR)
System.Runtime.InteropServices.Marshal.PtrToStructure(pLibAttr, typeof(TYPELIBATTR));
typeLib.ReleaseTLibAttr(pLibAttr);
string flags = string.Empty;
if ((libAttr.wLibFlags & LIBFLAGS.LIBFLAG_FHASDISKIMAGE) == LIBFLAGS.LIBFLAG_FHASDISKIMAGE)
flags = "HASDISKIMAGE";
// <file name="FwKernel.dll" asmv2:size="1507328">
XmlElement file = GetOrCreateFileNode(parent, fileName);
// <typelib tlbid="{2f0fccc0-c160-11d3-8da2-005004defec4}" version="1.0" helpdir=""
// resourceid="0" flags="HASDISKIMAGE" />
if (m_TlbGuids.ContainsKey(libAttr.guid))
{
Console.WriteLine("Warning: Type library with GUID {0} is defined in {1} and {2}",
libAttr.guid, m_TlbGuids[libAttr.guid], Path.GetFileName(fileName));
}
else
{
m_TlbGuids.Add(libAttr.guid, Path.GetFileName(fileName));
XmlElement elem = m_Doc.CreateElement("typelib", UrnAsmv1);
elem.SetAttribute("tlbid", string.Format("{{{0}}}", libAttr.guid));
elem.SetAttribute("version", string.Format("{0}.{1}", libAttr.wMajorVerNum,
libAttr.wMinorVerNum));
elem.SetAttribute("helpdir", string.Empty);
elem.SetAttribute("resourceid", "0");
elem.SetAttribute("flags", flags);
oldChild = file.SelectSingleNode(string.Format("typelib[tlbid='{{{0}}}']",
libAttr.guid));
if (oldChild != null)
file.ReplaceChild(elem, oldChild);
else
file.AppendChild(elem);
}
Debug.WriteLine(string.Format(@"typelib tlbid=""{0}"" version=""{1}.{2}"" helpdir="""" resourceid=""0"" flags=""{3}""",
libAttr.guid, libAttr.wMajorVerNum, libAttr.wMinorVerNum, flags));
int count = typeLib.GetTypeInfoCount();
for (int i = 0; i < count; i++)
{
ITypeInfo typeInfo;
typeLib.GetTypeInfo(i, out typeInfo);
ProcessTypeInfo(parent, libAttr.guid, typeInfo);
}
oldChild = parent.SelectSingleNode(string.Format("file[name='{0}']",
Path.GetFileName(fileName)));
if (oldChild != null)
parent.ReplaceChild(file, oldChild);
else
parent.AppendChild(file);
}
catch (System.Runtime.InteropServices.COMException)
{
// just ignore if this isn't a type library
if (m_fDisplayWarnings)
Console.WriteLine("Warning: Can't load type library {0}", fileName);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Creates the entries for the type library and all classes defined in this type
/// library. We can get the necessary information for the file element (file name and
/// size) directly from the file. We get the information for the type library from
/// the type library itself.
/// </summary>
/// <param name="parent">The parent node.</param>
/// <param name="fileName">Name (and path) of the file.</param>
/// ------------------------------------------------------------------------------------
public void ProcessTypeLibrary(XmlElement parent, string fileName)
{
_baseDirectory = Path.GetDirectoryName(fileName);
_fileName = fileName.ToLower();
try
{
_log.LogMessage(MessageImportance.Low, "\tProcessing type library {0}", fileName);
XmlNode oldChild;
ITypeLib typeLib;
RegHelper.LoadTypeLib(_fileName, out typeLib);
IntPtr pLibAttr;
typeLib.GetLibAttr(out pLibAttr);
var libAttr = (TYPELIBATTR)
Marshal.PtrToStructure(pLibAttr, typeof(TYPELIBATTR));
typeLib.ReleaseTLibAttr(pLibAttr);
string flags = string.Empty;
if ((libAttr.wLibFlags & LIBFLAGS.LIBFLAG_FHASDISKIMAGE) == LIBFLAGS.LIBFLAG_FHASDISKIMAGE)
flags = "HASDISKIMAGE";
// <file name="FwKernel.dll" asmv2:size="1507328">
var file = GetOrCreateFileNode(parent, fileName);
// <typelib tlbid="{2f0fccc0-c160-11d3-8da2-005004defec4}" version="1.0" helpdir=""
// resourceid="0" flags="HASDISKIMAGE" />
if (_tlbGuids.ContainsKey(libAttr.guid))
{
_log.LogWarning("Type library with GUID {0} is defined in {1} and {2}",
libAttr.guid, _tlbGuids[libAttr.guid], Path.GetFileName(fileName));
}
else
{
_tlbGuids.Add(libAttr.guid, Path.GetFileName(fileName));
XmlElement elem = _doc.CreateElement("typelib", UrnAsmv1);
elem.SetAttribute("tlbid", libAttr.guid.ToString("B"));
elem.SetAttribute("version", string.Format("{0}.{1}", libAttr.wMajorVerNum,
libAttr.wMinorVerNum));
elem.SetAttribute("helpdir", string.Empty);
elem.SetAttribute("resourceid", "0");
elem.SetAttribute("flags", flags);
oldChild = file.SelectSingleNode(string.Format("asmv1:typelib[asmv1:tlbid='{0}']",
libAttr.guid.ToString("B")), _nsManager);
if (oldChild != null)
file.ReplaceChild(elem, oldChild);
else
file.AppendChild(elem);
}
Debug.WriteLine(@"typelib tlbid=""{0}"" version=""{1}.{2}"" helpdir="""" resourceid=""0"" flags=""{3}""",
libAttr.guid, libAttr.wMajorVerNum, libAttr.wMinorVerNum, flags);
int count = typeLib.GetTypeInfoCount();
_log.LogMessage(MessageImportance.Low, "\t\tTypelib has {0} types", count);
for (int i = 0; i < count; i++)
{
ITypeInfo typeInfo;
typeLib.GetTypeInfo(i, out typeInfo);
ProcessTypeInfo(parent, libAttr.guid, typeInfo);
}
oldChild = parent.SelectSingleNode(string.Format("asmv1:file[asmv1:name='{0}']",
Path.GetFileName(fileName)), _nsManager);
if (oldChild != null)
parent.ReplaceChild(file, oldChild);
else
parent.AppendChild(file);
}
catch (Exception)
{
// just ignore if this isn't a type library
_log.LogMessage(MessageImportance.Normal, "Can't load type library {0}", fileName);
}
}
//直接和xml打交道的处理和部分对于显示的刷新。
//把dstXe加到srcXe里
public static bool insertXmlNode(MainWindow pW, XmlControl xmlCtrl, XmlElement dstXe, XmlElement srcXe, int index = 0)
{
XmlElement tmpXe1 = dstXe.OwnerDocument.CreateElement("tmp1");
XmlElement tmpXe2 = dstXe.OwnerDocument.CreateElement("tmp2");
if(index < (srcXe.ChildNodes.Count + 1) / 2)
{
srcXe.PrependChild(tmpXe1);
XmlNode iXe = tmpXe1;
for (int i = 0; i < index; i++)
{
XmlNode nextXe = iXe.NextSibling;
srcXe.ReplaceChild(tmpXe2, nextXe);
srcXe.ReplaceChild(nextXe, tmpXe1);
srcXe.ReplaceChild(tmpXe1, tmpXe2);
iXe = tmpXe1;
}
srcXe.ReplaceChild(dstXe, tmpXe1);
}
else
{
srcXe.AppendChild(tmpXe1);
XmlNode iXe = tmpXe1;
for (int i = srcXe.ChildNodes.Count - 1; i > index; i--)
{
XmlNode prevXe = iXe.PreviousSibling;
srcXe.ReplaceChild(tmpXe2, prevXe);
srcXe.ReplaceChild(prevXe, tmpXe1);
srcXe.ReplaceChild(tmpXe1, tmpXe2);
iXe = tmpXe1;
}
srcXe.ReplaceChild(dstXe, tmpXe1);
}
if (xmlCtrl != null)
{
insertItemByXe(pW, xmlCtrl, dstXe, srcXe, ref index);
}
return false;
}
private void PreprocessElement(XmlDocument document, XmlElement element, ref List<PreprocessorAreaData> datas, PreprocessorAreaData parentArea = null)
{
List<XmlElement> nodes = element.ChildNodes.OfType<XmlElement>().ToList();
foreach (XmlElement subElement in nodes)
{
if (subElement == null)
{
continue;
}
switch (subElement.Name.ToLower())
{
case "mssqlauditorpreprocessor":
{
string className = subElement.Attributes["preprocessor"].Value;
XmlAttribute idAttr = subElement.Attributes["id"];
XmlAttribute nameAttr = subElement.Attributes["name"];
XmlAttribute columnAttr = subElement.Attributes["column"];
XmlAttribute rowAttr = subElement.Attributes["row"];
XmlAttribute colSpanAttr = subElement.Attributes["colspan"];
XmlAttribute rowSpanAttr = subElement.Attributes["rowspan"];
XmlAttribute vertTestAlign = subElement.Attributes["text-vertical-align"];
XmlAttribute textAlign = subElement.Attributes["text-align"];
string id = "";
string preprocName = "unnamed";
if (nameAttr != null)
{
preprocName = nameAttr.Value;
}
if (idAttr != null)
{
id = idAttr.Value;
}
int col = ParseIntAttribute(columnAttr, 1);
int row = ParseIntAttribute(rowAttr, 1);
int colSpan = ParseIntAttribute(colSpanAttr, 1);
int rowSpan = ParseIntAttribute(rowSpanAttr, 1);
VerticalTextAlign? preprocVertTestAlign = null;
if (vertTestAlign != null)
{
VerticalTextAlign tempVertTestAlign;
if (Enum.TryParse(vertTestAlign.Value, out tempVertTestAlign))
{
preprocVertTestAlign = tempVertTestAlign;
}
}
TextAlign preprocTestAlign = TextAlign.Left;
if (textAlign != null)
{
if (!Enum.TryParse(textAlign.Value, out preprocTestAlign))
{
preprocTestAlign = TextAlign.Left;
}
}
IPreprocessor preprocessor =
(from proc in this._availablePreprocessors where proc.GetType().Name == className select proc)
.FirstOrDefault();
if (preprocessor != null)
{
string configuration = subElement.InnerXml;
IContentFactory factory = preprocessor.CreateContentFactory(id, configuration);
PreprocessorData data = new PreprocessorData
{
ContentFactory = factory,
Name = preprocName,
Column = col,
Row = row,
ColSpan = colSpan,
RowSpan = rowSpan,
VerticalTextAlign = preprocVertTestAlign,
TextAlign = preprocTestAlign
};
XmlElement newSubElement = document.CreateElement("div");
newSubElement.SetAttribute("style", "margin:0; padding:0;");
newSubElement.InnerXml = string.Empty;
element.ReplaceChild(newSubElement, subElement);
if (parentArea != null)
{
parentArea.Preprocessors.Add(data);
}
else
{
log.ErrorFormat(
"Invalid configuration: <mssqlauditorpreprocessor> is not embedded in <mssqlauditorpreprocessors>. " +
"Are you using old style configuration file?" + Environment.NewLine +
"Silently ignoring '{0}' with id='{1}' and name='{2}'",
className,
id,
preprocName
);
throw new ArgumentOutOfRangeException(
"document",
"Invalid configuration: <mssqlauditorpreprocessor> is not embedded in <mssqlauditorpreprocessors>!"
);
}
continue;
}
break;
}
case "mssqlauditorpreprocessors":
{
XmlAttribute idAttr = subElement.Attributes["id"];
XmlAttribute nameAttr = subElement.Attributes["name"];
XmlAttribute rowsAttr = subElement.Attributes["rows"];
XmlAttribute columnsAttr = subElement.Attributes["columns"];
XmlAttribute splitterAttr = subElement.Attributes["splitter"];
string id = "";
string name = "unnamed";
string rows = "";
string columns = "";
string splitter = "";
if (nameAttr != null)
{
name = nameAttr.Value;
}
if (idAttr != null)
{
id = idAttr.Value;
}
if (columnsAttr != null)
{
columns = columnsAttr.Value;
}
if (rowsAttr != null)
{
rows = rowsAttr.Value;
}
if (splitterAttr != null)
{
splitter = splitterAttr.Value;
}
PreprocessorAreaData container = new PreprocessorAreaData(id, name, columns, rows);
if (string.Equals(splitter, "no", StringComparison.InvariantCultureIgnoreCase))
{
container.NoSplitter = true;
}
datas.Add(container);
PreprocessElement(document, subElement, ref datas, container);
container.CheckPreprocessors();
continue;
}
}
PreprocessElement(document, subElement, ref datas);
}
}
/// <summary>
/// Сравнивает два документа. Результат в pFldLocal
/// </summary>
/// <param name="pFldLocal"></param>
/// <param name="pFldRemote"></param>
public static void compareFldrs(XmlElement pFldLocal, XmlElement pFldRemote) {
/*Обновление модулей и удаление старых*/
XmlNodeList vMdls = pFldLocal.SelectNodes("assembly");
foreach(XmlElement vNode in vMdls) {
XmlElement vRNode = (XmlElement)pFldRemote.SelectSingleNode("assembly[@name='" + vNode.GetAttribute("name") + "']");
if((vRNode != null) && (Utl.CompareVer(vRNode.GetAttribute("version"), vNode.GetAttribute("version")) > 0)) {
XmlNode vNewEl = pFldLocal.OwnerDocument.ImportNode(vRNode, true);
pFldLocal.ReplaceChild(vNewEl, vNode);
} else {
if(vRNode == null)
vNode.SetAttribute("action", "kill");
else
vNode.SetAttribute("action", "skip");
}
}
/*Добавляем новые модули*/
vMdls = pFldRemote.SelectNodes("assembly");
foreach(XmlElement vNode in vMdls) {
XmlElement vLNode = (XmlElement)pFldLocal.SelectSingleNode("assembly[@name='" + vNode.GetAttribute("name") + "']");
if(vLNode == null) {
XmlNode vNewEl = pFldLocal.OwnerDocument.ImportNode(vNode, true);
pFldLocal.AppendChild(vNewEl);
}
}
/*Обновляем существующие и удаляем старые папки*/
vMdls = pFldLocal.SelectNodes("folder");
foreach(XmlElement vNode in vMdls) {
XmlElement vRNode = (XmlElement)pFldRemote.SelectSingleNode("folder[@name='" + vNode.GetAttribute("name") + "']");
if(vRNode != null) {
compareFldrs(vNode, vRNode);
} else {
if(!vNode.GetAttribute("name").Equals("trash"))
vNode.SetAttribute("action", "kill");
}
}
/*Добавляем новые папки*/
vMdls = pFldRemote.SelectNodes("folder");
foreach(XmlElement vNode in vMdls) {
XmlNode vLNode = pFldLocal.SelectSingleNode("folder[@name='" + vNode.GetAttribute("name") + "']");
if(vLNode == null) {
XmlNode vNewEl = pFldLocal.OwnerDocument.ImportNode(vNode, true);
pFldLocal.AppendChild(vNewEl);
}
}
}
