Optionsgruppe leeren mit Klasse

2021, 5/2021, Formulare und Steuerelemente

Optionsgruppen sind praktische Steuerelemente für die Auswahl einiger weniger, vorab fest definierter Optionen. Leider bietet dieses Steuerelement nach einmaliger Auswahl nicht mehr die Möglichkeit, dieses wieder zu leeren. Im vorliegenden Beitrag schauen wir uns an, wie das grundsätzlich zu erledigen ist. Außerdem erstellen wir eine Klasse, mit der Sie den dazu benötigten Code für die Nutzung in mehreren Optionsgruppen wiederverwenden können, statt ihn jedes Mal zu reproduzieren.

Vorbereitung

Für die Beispiele in diesem Beitrag legen wir ein Formular mit einer Optionsgruppe namens ogr-Optionen an. Dieser fügen wir drei Optionen hinzu, deren Wert für die Eigenschaft Optionswert wir auf 1, 2 und 3 festlegen und die wir opt1, opt2 und opt3 benennen. Der Entwurf dieses Formulars sieht wie in Bild 1 aus.

Entwurf des Formulars mit der Optionsgruppe

Bild 1: Entwurf des Formulars mit der Optionsgruppe

Dieses Formular kopieren wir direkt einmal, und zwar unter dem Namen frmOptionenMitKlasse. Wir schauen uns also zuerst an, wie wir das Leeren der Optionsgruppe direkt im Klassenmodul des Formulars erledigen.

Danach programmieren wir Klassen, mit denen wir das Verhalten abbilden und wiederverwendbar machen, und wenden diese in der Kopie des Formulars an.

Gewünschtes Verhalten

Wir wollen erreichen, dass der Benutzer sowohl mit der Maus als auch mit der Tastatur eine einmal getätigte Auswahl in der Optionsgruppe wieder rückgängig machen kann.

Dazu untersuchen wir zwei Ereignisse: das Loslassen der linken Maustaste sowie das Betätigen der Leertaste. Hier prüfen wir jeweils, ob die aktuelle Option gerade aktiviert ist, und nur in diesem Fall soll die Optionsgruppe geleert werden.

Ereignisse zum Abbilden des Verhaltens

Dazu nutzen wir zwei Ereignisse der jeweiligen Optionsfelder, nämlich Bei Maustaste auf und Bei Taste auf. Diese legen wir für alle vorhandenen Optionsfelder an. Für das erste Optionsfeld sieht das im ersten Schritt dann wie folgt aus:

Private Sub opt1_MouseUp(Button As Integer,  Shift As Integer, X As Single, Y As Single)
End Sub
Private Sub opt1_KeyUp(KeyCode As Integer,  Shift As Integer)
End Sub

Hier brauchen wir nun Action. Für das Loslassen des Mauszeigers sieht das wie folgt aus:

  • Prüfen, ob die linke Maustaste gedrückt wurde
  • Prüfen, ob die Maus vor dem Loslassen die aktuell selektierte Option angeklickt hat
  • Dann die Optionsgruppe leeren

Für das Ereignis Bei Taste auf stehen folgende Aufgaben an:

  • Prüfen, ob die Leertaste gedrückt wurde
  • Prüfen, ob beim Betätigen der Leertaste der Fokus auf der aktuell selektierten Option liegt
  • Dann die Optionsgruppe leeren

Individueller Code für diese Optionsgruppe

Die Lösung für die eingangs beschriebene Optionsgruppe finden Sie in Listing 1. Wir kümmern uns zunächst um die Maus-ereignisse. Dazu schauen wir uns den Code für das Ereignis opt1_MouseUp an. Die Prozedur vergleicht zunächst den Wert des Parameters Button mit dem Wert der Konstanten acLeftButton und prüft damit, ob der Benutzer überhaupt die linke Maustaste gedrückt hat.

Private Sub opt1_MouseUp(Button As Integer, Shift As Integer, X As Single, Y As Single)
     If Button = acLeftButton Then
         UpdateOptiongroup Me!ogrOptionen, Me!opt1
     End If
End Sub
Private Sub opt2_MouseUp(Button As Integer, Shift As Integer, X As Single, Y As Single)
     If Button = acLeftButton Then
         UpdateOptiongroup Me!ogrOptionen, Me!opt2
     End If
End Sub
Private Sub opt3_MouseUp(Button As Integer, Shift As Integer, X As Single, Y As Single)
     If Button = acLeftButton Then
         UpdateOptiongroup Me!ogrOptionen, Me!opt3
     End If
End Sub
Private Sub opt1_KeyUp(KeyCode As Integer, Shift As Integer)
      Select Case KeyCode
          Case vbKeySpace
              UpdateOptiongroup Me!ogrOptionen, Me!opt1
      End Select
End Sub
Private Sub opt2_KeyUp(KeyCode As Integer, Shift As Integer)
      Select Case KeyCode
          Case vbKeySpace
              UpdateOptiongroup Me!ogrOptionen, Me!opt2
      End Select
End Sub
Private Sub opt3_KeyUp(KeyCode As Integer, Shift As Integer)
      Select Case KeyCode
          Case vbKeySpace
              UpdateOptiongroup Me!ogrOptionen, Me!opt2
      End Select
End Sub
Private Sub UpdateOptiongroup(ogr As OptionGroup, opt As OptionButton)
      If ogr = opt.OptionValue Then
          ogr = Null
      End If
End Sub

Listing 1: Prozeduren, um die aktuelle Option wieder abzuwählen

Ist das der Fall, ruft die Ereignisprozedur eine weitere Prozedur namens UpdateOptiongroup auf und übergibt dieser als Parameter einen Verweis auf die Optionsgruppe sowie auf das angeklickte Optionsfeld. Diese Prozedur prüft, ob der Wert der Optionsgruppe (aus dem Parameter ogr) mit dem Wert des Optionsfeldes (aus dem Parameter opt) übereinstimmt. In diesem Fall stellt sie den Wert der Optionsgruppe aus dem Parameter ogr auf Null ein.

Auf die gleiche Weise programmieren wir die Prozeduren für das Ereignis Bei Maustaste auf der anderen Optionsfelder. Die Prozeduren opt1_KeyUp, opt2_KeyUp und opt3_KeyUp werden beim Betätigen von Tasten ausgelöst. Hier prüfen wir, welche Taste der Benutzer gedrückt hat, denn das Ereignis wird beim Betätigen jeder Taste ausgelöst. Also vergleichen wir den Wert des Parameters KeyCode mit der Konstanten für die Leertaste, vbKeySpace. Sind die beiden gleich, rufen wir wieder die bereits beschriebene Prozedur UpdateOptiongroup auf und übergeben die entsprechenden Parameter.

Optionsgruppe leeren wiederverwendbar machen

Nun haben Sie bereits gesehen, dass es relativ viel Aufwand ist, den Code für eine Optionsgruppe zu schreiben. Wollen Sie den Code für eine weitere Optionsgruppe nutzen, reicht einfaches Kopieren nicht aus, denn Sie müssen diesen auch noch an die jeweiligen Steuerelementbezeichnungen und Optionswerte anpassen.

Deshalb wollen wir zwei Klassen programmieren, welche dies automatisch erledigen – und die Sie für jede betroffene Optionsgruppe einfach nur noch zu deklarieren, initialisieren und zuzuweisen brauchen.

Wir brauchen zwei Klassen, weil wir erstens die Optionsgruppen damit erfassen wollen und dort in einer Auflistung in einer zweiten Klasse die Optionsfelder. In dieser zweiten Klasse definieren wir die Ereignisse, die durch Bei Maustaste auf und Bei Taste auf ausgelöst werden.

Klasse zum Kapseln der Optionsfelder

Die Klasse, mit der wir jeweils ein Optionsfeld erfassen, heißt clsOptionbutton. Diese Klasse finden Sie in der Übersicht in Listing 2.

Private WithEvents m_OptionButton As OptionButton
Private m_OptionGroup As OptionGroup
Public Property Set OptionButton(opt As OptionButton)
     Set m_OptionButton = opt
     With m_OptionButton
         .OnMouseUp = "[Event Procedure]"
         .OnKeyUp = "[Event Procedure]"
     End With
End Property
Public Property Set OptionGroup(grp As OptionGroup)
     Set m_OptionGroup = grp
End Property
Private Sub m_OptionButton_KeyUp(KeyCode As Integer, Shift As Integer)
     Select Case KeyCode
         Case vbKeySpace
             UpdateOptiongroup m_OptionGroup, m_OptionButton
     End Select
End Sub
Private Sub m_OptionButton_MouseUp(Button As Integer, Shift As Integer, X As Single, _
         Y As Single)
     If Button = acLeftButton Then
         UpdateOptiongroup m_OptionGroup, m_OptionButton
     End If
End Sub
Private Sub UpdateOptiongroup(ogr As OptionGroup, opt As OptionButton)
     If ogr = opt.OptionValue Then
         ogr = Null
     End If
End Sub

Listing 2: Code der Klasse clsOptionButton

Sie deklariert eine Variable namens m_OptionButton für das OptionButton-Element, das sie aufnehmen soll, und legt für dieses das Schlüsselwort WithEvents fest. Dadurch können wir in dieser Klasse Ereignisprozeduren für das OptionButton-Element definieren. Außerdem definiert sie eine weitere Variable namens m_OptionGroup. Diese soll einen Verweis auf das OptionGroup-Steuerelement erhalten, den wir später in den Ereignisprozeduren benötigen.

Die erste Property Set-Methode bietet die Möglichkeit, der Klasse einen Verweis auf das zu verwendende OptionButton-Steuerelement zu übergeben, und zwar mit dem Parameter opt. Den Inhalt dieses Parameters weist die Prozedur der Variablen m_OptionButton zu. Anschließend legt sie für die beiden Eigenschaften OnMouseUp und OnKeyUp den Wert [Event Procedure] fest.

Das ist der Schritt neben dem Schlüsselwort WithEvents, um nicht nur das Anlegen, sondern auch das Auslösen von Ereignisprozeduren für dieses Steuerelement in der aktuellen Klasse zu ermöglichen.

Die zweite Property Set-Prozedur erlaubt das Zuweisen eines Verweises auf das betroffene OptionGroup-Steuerelement zu der Variablen m_OptionGroup.

Nun fehlen noch die Ereignisprozeduren. Diese legen Sie an, indem Sie im Kopf des Klassenmoduls im linken Kombinationsfeld den Eintrag m_OptionButton auswählen und im rechten einmal OnMouseUp und einmal OnKeyUp. Beim ersten Auswählen von m_OptionButton wird automatisch die Ereignisprozedur für das Click-Ereignis angelegt – diese können Sie gleich wieder entfernen.

Die Prozedur m_OptionButton_KeyUp füllen wir prinzipiell mit den gleichen Anweisungen wie die aus den obigen Beispielen, wo wir die Programmierung für jedes Optionsfeld einzeln vorgenommen haben.

Der erste Unterschied ist die Bezeichnung (m_OptionButton_KeyUp statt opt1_KeyUp). Der zweite und wichtigste Unterschied sind die Parameter, mit denen die Prozedur UpdateOptiongroup aufgerufen wird. Hier verwenden wir nun die beiden privat deklarierten und zuvor gefüllten Variablen m_OptionGroup und m_OptionButton.

Die Prozedur UpdateOptiongroup wiederum haben wir wie im einführenden Beispiel beibehalten.

Die Prozedur m_OptionButton_MouseUp erwartet die gleichen Anpassungen gegenüber dem Eingangsbeispiel, also ein neuer Prozedurname sowie die Verwendung von m_OptionGroup und m_OptionButton als Parameter beim Aufruf von Update-Optiongroup.

Ende des frei verfügbaren Teil. Wenn Du mehr lesen möchtest, hole Dir ...

den kompletten Artikel im PDF-Format mit Beispieldatenbank

diesen und alle anderen Artikel mit dem Jahresabo

Schreibe einen Kommentar