Connections.cs

using System;
using System.IO;
using System.Collections.Generic;
using System.Xml;
using System.Xml.Schema;
using Waher.Content.Xml;
using Waher.Content.Xsl;
 
namespace Waher.Client.WPF.Model
{
    public class Connections
    {
        private const string xmlRootElement = "ClientConnections";
        private const string xmlNamespace = "http://waher.se/Schema/ClientConnections.xsd";
 
        private readonly MainWindow owner;
        private readonly List<TreeNode> connections = new List<TreeNode>();
        private bool modified = false;
 
        public Connections(MainWindow Owner)
        {
            this.owner = Owner;
        }
 
        public MainWindow Owner => this.owner;
 
        public void Add(TreeNode RootNode)
        {
            lock (this.connections)
            {
                this.connections.Add(RootNode);
                this.modified = true;
            }
        }
 
        public bool Delete(TreeNode RootNode)
        {
            lock (this.connections)
            {
                if (this.connections.Remove(RootNode))
                {
                    this.modified = true;
                    return true;
                }
            }
 
            return false;
        }
 
        public bool Remove(TreeNode RootNode)
        {
            lock (this.connections)
            {
                if (this.connections.Remove(RootNode))
                {
                    this.modified = true;
                    return true;
                }
                else
                    return false;
            }
        }
 
        public bool Modified
        {
            get => this.modified;
            internal set{ this.modified = true; }
        }
 
        public void Save(string FileName)
        {
            lock (this.connections)
            {
                using (FileStream f = File.Create(FileName))
                {
                    using (XmlWriter w = XmlWriter.Create(f, XML.WriterSettings(true, false)))
                    {
                        w.WriteStartElement(xmlRootElement, xmlNamespace);
 
                        foreach (TreeNode RootNode in this.connections)
                            RootNode.Write(w);
 
                        w.WriteEndElement();
                        w.Flush();
                    }
                }
 
                this.modified = false;
            }
        }
 
        public void Load(string FileName)
        {
            XmlDocument Xml = new XmlDocument()
            {
                PreserveWhitespace = true
            };
            Xml.Load(FileName);
 
            this.Load(FileName, Xml);
        }
 
        public void Load(string FileName, XmlDocument Xml)
        {
            XSL.Validate(FileName, Xml, xmlRootElement, xmlNamespace, schema);
 
            lock (this.connections)
            {
                this.connections.Clear();
 
                foreach (XmlNode N in Xml.DocumentElement.ChildNodes)
                {
                    switch (N.LocalName)
                    {
                        case "XmppAccount":
                            this.connections.Add(new XmppAccountNode((XmlElement)N, this, null));
                            break;
                    }
                }
            }
        }
 
        private static readonly XmlSchema schema = XSL.LoadSchema("Waher.Client.WPF.Schema.ClientConnections.xsd");
 
        public void New()
        {
            TreeNode[] ToDispose;
 
            lock (this.connections)
            {
                ToDispose = this.connections.ToArray();
                this.connections.Clear();
            }
 
            foreach (TreeNode Node in ToDispose)
                Node.Dispose();
        }
 
        public TreeNode[] RootNodes
        {
            get
            {
                lock (this.connections)
                {
                    return this.connections.ToArray();
                }
            }
        }
 
    }
}