WindowStateManager WPF

using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Xml;
using System.Xml.Serialization;

namespace System.Windows {
    /// <summary>
    /// Remembers the window's size and position by saving window state to a xml file
    ///<example>
    ///
    /*
     WindowStateManager _windowState;

        public MainWindow() {
            InitializeComponent();

            _windowState = new WindowStateManager(this);
        }
     */
    ///
    ///</example>
    /// </summary>
    public class WindowStateManager {

        const string DATA_FILE_NAME = "WindowStateManager.xml";
        const string DATA_FILE_FORMAT = "WindowStateManager_{0}.xml";

        Window _parentWindow;
        WindowStateData _data;
        WindowStateData _originalData;
        double _lastWidth;
        double _lastHeight;
        double _lastTop;
        double _lastLeft;

        public IDictionary<string,object> AdditionalData {
            get {
                return Data.AdditionalData;
            }
        }

        public WindowStateData Data {
            get {
                return _data;
            }
        }

        public Window ParentWindow {
            get {
                return _parentWindow;
            }
        }

        public WindowStateManager(Window parentWindow) {
            bool createdNewInstance = false;

            _parentWindow = parentWindow;
            _data = LoadData(out createdNewInstance);
            _originalData = _data.Copy();

            if(createdNewInstance)
                _parentWindow.WindowStartupLocation = WindowStartupLocation.CenterScreen;
            else
                _parentWindow.WindowStartupLocation = WindowStartupLocation.Manual;

            _parentWindow.StateChanged += ParentWindow_StateChanged;
            _parentWindow.LocationChanged += ParentWindow_LocationChanged;
            _parentWindow.SizeChanged += ParentWindow_SizeChanged;
            _parentWindow.Closing += ParentWindow_Closing;

            Data.UpdateWindowProperties(ParentWindow);
            Debug.WriteLine("WindowStateManager ctr: " + Data.ToString());
        }


        public T GetAdditionalData<T>(string key,T defaultValue = default(T)) {
            if(!AdditionalData.ContainsKey(key))
                return defaultValue;
            object data = AdditionalData[key];
            if(data == null)
                return defaultValue;
            return (T)data;
        }

        void ParentWindow_StateChanged(object sender,EventArgs e)
        {
            _lastTop = ParentWindow.Top;
            _lastLeft = ParentWindow.Left;
            _lastWidth = ParentWindow.Width;
            _lastHeight = ParentWindow.Height;
        }

        void ParentWindow_LocationChanged(object sender,EventArgs e)
        {
            _lastTop = ParentWindow.Top;
            _lastLeft = ParentWindow.Left;
            _lastWidth = ParentWindow.Width;
            _lastHeight = ParentWindow.Height;
        }
        void ParentWindow_SizeChanged(object sender,SizeChangedEventArgs e)
        {
            if(ParentWindow.WindowState == WindowState.Normal)
            {
                if(e.WidthChanged)
                    _lastWidth = e.NewSize.Width;
                if(e.HeightChanged)
                    _lastHeight = e.NewSize.Height;
            }
        }

        void ParentWindow_Closing(object sender,System.ComponentModel.CancelEventArgs e) {

            Data.SetWindowProperties(ParentWindow,
                new Size(_lastWidth,_lastHeight),
                new Point(_lastTop,_lastLeft),
                _originalData);
            SaveData(Data);
            Debug.WriteLine("ParentWindow_Closing: " + Data.ToString());
        }
        string GetDataFileName() {
            if(_parentWindow == null)
                return DATA_FILE_NAME;

            return string.Format(DATA_FILE_FORMAT,_parentWindow.GetType().Name);
        }

        WindowStateData LoadData(out bool createdNewInstance) {
            string fn = GetDataFileName();
            try
            {
                if(File.Exists(fn))
                {
                    createdNewInstance = false;
                    return XmlHelpers.ReadObjectFromFile<WindowStateData>(fn);
                }
                else
                {
                    createdNewInstance = true;
                    return new WindowStateData();
                }
            }
            catch
            {
                createdNewInstance = true;
                return new WindowStateData();
            }
        }

        void SaveData(WindowStateData data) {
            string fn = GetDataFileName();
            XmlHelpers.SaveObjectToFile(data,fn);
        }

        [Serializable]
        public class WindowStateData {

            SerializableDictionary<string,object> _additionalData;

            public void UpdateWindowProperties(Window w) {

                WindowStateData data = this;

                w.Width = data.Width;
                w.Height = data.Height;

                if(data.Top > -1)
                    w.Top = data.Top;
                if(data.Left > -1)
                    w.Left = data.Left;

                if(data.AllowMaximized && data.State == WindowState.Maximized) {
                    w.WindowState = WindowState.Maximized;
                    return;
                }
            }

            public void SetWindowLocation(Window w) {
                WindowStateData data = this;
                data.State = w.WindowState;
                data.Top = w.Top;
                data.Left = w.Left;
            }
            public void SetWindowProperties(Window w,
                Size winHeightWidth,
                Point  winTopLeft,
                WindowStateData lastModstate) {

                WindowStateData data = this;
                data.State = w.WindowState;


                if(w.WindowState == System.Windows.WindowState.Normal) {
                    data.Width = w.Width;
                    data.Height = w.Height;
                    data.Top = w.Top;
                    data.Left = w.Left;
                }
                else if(w.WindowState == System.Windows.WindowState.Maximized) {
                    data.Width = winHeightWidth.Width;
                    data.Height = winHeightWidth.Height;
                    data.Top = winTopLeft.X;
                    data.Left = winTopLeft.Y;
                }
                else if(w.WindowState == System.Windows.WindowState.Minimized) {
                    data.Width = lastModstate.Width;
                    data.Height = lastModstate.Height;
                    data.Top = lastModstate.Top;
                    data.Left = lastModstate.Left;
                }
            }

            [XmlElement("AdditionalData")]
            public SerializableDictionary<string,object> AdditionalData {
                get {
                    if(_additionalData == null)
                        _additionalData = new SerializableDictionary<string,object>();
                    return _additionalData;
                }
                set { _additionalData = value; }
            }


            public double Width {
                get;
                set;
            }
            public double Height {
                get;
                set;
            }
            public double Top {
                get;
                set;
            }
            public double Left {
                get;
                set;
            }
            public WindowState State {
                get;
                set;
            }
            public bool AllowMaximized {
                get;
                set;
            }

            public void Reset() {
                Top = -1;
                Left = -1;
                Height = 400;
                Width = 600;
                State = WindowState.Normal;
                AllowMaximized = true;
            }
            public WindowStateData Copy() {
                WindowStateData copied = new WindowStateData();
                copied.Width = this.Width;
                copied.Height = this.Height;
                copied.Top = this.Top;
                copied.Left = this.Left;
                copied.State = this.State;
                copied.AllowMaximized = this.AllowMaximized;
                return copied;
            }

            public WindowStateData() {
                Reset();
            }
            public override string ToString() {
                return string.Format("w:{0:N0} h:{1:N0} t:{2:N0} l:{3:N0}",Width,Height,Top,Left);
            }
        }
    }

    internal class XmlHelpers {

        public static object CopyObject(object toCopy) {
            return CopyObject<object>(toCopy);
        }
        /// <summary>
        /// Copies an object using the XmlSerilizer class
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="toCopy"></param>
        /// <returns>New object</returns>
        public static T CopyObject<T>(T toCopy) {
            if(toCopy == null)
                throw new ArgumentNullException("toCopy");

            using(MemoryStream memoryStream = new MemoryStream()) {
                XmlSerializer xs = new XmlSerializer(toCopy.GetType());
                XmlSerializerNamespaces xmlNamespace = new XmlSerializerNamespaces();

                xmlNamespace.Add(string.Empty,string.Empty);
                xs.Serialize(memoryStream,toCopy,xmlNamespace);
                return (T)xs.Deserialize(memoryStream);
            }
        }
        /// <summary>
        /// Method to reconstruct an Object from XML string
        /// </summary>
        /// <param name="pXmlizedString"></param>
        /// <returns></returns>
        public static Object DeserializeObject(String pXmlizedString,Type objectType) {
            try {
                XmlSerializer xs = new XmlSerializer(objectType);
                using(MemoryStream memoryStream = new MemoryStream(StringToUTF8ByteArray(pXmlizedString))) {
                    XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream,Encoding.UTF8);
                    return xs.Deserialize(memoryStream);
                }
            }
            catch {
                throw;
            }
        }
        public static bool TryDeserializeObject(string xmlString,Type objType,out object theObject) {
            try {
                theObject = DeserializeObject(xmlString,objType);
                return true;
            }
            catch {
                theObject = null;
                return false;
            }
        }

        public static String SerializeObject(Object pObject) {
            return SerializeObject(pObject,pObject.GetType());
        }

        public static String SerializeObject(Object pObject,Type objectType) {
            try {
                String XmlizedString = null;

                using(MemoryStream memoryStream = new MemoryStream()) {
                    XmlSerializer xs = new XmlSerializer(objectType);

                    XmlSerializerNamespaces xmlNamespace = new XmlSerializerNamespaces();
                    xmlNamespace.Add(string.Empty,string.Empty);

                    xs.Serialize(memoryStream,pObject,xmlNamespace);
                    XmlizedString = UTF8ByteArrayToString(memoryStream.ToArray());
                }
                return XmlizedString;
            }
            catch {
                throw;
            }
        }

        public static bool TrySerializeObject(object pObject,Type objectType,out string xmlString) {
            try {
                xmlString = SerializeObject(pObject,objectType);
                return true;
            }
            catch {
                xmlString = null;
                return false;
            }
        }

        public static void SaveObjectToFile(object obj,string path) {
            File.WriteAllText(path,SerializeObject(obj,obj.GetType()));
        }

        public static T ReadObjectFromFile<T>(string path) {
            return (T)XmlHelpers.DeserializeObject(File.ReadAllText(path),typeof(T));
        }

        public static object ReadObjectFromFile<T>(string path,Type objType) {
            return XmlHelpers.DeserializeObject(File.ReadAllText(path),objType);
        }
        /// <summary>
        /// To convert a Byte Array of Unicode values (UTF-8 encoded) to a complete String.
        /// </summary>
        /// <param name="characters">Unicode Byte Array to be converted to String</param>
        /// <returns>String converted from Unicode Byte Array</returns>
        private static String UTF8ByteArrayToString(Byte[] characters) {
            UTF8Encoding encoding = new UTF8Encoding();
            String constructedString = encoding.GetString(characters);
            return (constructedString);
        }

        /// <summary>
        /// Converts the String to UTF8 Byte array and is used in De serialization
        /// </summary>
        /// <param name="pXmlString"></param>
        /// <returns></returns>
        private static Byte[] StringToUTF8ByteArray(String pXmlString) {
            UTF8Encoding encoding = new UTF8Encoding();
            Byte[] byteArray = encoding.GetBytes(pXmlString);
            return byteArray;
        }
    }

    [XmlRoot("dictionary")]
    [Serializable]
    public class SerializableDictionary<TKey,TValue>
        :Dictionary<TKey,TValue>,IXmlSerializable {

        #region Constructor
        public SerializableDictionary() {
        }

        public SerializableDictionary(IDictionary<TKey,TValue> dictionary)
            : base(dictionary) {
        }

        #endregion

        #region IXmlSerializable Members

        public System.Xml.Schema.XmlSchema GetSchema() {
            return null;
        }

        public void ReadXml(System.Xml.XmlReader reader) {
            XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
            XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));

            bool wasEmpty = reader.IsEmptyElement;

            reader.Read();

            if(wasEmpty)
                return;

            while(reader.NodeType != System.Xml.XmlNodeType.EndElement) {
                reader.ReadStartElement("item");
                reader.ReadStartElement("key");
                TKey key = (TKey)keySerializer.Deserialize(reader);
                reader.ReadEndElement();

                reader.ReadStartElement("value");
                TValue value = (TValue)valueSerializer.Deserialize(reader);
                reader.ReadEndElement();

                this.Add(key,value);

                reader.ReadEndElement();
                reader.MoveToContent();
            }

            reader.ReadEndElement();
        }

        public void WriteXml(System.Xml.XmlWriter writer) {
            XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
            XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));

            foreach(TKey key in this.Keys) {
                writer.WriteStartElement("item");

                writer.WriteStartElement("key");
                keySerializer.Serialize(writer,key);
                writer.WriteEndElement();

                writer.WriteStartElement("value");
                TValue value = this[key];
                valueSerializer.Serialize(writer,value);
                writer.WriteEndElement();

                writer.WriteEndElement();
            }
        }

        #endregion
    }
}