Permalink
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Showing
with
1,043 additions
and 20 deletions.
- +412 −0 Merry Xmas/Common/NavigationHelper.cs
- +149 −0 Merry Xmas/Common/ObservableDictionary.cs
- +7 −0 Merry Xmas/Common/ReadMe.txt
- +86 −0 Merry Xmas/Common/RelayCommand.cs
- +257 −0 Merry Xmas/Common/SuspensionManager.cs
- +37 −0 Merry Xmas/MainPage.xaml
- +79 −3 Merry Xmas/MainPage.xaml.cs
- +16 −17 Merry Xmas/Merry Xmas.csproj
@@ -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; | ||
} | ||
} | ||
} | ||
} |
@@ -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. |
@@ -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); | ||
} | ||
} | ||
} | ||
} |
Oops, something went wrong.