Могу ли я использовать Caliburn для привязки к RoutedCommands? - PullRequest
Новая
       6

Могу ли я использовать Caliburn для привязки к RoutedCommands?

3 голосов
/ 29 июля 2010

Как лучше всего использовать встроенные в WPF RoutedCommands с Caliburn ?

Например, в моей оболочке у меня есть меню «Правка» с элементом «Копировать», прикрепленным к стандартномукоманда найдена в ApplicationCommands: 

<Menu>
    <MenuItem Header="Edit">
        <MenuItem Header="Copy"
                  Command="ApplicationCommands.Copy" />
    </MenuItem>
</Menu>

Я хочу, чтобы этот элемент обрабатывался TextBox, когда он имеет фокус, и моим собственным контролем, когда он имеет фокус.В моих элементах управления я могу обрабатывать Execute и CanExecute в коде позади, создавая CommandBinding: 

<UserControl.CommandBindings>
    <CommandBinding Command="ApplicationCommands.Copy"
                    Executed="CopyCommandExecute"
                    CanExecute="CanCopyCommandExecute" />
</UserControl.CommandBindings>

Есть ли способ, используя Caliburn, вместо этого обрабатывать с помощью методов в моей ViewModel, илиперенаправить на другую команду, которую я выставляю из ViewModel?Или я поступаю неправильно?

1 Ответ

1 голос
/ 30 июля 2010

Я закончил тем, что создал поведение , которое позволяет перенаправлять команды буфера обмена RoutedCommands другим командам. 

public class ClipboardBehavior : Behavior<Control>
{
    public static readonly DependencyProperty CopyCommandProperty =
        DependencyProperty.Register("CopyCommand",
                                    typeof (ICommand),
                                    typeof (ClipboardBehavior),
                                    new PropertyMetadata(default(ICommand)));

    public static readonly DependencyProperty CutCommandProperty =
        DependencyProperty.Register("CutCommand",
                                    typeof (ICommand),
                                    typeof (ClipboardBehavior),
                                    new PropertyMetadata(default(ICommand)));

    public static readonly DependencyProperty DeleteCommandProperty =
        DependencyProperty.Register("DeleteCommand",
                                    typeof (ICommand),
                                    typeof (ClipboardBehavior),
                                    new PropertyMetadata(default(ICommand)));

    public static readonly DependencyProperty PasteCommandProperty =
        DependencyProperty.Register("PasteCommand",
                                    typeof (ICommand),
                                    typeof (ClipboardBehavior),
                                    new PropertyMetadata(default(ICommand)));

    public ICommand DeleteCommand
    {
        get { return (ICommand) GetValue(DeleteCommandProperty); }
        set { SetValue(DeleteCommandProperty, value); }
    }

    public ICommand CutCommand
    {
        get { return (ICommand) GetValue(CutCommandProperty); }
        set { SetValue(CutCommandProperty, value); }
    }

    public ICommand CopyCommand
    {
        get { return (ICommand) GetValue(CopyCommandProperty); }
        set { SetValue(CopyCommandProperty, value); }
    }

    public ICommand PasteCommand
    {
        get { return (ICommand) GetValue(PasteCommandProperty); }
        set { SetValue(PasteCommandProperty, value); }
    }

    protected override void OnAttached()
    {
        AddBinding(ApplicationCommands.Delete, () => DeleteCommand);
        AddBinding(ApplicationCommands.Cut, () => CutCommand);
        AddBinding(ApplicationCommands.Copy, () => CopyCommand);
        AddBinding(ApplicationCommands.Paste, () => PasteCommand);
    }

    private void AddBinding(ICommand command, Func<ICommand> executingCommand)
    {
        var binding = new CommandBinding(command,
                                         (sender, e) => Execute(e, executingCommand()),
                                         (sender, e) => CanExecute(e, executingCommand()));

        AssociatedObject.CommandBindings.Add(binding);
    }

    private static void CanExecute(CanExecuteRoutedEventArgs args, ICommand command)
    {
        if (command != null)
        {
            args.CanExecute = command.CanExecute(args.Parameter);
            args.ContinueRouting = false;
        }
    }

    private static void Execute(ExecutedRoutedEventArgs e, ICommand command)
    {
        if (command != null)
            command.Execute(e.Parameter);
    }
}
...