InputBinding Clase

Definición

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

Herencia

Object

DispatcherObject

DependencyObject

InputBinding

Herencia

Object

DispatcherObject

DependencyObject

Freezable

InputBinding

Derivado

System.Windows.Input.KeyBinding

System.Windows.Input.MouseBinding

Implementaciones

ICommandSource

Ejemplos

En el ejemplo siguiente se muestra cómo usar un KeyBinding para enlazar un KeyGesture objeto al Open comando . Cuando se realiza el gesto de tecla, se invoca el comando Open.

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

En los ejemplos siguientes se muestra cómo enlazar un comando personalizado a InputBinding objetos . En estos ejemplos se crea una aplicación que permite al usuario cambiar el color de fondo realizando una de las siguientes acciones:

• Hacer clic en un botón.

• Presione CTRL+C.

• Haga clic con el botón derecho en un ( StackPanel fuera de ListBox).

En el primer ejemplo se crea una clase denominada SimpleDelegateCommand. Esta clase acepta un delegado para que el objeto que crea el comando pueda definir la acción que se produce cuando se ejecuta el comando. SimpleDelegateCommand también define las propiedades que especifican qué tecla y entrada del mouse invoca el comando . GestureKey y GestureModifier especifican la entrada del teclado; MouseGesture especifica la entrada del 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

En el ejemplo siguiente se crea e inicializa , ColorChangeCommandque es .SimpleDelegateCommand En el ejemplo también se define el método que se ejecuta cuando se invoca el comando y se establecen las GestureKeypropiedades , GestureModifiery MouseGesture . Una aplicación llamaría al InitializeCommand método cuando comienza el programa, como en el constructor de .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 último, en el ejemplo siguiente se crea la interfaz de usuario. En el ejemplo se agrega un KeyBinding y a MouseBinding un StackPanel objeto que contiene y Button .ListBox Cuando el usuario selecciona un elemento en ListBox, puede cambiar el color del fondo al color seleccionado. En cada caso, la CommandParameter propiedad está enlazada al elemento seleccionado en ListBoxy la Command propiedad está enlazada a .ColorChangeCommand Las KeyBinding.Keypropiedades , KeyBinding.Modifiersy MouseBinding.MouseAction se enlazan a las propiedades correspondientes de la SimpleDelegateCommand clase .

<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>

Comentarios

Puede especificar que la entrada del usuario invoca un comando mediante la creación de un InputBinding. Cuando el usuario realiza la entrada especificada, se ejecuta el ICommand objeto que se establece en la Command propiedad .

Puede especificar que InputBinding invoca un comando definido en un objeto mediante la creación de un enlace en las Commandpropiedades , CommandParametery CommandTarget . Esto le permite definir un comando personalizado y asociarlo con la entrada del usuario. Para obtener más información, vea el segundo ejemplo de la sección Ejemplos.

InputBinding Se puede definir en un objeto específico o en el nivel de clase registrando un RegisterClassInputBinding objeto con .CommandManager

La InputBinding propia clase no admite el uso de XAML porque no expone un constructor sin parámetros público (hay un constructor sin parámetros, pero está protegido). Sin embargo, las clases derivadas pueden exponer un constructor público y, por tanto, pueden establecer propiedades en la clase derivada que se hereda de InputBinding con un uso xaml. Dos clases derivadas existentes InputBindingque se pueden crear instancias en XAML y que pueden establecer propiedades en XAML son KeyBinding y MouseBinding. La propiedad típica de la programación WPF que se establece en XAML y toma uno o varios InputBinding objetos como valores es la UIElement.InputBindings propiedad .

Uso de elementos de objeto XAML

<inputBindingDerivedClass.../>

Valores XAML

inputBindingDerivedClass
Clase derivada de que admite la sintaxis de InputBinding elementos de objeto, como KeyBinding o MouseBinding. Vea la sección Comentarios.

Constructores

Campos

Propiedades

Métodos

Eventos

Se aplica a

Consulte también

• InputBindings
• CommandBinding