Settings.cs

using System;
using System.Windows.Forms;
using System.Xml;
using be.gaudry.observer;
 
namespace be.gaudry.model.config
{
    public class Settings
    {
        #region declarations and constructors
        private XmlDocument xmlDocument;
        private string documentPath;
        private bool hidden;
        /// <summary>
        /// Provides method to store settings in a hidden xml file in the application directory
        /// </summary>
        public Settings()
            : this(Application.StartupPath + "\\settings.xml",true)
        {
        }
        /// <summary>
        /// Provides method to store settings in a xml file
        /// </summary>
        /// <param name="documentPath">Path of the xml file</param>
        /// <param name="hidden">True if the file must be hidden</param>
        public Settings(string documentPath, bool hidden)
        {
            this.documentPath = documentPath;
            this.hidden = hidden;
            xmlDocument = new XmlDocument();
            initDocument();
        } 
        #endregion
 
        #region initializations
        /// <summary>
        /// Loads document if file is found, or create a new xml document in memory.
        /// </summary>
        private void initDocument()
        {
            try 
            {
                hide(false);
                xmlDocument.Load(documentPath);
                hide(true);
            }
            catch { xmlDocument.LoadXml("<settings></settings>"); }
        } 
        #endregion
 
        #region public methods and properties
        public String SettingsPath
        {
            get
            {
                return documentPath;
            }
            set
            {
                documentPath = value;
                initDocument();
            }
        }
 
        /// <summary>
        /// Saves all settings
        /// </summary>
        public void save()
        {
            try
            {
                hide(false);
                xmlDocument.Save(documentPath);
                hide(true);
            }
            catch (Exception e)
            {
                StaticObservable.notify(new Notification(Notification.VERBOSE.lowError, e, this));
            }
        }
        /// <summary>
        /// Modify the file attribute to hide the settings file
        /// </summary>
        private void hide(bool hide)
        {
            if (hidden && System.IO.File.Exists(documentPath))
            {
                try
                {
                    if (!hide)//((System.IO.File.GetAttributes(documentPath) & System.IO.FileAttributes.Hidden) == System.IO.FileAttributes.Hidden)
                    {
                        // Show the file.
                        System.IO.File.SetAttributes(documentPath, System.IO.FileAttributes.Archive);
                    }
                    else
                    {
                        // Hide the file.
                        System.IO.File.SetAttributes(documentPath, System.IO.File.GetAttributes(documentPath) | System.IO.FileAttributes.Hidden);
                    }
 
                }
                catch { }
            }
        }
 
        #region int value
        //todo : use tryparse instead ?
        public int getSetting(string xPath, int defaultValue)
        { return Convert.ToInt16(getSetting(xPath, Convert.ToString(defaultValue))); }
 
        /// <summary>
        /// Sets an int value in the setting file.
        /// </summary>
        /// <param name="xPath">xml node path (slashes separated nodes)</param>
        /// <param name="value">value to set</param>
        /// <param name="save">true to save this value. Otherwise, you can set all values and call once the <code>save()</code> method.</param>
        public void putSetting(string xPath, int value, bool save)
        { putSetting(xPath, Convert.ToString(value), save); }
 
        #endregion
 
        #region bool value
        public bool getSetting(string xPath, bool defaultValue)
        { return "true".Equals(getSetting(xPath, (defaultValue) ? "true" : "false")); }
 
        /// <summary>
        /// Sets a bool value in the setting file.
        /// </summary>
        /// <param name="xPath">xml node path (slashes separated nodes)</param>
        /// <param name="value">value to set</param>
        /// <param name="save">true to save this value. Otherwise, you can set all values and call once the <code>save()</code> method.</param>
        public void putSetting(string xPath, bool value, bool save)
        { putSetting(xPath, (value) ? "true" : "false", save); } 
        #endregion
 
        #region string value (default)
        public string getSetting(string xPath, string defaultValue)
        {
            XmlNode xmlNode = xmlDocument.SelectSingleNode("settings/" + xPath);
            if (xmlNode != null) { return xmlNode.InnerText; }
            else { return defaultValue; }
        }
        /// <summary>
        /// Sets a value in the setting file.
        /// </summary>
        /// <param name="xPath">xml node path (slashes separated nodes)</param>
        /// <param name="value">value to set</param>
        /// <param name="save">true to save this value. Otherwise, you can set all values and call once the <code>save()</code> method.</param>
        public void putSetting(string xPath, string value, bool save)
        {
            try
            {
                XmlNode xmlNode = xmlDocument.SelectSingleNode("settings/" + xPath);
                if (xmlNode == null) { xmlNode = createMissingNode("settings/" + xPath); }
                xmlNode.InnerText = value;
                if (save)
                {
                    hide(false);
                    xmlDocument.Save(documentPath);
                    hide(true);
                }
            }
            catch (System.IO.DirectoryNotFoundException dnfe)
            {
                StaticObservable.notify(new Notification(Notification.VERBOSE.lowError, dnfe, this));
            }
        }
        #endregion 
 
        #endregion
 
        #region private methods
        private XmlNode createMissingNode(string xPath)
        {
            string[] xPathSections = xPath.Split('/');
            string currentXPath = "";
            XmlNode testNode = null;
            XmlNode currentNode = xmlDocument.SelectSingleNode("settings");
            foreach (string xPathSection in xPathSections)
            {
                currentXPath += xPathSection;
                testNode = xmlDocument.SelectSingleNode(currentXPath);
                if (testNode == null) { currentNode.InnerXml += "<" + xPathSection + "></" + xPathSection + ">"; }
                currentNode = xmlDocument.SelectSingleNode(currentXPath);
                currentXPath += "/";
            }
            return currentNode;
        } 
        #endregion
    }
}