// <copyright file="RelayCommand.cs" company="GalaSoft Laurent Bugnion">
|
// Copyright © GalaSoft Laurent Bugnion 2009-2013
|
// </copyright>
|
// ****************************************************************************
|
// <author>Laurent Bugnion</author>
|
// <email>laurent@galasoft.ch</email>
|
// <date>22.4.2009</date>
|
// <project>BioNano.Common.Framework.Mvvm</project>
|
// <web>http://www.galasoft.ch</web>
|
// <license>
|
// See license.txt in this project or http://www.galasoft.ch/license_MIT.txt
|
// </license>
|
// <LastBaseLevel>BL0011</LastBaseLevel>
|
// ****************************************************************************
|
// <credits>This class was developed by Josh Smith (http://joshsmithonwpf.wordpress.com) and
|
// slightly modified with his permission.</credits>
|
// ****************************************************************************
|
|
using System;
|
using System.Diagnostics.CodeAnalysis;
|
using System.Windows.Input;
|
|
////using GalaSoft.Utilities.Attributes;
|
|
namespace Bro.Common.ImageCanvas
|
{
|
/// <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'. This class does not allow you to accept command parameters in the
|
/// Execute and CanExecute callback methods.
|
/// </summary>
|
////[ClassInfo(typeof(RelayCommand),
|
//// Description = "A command whose sole purpose is to relay its functionality to other objects by invoking delegates.",
|
//// UrlContacts = "http://www.galasoft.ch/contact_en.html",
|
//// Email = "laurent@galasoft.ch")]
|
internal class RelayCommand<T> : ICommand
|
{
|
private readonly Action<T> _execute;
|
private readonly Func<T, bool> _canExecute;
|
|
/// <summary>
|
/// Initializes a new instance of the RelayCommand class that
|
/// can always execute.
|
/// </summary>
|
/// <param name="execute">The execution logic.</param>
|
/// <exception cref="ArgumentNullException">If the execute argument is null.</exception>
|
public RelayCommand(Action<T> execute)
|
: this(execute, null)
|
{
|
}
|
|
/// <summary>
|
/// Initializes a new instance of the RelayCommand class.
|
/// </summary>
|
/// <param name="execute">The execution logic.</param>
|
/// <param name="canExecute">The execution status logic.</param>
|
/// <exception cref="ArgumentNullException">If the execute argument is null.</exception>
|
public RelayCommand(Action<T> execute, Func<T, bool> canExecute)
|
{
|
if (execute == null)
|
{
|
throw new ArgumentNullException(nameof(execute));
|
}
|
|
_execute = execute;
|
|
if (canExecute != null)
|
{
|
_canExecute = canExecute;
|
}
|
}
|
|
#if SILVERLIGHT
|
/// <summary>
|
/// Occurs when changes occur that affect whether the command should execute.
|
/// </summary>
|
public event EventHandler CanExecuteChanged;
|
#else
|
#if NETFX_CORE
|
/// <summary>
|
/// Occurs when changes occur that affect whether the command should execute.
|
/// </summary>
|
public event EventHandler CanExecuteChanged;
|
#else
|
#if XAMARIN
|
/// <summary>
|
/// Occurs when changes occur that affect whether the command should execute.
|
/// </summary>
|
public event EventHandler CanExecuteChanged;
|
#else
|
/// <summary>
|
/// Occurs when changes occur that affect whether the command should execute.
|
/// </summary>
|
public event EventHandler CanExecuteChanged
|
{
|
add
|
{
|
if (_canExecute != null)
|
CommandManager.RequerySuggested += value;
|
}
|
|
remove
|
{
|
if (_canExecute != null)
|
CommandManager.RequerySuggested -= value;
|
}
|
}
|
#endif
|
#endif
|
#endif
|
|
/// <summary>
|
/// Raises the <see cref="CanExecuteChanged" /> event.
|
/// </summary>
|
[SuppressMessage(
|
"Microsoft.Performance",
|
"CA1822:MarkMembersAsStatic",
|
Justification = "The this keyword is used in the Silverlight version")]
|
[SuppressMessage(
|
"Microsoft.Design",
|
"CA1030:UseEventsWhereAppropriate",
|
Justification = "This cannot be an event")]
|
public void RaiseCanExecuteChanged()
|
{
|
#if SILVERLIGHT
|
var handler = CanExecuteChanged;
|
if (handler != null)
|
{
|
handler(this, EventArgs.Empty);
|
}
|
#else
|
#if NETFX_CORE
|
var handler = CanExecuteChanged;
|
if (handler != null)
|
{
|
handler(this, EventArgs.Empty);
|
}
|
#else
|
#if XAMARIN
|
var handler = CanExecuteChanged;
|
if (handler != null)
|
{
|
handler(this, EventArgs.Empty);
|
}
|
#else
|
CommandManager.InvalidateRequerySuggested();
|
#endif
|
#endif
|
#endif
|
}
|
|
/// <summary>
|
/// Defines the method that determines whether the command can execute in its current state.
|
/// </summary>
|
/// <param name="parameter">This parameter will always be ignored.</param>
|
/// <returns>true if this command can be executed; otherwise, false.</returns>
|
public bool CanExecute(object parameter)
|
{
|
if (_canExecute == null) return true;
|
if (parameter == null
|
#if NETFX_CORE
|
&& typeof(T).GetTypeInfo().IsValueType)
|
#else
|
&& typeof(T).IsValueType)
|
#endif
|
{
|
return _canExecute(default(T));
|
}
|
|
return _canExecute((T)parameter);
|
}
|
|
/// <summary>
|
/// Defines the method to be called when the command is invoked.
|
/// </summary>
|
/// <param name="parameter">This parameter will always be ignored.</param>
|
public virtual void Execute(object parameter)
|
{
|
var val = parameter;
|
|
#if !NETFX_CORE
|
if (parameter != null
|
&& parameter.GetType() != typeof(T))
|
{
|
if (parameter is IConvertible)
|
{
|
val = Convert.ChangeType(parameter, typeof(T), null);
|
}
|
}
|
#endif
|
|
if (val == null)
|
{
|
#if NETFX_CORE
|
if (typeof(T).GetTypeInfo().IsValueType)
|
#else
|
if (typeof(T).IsValueType)
|
#endif
|
{
|
_execute(default(T));
|
}
|
else
|
{
|
_execute((T)val);
|
}
|
}
|
else
|
{
|
_execute((T)val);
|
}
|
}
|
}
|
}
|
