You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
279 lines
7.7 KiB
279 lines
7.7 KiB
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Windows;
|
|
using System.Windows.Input;
|
|
using System.Windows.Interactivity;
|
|
|
|
namespace GummingCommon
|
|
{
|
|
public class EventToCommand : TriggerAction<FrameworkElement>, ICommandSource
|
|
{
|
|
/// <summary>
|
|
/// EventArgs
|
|
/// </summary>
|
|
public static readonly DependencyProperty EventArgsProperty = DependencyProperty.Register(
|
|
"EventArgs",
|
|
typeof(object),
|
|
typeof(EventToCommand));
|
|
|
|
|
|
/// <summary>
|
|
/// Identifies the <see cref="CommandParameter" /> dependency property
|
|
/// </summary>
|
|
public static readonly DependencyProperty CommandParameterProperty = DependencyProperty.Register(
|
|
"CommandParameter",
|
|
typeof(object),
|
|
typeof(EventToCommand),
|
|
new PropertyMetadata(
|
|
null,
|
|
(s, e) =>
|
|
{
|
|
var sender = s as EventToCommand;
|
|
if (sender == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (sender.AssociatedObject == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
sender.EnableDisableElement();
|
|
}));
|
|
|
|
/// <summary>
|
|
/// Identifies the <see cref="Command" /> dependency property
|
|
/// </summary>
|
|
public static readonly DependencyProperty CommandProperty = DependencyProperty.Register(
|
|
"Command",
|
|
typeof(ICommand),
|
|
typeof(EventToCommand),
|
|
new PropertyMetadata(
|
|
null,
|
|
(s, e) => OnCommandChanged(s as EventToCommand, e)));
|
|
|
|
/// <summary>
|
|
/// Identifies the <see cref="MustToggleIsEnabled" /> dependency property
|
|
/// </summary>
|
|
public static readonly DependencyProperty MustToggleIsEnabledProperty = DependencyProperty.Register(
|
|
"MustToggleIsEnabled",
|
|
typeof(bool),
|
|
typeof(EventToCommand),
|
|
new PropertyMetadata(
|
|
false,
|
|
(s, e) =>
|
|
{
|
|
var sender = s as EventToCommand;
|
|
if (sender == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (sender.AssociatedObject == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
sender.EnableDisableElement();
|
|
}));
|
|
|
|
/// <summary>
|
|
/// Gets or sets the ICommand that this trigger is bound to. This
|
|
/// is a DependencyProperty.
|
|
/// </summary>
|
|
public ICommand Command
|
|
{
|
|
get
|
|
{
|
|
return (ICommand)GetValue(CommandProperty);
|
|
}
|
|
|
|
set
|
|
{
|
|
SetValue(CommandProperty, value);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Allows access to event args in binding
|
|
/// <example>
|
|
/// CommandParameter="{Binding EventArgs, RelativeSource={RelativeSource Self}}"
|
|
/// </example>
|
|
/// </summary>
|
|
public object EventArgs
|
|
{
|
|
get
|
|
{
|
|
return GetValue(EventArgsProperty);
|
|
}
|
|
|
|
set
|
|
{
|
|
SetValue(EventArgsProperty, value);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets an object that will be passed to the <see cref="Command" />
|
|
/// attached to this trigger. This is a DependencyProperty.
|
|
/// </summary>
|
|
public object CommandParameter
|
|
{
|
|
get
|
|
{
|
|
return this.GetValue(CommandParameterProperty);
|
|
}
|
|
|
|
set
|
|
{
|
|
SetValue(CommandParameterProperty, value);
|
|
}
|
|
}
|
|
|
|
public IInputElement CommandTarget
|
|
{
|
|
get { return this.AssociatedObject; }
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value indicating whether the attached element must be
|
|
/// disabled when the <see cref="Command" /> property's CanExecuteChanged
|
|
/// event fires. If this property is true, and the command's CanExecute
|
|
/// method returns false, the element will be disabled. If this property
|
|
/// is false, the element will not be disabled when the command's
|
|
/// CanExecute method changes. This is a DependencyProperty.
|
|
/// </summary>
|
|
public bool MustToggleIsEnabled
|
|
{
|
|
get
|
|
{
|
|
return (bool)this.GetValue(MustToggleIsEnabledProperty);
|
|
}
|
|
|
|
set
|
|
{
|
|
SetValue(MustToggleIsEnabledProperty, value);
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Called when this trigger is attached to a FrameworkElement.
|
|
/// </summary>
|
|
protected override void OnAttached()
|
|
{
|
|
base.OnAttached();
|
|
EnableDisableElement();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Provides a simple way to invoke this trigger programatically
|
|
/// without any EventArgs.
|
|
/// </summary>
|
|
public void Invoke()
|
|
{
|
|
Invoke(null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Executes the trigger.
|
|
/// <para>To access the EventArgs of the fired event, use a RelayCommand<EventArgs>
|
|
/// and leave the CommandParameter and CommandParameterValue empty!</para>
|
|
/// </summary>
|
|
/// <param name="parameter">The EventArgs of the fired event.</param>
|
|
protected override void Invoke(object parameter)
|
|
{
|
|
|
|
EventArgs = parameter;
|
|
|
|
if (AssociatedElementIsDisabled())
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (CanExecute())
|
|
Execute();
|
|
}
|
|
|
|
private static void OnCommandChanged(
|
|
EventToCommand element,
|
|
DependencyPropertyChangedEventArgs e)
|
|
{
|
|
if (element == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (e.OldValue != null)
|
|
{
|
|
((ICommand)e.OldValue).CanExecuteChanged -= element.OnCommandCanExecuteChanged;
|
|
}
|
|
|
|
var command = (ICommand)e.NewValue;
|
|
|
|
if (command != null)
|
|
{
|
|
command.CanExecuteChanged += element.OnCommandCanExecuteChanged;
|
|
}
|
|
|
|
element.EnableDisableElement();
|
|
}
|
|
|
|
private bool AssociatedElementIsDisabled()
|
|
{
|
|
|
|
return AssociatedObject != null && !AssociatedObject.IsEnabled;
|
|
}
|
|
|
|
private void EnableDisableElement()
|
|
{
|
|
|
|
if (AssociatedObject == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
if (MustToggleIsEnabled && Command != null)
|
|
{
|
|
AssociatedObject.IsEnabled = CanExecute();
|
|
}
|
|
}
|
|
|
|
private void OnCommandCanExecuteChanged(object sender, EventArgs e)
|
|
{
|
|
EnableDisableElement();
|
|
}
|
|
|
|
public void Execute()
|
|
{
|
|
if (Command == null)
|
|
return;
|
|
|
|
var routedCommand = Command as RoutedCommand;
|
|
if (routedCommand != null)
|
|
routedCommand.Execute(CommandParameter, CommandTarget);
|
|
else
|
|
Command.Execute(CommandParameter);
|
|
}
|
|
|
|
public bool CanExecute()
|
|
{
|
|
if (Command == null)
|
|
return false;
|
|
|
|
var routedCommand = Command as RoutedCommand;
|
|
if (routedCommand != null)
|
|
return routedCommand.CanExecute(CommandParameter, CommandTarget);
|
|
|
|
return Command.CanExecute(CommandParameter);
|
|
}
|
|
}
|
|
}
|