In diesem Kapitel wird der Umgang mit Tastatur- und Mausereignissen beschrieben.

13 Tastatur- und Mausereignisse

13.1 Die Tastaturschnittstelle

13.1.1 Allgemeines

Die Tastatur ist die wichtigste Eingabeschnittstelle. Ihre Tasten sind entweder mit Zeichencodes oder allgemeinen Funktionen verknüpft und lassen sich in vier Gruppen einteilen:

• Zeichentasten: Die Zeichentasten dienen zur Eingabe von Buchstaben, Zahlen und Symbolen. Die Zeichencodes gehören zum ASCII-Zeichensatz, intern werden sie als 16-Bit-Unicode behandelt.

• Zustandstasten: Zu ihnen zählen die -, - und -Tasten. In der Regel interpretieren eingabefähige Komponenten nur die Kombination mit Zeichen- oder Funktionstasten.

• Funktionstasten: Sie führen eine bestimmte Funktionalität aus. Dazu gehören die -, - und -Tasten ebenso wie die Funktionstasten bis und die Cursortasten.

• Ein/Aus-Tasten: Sie dienen als Schalter, unter anderem die - und -Tasten.

Tastatureingaben des Anwenders werden von der fokussierten Komponente entgegengenommen. Einfache Reaktionen auf die Eingaben werden von der Komponente selbst ausgeführt. Beispielsweise können Sie in eine Textbox Zeichen eingeben, mit der Rücktaste das vor dem Eingabecursor stehende Zeichen löschen usw. Sollen bei einer Eingabe über den internen Standard hinausgehende Reaktionen erfolgen, müssen Sie das codieren. Damit lässt sich zum Beispiel erreichen, dass das Drücken der -Taste einen anwendungsspezifischen Dialog öffnet oder bestimmte Zeichen der Benutzereingabe nicht weiterverarbeitet werden.

13.1.2 Tastaturereignisse

In der Klasse Control sind drei tastaturbezogene Ereignisse definiert: KeyDown, KeyPress und KeyUp. Allerdings veröffentlichen nicht alle von der Basisklasse Control abgeleiteten Komponenten diese drei Ereignisse, denn Voraussetzung dafür ist die Fokussierfähigkeit. Ein Label beispielsweise reiht sich zwar in die Fokussierreihenfolge ein, ist aber nicht in der Lage, Tastatureingaben zu verarbeiten.

KeyDown und KeyUp sind mit dem sogenannten Tastaturcode verknüpft, der für jede Taste eindeutig festgelegt ist. Damit werden beide bei jedem Tastaturanschlag ausgelöst:

• KeyDown, wenn die Taste gedrückt wird

• KeyUp, wenn die Taste losgelassen wird

Das Ereignis KeyPress tritt nach KeyDown auf, wenn der Anwender auf eine Buchstaben- oder Zifferntaste drückt. Dabei sind einige Sonderfälle zu berücksichtigen:

• Wird eine Tastenkombination aus einer oder mehreren Zustandstasten zusammen mit einer Taste für einen Zeichencode gedrückt, z. B. + , wird das KeyDown-Ereignis sowohl für die Zustandstaste als auch für die Zeichentaste ausgelöst. Dasselbe gilt auch für KeyUp.

• Hält man eine Zustandstaste längere Zeit gedrückt, tritt KeyDown wiederholt auf.

• Wird eine Zeichentaste längere Zeit gedrückt, schreibt sich das Zeichen wiederholt in das Ausgabeziel, beispielsweise in eine Textbox. Dabei tritt für die Dauer des Tastendrucks das Ereignispaar KeyDown/KeyPress so lange auf, bis die Taste losgelassen wird und ein abschließendes KeyUp ausgelöst wird.

• Ist in einer Textbox die Eigenschaft AcceptsTab auf True gesetzt, kann der Benutzer mit der -Taste ein Tabstopp-Zeichen in ein mehrzeiliges Textfeld eingeben. In diesem Fall wird kein Tastaturereignis ausgelöst.

• KeyPress tritt auf, wenn ein ASCII-Zeichen erzeugt wird. Das gilt auch für den Fall, dass eine Kombination aus zwei Zustandstasten mit einer Zeichentaste gedrückt wird, zum Beispiel + + oder + für das Zeichen @.

13.1.3 Die Ereignisse KeyDown und KeyUp

Die Parameterlisten eines Ereignishandlers und des Delegates des Ereignisses müssen übereinstimmen. Sowohl KeyDown als auch KeyUp sind vom Typ KeyEventHandler:

Public Delegate Sub KeyEventHandler(sender As Object, e As KeyEventArgs)

Das Objekt vom Typ KeyEventArgs beschreibt genauer, welche Taste(n) gedrückt wurden:

Die Eigenschaften Alt, Control und Shift sagen, ob die gleichnamige Zustandstaste gedrückt ist, Modifiers kombiniert diese drei Informationen in einem Wert. KeyData und KeyValue haben zwar denselben Informationsgehalt, unterscheiden sich jedoch im Typ. KeyData enthält die Tastaturcodes aller gleichzeitig gedrückten Tasten und ist somit die Zusammenfassung der Eigenschaften KeyCode und Modifiers.

KeyCode und die Enumeration Keys

Drei Eigenschaften in der Tabelle 13.1 sind von einem noch unbekannten Typ: Keys.

Jede Taste einer Tastatur wird durch eine eindeutige Zahl beschrieben, den Tastaturcode. Die Enumeration Keys beschreibt alle erlaubten Tastencodes. Ich möchte nur die wichtigsten vorstellen, auf die Sie bei der täglichen Programmierung häufig zugreifen. Der besseren Übersicht wegen habe ich sie zu mehreren logischen Gruppen zusammengefasst.

Die wichtigste Gruppe ist die der Buchstabentasten, die insgesamt 26 Mitglieder enthält. Die Werte der Konstanten in Keys sind mit den ASCII-Codes für Großbuchstaben identisch:

Auch bei den Zahlen stimmen die Konstantenwerte mit den ASCII-Codes überein:

Die von uns üblicherweise als Alt bezeichnete Taste heißt hier Menu (siehe Tabelle 13.4). Das stammt vermutlich daher, dass die -Taste sehr häufig zur Menüauswahl eingesetzt wird. Es gibt noch ähnlich lautende Konstanten, die zwischen der linken bzw. rechten Anordnung unterscheiden. Die Notwendigkeit der Unterscheidung kommt nur recht selten vor.

Sehr häufig anzutreffen sind die mit den Funktionstasten verbundenen anwendungsspezifischen Funktionalitäten (Tabelle 13.5). Tastaturen mit 24 Funktionstasten sind etwas unüblich, Ich habe einmal eine in einer Bibliothek gesehen. Normal sind 12 Funktionstasten.

Wenn Sie Konstantenbezeichner anderer Tasten brauchen, schlagen Sie in der Dokumentation der Keys-Enumeration nach.

Wie man mit den Keys-Konstanten arbeitet, zeigt das folgende Beispiel eines Fensters, das eine Textbox enthält. Die Benutzereingabe wird im Ereignis KeyDown überprüft. Gibt der Anwender einen der Buchstaben M, N oder I ein, wird je nach Buchstabe die WindowState-Eigenschaft der Form auf maximiert, minimiert oder normal eingestellt.

'...\TastaturMaus\Tastatur\KeyDown.vb

Public Class KeyDown 
  Private Sub Taste(sender AsObject, e As KeyEventArgs) _ 
  Handles TextBox1.KeyDown 
    If e.KeyCode = Keys.N Then 
      Me.WindowState = FormWindowState.Normal 
    ElseIf e.KeyCode = Keys.M Then 
      Me.WindowState = FormWindowState.Maximized 
    ElseIf e.KeyCode = Keys.I Then 
      Me.WindowState = FormWindowState.Minimized 
    End If 
  End Sub 
End Class

Der Tastencode wird mit der Eigenschaft KeyCode des KeyEventArgs-Objekts abgefragt. Es spielt dabei keine Rolle, ob der Anwender die Zeichen als Groß- oder Kleinbuchstaben eingibt, denn ausschlaggebend ist einzig und allein die gedrückte Taste und nicht das Zeichen. Ist eine Unterscheidung zwischen Groß- und Kleinschreibung zwingend notwendig, gibt es zwei Alternativen: Entweder wird der Zustand der -Taste abgefragt, oder – was einfacher ist – es wird nicht das Ereignis KeyDown, sondern das Ereignis KeyPress behandelt.

Eigenschaft KeyData

Die Klasse KeyEventArgs stellt in drei Eigenschaften Informationen zu gedrückten Tasten zur Verfügung, die sich teils überlappen. Alle haben den Typ Keys und hängen zusammen: KeyData = KeyCode + Modifiers.

Jeder Tastendruck hat die Ereigniskette KeyDown und KeyUp zur Folge, bei mehreren gleichzeitig gedrückten Tasten löst jede gedrückte Taste ein eigenes Ereignis aus. Bei der Untersuchung einer Tastenkombination interessiert aber nicht die einzelne Taste, sondern die Gesamtheit aller gleichzeitig gedrückten Tasten. Um diese Information zu erhalten, wertet man die Bitmaske der vier Byte großen Eigenschaft KeyData aus. Die beiden unteren Bytes beschreiben, welche Tasten der Anwender gedrückt hält. Darin sind auch die Zustandstasten enthalten, gegebenenfalls nach linker und rechter Taste unterschieden. Wenn das Ereignis einer »normalen« Taste ausgelöst wird, taucht die gegebenenfalls auch gedrückte Zustandstaste nicht in den beiden unteren Bytes auf. Um diese zu erfassen, beschreiben die oberen beiden Bytes den Zustand von , und (nicht die Tasten selbst, so dass rechte und linke Version nicht unterschieden werden). Die Werte zeigt Tabelle 13.6.

Beachten Sie, dass der Wert für die -Taste nun tatsächlich auch Alt heißt und nicht mehr Menu. Durch die Werte wird bei gedrückter Zustandstaste immer nur ein ganz bestimmtes Bit im vierten Byte gesetzt:

Shift   = 0000 0000 0000 0001 .... 
Control = 0000 0000 0000 0010 .... 
Alt     = 0000 0000 0000 0100 ....

Sind mehrere Zustandstasten gleichzeitig gedrückt, werden die zugeordneten Bits einfach bitweise ODER-verknüpft.

Dazu ein Beispiel. Die Taste wird durch die Zahl 120 beschrieben, deren Bitmuster

0111 1000

ist und hexadezimal 0x0078 lautet. Ist nur eine Taste gedrückt, hat KeyData denselben Inhalt wie KeyCode. Wird beispielsweise nur die -Taste gedrückt, führen die beiden folgenden Zeilen demnach gleichermaßen zum Schließen der aktuellen Form:

If e.KeyCode = Keys.F9 Then Me.Close() 
If e.KeyData = Keys.F9 Then Me.Close()

Verändern wir nun das Beispiel und fragen eine Tastenkombination ab. Mit der Tastenkombination + + soll das aktuelle Formular geschlossen werden:

Private Sub Taste(sender AsObject, e As KeyEventArgs) _ 
Handles TextBox1.KeyDown 
  If e.KeyData = (Keys.Shift Or Keys.Alt Or Keys.F9) Then Me.Close() 
End Sub

Die Keys-Werte der gewünschten Kombination werden mit dem bitweisen ODER-Operator verknüpft, und das Ergebnis wird mit dem aktuellen Inhalt von KeyData verglichen. Stimmt die gewünschte Tastenkombination mit dem vorliegenden Bitmuster überein, wird die Methode Close auf das aktuelle Form-Objekt aufgerufen.

Eigenschaft Modifiers

Mit Modifiers werden alle drei Zustandstasten zusammen beschrieben. Das entspricht dem Inhalt der oberen beiden Bytes von KeyData. Damit gilt folgerichtig auch, dass die bitweise Verknüpfung von Modifiers und KeyCode der Inhalt von KeyData ist.

Eine ergänzende Alternative zu der Eigenschaft Modifiers

Die Klasse Control hat eine weitere Möglichkeit, den Status der drei Zustandstasten festzustellen: die klassengebundene, schreibgeschützte Eigenschaft ModifierKeys. Während die Eigenschaft Modifiers der Klasse KeyEventArgs immer an das KeyDown- oder KeyUp-Ereignis einer bestimmten Komponente gebunden ist, agiert die Eigenschaft ModifierKeys vollkommen ereignisunabhängig und ist somit auch unabhängig von jeglichem Steuerelement. Sie wird auf die Klasse Control aufgerufen und liefert wie Modifiers den Zustand der Tasten , und . Damit wird es möglich, die Zustandstasten auch im Zusammenhang mit Ereignissen auszuwerten, die darüber keine Informationen liefern.

Das folgende Codefragment ist der Ereignishandler des Click-Ereignisses einer Schaltfläche. Obwohl das Ereignis keine Tastaturinformationen bereitstellt, wird ein Meldungsfenster geöffnet, wenn entweder die - oder die -Taste während des Klickens gedrückt ist.

Private Sub X_Click(sender As Object, ByVal e As EventArgs) Handles X.Click 
  Dim keys As Keys = Control.ModifierKeys 
  If keys = Keys.Alt OrElse keys = Keys.Shift Then _ 
    MessageBox.Show("Zustandstaste 'Alt' oder 'Shift' gedrückt") 
End Sub

Soll eine Kombination mehrerer Zustandstasten zu einem bestimmten Verhalten der Anwendung führen, müssen die entsprechenden Enumerationskonstanten mit dem bitweisen ODER-Operator verknüpft werden. Im folgenden Beispiel wird das Meldungsfenster nur angezeigt, wenn die - und die -Taste gleichzeitig gedrückt sind:

Private Sub X_Click(sender As Object, ByVal e As EventArgs) Handles X.Click 
  Dim keys As Keys = Control.ModifierKeys 
  If keys = (Keys.Alt Or Keys.Shift) Then _ 
    MessageBox.Show("Zustandstasten 'Alt' und 'Shift' gedrückt") 
End Sub

Die Eigenschaft SuppressKeyPress

Möchten Sie verhindern, dass ein oder mehrere Tastaturereignisse vom Steuerelement empfangen und verarbeitet werden, setzen Sie im Ereignishandler SuppressKeyPress=True.

if e.KeyData = Keys.A Then e.SuppressKeyPress = True

Mit diesem Codefragment wird das Drücken der Taste unterdrückt und nicht zur Verarbeitung an das Steuerelement weitergeleitet.

13.1.4 Das Ereignis KeyPress

Die bisher besprochenen Eigenschaften KeyDown und KeyUp behandeln ganz allgemein das Drücken einer Taste auf der Tastatur. Viele Tasten erzeugen aber Zeichencodes, die für das Ausgabeziel bestimmt sind. Bei diesen Tasten wird zwischen KeyDown und KeyUp ein weiteres Ereignis ausgelöst: KeyPress.

Der Ereignishandler von KeyPress hat ein Argument vom Typ KeyPressEventArgs, der das Ereignis durch zwei Eigenschaften beschreibt: KeyChar und Handled (siehe Tabelle 13.7).

Die Eigenschaft KeyChar enthält das ASCII-Zeichen der gedrückten Taste.

Um den Unterschied zwischen den Ereignissen KeyDown und KeyUp und KeyPress zu verdeutlichen, ist das Beispiel KeyDown nun so umgeschrieben worden, dass die Benutzereingabe nicht mehr von KeyDown, sondern von KeyPress ausgewertet wird.

'...\TastaturMaus\Tastatur\KeyPress.vb

Public Class KeyPress 
  Private Sub Taste(sender AsObject, e As KeyPressEventArgs) _ 
  Handles TextBox1.KeyPress 
    If e.KeyChar = "N"c Then 
      Me.WindowState = FormWindowState.Normal 
    ElseIf e.KeyChar = "M"c Then 
      Me.WindowState = FormWindowState.Maximized 
    ElseIf e.KeyChar = "I"c Then 
      Me.WindowState = FormWindowState.Minimized 
    End If 
  End Sub 
End Class

Rufen wir uns noch einmal in Erinnerung: Im Beispiel KeyDown wurde nur die gedrückte Taste ausgewertet. Der Zustand der Taste spielte dabei keine Rolle. Deshalb wurde auch nicht zwischen der Groß- und Kleinschreibung unterschieden, und das Programm reagierte in beiden Fällen gleich. KeyPress wertet jedoch den ASCII-Code aus, der bei den Klein- und Großbuchstaben unterschiedlich ist. Der Anwender wird also gezwungen, »M« und nicht »m« einzugeben, um das Fenster zu maximieren.

Eigenschaft Handled

Normalerweise werden Tastatureingaben automatisch verarbeitet. Gibt der Anwender in einer Textbox den Buchstaben »A« ein, wird dieser sofort im Steuerelement ausgegeben. Die Tastaturereignisse sind meist dann von Interesse, wenn die Benutzereingabe ausgewertet werden muss. Das ist zum Beispiel dann der Fall, wenn eine bestimmte Eingabe unterdrückt und durch eine andere ersetzt werden soll.

Nehmen wir an, dass die Eingabe eines Umlauts automatisch durch »ae«, »oe« bzw. »ue« ersetzt werden soll. Am einfachsten manipulieren Sie den Inhalt der Textbox über die Eigenschaft SelectedText, um die Zeichenfolge direkt in die Anzeige der Textbox zu schreiben. Ist ein Teil der Zeichenfolge markiert, werden die markierten Zeichen durch die neue Zeichenfolge ersetzt; ist kein Text markiert, wird die Zeichenfolge an der aktuellen Cursorposition eingesetzt.

Private Sub Umlaut(ByVal sender As Object, ByVal e As KeyPressEventArgs) _ 
Handles TextBox1.KeyPress 
  If e.KeyChar = "ä"c Then 
    TextBox1.SelectedText = "ae" 
  ElseIf e.KeyChar = "ö"c Then 
    TextBox1.SelectedText = "oe" 
  ElseIf e.KeyChar = "ü"c Then 
    TextBox1.SelectedText = "ue" 
  End If 
End Sub

Geben wir das mit TextBox1 bezeichnete TextBox-Objekt »Händler« an der Tastatur ein, lautet die Ausgabe Haeändler. Das Programm hat zwar die Eingabe des Umlauts richtig erkannt und »ae« in die Textbox geschrieben, allerdings sorgt die automatische Eingabeverarbeitung auch dafür, dass der unerwünschte Umlaut außerdem ausgegeben wird.

Jetzt kommt die Eigenschaft Handled vom Typ Boolean ins Spiel. Der Standardwert False betrachtet die Verarbeitung als unvollendet, und das Programm macht mit der Standardverarbeitung weiter. Wird Handled=True gesetzt, schalten wir die automatische Eingabeverarbeitung aus und nehmen die Ereignisbehandlung komplett selbst in die Hand.

'...\TastaturMaus\Tastatur\Handled.vb

Public Class Handled 
  Private Sub Umlaut(ByVal sender As Object, ByVal e As KeyPressEventArgs) _ 
  Handles TextBox1.KeyPress 
    If e.KeyChar = "ä"c Then 
      TextBox1.SelectedText = "ae" : e.Handled = True 
    ElseIf e.KeyChar = "ö"c Then 
      TextBox1.SelectedText = "oe"" : e.Handled = True 
    ElseIf e.KeyChar = "ü"c Then 
      TextBox1.SelectedText = "ue"" : e.Handled = True 
    End If 
  End Sub 
End Class

Die Anweisung E.Handled=True sollte übrigens nicht nach der letzten If-Anweisung stehen. Wenn Sie das machen, schalten Sie – bis auf die Umlaute – die Behandlung aller anderen Zeichen ab.

Handled wird auch von den beiden Ereignissen KeyDown und KeyUp unterstützt. Allerdings zeigt sich hier ein anderes Verhalten, wenn auf eine Ziffern- oder Buchstabentaste gedrückt wird. Dazu ein Beispiel:

Private Sub textBox1_KeyDown(sender As Object, e As KeyEventArgs e) _ 
Handles textBox1.KeyDown 
  If e.KeyCode = Keys.A Then 
    textBox1.SelectedText = "Hallo" 
    e.Handled = True 
  End If 
End Sub

Obwohl der Code sehr ähnlich zum Beispiel Handled ist, wird ein eingegebenes Zeichen »a« (bzw. »A«) nicht durch die Zeichenfolge »Hallo« ersetzt, sondern nur ergänzt. Die Einstellung Handled=True bleibt wirkungslos, weil für die Zeichenverarbeitung nur das Ereignis KeyPress verantwortlich ist. Selbst ein zweiter KeyDown-Ereignishandler wird ausgeführt.

Abschalten einer bestimmten Taste

Manchmal kommt es vor, dass man die Funktionalität einer bestimmten Taste nicht zulassen kann und diese deaktivieren muss. Auch hierzu bietet sich Handled an.

Im folgenden Codefragment wird die Home-Taste (= ) abgeschaltet. Damit wird es dem Anwender unmöglich gemacht, den Eingabecursor an die erste Position zu setzen. Dass das mit den Steuerungstasten immer noch möglich ist, übersehen wir hierbei großzügig.

Private Sub textBox1_KeyDown(sender As Object, e As KeyEventArgs e) _ 
Handles textBox1.KeyDown 
  If e.KeyCode = Keys.Home Then e.Handled = True 
End Sub

Mit Return zur nächsten Textbox

Normalerweise wird mit der Tabulatortaste von einer Textbox in die nächste gesprungen. Manche Anwender verwenden aber stattdessen lieber die -Taste. Das folgende Beispiel soll zeigen, wie das Drücken von abgefangen und das nächste Steuerelement fokussiert wird. Dabei hilft uns die Methode ProcessTabKey der Form weiter, der wir True übergeben, um das nächste in der Fokussierreihenfolge stehende Steuerelement zu erreichen.

Private Sub TextBox1_KeyPress(sender As Object, e As KeyPressEventArgs) _ 
Handles TextBox1.KeyPress 
  If e.KeyChar.Equals(ChrW(13)) Then 
    Me.ProcessTabKey(True) 
    e.Handled=True 
  End If 
End Sub

13.1.5 Tastaturereignisse der Form

Als abgeleitete Klasse von Control erbt auch die Klasse Form die Tastaturereignisse. Sie werden jedoch unterdrückt, sobald die Form ein Steuerelement enthält, das selbst Tastaturereignisse verarbeiten kann. Manchmal möchte man aber bestimmte Tasten nur in der Form – seltener sowohl in der Form als auch in einem Steuerelement – verarbeiten.

Damit das Fenster Tastaturereignisse empfangen kann, muss die Eigenschaft KeyPreview des Form-Objekts auf True gesetzt werden. Jedes Tastaturereignis wird dann zuerst von der Form entgegengenommen und erst danach vom aktiven Steuerelement.

• KeyDown (Form)

• KeyDown (Steuerelement)

• KeyPress (Form)

• KeyPress (Steuerelement)

• KeyUp (Form)

• KeyUp (Steuerelement)

Soll mit der Einstellung KeyPreview=True ausschließlich die Form für die Verarbeitung eines der drei Tastaturereignisse verantwortlich sein, muss im entsprechenden Ereignishandler der Form Handled=True gesetzt werden. Die Auslösung des entsprechenden Ereignisses des Steuerelements wird damit verhindert.

13.1.6 Tastatureingaben simulieren

Mit der statischen Methode Send aus der Klasse SendKeys im Namensraum System.Windows. Forms können Sie eine Tastatureingabe auch mittels Programmcode simulieren, zum Beispiel:

SendKeys.Send("Hallo")

Empfänger der Zeichenfolge ist das Steuerelement, das den Eingabefokus hat. Damit ließe sich das Beispiel Handled auch wie folgt codieren:

Private Sub Umlaut(ByVal sender As Object, ByVal e As KeyPressEventArgs) _ 
Handles TextBox1.KeyPress 
  If e.KeyChar = "ä"c Then 
    SendKeys.Send("ae") 
    e.Handled = True 
  ... 
End Sub

Die Send-Methode nimmt eine Zeichenfolge entgegen. Die einfachste Form ist ein Text in Anführungsstrichen. Es gibt auch Tastatureingaben, die kein Zeichen ausgeben. Für diese Tasten gilt eine besondere Festlegung: Sie werden durch einen festgelegten Zeichencode beschrieben, der in geschweifte Klammern eingeschlossen wird. Die folgende Anweisung simuliert beispielsweise das Drücken der -Taste:

SendKeys.Send("{F4}")

Die Zeichencodes, die den einzelnen Tasten zugeordnet sind, können Sie der Dokumentation der Klasse SendKeys entnehmen.

Wollen Sie eine Tastenkombination mit den Zustandstasten , und simulieren, wird der jeweilige Buchstabe in runden Klammern angegeben und davor ein Codezeichen gesetzt. Die drei Codezeichen können Sie der Tabelle 13.8 entnehmen.

Die Anweisung für die Tastenkombination und lautet dann:

SendKeys.Send("+(A)")

Neben der Methode Send enthält die Klasse SendKeys noch die Methode SendWait, die zuerst auf die vollständige Verarbeitung der Tastatureingabe wartet.

Ihre Meinung

Wie hat Ihnen das Openbook gefallen? Wir freuen uns immer über Ihre Rückmeldung. Schreiben Sie uns gerne Ihr Feedback als E-Mail an kommunikation@rheinwerk-verlag.de.