Freigeben über

Übersicht über die Eingabe

  • Artikel

Aktualisiert: November 2007

Das Windows Presentation Foundation (WPF)-Subsystem stellt eine leistungsfähige API zum Abrufen von Inhalt von verschiedenen Geräten, darunter der Maus, der Tastatur und dem Tablettstift, bereit.

In diesem Thema werden die von WPF bereitgestellten Dienste beschrieben und die Architektur von Eingabesystemen erläutert.

Dieses Thema enthält folgende Abschnitte.

  • Eingabe-API
  • Ereignisrouting
  • Behandeln von Eingabeereignissen
  • Texteingabe
  • Focus
  • Mausposition
  • Mausauswahl
  • Befehle
  • Das Eingabesystem und die Basiselemente
  • Weitere Informationen
  • Verwandte Abschnitte

Eingabe-API

Die API-Bereitstellung für die primäre Eingabe findet sich in den Basiselementklassen: UIElement, ContentElement, FrameworkElement und FrameworkContentElement. Weitere Informationen zu den Basiselementen finden Sie unter Übersicht über Basiselemente. Diese Klassen bieten Funktionen für Eingabeereignisse, die sich auf Tastatureingaben, Maustasten, das Mausrad, die Mausbewegung, die Fokusverwaltung und die Mauszeigererkennung beziehen, um nur einige zu nennen. Indem die Eingabe-API auf den Basiselementen platziert wird, statt alle Eingabeereignisse als einen Dienst zu behandeln, ermöglicht die Eingabearchitektur, dass die Eingabeereignisse ein bestimmtes Objekt in der UI als Quelle verwenden. Auf dieses Weise wird auch ein Schema zum Ereignisrouting unterstützt, bei dem mehr als ein Element ein Eingabeereignis verarbeiten kann. Vielen Eingabeereignissen ist ein Ereignispaar zugeordnet. So ist ein KeyDown-Ereignis beispielsweise mit dem KeyDown-Ereignis und dem PreviewKeyDown-Ereignis verknüpft. Der Unterschied zwischen diesen Ereignissen besteht darin, wie sie zum Zielelement weitergeleitet werden. Vorschauereignisse gehen anhand von Tunneling in der Elementstruktur vom Stammelement nach unten zum Zielelement. Bubbling-Ereignisse gehen anhand von Bubbling vom Zielelement nach oben zum Stammelement. Das Ereignisrouting in WPF wird weiter unten in dieser Übersicht und unter Übersicht über Routingereignisse ausführlicher erläutert.

Tastatur- und Mausklassen

Außer der Eingabe-API für Basiselementklassen bieten die Keyboard-Klasse und die Mouse-Klassen eine weitere API für die Tastatur- und Mauseingabe.

Beispiele für die Eingabe-API in der Keyboard-Klasse sind die Modifiers-Eigenschaft, mit der die derzeit gedrückten ModifierKeys zurückgegeben werden, und die IsKeyDown-Methode, die angibt, ob eine bestimmte Taste gedrückt wird.

Im folgenden Beispiel wird die GetKeyStates-Methode verwendet, um zu ermitteln, ob sich eine Key im gedrückten Zustand befindet.

// Uses the Keyboard.GetKeyStates to determine if a key is down.
// A bitwise AND operation is used in the comparison. 
// e is an instance of KeyEventArgs.
if ((Keyboard.GetKeyStates(Key.Return) & KeyStates.Down) > 0)
{
    btnNone.Background = Brushes.Red;
}

Beispiele für die Eingabe-API in der Mouse-Klasse sind MiddleButton, mit der der Zustand der mittleren Maustaste abgerufen wird, sowie DirectlyOver, wodurch das Element aufgerufen wird, über dem sich derzeit der Mauszeiger befindet.

Das folgende Beispiel ermittelt, ob sich die LeftButton der Maus im Pressed-Zustand befindet.

if (Mouse.LeftButton == MouseButtonState.Pressed)
{
    UpdateSampleResults("Left Button Pressed");
}

Die Mouse-Klasse und die Keyboard-Klasse werden im Laufe dieser Übersicht noch ausführlicher erläutert.

Tablettstifteingabe

WPF verfügt über die integrierte Unterstützung für den Stylus. Der Stylus ist ein Eingabegerät, das durch Tablet PC populär gemacht wurde. WPF-Anwendungen können den Tablettstift wie eine Maus behandeln, indem die Maus-API verwendet wird, wobei WPF jedoch auch eine Tablettstift-Geräteabstraktion bereitstellt, die ein ähnliches Modell wie für die Tastatur und die Maus verwendet. Alle auf den Tablettstift bezogenen APIs enthalten das Wort "Stylus".

Da der Tablettstift wie eine Maus verwendet werden kann, können einige Anwendungen, die nur die Mauseingabe unterstützen, automatisch auch den Tablettstift bis zu einem bestimmten Grad unterstützen. Wenn der Tablettstift auf diese Weise verwendet wird, wird der Anwendung ermöglicht, das entsprechende Tablettstiftereignis und dann das entsprechende Mausereignis zu verarbeiten. Darüber hinaus sind allgemeinere Dienste, wie zum Beispiel die Freihandeingabe, ebenfalls durch die Tablettstift-Geräteabstraktion verfügbar. Weitere Informationen zur Freihandeingabe finden Sie unter Erste Schritte mit Freihandeingaben.

Ereignisrouting

Ein FrameworkElement kann andere Elemente als untergeordnete Elemente im Inhaltsmodell enthalten, sodass sich eine Elementstruktur ergibt. In WPF kann das übergeordnete Element an Eingaben beteiligt sein, die sich an seine untergeordneten Elemente oder andere Nachfolgeelemente richten. Dies ist insbesondere dann nützlich, wenn Steuerelemente aus kleineren Steuerelementen erstellt werden sollen; dieser Vorgang wird als "Steuerelementzusammensetzung" oder "Compositing" bezeichnet. Weitere Informationen über Elementstrukturen und darüber, wie sich Elementstrukturen auf Ereignisrouten beziehen, finden Sie unter Strukturen in WPF.

Das Ereignisrouting bezeichnet den Vorgang, bei dem Ereignisse an mehrere Elemente weitergeleitet werden, sodass ein bestimmtes Objekt oder Element entlang der Route möglicherweise eine signifikante Antwort (durch Behandlung) auf ein Ereignis geben kann, das aus der Quelle eines anderen Elements stammt. Routingereignisse verwenden einen von drei Routingmechanismen: direkt, Bubbling und Tunneling. Beim direkten Routing wird das Quellelement als einziges Element benachrichtigt, und das Ereignis wird nicht an andere Elemente weitergeleitet. Das direkt geroutete Ereignis bietet jedoch trotzdem einige weitere Möglichkeiten, die nur für geroutete Ereignisse verfügbar sind, im Gegensatz zu standardmäßigen CLR-Ereignissen. Bubbling arbeitet sich in der Elementstruktur nach oben vor, indem zuerst das Element benachrichtigt wird, das Quelle des Ereignisses ist, dann das übergeordnete Element usw. Tunneling arbeitet sich vom Stamm der Elementstruktur nach unten vor und endet beim ursprünglichen Quellelement. Weitere Informationen zu Routingereignissen finden Sie unter Übersicht über Routingereignisse.

WPF-Eingabeereignisse bestehen in der Regel aus Paaren, die sich aus einem Tunneling- und einem Bubbling-Ereignis zusammensetzen. Tunneling-Ereignisse unterscheiden sich durch das "Preview"-Präfix von Bubbling-Ereignissen. So ist zum Beispiel PreviewMouseMove die Tunneling-Version eines Mausbewegungsereignisses und MouseMove die Bubbling-Version dieses Ereignisses. Diese Ereignispaare sind eine Konvention, die auf Elementebene implementiert ist und keine im WPF-Ereignissystem integrierte Funktion darstellt. Ausführliche Informationen finden Sie im Abschnitt zu WPF-Eingabeereignissen in Übersicht über Routingereignisse.

Behandeln von Eingabeereignissen

Um Eingaben für ein Element zu erhalten, muss ein Ereignishandler mit diesem speziellen Ereignis verknüpft sein. In XAML ist dies auf einfache Weise durchzuführen: Sie verweisen auf den Namen des Ereignisses als ein Attribut des Elements, das dieses Ereignis überwacht. Anschließend legen Sie den Wert des Attributs auf den Namen des von Ihnen definierten Ereignishandlers fest, basierend auf einem Delegaten. Der Ereignishandler muss in Code wie C# geschrieben werden und kann in einer Code-Behind-Datei enthalten sein.

Tastaturereignisse treten auf, wenn das Betriebssystem Tastaturaktionen meldet, die auftreten, während der Tastaturfokus auf einem Element liegt. Maus- und Tablettstiftereignisse lassen sich in zwei Kategorien einteilen: Ereignisse, die eine Änderung der Zeigerposition relativ zum Element melden, und Ereignisse, die Änderungen des Zustands der Gerätetasten melden.

Beispiel für Tastatureingabeereignisse

Im folgenden Beispiel wird ein Drücken der NACH-LINKS-TASTE überwacht. Es wird ein StackPanel erstellt, das über eine Button verfügt. An die Button-Instanz wird ein Ereignishandler angefügt, der das Drücken der NACH-LINKS-TASTE überwacht.

Im ersten Abschnitt des Beispiels werden der StackPanel und die Button erstellt, und der Ereignishandler für KeyDown wird angefügt.

<StackPanel>
  <Button Background="AliceBlue"
          KeyDown="OnButtonKeyDown"
          Content="Button1"/>
</StackPanel>

// Create the UI elements.
StackPanel keyboardStackPanel = new StackPanel();
Button keyboardButton1 = new Button();

// Set properties on Buttons.
keyboardButton1.Background = Brushes.AliceBlue;
keyboardButton1.Content = "Button 1";

// Attach Buttons to StackPanel.
keyboardStackPanel.Children.Add(keyboardButton1);

// Attach event handler.
keyboardButton1.KeyDown += new KeyEventHandler(OnButtonKeyDown);

Der zweite Abschnitt ist in Code geschrieben und definiert den Ereignishandler. Wenn die NACH-LINKS-TASTE gedrückt wird und die Button den Tastaturfokus hat, wird der Handler ausgeführt, und die Background-Farbe der Button ändert sich. Wenn die Taste gedrückt wird, es sich jedoch nicht um die NACH-LINKS-TASTE handelt, ändert sich die Background-Farbe der Button-Taste wieder in die Anfangsfarbe.

private void OnButtonKeyDown(object sender, KeyEventArgs e)
{
    Button source = e.Source as Button;
    if (source != null)
    {
        if (e.Key == Key.Left)
        {
            source.Background = Brushes.LemonChiffon;
        }
        else
        {
            source.Background = Brushes.AliceBlue;
        }
    }
}

Beispiel für Mauseingabeereignisse

Im folgenden Beispiel ändert sich die Background-Farbe einer Button, wenn der Mauszeiger auf die Button geführt wird. Die Background-Farbe wird wieder zurückgesetzt, wenn der Mauszeiger von der Button weg bewegt wird.

Im ersten Abschnitt dieses Beispiels werden der StackPanel und das Button-Steuerelement erstellt, und der Ereignishandler für das MouseEnter-Ereignis und das MouseLeave-Ereignis wird der Button hinzugefügt.

<StackPanel>
  <Button Background="AliceBlue"
          MouseEnter="OnMouseExampleMouseEnter"
          MouseLeave="OnMosueExampleMouseLeave">Button

  </Button>
</StackPanel>

// Create the UI elements.
StackPanel mouseMoveStackPanel = new StackPanel();
Button mouseMoveButton = new Button();

// Set properties on Button.
mouseMoveButton.Background = Brushes.AliceBlue;
mouseMoveButton.Content = "Button";

// Attach Buttons to StackPanel.
mouseMoveStackPanel.Children.Add(mouseMoveButton);

// Attach event handler.
mouseMoveButton.MouseEnter += new MouseEventHandler(OnMouseExampleMouseEnter);
mouseMoveButton.MouseLeave += new MouseEventHandler(OnMosueExampleMouseLeave);

Der zweite Abschnitt des Beispiels wird in Code geschrieben und definiert die Ereignishandler. Wenn der Mauszeiger auf die Button bewegt wird, ändert sich die Background-Farbe der Button in SlateGray. Wenn der Mauszeiger von der Button weg bewegt wird, ändert sich die Background-Farbe der Button zurück in AliceBlue.

private void OnMouseExampleMouseEnter(object sender, MouseEventArgs e)
{
    // Cast the source of the event to a Button.
    Button source = e.Source as Button;

    // If source is a Button.
    if (source != null)
    {
        source.Background = Brushes.SlateGray;
    }
}

private void OnMosueExampleMouseLeave(object sender, MouseEventArgs e)
{
    // Cast the source of the event to a Button.
    Button source = e.Source as Button;

    // If source is a Button.
    if (source != null)
    {
        source.Background = Brushes.AliceBlue;
    }
}

Texteingabe

Das TextInput-Ereignis ermöglicht Ihnen, die Texteingabe auf eine geräteunabhängige Weise zu überwachen. Die Tastatur ist die primäre Quelle für Texteingaben, wobei Sprach-, Handschrift- und andere Eingabegeräte ebenfalls Texteingaben generieren können.

Für die Tastatureingabe sendet WPF zuerst die entsprechenden KeyDown/KeyUp-Ereignisse. Wenn diese Ereignisse nicht verarbeitet werden und es sich bei der Taste um Text handelt (statt um eine Steuertaste wie zum Beispiel Richtungstasten oder Funktionstasten), wird ein TextInput-Ereignis ausgelöst. Es besteht nicht immer eine einfache Eins-zu-Eins-Zuordnung zwischen KeyDown/KeyUp-Ereignissen und TextInput-Ereignissen, da mehrere Tastatureingaben ein einzelnes Zeichen als Texteingabe und einzelne Tastatureingaben Zeichenfolgen generieren können. Dies trifft insbesondere auf Sprachen wie Chinesisch, Japanisch und Koreanisch zu, die Eingabemethoden-Editoren (Input Method Editors, IMEs) zum Generieren von Tausenden möglicher Zeichen entsprechend ihrem Alphabet verwenden.

Wenn WPF ein KeyUp/KeyDown-Ereignis sendet, wird Key auf Key.System festgelegt, wenn die Tastatureingaben Teil eines TextInput-Ereignisses werden könnten (wenn z. B. ALT+S gedrückt wird). Auf diese Weise wird dem Code in einem KeyDown-Ereignishandler ermöglicht, eine Überprüfung auf Key.System vorzunehmen; wenn dies gefunden wird, kann die Verarbeitung dem Handler des anschließend ausgelösten TextInput-Ereignisses überlassen werden. In diesem Fällen können die zahlreichen Eigenschaften des TextCompositionEventArgs-Arguments verwendet werden, um die ursprünglichen Tastatureingaben zu ermitteln. Ähnliches liegt vor, wenn ein IME aktiviert ist; Key weist den Wert Key.ImeProcessed auf, und ImeProcessedKey gibt die ursprüngliche Tastatureingabe bzw. die Tastatureingaben zurück.

Das folgende Beispiel definiert einen Handler für das Click-Ereignis und einen Handler für das KeyDown-Ereignis.

Das erste Segment des Codes oder Markups erstellt die Benutzeroberfläche.

<StackPanel KeyDown="OnTextInputKeyDown">
  <Button Click="OnTextInputButtonClick"
          Content="Open" />
  <TextBox> . . . </TextBox>
</StackPanel>

// Create the UI elements.
StackPanel textInputStackPanel = new StackPanel();
Button textInputeButton = new Button();
TextBox textInputTextBox = new TextBox();
textInputeButton.Content = "Open";

// Attach elements to StackPanel.
textInputStackPanel.Children.Add(textInputeButton);
textInputStackPanel.Children.Add(textInputTextBox);

// Attach event handlers.
textInputStackPanel.KeyDown += new KeyEventHandler(OnTextInputKeyDown);
textInputeButton.Click += new RoutedEventHandler(OnTextInputButtonClick);

Das zweite Segment des Codes enthält die Ereignishandler.

private void OnTextInputKeyDown(object sender, KeyEventArgs e)
{
    if (e.Key == Key.O && Keyboard.Modifiers == ModifierKeys.Control)
    {
        handle();
        e.Handled = true;
    }
}

private void OnTextInputButtonClick(object sender, RoutedEventArgs e)
{
    handle();
    e.Handled = true;
} 

public void handle()
{
    MessageBox.Show("Pretend this opens a file");
}

Da Eingabeereignisse mit Bubbling die Ereignisroute nach oben durchlaufen, empfängt der StackPanel die Eingabe unabhängig davon, auf welchem Element der Tastaturfokus liegt. Das TextBox-Steuerelement wird zuerst benachrichtigt, und der OnTextInputKeyDown-Handler wird nur dann aufgerufen, wenn das TextBox die Eingabe nicht verarbeitet hat. Wenn das PreviewKeyDown-Ereignis statt des KeyDown-Ereignisses versendet wird, wird zuerst der OnTextInputKeyDown-Handler aufgerufen.

In diesem Beispiel wird die Behandlungslogik zweimal geschrieben: einmal für STRG+O, und noch einmal für das Klickereignis der Schaltfläche. Dies kann durch die Verwendung von Befehlen vereinfacht werden, anstatt die Eingabeereignisse direkt zu behandeln. Befehle werden in dieser Übersicht und unter Befehlsübersicht erläutert.

Focus

Es gibt zwei Hauptkonzepte in Bezug auf den Fokus in WPF: den Tastaturfokus und den logischen Fokus.

Tastaturfokus

Tastaturfokus bezieht sich auf das Element, dem die Tastatureingabe gilt. Auf dem gesamten Desktop kann es nur ein Element mit Tastaturfokus geben. In WPF weist IsKeyboardFocused für das Element, das den Tastaturfokus besitzt, den Wert true auf. Die statische Keyboard-Methode FocusedElement gibt das Element zurück, das derzeit über den Tastaturfokus verfügt.

Der Tastaturfokus kann erhalten werden, indem mit der Tabstopptaste zu einem Element gewechselt wird oder indem mit der Maus auf bestimmte Elemente geklickt wird, wie z. B. TextBox. Der Tastaturfokus kann auch programmgesteuert über die Focus-Methode in der Keyboard-Klasse bezogen werden. Die Focus-Methode versucht, den Tastaturfokus auf das angegebene Element zu legen. Das von Focus zurückgegebene Element ist das Element, das derzeit über den Tastaturfokus verfügt.

Damit ein Element den Tastaturfokus erhalten kann, müssen die Focusable-Eigenschaft und die IsVisible-Eigenschaft auf true festgelegt sein. In einigen Klassen, wie z. B. Panel ist Focusable standardmäßig auf false festgelegt; Sie müssen diese Eigenschaft daher auf true festlegen, damit dieses Element den Fokus übernehmen kann.

Im folgenden Beispiel wird Focus verwendet, um den Tastaturfokus auf eine Button festzulegen. Am besten platzieren Sie den Anfangsfokus in einer Anwendung im Loaded-Ereignishandler.

private void OnLoaded(object sender, RoutedEventArgs e)
{
    // Sets keyboard focus on the first Button in the sample.
    Keyboard.Focus(firstButton);
}

Weitere Informationen über den Tastaturfokus finden Sie unter Fokus - Übersicht.

Logischer Fokus

Der logische Fokus bezieht sich auf das FocusManager.FocusedElement in einem Fokusbereich. In einer Anwendung kann der logische Fokus auf mehreren Elementen liegen, innerhalb eines bestimmten Fokusbereichs kann jedoch immer nur ein Element den logischen Fokus haben.

Bei einem Fokusbereich handelt es sich um ein Containerelement, das das FocusedElement innerhalb seines Bereichs verfolgt. Wenn der Fokus einen Fokusbereich verlässt, verliert das fokussierte Element den Tastaturfokus, behält jedoch den logischen Fokus. Wenn der Fokus in den Fokusbereich zurückkehrt, erhält das fokussierte Element wieder den Tastaturfokus. Auf diese Weise kann der Tastaturfokus zwischen verschiedenen Fokusbereichen wechseln, wobei sichergestellt ist, dass das fokussierte Element im Fokusbereich den Tastaturfokus wieder erhält, wenn dieser in diesen Fokusbereich zurückkehrt.

Ein Element kann in Extensible Application Markup Language (XAML) in einen Fokusbereich umgewandelt werden, indem die mit dem FocusManager verknüpfte IsFocusScope-Eigenschaft auf true festgelegt wird, oder im Code, indem die verknüpfte Eigenschaft mit der SetIsFocusScope-Methode festgelegt wird.

Im folgenden Beispiel wird ein StackPanel in einen Fokusbereich umgewandelt, indem die angefügte IsFocusScope-Eigenschaft festgelegt wird.

<StackPanel Name="focusScope1" 
            FocusManager.IsFocusScope="True"
            Height="200" Width="200">
  <Button Name="button1" Height="50" Width="50"/>
  <Button Name="button2" Height="50" Width="50"/>
</StackPanel>

StackPanel focuseScope2 = new StackPanel();
FocusManager.SetIsFocusScope(focuseScope2, true);

Folgende Klassen in WPF sind standardmäßig Fokusbereiche: Window, Menu, ToolBar und ContextMenu

Ein Element, das über den Tastaturfokus verfügt, hat auch den logischen Fokus für den Fokusbereich, zu dem es gehört; daher wird beim Festlegen des Fokus auf ein Element mit der Focus-Methode in der Keyboard-Klasse oder der Basiselementklasse versucht, dem Element den Tastaturfokus und den logischen Fokus zuzuweisen.

Um das fokussierte Element in einem Fokusbereich zu bestimmen, verwenden Sie GetFocusedElement. Um das fokussierte Element für einen Fokusbereich zu ändern, verwenden Sie SetFocusedElement.

Weitere Informationen über den logischen Fokus finden Sie unter Fokus - Übersicht.

Mausposition

Die Eingabe-API von WPF bietet nützliche Informationen in Bezug auf Koordinatensysteme. So ist die Koordinate (0,0) beispielsweise die Koordinate oben links, jedoch oben links von welchem Element in der Struktur? Das Element, das das Eingabeziel ist? Das Element, an das Sie den Ereignishandler angefügt haben? Oder etwas anderes? Um eine Verwechslung zu vermeiden, erfordert die WPF-Eingabe-API die Angabe eines Referenzrahmens, wenn Sie mit Koordinaten arbeiten, die von der Maus abgeleitet werden. Die GetPosition-Methode gibt die Koordinate des Mauszeigers relativ zum angegebenen Element zurück.

Mausauswahl

Mausgeräte verfügen typischerweise über ein modales Merkmal, das als Mausauswahl bezeichnet wird. Die Mausauswahl wird verwendet, um einen vorübergehenden Eingabezustand beizubehalten, während ein Drag & Drop-Vorgang gestartet wird, damit nicht unbedingt andere Vorgänge auftreten, die die nominale Position des Mauszeigers auf dem Bildschirm betreffen. Während des Ziehens kann der Benutzer nicht klicken, ohne den Drag & Drop-Vorgang abzubrechen, wodurch die meisten Mauszeigerhinweise hinfällig werden, während die Mausauswahl vom Ursprung des Ziehens beibehalten wird. Das Eingabesystem stellt APIs bereit, die den Mausauswahlstatus ermitteln können, sowie APIs, die die Mausauswahl für ein bestimmtes Element erzwingen oder den Mausauswahlstatus löschen können. Weitere Informationen über Drag & Dropvorgänge finden Sie unter Übersicht über Drag & Drop.

Befehle

Befehle ermöglichen die Eingabebehandlung auf einer eher semantischen Ebene als die Geräteeingabe. Befehle sind einfache Direktiven, wie zum Beispiel Cut, Copy, Paste oder Open. Befehle sind nützlich, um die Befehlslogik zu zentralisieren. Auf den gleichen Befehl kann über ein Menu, in einer ToolBar oder über eine Tastenkombination zugegriffen werden. Befehle stellen außerdem eine Möglichkeit dar, Steuerelemente zu deaktivieren, wenn der Befehl nicht verfügbar ist.

RoutedCommand ist die WPF-Implementierung von ICommand. Wenn ein RoutedCommand ausgeführt wird, werden ein PreviewExecuted-Ereignis und ein Executed-Ereignis im Befehlsziel ausgelöst, die wie andere Eingaben auch mit Tunneling und Bubbling die Elementstruktur durchlaufen. Wenn kein Befehlsziel festgelegt ist, ist das Element mit dem Tastaturfokus das Befehlsziel. Die Logik, die den Befehl ausführt, wird an eine CommandBinding angefügt. Wenn ein Executed-Ereignis eine CommandBinding für den angegebenen Befehl erreicht, wird der ExecutedRoutedEventHandler der CommandBinding aufgerufen. Dieser Handler führt die Aktion für den Befehl aus.

Weitere Informationen über Befehle finden Sie unter Befehlsübersicht.

WPF stellt eine Bibliothek mit häufig verwendeten Befehlen bereit, die ApplicationCommands, MediaCommands, ComponentCommands, NavigationCommands und EditingCommands umfasst; Sie können auch eigene Befehle definieren.

Das folgende Beispiel veranschaulicht, wie ein MenuItem so eingerichtet wird, dass beim Klicken darauf der Paste-Befehl für das TextBox ausgeführt wird, wobei davon ausgegangen wird, dass der Tastaturfokus auf dem TextBox liegt.

<StackPanel>
  <Menu>
    <MenuItem Command="ApplicationCommands.Paste" />
  </Menu>
  <TextBox />
</StackPanel>

// Creating the UI objects
StackPanel mainStackPanel = new StackPanel();
TextBox pasteTextBox = new TextBox();
Menu stackPanelMenu = new Menu();
MenuItem pasteMenuItem = new MenuItem();

// Adding objects to the panel and the menu
stackPanelMenu.Items.Add(pasteMenuItem);
mainStackPanel.Children.Add(stackPanelMenu);
mainStackPanel.Children.Add(pasteTextBox);

// Setting the command to the Paste command
pasteMenuItem.Command = ApplicationCommands.Paste;

Weitere Informationen über Befehle in WPF finden Sie unter Befehlsübersicht.

Das Eingabesystem und die Basiselemente

Eingabeereignisse wie die angefügten Ereignisse, die von den Klassen Mouse, Keyboard und Stylus definiert werden, werden vom Eingabesystem ausgelöst und an einer bestimmten Position im Objektmodell eingefügt, basierend auf einem Treffertest der visuellen Struktur zur Laufzeit.

Jedes der Elemente, das von Mouse, Keyboard und Stylus als ein angefügtes Ereignis definiert wird, wird ebenfalls von der UIElement-Basiselementklasse und der ContentElement-Basiselementklasse als ein neues Routingereignis erneut verfügbar gemacht. Die Basiselement-Routingereignisse werden von Klassen generiert, die das ursprüngliche angefügte Ereignis verarbeiten und die Ereignisdaten wiederverwenden.

Wenn das Eingabeereignis durch seine Basiselement-Eingabeereignisimplementierung mit einem bestimmten Quellelement verknüpft wird, kann es durch den Rest einer Ereignisroute, die aus einer Kombination von logischen und visuellen Strukturobjekten besteht, geleitet und vom Anwendungscode verarbeitet werden. Im Allgemeinen ist es einfacher, diese gerätebezogenen Eingabeereignisse anhand der Routingereignisse für UIElement und ContentElement zu verarbeiten, da Sie eine intuitivere Ereignishandlersyntax sowohl im XAML als auch im Code verwenden können. Sie könnten auch entscheiden, stattdessen das angefügte Ereignis zu behandeln, das den Prozess initiiert hat, wobei dies jedoch verschiedene Probleme aufwirft: Das angefügte Ereignis ist möglicherweise für die Behandlung durch die Basiselementklasse markiert, und Sie müssen Accessormethoden statt echter Ereignissyntax verwenden, um Handler für angefügte Ereignisse anfügen zu können.

Weitere Informationen

Sie haben jetzt mehr über verschiedene Methoden zum Behandeln von Eingaben in WPF erfahren. Außerdem sollten Sie nun mehr über die verschiedenen Typen von Eingabeereignissen und die Routingereignismechanismen, die von WPF verwendet werden, wissen.

Es sind zusätzliche Ressourcen verfügbar, die WPF-Frameworkelemente und das Ereignisrouting noch ausführlicher erläutern. Weitere Informationen erhalten Sie in den folgenden Übersichten: Befehlsübersicht, Fokus - Übersicht, Übersicht über Basiselemente, Strukturen in WPF und Übersicht über Routingereignisse.

Siehe auch

Konzepte

Fokus - Übersicht

Befehlsübersicht

Übersicht über Routingereignisse

Übersicht über Basiselemente

Weitere Ressourcen

Eigenschaften