Modify main page

for #2

Merry Xmas/Common/ObservableDictionary.cs

@@ -0,0 +1,149 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Windows.Foundation.Collections;
+
+namespace Merry_Xmas.Common
+{
+    /// <summary>
+    /// Implementation of IObservableMap that supports reentrancy for use as a default view
+    /// model.
+    /// </summary>
+    public class ObservableDictionary : IObservableMap<string, object>
+    {
+        private class ObservableDictionaryChangedEventArgs : IMapChangedEventArgs<string>
+        {
+            public ObservableDictionaryChangedEventArgs(CollectionChange change, string key)
+            {
+                this.CollectionChange = change;
+                this.Key = key;
+            }
+
+            public CollectionChange CollectionChange { get; private set; }
+            public string Key { get; private set; }
+        }
+
+        private Dictionary<string, object> _dictionary = new Dictionary<string, object>();
+        public event MapChangedEventHandler<string, object> MapChanged;
+
+        private void InvokeMapChanged(CollectionChange change, string key)
+        {
+            var eventHandler = MapChanged;
+            if (eventHandler != null)
+            {
+                eventHandler(this, new ObservableDictionaryChangedEventArgs(change, key));
+            }
+        }
+
+        public void Add(string key, object value)
+        {
+            this._dictionary.Add(key, value);
+            this.InvokeMapChanged(CollectionChange.ItemInserted, key);
+        }
+
+        public void Add(KeyValuePair<string, object> item)
+        {
+            this.Add(item.Key, item.Value);
+        }
+
+        public bool Remove(string key)
+        {
+            if (this._dictionary.Remove(key))
+            {
+                this.InvokeMapChanged(CollectionChange.ItemRemoved, key);
+                return true;
+            }
+            return false;
+        }
+
+        public bool Remove(KeyValuePair<string, object> item)
+        {
+            object currentValue;
+            if (this._dictionary.TryGetValue(item.Key, out currentValue) &&
+                Object.Equals(item.Value, currentValue) && this._dictionary.Remove(item.Key))
+            {
+                this.InvokeMapChanged(CollectionChange.ItemRemoved, item.Key);
+                return true;
+            }
+            return false;
+        }
+
+        public object this[string key]
+        {
+            get
+            {
+                return this._dictionary[key];
+            }
+            set
+            {
+                this._dictionary[key] = value;
+                this.InvokeMapChanged(CollectionChange.ItemChanged, key);
+            }
+        }
+
+        public void Clear()
+        {
+            var priorKeys = this._dictionary.Keys.ToArray();
+            this._dictionary.Clear();
+            foreach (var key in priorKeys)
+            {
+                this.InvokeMapChanged(CollectionChange.ItemRemoved, key);
+            }
+        }
+
+        public ICollection<string> Keys
+        {
+            get { return this._dictionary.Keys; }
+        }
+
+        public bool ContainsKey(string key)
+        {
+            return this._dictionary.ContainsKey(key);
+        }
+
+        public bool TryGetValue(string key, out object value)
+        {
+            return this._dictionary.TryGetValue(key, out value);
+        }
+
+        public ICollection<object> Values
+        {
+            get { return this._dictionary.Values; }
+        }
+
+        public bool Contains(KeyValuePair<string, object> item)
+        {
+            return this._dictionary.Contains(item);
+        }
+
+        public int Count
+        {
+            get { return this._dictionary.Count; }
+        }
+
+        public bool IsReadOnly
+        {
+            get { return false; }
+        }
+
+        public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
+        {
+            return this._dictionary.GetEnumerator();
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return this._dictionary.GetEnumerator();
+        }
+
+        public void CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
+        {
+            int arraySize = array.Length;
+            foreach (var pair in this._dictionary)
+            {
+                if (arrayIndex >= arraySize) break;
+                array[arrayIndex++] = pair;
+            }
+        }
+    }
+}

Merry Xmas/Common/ReadMe.txt

@@ -0,0 +1,7 @@
+The Common directory contains classes that simplify application development.
+
+Classes in the Common directory form part of your project and may be further enhanced to meet your
+needs.  Care should be taken when altering existing methods and properties as incompatible changes
+will require corresponding changes to code included in a variety of Visual Studio templates.  For
+example, additional pages added to your project are written assuming that the original methods and
+properties in Common classes are still present and that the names of the types have not changed.

Merry Xmas/Common/RelayCommand.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Input;
+
+namespace Merry_Xmas.Common
+{
+    /// <summary>
+    /// A command whose sole purpose is to relay its functionality 
+    /// to other objects by invoking delegates. 
+    /// The default return value for the CanExecute method is 'true'.
+    /// <see cref="RaiseCanExecuteChanged"/> needs to be called whenever
+    /// <see cref="CanExecute"/> is expected to return a different value.
+    /// </summary>
+    public class RelayCommand : ICommand
+    {
+        private readonly Action _execute;
+        private readonly Func<bool> _canExecute;
+
+        /// <summary>
+        /// Raised when RaiseCanExecuteChanged is called.
+        /// </summary>
+        public event EventHandler CanExecuteChanged;
+
+        /// <summary>
+        /// Creates a new command that can always execute.
+        /// </summary>
+        /// <param name="execute">The execution logic.</param>
+        public RelayCommand(Action execute)
+            : this(execute, null)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new command.
+        /// </summary>
+        /// <param name="execute">The execution logic.</param>
+        /// <param name="canExecute">The execution status logic.</param>
+        public RelayCommand(Action execute, Func<bool> canExecute)
+        {
+            if (execute == null)
+                throw new ArgumentNullException("execute");
+            _execute = execute;
+            _canExecute = canExecute;
+        }
+
+        /// <summary>
+        /// Determines whether this <see cref="RelayCommand"/> can execute in its current state.
+        /// </summary>
+        /// <param name="parameter">
+        /// Data used by the command. If the command does not require data to be passed, this object can be set to null.
+        /// </param>
+        /// <returns>true if this command can be executed; otherwise, false.</returns>
+        public bool CanExecute(object parameter)
+        {
+            return _canExecute == null ? true : _canExecute();
+        }
+
+        /// <summary>
+        /// Executes the <see cref="RelayCommand"/> on the current command target.
+        /// </summary>
+        /// <param name="parameter">
+        /// Data used by the command. If the command does not require data to be passed, this object can be set to null.
+        /// </param>
+        public void Execute(object parameter)
+        {
+            _execute();
+        }
+
+        /// <summary>
+        /// Method used to raise the <see cref="CanExecuteChanged"/> event
+        /// to indicate that the return value of the <see cref="CanExecute"/>
+        /// method has changed.
+        /// </summary>
+        public void RaiseCanExecuteChanged()
+        {
+            var handler = CanExecuteChanged;
+            if (handler != null)
+            {
+                handler(this, EventArgs.Empty);
+            }
+        }
+    }
+}