InputBinding Klas

Definitie

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

Overname

Object

DispatcherObject

DependencyObject

InputBinding

Overname

Object

DispatcherObject

DependencyObject

Freezable

InputBinding

Afgeleid

System.Windows.Input.KeyBinding

System.Windows.Input.MouseBinding

Implementeringen

ICommandSource

Voorbeelden

In het volgende voorbeeld ziet u hoe u een KeyBinding verbinding KeyGesture met de Open opdracht gebruikt. Wanneer de toetsbeweging wordt uitgevoerd, wordt de opdracht Openen aangeroepen.

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

In de volgende voorbeelden ziet u hoe u een aangepaste opdracht koppelt aan InputBinding objecten. In deze voorbeelden wordt een toepassing gemaakt waarmee de gebruiker de achtergrondkleur kan wijzigen door een van de volgende acties uit te voeren:

• Klik op een knop.

• Druk op Ctrl+C.

• Klik met de rechtermuisknop op een StackPanel (buiten het ListBox).

In het eerste voorbeeld wordt een klasse met de naam SimpleDelegateCommandgemaakt. Deze klasse accepteert een gemachtigde, zodat het object dat de opdracht maakt, de actie kan definiëren die optreedt wanneer de opdracht wordt uitgevoerd. SimpleDelegateCommand definieert ook eigenschappen die aangeven welke toets- en muisinvoer de opdracht aanroept. GestureKey en GestureModifier geef de toetsenbordinvoer op. MouseGesture Hiermee geeft u de muisinvoer op.

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

In het volgende voorbeeld wordt de ColorChangeCommand, een SimpleDelegateCommand. In het voorbeeld wordt ook de methode gedefinieerd die wordt uitgevoerd wanneer de opdracht wordt aangeroepen en de GestureKey, GestureModifieren MouseGesture eigenschappen wordt ingesteld. Een toepassing roept de InitializeCommand methode aan wanneer het programma begint, zoals in de constructor van een 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

Ten slotte maakt het volgende voorbeeld de gebruikersinterface. In het voorbeeld worden een en een MouseBinding toegevoegd aan een StackPanel met een ButtonListBox.KeyBinding Wanneer de gebruiker een item in de ListBoxlijst selecteert, kan deze de kleur van de achtergrond wijzigen in de geselecteerde kleur. In elk geval is de CommandParameter eigenschap gebonden aan het geselecteerde item in de ListBox, en de Command eigenschap is gebonden aan de ColorChangeCommand. De KeyBinding.Key, KeyBinding.Modifiersen MouseBinding.MouseAction eigenschappen zijn gebonden aan de bijbehorende eigenschappen van de SimpleDelegateCommand klasse.

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

Opmerkingen

U kunt opgeven dat gebruikersinvoer een opdracht aanroept door een InputBinding. Wanneer de gebruiker de opgegeven invoer uitvoert, wordt de ICommand eigenschap uitgevoerd die is ingesteld op de Command eigenschap.

U kunt opgeven dat de InputBinding aanroept van een opdracht die is gedefinieerd voor een object door een binding te maken op de Command, CommandParameteren CommandTarget eigenschappen. Hiermee kunt u een aangepaste opdracht definiëren en deze koppelen aan gebruikersinvoer. Zie het tweede voorbeeld in de sectie Voorbeelden voor meer informatie.

Een InputBinding kan worden gedefinieerd voor een specifiek object of op klasseniveau door een RegisterClassInputBinding te registreren bij de CommandManager.

De InputBinding klasse zelf biedt geen ondersteuning voor XAML-gebruik omdat er geen openbare parameterloze constructor wordt weergegeven (er is een parameterloze constructor, maar deze is beveiligd). Afgeleide klassen kunnen echter een openbare constructor beschikbaar maken en kunnen daarom eigenschappen instellen voor de afgeleide klasse die worden overgenomen van InputBinding met een XAML-gebruik. Twee bestaande InputBinding- afgeleide klassen die kunnen worden geïnstantieerd in XAML en kunnen eigenschappen instellen in XAML zijn KeyBinding en MouseBinding. De typische eigenschap in WPF programmeren die is ingesteld in XAML en gebruikt een of meer InputBinding-objecten als waarden is de eigenschap UIElement.InputBindings.

Gebruik van XAML-objectelementen

< inputBindingDerivedClass.../>

XAML-waarden

inputBindingDerivedClass Een afgeleide klasse van die ondersteuning biedt voor de syntaxis van InputBinding objectelementen, zoals KeyBinding of MouseBinding. Zie opmerkingen.

Zie ook

• InputBindings
• CommandBinding