Squashed 'FSI.Lib/' content from commit dceb500

git-subtree-dir: FSI.Lib
git-subtree-split: dceb5008a2176c2b8ab5e55a73b1c25d31a7f841

FSI.Lib/MVVM/DelegateCommand.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Windows.Input;
+
+namespace FSI.Lib.MVVM
+{
+    /// <summary>
+    ///     DelegateCommand borrowed from
+    ///     http://www.wpftutorial.net/DelegateCommand.html
+    /// </summary>
+    public class DelegateCommand : ICommand
+    {
+        private readonly Predicate<object> _canExecute;
+        private readonly Action<object> _execute;
+
+        public DelegateCommand(Action<object> execute,
+            Predicate<object> canExecute = null)
+        {
+            _execute = execute;
+            _canExecute = canExecute;
+        }
+
+        public void RaiseCanExecuteChanged()
+        {
+            CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+        }
+
+        #region ICommand Members
+
+        public event EventHandler CanExecuteChanged;
+
+        public bool CanExecute(object parameter)
+        {
+            return _canExecute == null || _canExecute(parameter);
+        }
+
+        public void Execute(object parameter)
+        {
+            _execute(parameter);
+        }
+
+        #endregion
+    }
+}

FSI.Lib/MVVM/RelayCommand.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Windows.Input;
+
+namespace FSI.Lib.MVVM
+{
+    public class RelayCommand<T> : ICommand
+    {
+        #region Fields
+
+        readonly Action<T> _execute = null;
+        readonly Predicate<T> _canExecute = null;
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of <see cref="DelegateCommand{T}"/>.
+        /// </summary>
+        /// <param name="execute">Delegate to execute when Execute is called on the command.  This can be null to just hook up a CanExecute delegate.</param>
+        /// <remarks><seealso cref="CanExecute"/> will always return true.</remarks>
+        public RelayCommand(Action<T> 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<T> execute, Predicate<T> canExecute)
+        {
+            if (execute == null)
+                throw new ArgumentNullException("execute");
+
+            _execute = execute;
+            _canExecute = canExecute;
+        }
+
+        #endregion
+
+        #region ICommand Members
+
+        ///<summary>
+        ///Defines the method that determines whether the command 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((T)parameter);
+        }
+
+        ///<summary>
+        ///Occurs when changes occur that affect whether or not the command should execute.
+        ///</summary>
+        public event EventHandler CanExecuteChanged
+        {
+            add { CommandManager.RequerySuggested += value; }
+            remove { CommandManager.RequerySuggested -= value; }
+        }
+
+        ///<summary>
+        ///Defines the method to be called when the command is invoked.
+        ///</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 <see langword="null" />.</param>
+        public void Execute(object parameter)
+        {
+            _execute((T)parameter);
+        }
+
+        #endregion
+    }
+}

FSI.Lib/MVVM/ViewModel/CurrentTimeViewModel.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FSI.Lib.MVVM.ViewModel
+{
+    public class CurrentTimeViewModel : INotifyPropertyChanged
+    {
+        private string _currentTime;
+
+        public CurrentTimeViewModel()
+        {
+            UpdateTime();
+        }
+
+        private async void UpdateTime()
+        {
+            CurrentTime = DateTime.Now.ToString("G");
+            await Task.Delay(1000);
+            UpdateTime();
+        }
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+
+        public string CurrentTime
+        {
+            get { return _currentTime; }
+            set { _currentTime = value; OnPropertyChanged(); }
+        }
+    }
+}

FSI.Lib/MVVM/ViewModelBase.cs

@@ -0,0 +1,61 @@
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+
+/* Example for use:
+  
+public class MyViewModel : ViewModelBase
+{
+    private int myProperty;
+    public int MyProperty
+    {
+        get { return myProperty; }
+        set { SetProperty(ref myProperty, value);
+    }
+}
+
+*/
+
+
+namespace FSI.Lib.MVVM
+{
+    public class ViewModelBase : INotifyPropertyChanged
+    {
+        /// <summary>
+        /// Multicast event for property change notifications.
+        /// </summary>
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        /// <summary>
+        /// Checks if a property already matches the desired value.  Sets the property and
+        /// notifies listeners only when necessary.
+        /// </summary>
+        /// <typeparam name="T">Type of the property.</typeparam>
+        /// <param name="storage">Reference to a property with both getter and setter.</param>
+        /// <param name="value">Desired value for the property.</param>
+        /// <param name="propertyName">Name of the property used to notify listeners.This
+        /// value is optional and can be provided automatically when invoked from compilers that
+        /// support CallerMemberName.</param>
+        /// <returns>True if the value was changed, false if the existing value matched the
+        /// desired value.</returns>
+        protected virtual bool SetProperty<T>(ref T storage, T value, [CallerMemberName] string propertyName = null)
+        {
+            if (object.Equals(storage, value)) return false;
+            storage = value;
+            // Log.DebugFormat("{0}.{1} = {2}", this.GetType().Name, propertyName, storage);
+            this.OnPropertyChanged(propertyName);
+            return true;
+        }
+
+
+        /// <summary>
+        /// Notifies listeners that a property value has changed.
+        /// </summary>
+        /// <param name="propertyName">Name of the property used to notify listeners.  This
+        /// value is optional and can be provided automatically when invoked from compilers
+        /// that support <see cref="CallerMemberNameAttribute"/>.</param>
+        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
+        {
+            this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+    }
+}