# Button Ein `Button` ist ein Steuerelement, mit dem der Benutzer **Aktionen auslösen** kann. Im Gegensatz zu Controls wie `TextBox`, `ListBox` oder `CheckedListBox` speichert ein `Button` keine Daten. Er dient ausschließlich dazu, eine Aktion auszuführen, beispielsweise das Speichern einer Datei, das Öffnen eines Dialogs oder das Starten einer Berechnung. --- ## **Grundlagen** Ein `Button` löst **eine Aktion** aus. - `Button` → führt eine Aktion aus - `Label` → zeigt Informationen an - `TextBox` → ermöglicht Texteingaben #### Button erstellen ```powershell # Klassisch $button = New-Object System.Windows.Forms.Button # .NET-Style $button = [System.Windows.Forms.Button]::new() ``` #### Button hinzufügen Ein `Button` wird wie jedes andere Control der `Controls`-Collection seines Parent-Containers hinzugefügt. ```powershell $form.Controls.Add($button) # oder $tabPage.Controls.Add($button) ``` #### Click-Event hinzufügen Die häufigste Aufgabe eines Buttons besteht darin, auf einen Mausklick zu reagieren. ```powershell $button.Add_Click({ param($sender, $e) Write-Host "Button wurde geklickt." }) ``` --- # **Eigenschaften**
EigenschaftBeschreibung
`AutoSize`Passt die Größe des Buttons automatisch an dessen Inhalt an.
`AutoEllipsis`Kürzt zu langen Text automatisch mit `...`.
`BackColor`Legt die Hintergrundfarbe des Buttons fest.
`DialogResult`Gibt den Rückgabewert eines Dialogfensters beim Klick auf den Button an.
`Dock`Dockt den Button an einer Seite seines Parent-Containers an.
`Enabled`Legt fest, ob der Button verwendet werden kann.
`FlatAppearance`Enthält Darstellungseigenschaften für flache Buttons.
`FlatStyle`Bestimmt das Erscheinungsbild des Buttons.
`Font`Legt Schriftart, -größe und -stil fest.
`ForeColor`Legt die Textfarbe fest.
`Image`Zeigt ein Bild auf dem Button an.
`ImageAlign`Bestimmt die Position des Bildes innerhalb des Buttons.
`ImageIndex`Wählt ein Bild anhand seines Indexes aus der `ImageList` aus.
`ImageKey`Wählt ein Bild anhand seines Namens aus der `ImageList` aus.
`ImageList`Legt die Bildersammlung für den Button fest.
`Location`Bestimmt die Position des Buttons im Parent-Container.
`Margin`Legt den äußeren Abstand zu benachbarten Controls fest.
`MaximumSize`Definiert die maximal zulässige Größe.
`MinimumSize`Definiert die minimal zulässige Größe.
`Name`Legt den internen Namen des Buttons fest.
`Padding`Legt den Innenabstand zwischen Rand und Inhalt fest.
`Size`Bestimmt Breite und Höhe des Buttons.
`TabIndex`Legt die Reihenfolge der Tabulator-Navigation fest.
`TabStop`Legt fest, ob der Button per Tabulator fokussiert werden kann.
`Text`Bestimmt die sichtbare Beschriftung des Buttons.
`TextAlign`Legt die Position des Textes fest.
`TextImageRelation`Bestimmt die Anordnung von Bild und Text.
`UseMnemonic`Aktiviert Tastenkombinationen über `&` im Text.
`UseVisualStyleBackColor`Verwendet das Windows-Design für den Hintergrund.
`Visible`Legt fest, ob der Button sichtbar ist.
AutoSize #### **AutoSize** **Typ** = `[System.Boolean]` Der Wert von `AutoSize` legt fest, ob sich die Größe des Buttons automatisch an dessen Inhalt anpasst. Standardmäßig besitzt diese Eigenschaft den Wert `False`, wodurch ausschließlich die Eigenschaft `Size` die Größe bestimmt. Ist `AutoSize` auf `True` gesetzt, wird die Breite und Höhe des Buttons automatisch an den enthaltenen Text beziehungsweise das Bild angepasst. ```powershell $button.AutoSize = $true ```
AutoEllipsis #### **AutoEllipsis** **Typ** = `[System.Boolean]` Der Wert von `AutoEllipsis` legt fest, ob zu langer Text automatisch mit `...` gekürzt werden soll, wenn dieser nicht vollständig dargestellt werden kann. Standardmäßig ist diese Eigenschaft auf `False` gesetzt. ```powershell $button.AutoEllipsis = $true ```
BackColor #### **BackColor** **Typ** = `[System.Drawing.Color]` Der Wert von `BackColor` legt die Hintergrundfarbe des Buttons fest. Standardmäßig wird die Hintergrundfarbe durch das aktuelle Windows-Design bestimmt. Soll eine eigene Hintergrundfarbe verwendet werden, muss zusätzlich `UseVisualStyleBackColor` auf `$false` gesetzt werden. ```powershell $button.UseVisualStyleBackColor = $false $button.BackColor = "RoyalBlue" ``` > 💡 **Hinweis** > Solange `UseVisualStyleBackColor` aktiviert ist, wird `BackColor` häufig ignoriert.
DialogResult #### **DialogResult** **Typ** = `[System.Windows.Forms.DialogResult]` Der Wert von `DialogResult` legt fest, welcher Rückgabewert beim Anklicken des Buttons an ein modales Dialogfenster (`ShowDialog()`) zurückgegeben wird. Standardmäßig besitzt diese Eigenschaft den Wert `None`. Wird beispielsweise `OK`, `Cancel` oder `Yes` festgelegt, schließt sich das Dialogfenster automatisch und `ShowDialog()` liefert den entsprechenden Wert zurück. Diese Eigenschaft wird hauptsächlich in Dialogfenstern verwendet. ```powershell $button.DialogResult = "OK" ```
Dock #### **Dock** **Typ** = `[System.Windows.Forms.DockStyle]` Der Wert von `Dock` legt fest, an welcher Seite seines Parent-Containers der Button angedockt wird. Standardmäßig besitzt diese Eigenschaft den Wert `None`, wodurch Position und Größe ausschließlich über `Location` und `Size` bestimmt werden. Alternativ kann der Button am oberen (`Top`), unteren (`Bottom`), linken (`Left`) oder rechten (`Right`) Rand angedockt oder mit `Fill` über den gesamten verfügbaren Bereich ausgedehnt werden. Im Gegensatz zu `Anchor` übernimmt `Dock` sowohl die Positionierung als auch die Größenanpassung des Controls. ```powershell $button.Dock = "Fill" ```
Enabled #### **Enabled** **Typ** = `[System.Boolean]` Der Wert von `Enabled` legt fest, ob der Button vom Benutzer verwendet werden kann. Standardmäßig besitzt diese Eigenschaft den Wert `True`. Ist sie auf `False` gesetzt, wird der Button ausgegraut dargestellt und reagiert weder auf Maus- noch auf Tastatureingaben. ```powershell $button.Enabled = $false ```
FlatAppearance #### **FlatAppearance** **Typ** = `[System.Windows.Forms.FlatButtonAppearance]` Der Wert von `FlatAppearance` enthält verschiedene Eigenschaften zur Darstellung eines Buttons mit dem `FlatStyle` `Flat` oder `Popup`. Hierüber können unter anderem die Rahmenfarbe (`BorderColor`), Rahmenstärke (`BorderSize`) sowie die Hintergrundfarben beim Überfahren oder Anklicken angepasst werden. ```powershell $button.FlatStyle = "Flat" $button.FlatAppearance.BorderSize = 1 $button.FlatAppearance.BorderColor = "DodgerBlue" ``` > 💡 **Hinweis** > Die Eigenschaften von `FlatAppearance` wirken nur bei den Darstellungsarten `Flat` und teilweise `Popup`.
FlatStyle #### **FlatStyle** **Typ** = `[System.Windows.Forms.FlatStyle]` Der Wert von `FlatStyle` bestimmt das Erscheinungsbild des Buttons. Standardmäßig besitzt diese Eigenschaft den Wert `Standard`. Alternativ stehen `Flat`, `Popup` und `System` zur Verfügung. - **Standard** → Standarddarstellung - **Flat** → flacher Button - **Popup** → flach, hebt sich beim Überfahren hervor - **System** → Darstellung vollständig durch Windows ```powershell $button.FlatStyle = "Flat" ```
Font #### **Font** **Typ** = `[System.Drawing.Font]` Der Wert von `Font` legt die Schriftart fest, mit der der Text des Buttons dargestellt wird. Änderungen an dieser Eigenschaft beeinflussen sowohl Schriftart als auch Schriftgröße und Schriftstil. ```powershell $button.Font = [System.Drawing.Font]::new( "Segoe UI", 10, "Bold" ) ```
ForeColor #### **ForeColor** **Typ** = `[System.Drawing.Color]` Der Wert von `ForeColor` legt die Farbe fest, mit der der Text des Buttons dargestellt wird. ```powershell $button.ForeColor = "White" ```
Image #### **Image** **Typ** = `[System.Drawing.Image]` Der Wert von `Image` legt das Bild fest, das auf dem Button angezeigt werden soll. Standardmäßig besitzt diese Eigenschaft den Wert `$null`, wodurch kein Bild dargestellt wird. Ist sowohl ein Bild als auch ein Text vorhanden, bestimmt `TextImageRelation`, wie beide Elemente zueinander angeordnet werden. ```powershell $button.Image = [System.Drawing.Image]::FromFile( "C:\Icons\Save.png" ) ``` > 💡 **Hinweis** > Soll das Bild aus einer `ImageList` stammen, werden stattdessen die Eigenschaften `ImageList` sowie `ImageIndex` oder `ImageKey` verwendet.
ImageAlign #### **ImageAlign** **Typ** = `[System.Drawing.ContentAlignment]` Der Wert von `ImageAlign` legt fest, an welcher Position das Bild innerhalb des Buttons dargestellt wird. Standardmäßig befindet sich das Bild mittig (`MiddleCenter`). Zusammen mit `TextAlign` und `TextImageRelation` lässt sich die Anordnung von Bild und Text individuell festlegen. ```powershell $button.ImageAlign = "MiddleLeft" ```
ImageIndex #### **ImageIndex** **Typ** = `[System.Int32]` Der Wert von `ImageIndex` bestimmt den Index des Bildes innerhalb der zugewiesenen `ImageList`. Standardmäßig besitzt diese Eigenschaft den Wert `-1`, wodurch kein Bild ausgewählt ist. ```powershell $button.ImageList = $imageList $button.ImageIndex = 0 ``` > 💡 **Hinweis** > `ImageIndex` und `ImageKey` dienen demselben Zweck. Es sollte immer nur eine der beiden Eigenschaften verwendet werden.
ImageKey #### **ImageKey** **Typ** = `[System.String]` Der Wert von `ImageKey` legt den Namen eines Bildes innerhalb der zugewiesenen `ImageList` fest. Im Gegensatz zu `ImageIndex` erfolgt die Auswahl hierbei über den Namen des Bildes. ```powershell $button.ImageList = $imageList $button.ImageKey = "Save" ```
ImageList #### **ImageList** **Typ** = `[System.Windows.Forms.ImageList]` Der Wert von `ImageList` legt die Bildersammlung fest, aus der der Button seine Bilder beziehen kann. Die Eigenschaft selbst bestimmt noch kein Bild. Welches Bild angezeigt wird, wird anschließend über `ImageIndex` oder `ImageKey` ausgewählt. ```powershell $button.ImageList = $imageList $button.ImageIndex = 2 ```
Location #### **Location** **Typ** = `[System.Drawing.Point]` Der Wert von `Location` legt die Position des Buttons innerhalb seines Parent-Containers fest. Die Position wird über die X- und Y-Koordinate relativ zum Parent-Control angegeben. ```powershell $button.Location = "20, 40" ``` > 💡 **Hinweis** > Ist zusätzlich `Dock` aktiviert, wird `Location` vom Layoutsystem automatisch verwaltet.
Margin #### **Margin** **Typ** = `[System.Windows.Forms.Padding]` Der Wert von `Margin` legt den äußeren Abstand des Buttons zu benachbarten Controls fest. Die Eigenschaft wird hauptsächlich von Layout-Containern wie `FlowLayoutPanel` oder `TableLayoutPanel` berücksichtigt. ```powershell $button.Margin = [System.Windows.Forms.Padding]::new(10) ```
MaximumSize #### **MaximumSize** **Typ** = `[System.Drawing.Size]` Der Wert von `MaximumSize` legt die maximal zulässige Größe des Buttons fest. Standardmäßig besitzt diese Eigenschaft den Wert `(0,0)`. Dadurch existiert keine Größenbegrenzung. ```powershell $button.MaximumSize = "250, 50" ```
MinimumSize #### **MinimumSize** **Typ** = `[System.Drawing.Size]` Der Wert von `MinimumSize` legt die minimal zulässige Größe des Buttons fest. Unterschreitet eine Größenänderung diesen Wert, bleibt die festgelegte Mindestgröße erhalten. ```powershell $button.MinimumSize = "120, 35" ```
Name #### **Name** **Typ** = `[System.String]` Der Wert von `Name` legt den internen Namen des Buttons fest. Der Name dient ausschließlich der Identifikation innerhalb des Programms und wird dem Benutzer nicht angezeigt. Besonders bei größeren Formularen erleichtert ein eindeutiger Name die spätere Verwaltung und den Zugriff auf Controls. ```powershell $button.Name = "btnSave" ```
Padding #### **Padding** **Typ** = `[System.Windows.Forms.Padding]` Der Wert von `Padding` legt den Innenabstand zwischen dem Rand des Buttons und dessen Inhalt fest. Dadurch kann zusätzlicher Abstand zwischen Rahmen, Text und Bild geschaffen werden. ```powershell $button.Padding = [System.Windows.Forms.Padding]::new(8) ```
Size #### **Size** **Typ** = `[System.Drawing.Size]` Der Wert von `Size` legt die Breite und Höhe des Buttons fest. Standardmäßig wird die Größe ausschließlich durch diese Eigenschaft bestimmt. Ist `AutoSize` aktiviert, kann die Größe automatisch anhand des Inhalts berechnet werden. ```powershell $button.Size = "120, 35" ```
TabIndex #### **TabIndex** **Typ** = `[System.Int32]` Der Wert von `TabIndex` legt die Reihenfolge fest, in der das Control den Fokus erhält, wenn der Benutzer die **Tabulator-Taste** betätigt. Standardmäßig vergibt der Designer beziehungsweise die Reihenfolge der hinzugefügten Controls fortlaufende Werte. Das Control mit dem kleinsten `TabIndex` erhält den Fokus zuerst. ```powershell $button.TabIndex = 2 ``` > 💡 **Hinweis** > Die tatsächliche Tabulator-Reihenfolge ergibt sich aus dem Zusammenspiel von `TabIndex` und `TabStop`.
TabStop #### **TabStop** **Typ** = `[System.Boolean]` Der Wert von `TabStop` legt fest, ob der Button über die **Tabulator-Taste** den Fokus erhalten kann. Standardmäßig besitzt diese Eigenschaft den Wert `True`. Wird sie auf `False` gesetzt, überspringt die Tabulator-Navigation den Button, obwohl dieser weiterhin per Mausklick verwendet werden kann. ```powershell $button.TabStop = $false ```
Text #### **Text** **Typ** = `[System.String]` Der Wert von `Text` legt die sichtbare Beschriftung des Buttons fest. Standardmäßig besitzt diese Eigenschaft den Wert `""` (leerer String). Der Text wird innerhalb des Buttons entsprechend der Eigenschaft `TextAlign` dargestellt. ```powershell $button.Text = "Speichern" ``` Soll der Button ausschließlich ein Symbol enthalten, kann der Text leer bleiben. ```powershell $button.Text = "" ```
TextAlign #### **TextAlign** **Typ** = `[System.Drawing.ContentAlignment]` Der Wert von `TextAlign` legt fest, an welcher Position der Text innerhalb des Buttons dargestellt wird. Standardmäßig besitzt diese Eigenschaft den Wert `MiddleCenter`, wodurch der Text zentriert angezeigt wird. In Kombination mit `ImageAlign` und `TextImageRelation` kann die Position von Text und Bild unabhängig voneinander festgelegt werden. ```powershell $button.TextAlign = "MiddleRight" ```
TextImageRelation #### **TextImageRelation** **Typ** = `[System.Windows.Forms.TextImageRelation]` Der Wert von `TextImageRelation` legt fest, wie Text und Bild innerhalb des Buttons zueinander angeordnet werden. Diese Eigenschaft besitzt nur dann eine sichtbare Auswirkung, wenn sowohl `Text` als auch `Image` beziehungsweise `ImageList` verwendet werden. Folgende Werte stehen zur Verfügung: - **Overlay** → Text und Bild liegen übereinander - **ImageBeforeText** → Bild links vom Text - **TextBeforeImage** → Text links vom Bild - **ImageAboveText** → Bild oberhalb des Textes - **TextAboveImage** → Text oberhalb des Bildes ```powershell $button.Image = $image $button.Text = "Speichern" $button.TextImageRelation = "ImageBeforeText" ``` > 💡 **Hinweis** > Die genaue Position wird zusätzlich durch `ImageAlign` und `TextAlign` beeinflusst.
UseMnemonic #### **UseMnemonic** **Typ** = `[System.Boolean]` Der Wert von `UseMnemonic` legt fest, ob im Text enthaltene Mnemonics ausgewertet werden. Standardmäßig besitzt diese Eigenschaft den Wert `True`. Ein kaufmännisches Und (`&`) kennzeichnet den folgenden Buchstaben als Tastenkombination. Dieser Buchstabe wird unterstrichen und kann zusammen mit der **Alt-Taste** verwendet werden. ```powershell $button.Text = "&Speichern" ``` Im Beispiel kann der Button mit **Alt + S** aktiviert werden. Soll das Zeichen `&` hingegen als normales Zeichen dargestellt werden, muss es doppelt angegeben werden. ```powershell $button.Text = "Speichern && Schließen" ```
UseVisualStyleBackColor #### **UseVisualStyleBackColor** **Typ** = `[System.Boolean]` Der Wert von `UseVisualStyleBackColor` legt fest, ob der Button seine Hintergrundfarbe vom aktuellen Windows-Design übernimmt. Standardmäßig besitzt diese Eigenschaft den Wert `True`. Dadurch bestimmt Windows die Darstellung des Buttons, wodurch eine einheitliche Optik mit dem Betriebssystem erreicht wird. Soll eine eigene Hintergrundfarbe über `BackColor` verwendet werden, muss `UseVisualStyleBackColor` auf `$false` gesetzt werden. ```powershell $button.UseVisualStyleBackColor = $false $button.BackColor = "RoyalBlue" ``` > 💡 **Hinweis** > Solange `UseVisualStyleBackColor` aktiviert ist, wird `BackColor` häufig vollständig ignoriert.
Visible #### **Visible** **Typ** = `[System.Boolean]` Der Wert von `Visible` legt fest, ob der Button sichtbar dargestellt wird. Standardmäßig besitzt diese Eigenschaft den Wert `True`. Wird sie auf `False` gesetzt, wird der Button nicht angezeigt und kann weder per Maus noch per Tastatur verwendet werden. ```powershell $button.Visible = $false ``` Die Eigenschaft eignet sich insbesondere, um Bedienelemente abhängig vom Programmzustand ein- oder auszublenden. ```powershell $button.Visible = $userIsAdmin ```
--- ## **Methoden**
MethodeBeschreibung
`PerformClick()`Löst das `Click`-Event programmgesteuert aus.
`Select()`Versucht, den Button auszuwählen.
`Focus()`Versucht, den Tastaturfokus auf den Button zu setzen.
`BringToFront()`Bringt den Button innerhalb seines Parent-Containers in die vorderste Ebene.
`SendToBack()`Verschiebt den Button innerhalb seines Parent-Containers in die hinterste Ebene.
PerformClick() #### **PerformClick()** ```powershell $button.PerformClick() ``` --- **Beschreibung** Die Methode `PerformClick()` löst programmgesteuert einen Klick auf den Button aus. Dabei wird das `Click`-Event genauso ausgelöst, als hätte der Benutzer den Button mit der Maus angeklickt. Dadurch kann dieselbe Programmlogik sowohl durch Benutzereingaben als auch durch Code ausgeführt werden. Die Methode führt den Klick nur aus, wenn der Button aktiviert (`Enabled = $true`) und sichtbar (`Visible = $true`) ist. --- **Rückgabe** Keine Rückgabe `System.Void` --- **Beispiel** ```powershell $button.Add_Click({ Write-Host "Button wurde geklickt." }) # Klick per Code auslösen $button.PerformClick() ```
Select() #### **Select()** ```powershell $button.Select() ``` --- **Beschreibung** Die Methode `Select()` versucht, den Eingabefokus auf den Button zu setzen. Der Button erhält den Fokus jedoch nur, wenn er aktiviert (`Enabled = $true`), sichtbar (`Visible = $true`) und innerhalb seines Parent-Containers auswählbar ist. Nach erfolgreichem Aufruf kann der Button beispielsweise direkt über die Leertaste oder Eingabetaste ausgelöst werden. --- **Rückgabe** Keine Rückgabe `System.Void` --- **Beispiel** ```powershell $button.Select() ```
Focus() #### **Focus()** ```powershell $button.Focus() ``` --- **Beschreibung** Die Methode `Focus()` versucht, den Tastaturfokus auf den Button zu setzen. Im Gegensatz zu `Select()` liefert die Methode einen Rückgabewert, anhand dessen überprüft werden kann, ob das Setzen des Fokus erfolgreich war. Die Methode schlägt beispielsweise fehl, wenn der Button deaktiviert oder nicht sichtbar ist. --- **Rückgabe** Gibt `True` zurück, wenn der Fokus erfolgreich gesetzt werden konnte, andernfalls `False`. Rückgabetyp: `System.Boolean` --- **Beispiel** ```powershell if ($button.Focus()) { Write-Host "Button besitzt jetzt den Fokus." } else { Write-Host "Fokus konnte nicht gesetzt werden." } ```
BringToFront() #### **BringToFront()** ```powershell $button.BringToFront() ``` --- **Beschreibung**Die Methode `BringToFront()` bringt den Button innerhalb seines Parent-Containers in die vorderste Ebene der Z-Reihenfolge. Dies ist insbesondere relevant, wenn sich mehrere Controls überlappen. Der Button wird dadurch vor anderen Controls desselben Parent-Containers dargestellt. Die Methode verändert weder die Position (`Location`) noch die Größe (`Size`) des Buttons. --- **Rückgabe**Keine Rückgabe `System.Void` --- **Beispiel**```powershell $button.BringToFront() ```
SendToBack() #### **SendToBack()** ```powershell $button.SendToBack() ``` --- **Beschreibung** Die Methode `SendToBack()` verschiebt den Button innerhalb seines Parent-Containers in die hinterste Ebene der Z-Reihenfolge. Dies ist insbesondere relevant, wenn sich mehrere Controls überlappen. Der Button wird dadurch hinter anderen Controls desselben Parent-Containers dargestellt. Die Methode verändert weder die Position (`Location`) noch die Größe (`Size`) des Buttons. --- **Rückgabe**Keine Rückgabe `System.Void` --- **Beispiel**```powershell $button.SendToBack() ```
--- ## **Events**
EventBeschreibung
`Click`Wird ausgelöst, wenn der Button angeklickt wird.
`DoubleClick`Wird bei einem Doppelklick ausgelöst.
`MouseClick`Reagiert auf einen Mausklick und liefert Informationen über die Maustaste.
`MouseDown`Wird beim Drücken einer Maustaste ausgelöst.
`MouseUp`Wird beim Loslassen einer Maustaste ausgelöst.
`MouseEnter`Wird ausgelöst, wenn der Mauszeiger den Button betritt.
`MouseLeave`Wird ausgelöst, wenn der Mauszeiger den Button verlässt.
`MouseMove`Wird während der Mausbewegung über dem Button ausgelöst.
`GotFocus`Wird ausgelöst, wenn der Button den Tastaturfokus erhält.
`LostFocus`Wird ausgelöst, wenn der Button den Tastaturfokus verliert.
`KeyDown`Wird beim Drücken einer Taste ausgelöst.
`KeyPress`Wird ausgelöst, wenn ein druckbares Zeichen eingegeben wird.
`KeyUp`Wird beim Loslassen einer Taste ausgelöst.
Click #### **Click** Das `Click`-Event wird ausgelöst, wenn der Benutzer den Button anklickt oder dieser programmgesteuert über `PerformClick()` ausgelöst wird. Dies ist das am häufigsten verwendete Event eines Buttons und dient üblicherweise zum Ausführen einer Aktion. --- **Beispiel** ```powershell $button.Add_Click({ Write-Host "Speichern..." }) ```
DoubleClick #### **DoubleClick** Das `DoubleClick`-Event wird ausgelöst, wenn der Benutzer den Button doppelt anklickt. Da Buttons normalerweise bereits auf den ersten Klick reagieren, wird dieses Event nur selten verwendet. --- **Beispiel** ```powershell $button.Add_DoubleClick({ Write-Host "Doppelklick" }) ```
MouseClick #### **MouseClick** Das `MouseClick`-Event wird ausgelöst, wenn der Benutzer den Button mit einer Maustaste anklickt. Im Gegensatz zum `Click`-Event stehen zusätzliche Informationen zur verwendeten Maustaste sowie zur Mausposition zur Verfügung. ---
EigenschaftTypBeschreibung
`Button``MouseButtons`Gibt an, welche Maustaste gedrückt wurde (`Left`, `Right`, `Middle`, `XButton1`, `XButton2`).
`Clicks``Int32`Anzahl der aufeinanderfolgenden Mausklicks.
`X``Int32`X-Koordinate des Mauszeigers relativ zum Button.
`Y``Int32`Y-Koordinate des Mauszeigers relativ zum Button.
`Location``Point`Mausposition als `Point` (`X` und `Y` zusammengefasst).
`Delta``Int32`Wert des Mausrads. Beim `MouseClick` normalerweise `0`. Relevant vor allem beim `MouseWheel`-Event.
### Beispiel ```powershell $button.Add_MouseClick({ param($sender, $e) Write-Host "Taste : $($e.Button)" Write-Host "Klicks : $($e.Clicks)" Write-Host "X : $($e.X)" Write-Host "Y : $($e.Y)" Write-Host "Position : $($e.Location)" }) ``` ### Ausgabe ```powershell Taste : Left Klicks : 1 X : 84 Y : 17 Position : {X=84,Y=17} ``` --- ```powershell $button.Add_MouseClick({ param($sender, $e) Write-Host $e.Button }) ```
MouseDown #### **MouseDown** Das `MouseDown`-Event wird ausgelöst, sobald der Benutzer eine Maustaste auf dem Button drückt. Dieses Event eignet sich beispielsweise zum Starten von Drag-and-Drop-Operationen oder zum Erfassen der gedrückten Maustaste. --- **Beispiel** ```powershell $button.Add_MouseDown({ param($sender, $e) Write-Host "Taste gedrückt." }) ```
MouseUp #### **MouseUp** Das `MouseUp`-Event wird ausgelöst, sobald eine gedrückte Maustaste wieder losgelassen wird. --- **Beispiel** ```powershell $button.Add_MouseUp({ Write-Host "Taste losgelassen." }) ```
MouseEnter #### **MouseEnter** Das `MouseEnter`-Event wird ausgelöst, wenn sich der Mauszeiger erstmals über dem Button befindet. Es wird häufig verwendet, um beispielsweise Informationen einzublenden oder das Aussehen eines Controls zu verändern. --- **Beispiel** ```powershell $button.Add_MouseEnter({ $button.BackColor = "LightBlue" }) ```
MouseLeave #### **MouseLeave** Das `MouseLeave`-Event wird ausgelöst, wenn der Mauszeiger den Button wieder verlässt. --- **Beispiel** ```powershell $button.Add_MouseLeave({ $button.BackColor = "White" }) ```
MouseMove #### **MouseMove** Das `MouseMove`-Event wird fortlaufend ausgelöst, während sich der Mauszeiger innerhalb des Buttons bewegt. Über die Ereignisparameter können die aktuellen Mauskoordinaten abgefragt werden. --- **Beispiel** ```powershell $button.Add_MouseMove({ param($sender, $e) Write-Host "$($e.X), $($e.Y)" }) ```
GotFocus #### **GotFocus** Das `GotFocus`-Event wird ausgelöst, sobald der Button den Tastaturfokus erhält. --- **Beispiel** ```powershell $button.Add_GotFocus({ Write-Host "Button besitzt den Fokus." }) ```
LostFocus #### **LostFocus** Das `LostFocus`-Event wird ausgelöst, wenn der Button den Tastaturfokus verliert. --- **Beispiel** ```powershell $button.Add_LostFocus({ Write-Host "Fokus verloren." }) ```
KeyDown #### **KeyDown** Das `KeyDown`-Event wird ausgelöst, sobald eine Taste gedrückt wird, während der Button den Fokus besitzt. --- **Beispiel** ```powershell $button.Add_KeyDown({ param($sender, $e) if ($e.KeyCode -eq "Enter") { Write-Host "Enter" } }) ```
KeyPress #### **KeyPress** Das `KeyPress`-Event wird ausgelöst, wenn ein druckbares Zeichen eingegeben wird. Es eignet sich insbesondere zur Verarbeitung einzelner Zeichen. --- **Beispiel** ```powershell $button.Add_KeyPress({ param($sender, $e) Write-Host $e.KeyChar }) ```
KeyUp #### **KeyUp** Das `KeyUp`-Event wird ausgelöst, sobald eine gedrückte Taste wieder losgelassen wird. --- **Beispiel** ```powershell $button.Add_KeyUp({ Write-Host "Taste losgelassen." }) ```
--- ## **Tipps & Tricks** #### Standard-Button eines Dialogs festlegen Über die Eigenschaft `AcceptButton` eines Formulars kann festgelegt werden, welcher Button beim Drücken der **Eingabetaste** automatisch ausgelöst wird. ```powershell $form.AcceptButton = $button ``` #### Abbrechen-Button festlegen Über die Eigenschaft `CancelButton` kann ein Button festgelegt werden, der beim Drücken der **Esc-Taste** ausgelöst wird. ```powershell $form.CancelButton = $cancelButton ``` #### Eigenes Icon links neben dem Text anzeigen ```powershell $button.Image = [System.Drawing.Image]::FromFile("Save.png") $button.ImageAlign = "MiddleLeft" $button.TextImageRelation = "ImageBeforeText" $button.Text = "Speichern" ``` #### Button farbig darstellen Damit `BackColor` verwendet wird, muss die Windows-Designfarbe deaktiviert werden. ```powershell $button.UseVisualStyleBackColor = $false $button.BackColor = "RoyalBlue" $button.ForeColor = "White" ```