InputBinding Classe

Definição

public ref class InputBinding : System::Windows::DependencyObject, System::Windows::Input::ICommandSource

public ref class InputBinding : System::Windows::Freezable, System::Windows::Input::ICommandSource

public class InputBinding : System.Windows.DependencyObject, System.Windows.Input.ICommandSource

public class InputBinding : System.Windows.Freezable, System.Windows.Input.ICommandSource

type InputBinding = class
    inherit DependencyObject
    interface ICommandSource

type InputBinding = class
    inherit Freezable
    interface ICommandSource

Public Class InputBinding
Inherits DependencyObject
Implements ICommandSource

Public Class InputBinding
Inherits Freezable
Implements ICommandSource

Herança

Object

DispatcherObject

DependencyObject

InputBinding

Herança

Object

DispatcherObject

DependencyObject

Freezable

InputBinding

Derivado

System.Windows.Input.KeyBinding

System.Windows.Input.MouseBinding

Implementações

ICommandSource

Exemplos

O exemplo a seguir mostra como usar um KeyBinding para associar um KeyGesture ao Open comando. Quando o gesto de chave é executado, o comando Abrir é invocado.

<Window.InputBindings>
  <KeyBinding Key="B"
              Modifiers="Control" 
              Command="ApplicationCommands.Open" />
</Window.InputBindings>

Os exemplos a seguir mostram como associar um comando personalizado a InputBinding objetos. Estes exemplos criam um aplicativo que permite que o usuário altere a cor da tela de fundo executando uma das seguintes ações:

• Clicando em um botão.

• Pressionando CTRL+C.

• Clicando com o botão direito do mouse em um StackPanel (fora do ListBox).

O primeiro exemplo cria uma classe chamada SimpleDelegateCommand. Essa classe aceita um delegado para que o objeto que cria o comando possa definir a ação que ocorre quando o comando é executado. SimpleDelegateCommand também define propriedades que especificam qual chave e entrada do mouse invoca o comando. GestureKey e especifique GestureModifier a entrada do teclado; MouseGesture especifica a entrada do mouse.

 // Create a class that implements ICommand and accepts a delegate.
public class SimpleDelegateCommand : ICommand
{
    // Specify the keys and mouse actions that invoke the command. 
    public Key GestureKey { get; set; }
    public ModifierKeys GestureModifier { get; set; }
    public MouseAction MouseGesture { get; set; }

    Action<object> _executeDelegate;

    public SimpleDelegateCommand(Action<object> executeDelegate)
    {
        _executeDelegate = executeDelegate;
    }

    public void Execute(object parameter)
    {
        _executeDelegate(parameter);
    }

    public bool CanExecute(object parameter) { return true; }
    public event EventHandler CanExecuteChanged;
}

' Create a class that implements ICommand and accepts a delegate. 
Public Class SimpleDelegateCommand
    Implements ICommand

    ' Specify the keys and mouse actions that invoke the command. 
    Private _GestureKey As Key
    Private _GestureModifier As ModifierKeys
    Private _MouseGesture As MouseAction

    Public Property GestureKey() As Key
        Get
            Return _GestureKey
        End Get
        Set(ByVal value As Key)
            _GestureKey = value
        End Set
    End Property

    Public Property GestureModifier() As ModifierKeys
        Get
            Return _GestureModifier
        End Get
        Set(ByVal value As ModifierKeys)
            _GestureModifier = value
        End Set
    End Property

    Public Property MouseGesture() As MouseAction
        Get
            Return _MouseGesture
        End Get
        Set(ByVal value As MouseAction)
            _MouseGesture = value
        End Set
    End Property

    Private _executeDelegate As Action(Of Object)

    Public Sub New(ByVal executeDelegate As Action(Of Object))
        _executeDelegate = executeDelegate
    End Sub

    Public Sub Execute(ByVal parameter As Object) _
        Implements ICommand.Execute

        _executeDelegate(parameter)
    End Sub

    Public Function CanExecute(ByVal parameter As Object) As Boolean _
        Implements ICommand.CanExecute

        Return True
    End Function

    Public Event CanExecuteChanged As EventHandler _
        Implements ICommand.CanExecuteChanged
End Class

O exemplo a seguir cria e inicializa o ColorChangeCommand, que é um SimpleDelegateCommand. O exemplo também define o método que é executado quando o comando é invocado e define o GestureKey, GestureModifiere MouseGesture as propriedades. Um aplicativo chamaria o InitializeCommand método quando o programa fosse iniciado, como no construtor de um Window.

public SimpleDelegateCommand ChangeColorCommand
{
    get { return changeColorCommand; }
}

private SimpleDelegateCommand changeColorCommand;

private void InitializeCommand()
{
    originalColor = this.Background;

    changeColorCommand = new SimpleDelegateCommand(x => this.ChangeColor(x));

    DataContext = this;
    changeColorCommand.GestureKey = Key.C;
    changeColorCommand.GestureModifier = ModifierKeys.Control;
    ChangeColorCommand.MouseGesture = MouseAction.RightClick;
}

private Brush originalColor, alternateColor;

// Switch the Background color between
// the original and selected color.
private void ChangeColor(object colorString)
{
    if (colorString == null)
    {
        return;
    }

    Color newColor = 
        (Color)ColorConverter.ConvertFromString((String)colorString);
    
    alternateColor = new SolidColorBrush(newColor);

    if (this.Background == originalColor)
    {
        this.Background = alternateColor;
    }
    else
    {
        this.Background = originalColor;
    }
}

Public ReadOnly Property ChangeColorCommand() As SimpleDelegateCommand
    Get
        Return _changeColorCommand
    End Get
End Property

Private _changeColorCommand As SimpleDelegateCommand
Private originalColor As Brush, alternateColor As Brush

Private Sub InitializeCommand()
    originalColor = Me.Background

    _changeColorCommand = New SimpleDelegateCommand(Function(x) Me.ChangeColor(x))

    DataContext = Me
    _changeColorCommand.GestureKey = Key.C
    _changeColorCommand.GestureModifier = ModifierKeys.Control
    _changeColorCommand.MouseGesture = MouseAction.RightClick
End Sub

' Switch the Background color between 
' the original and selected color. 
Private Function ChangeColor(ByVal colorString As Object) As Integer

    If colorString Is Nothing Then
        Return 0
    End If

    Dim newColor As Color = DirectCast(ColorConverter.ConvertFromString(DirectCast(colorString, [String])), Color)

    alternateColor = New SolidColorBrush(newColor)

    If Brush.Equals(Me.Background, originalColor) Then
        Me.Background = alternateColor
    Else
        Me.Background = originalColor
    End If

    Return 0
End Function

Por fim, o exemplo a seguir cria a interface do usuário. O exemplo adiciona um KeyBinding e um MouseBinding a um StackPanel que contém um Button e um ListBox. Quando o usuário seleciona um item no ListBox, ele pode alterar a cor da tela de fundo para a cor selecionada. Em cada caso, a CommandParameter propriedade é associada ao item selecionado no ListBox, e a Command propriedade é associada ao ColorChangeCommand. As KeyBinding.Keypropriedades e as MouseBinding.MouseActionKeyBinding.Modifierspropriedades são associadas às propriedades correspondentes na SimpleDelegateCommand classe.

<StackPanel Background="Transparent">
  <StackPanel.InputBindings>
    
    <KeyBinding Command="{Binding ChangeColorCommand}"
                CommandParameter="{Binding ElementName=colorPicker, Path=SelectedItem}"
                Key="{Binding ChangeColorCommand.GestureKey}"
                Modifiers="{Binding ChangeColorCommand.GestureModifier}"/>

    <MouseBinding Command="{Binding ChangeColorCommand}"
                  CommandParameter="{Binding ElementName=colorPicker, Path=SelectedItem}"
                  MouseAction="{Binding ChangeColorCommand.MouseGesture}"/>
  
  </StackPanel.InputBindings>
  
  <Button Content="Change Color" 
          Command="{Binding ChangeColorCommand}" 
          CommandParameter="{Binding ElementName=colorPicker, Path=SelectedItem}">
  </Button>

  <ListBox Name="colorPicker"
           Background="Transparent"
           xmlns:sys="clr-namespace:System;assembly=mscorlib">
    <sys:String>Red</sys:String>
    <sys:String>Green</sys:String>
    <sys:String>Blue</sys:String>
    <sys:String>Yellow</sys:String>
    <sys:String>Orange</sys:String>
    <sys:String>Purple</sys:String>
  </ListBox>
</StackPanel>

Comentários

Você pode especificar que a entrada do usuário invoca um comando criando um InputBinding. Quando o usuário executa a entrada especificada, o ICommand que é definido como a Command propriedade é executado.

Você pode especificar que o InputBinding comando invoca um comando definido em um objeto criando uma associação no Commande CommandParameterCommandTarget nas propriedades. Isso permite definir um comando personalizado e associá-lo à entrada do usuário. Para obter mais informações, consulte o segundo exemplo na seção Exemplos.

Um InputBinding pode ser definido em um objeto específico ou no nível da classe registrando um RegisterClassInputBinding com o CommandManager.

A InputBinding classe em si não dá suporte ao uso de XAML porque não expõe um construtor público sem parâmetros (há um construtor sem parâmetros, mas está protegido). No entanto, classes derivadas podem expor um construtor público e, portanto, podem definir propriedades na classe derivada que são herdadas InputBinding com um uso XAML. Duas classes derivadas existentes InputBindingque podem ser instanciadas em XAML e podem definir propriedades em XAML são KeyBinding e MouseBinding. A propriedade típica na programação do WPF que é definida em XAML e usa um ou mais InputBinding objetos como valores é a UIElement.InputBindings propriedade.

Uso do elemento do objeto XAML

< inputBindingDerivedClass.../>

Valores XAML

inputBindingDerivedClass Uma classe derivada que InputBinding dá suporte à sintaxe do elemento de objeto, como KeyBinding ou MouseBinding. Consulte os comentários.

Confira também

• InputBindings
• CommandBinding