InputBinding Classe

Definizione

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

Ereditarietà

Object

DispatcherObject

DependencyObject

InputBinding

Ereditarietà

Object

DispatcherObject

DependencyObject

Freezable

InputBinding

Derivato

System.Windows.Input.KeyBinding

System.Windows.Input.MouseBinding

Implementazioni

ICommandSource

Esempio

Nell'esempio seguente viene illustrato come usare un KeyBinding oggetto per associare un KeyGesture oggetto al Open comando . Quando viene eseguito il movimento della chiave, viene richiamato il comando Apri.

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

Negli esempi seguenti viene illustrato come associare un comando personalizzato agli InputBinding oggetti . Questi esempi creano un'applicazione che consente all'utente di modificare il colore di sfondo eseguendo una delle azioni seguenti:

• Fare clic su un pulsante.

• Premendo CTRL+C.

• Fare clic con il pulsante destro del mouse su un oggetto StackPanel (all'esterno di ListBox).

Il primo esempio crea una classe denominata SimpleDelegateCommand. Questa classe accetta un delegato in modo che l'oggetto che crea il comando possa definire l'azione che si verifica quando viene eseguito il comando. SimpleDelegateCommand definisce anche le proprietà che specificano il tasto e l'input del mouse richiamano il comando. GestureKey e GestureModifier specificare l'input della tastiera; MouseGesture specifica l'input 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

Nell'esempio seguente viene creato e inizializzato , ColorChangeCommandche è un SimpleDelegateCommandoggetto . L'esempio definisce anche il metodo eseguito quando il comando viene richiamato e imposta le GestureKeyproprietà , GestureModifiere MouseGesture . Un'applicazione chiamerebbe il InitializeCommand metodo all'avvio del programma, ad esempio nel costruttore di un oggetto 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

Infine, l'esempio seguente crea l'interfaccia utente. Nell'esempio viene aggiunto un oggetto KeyBinding e a MouseBinding un StackPanel oggetto che contiene un Button oggetto e un oggetto ListBox. Quando l'utente seleziona un elemento in ListBox, può modificare il colore dello sfondo impostando il colore selezionato. In ogni caso, la CommandParameter proprietà è associata all'elemento selezionato in ListBoxe la Command proprietà è associata a ColorChangeCommand. Le KeyBinding.Keyproprietà , KeyBinding.Modifierse MouseBinding.MouseAction sono associate alle proprietà corrispondenti della 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>

Commenti

È possibile specificare che l'input dell'utente richiama un comando creando un oggetto InputBinding. Quando l'utente esegue l'input specificato, viene eseguito l'oggetto ICommand impostato sulla Command proprietà .

È possibile specificare che InputBinding richiama un comando definito in un oggetto creando un'associazione nelle Commandproprietà , CommandParametere CommandTarget . In questo modo è possibile definire un comando personalizzato e associarlo all'input dell'utente. Per altre informazioni, vedere il secondo esempio nella sezione Esempi.

Un InputBinding oggetto può essere definito in un oggetto specifico o a livello di classe registrando un RegisterClassInputBinding oggetto con .CommandManager

La InputBinding classe stessa non supporta l'utilizzo di XAML perché non espone un costruttore pubblico senza parametri (esiste un costruttore senza parametri, ma è protetto). Tuttavia, le classi derivate possono esporre un costruttore pubblico e pertanto possono impostare proprietà sulla classe derivata ereditata da InputBinding con un utilizzo XAML. Due classi derivate esistenti InputBindingche possono essere create un'istanza in XAML e possono impostare le proprietà in XAML sono KeyBinding e MouseBinding. La proprietà tipica nella programmazione WPF impostata in XAML e accetta uno o più InputBinding oggetti come valori è la UIElement.InputBindings proprietà .

Utilizzo dell'elemento oggetto XAML

< inputBindingDerivedClass.../>

Valori XAML

inputBindingDerivedClass Classe derivata di che supporta la sintassi degli InputBinding elementi oggetto, ad esempio KeyBinding o MouseBinding. Vedere le Note.

Vedi anche

• InputBindings
• CommandBinding