twinBASIC: Daten von Form zu Form

Wenn man mit SDI-Forms arbeiten, also mit solchen Formularen, die als einzelne Fenster geöffnet werden, möchte man manchmal eine der folgenden beiden Aufgaben erledigen – oder auch beide: Das aufrufende Formular soll Daten an das aufgerufene Formular übergeben, beispielsweise um den Primärschlüssel eines im Detailformular anzuzeigenden Datensatzes zu übergeben. Oder man möchte ein Formular zum Abfragen von Daten öffnen und diese dann vom aufrufenden Formular aus aufrufen. Wie beides gelingt und welche unterschiedlichen Wege es dazu gibt, schauen wir uns in diesem Artikel an. Außerdem betrachten wir, welche Arten von Daten man grundsätzlich übertragen können sollte.

Es wird immer wieder Anlässe geben, bei denen wir einen Button auf einer Form verwenden, um eine andere Form damit zu öffnen. In manchen Fällen reicht dies aus – wir verwenden die andere Form dann für einen Zweck, der in sich abgeschlossen ist. In vielen Fällen wird es jedoch so sein, dass wir Daten von einem zum anderen Fenster übergeben wollen – und vielleicht auch wieder zurück. Ein Beispiel sind Forms, die an Daten gebunden sind. Wenn wir etwa ein Form-Objekt nutzen, um darauf eine Liste von Produkten anzuzeigen, wollen wir meist auch ein weiteres Form verwenden, um die Details eines einzelnen Produkts zu liefern – beispielsweise um diese bearbeiten zu können. Wenn wir dann einen der Einträge in der Liste markieren und auf eine Schaltfläche klicken, um die Form mit den Details anzuzeigen, müssen wir dieser Form auf irgendeine Weise die Information übergeben, zu welchem Produkt es die Detaildaten anzeigen soll.

Andersherum wollen wir nach dem Bearbeiten des Produkts oder auch nach dem Anlegen eines neuen Produkts und dem Schließen des Detailfensters Informationen an das aufrufende Fenster zurückgeben – zum Beispiel, weil wir den soeben bearbeiteten oder angelegten Datensatz in der Liste markieren wollen oder weil die Änderungen in den Daten direkt in den dort angezeigten Eintrag übernommen werden sollen.

Es gibt auch noch einfachere Beispiele, die es bereits gibt – zum Beispiel das mit der Funktion MsgBox angezeigte Meldungsfenster oder das mit InputBox angezeigte Eingabefenster für einen einfachen Text.

Wenn wir einmal Daten vom Benutzer abfragen wollen, die zu umfangreich sind als jene, die wir mit MsgBox und InputBox ermitteln können, müssen wir eigene Forms dafür entwickeln – und die dort ermittelten Daten wollen wir auf irgendeine Weise für die Weiterverarbeitung auslesen.

Weitere Beispiele für das Übertragen von Daten

Beispiele für das Übertragen von Daten zwischen zwei Form-Objekten sind die folgenden:

• Anmeldeformular
• Suchformular
• Einstellungen und Konfigurationen
• Übertragung der ID eines ausgewählten Datensatzes von einer Hauptform zur Bearbeitungsform.
• Workflows über mehrere Forms

Möglichkeiten zur Übertragung von Daten an die zu öffnende Form

Im Folgenden schauen wir uns verschiedene Möglichkeiten an, wie wir Daten vom aufrufenden Form-Objekt zum aufgerufenen Form-Objekt und zurück übergeben können:

• Zwischenspeichern in einer globalen Variablen, die von der aufrufenden Form aus gefüllt und von der aufgerufenen Form aus ausgelesen wird und umgekehrt
• Wenn der zu übergebende Wert in einem Steuerelement der aufrufenden Form enthalten ist, können wir dieses von der aufgerufenen Form aus auslesen.
• Übergeben der Informationen von der aufrufenden Form an eine öffentliche Eigenschaft der aufgerufenen Form. Diese kann von der aufgerufenen Form auch geändert werden, damit wir den Wert wieder in die aufrufende Form zurückholen können.

Von Form zu Form mit einer globalen Variablen

Die Verwendung einer globalen Variablen ist ein Weg, mit dem wir Daten zwar nicht direkt von einer Form zur nächsten übertragen, aber wir können so einen Wert von der ersten Form aus so zur Verfügung stellen, dass die aufgerufene Form diesen auch nutzen kann. Der Nachteil ist, dass dieser Wert nicht nur von den beiden Forms gelesen und geschrieben werden kann, die ihn nutzen, sondern auch noch von anderen Stellen aus. Hier ist also sicherzustellen, dass diese Variable nur für diesen speziellen Zweck verwendet wird – beispielsweise durch einen eindeutigen Namen.

Für das Beispiel benötigen wir als Erstes eine globale Variable, in der wir den zu übergebenden Wert speichern können. Diese legen wir in einem neuen Modul namens mdlGlobal unter dem Namen strGlobal an (siehe Bild 1). Da wir nur Texte von einem Textfeld zum nächsten übertragen wollen, reicht der Datentyp String aus.

Bild 1: Globale Variable

Im Formular frmMain haben wir ein Textfeld namens txtValue erstellt, in das wir den zu übertragenden Wert eintragen. Für die Schaltfläche cmdSendViaGlobalVariable haben wir den folgenden Code hinterlegt:

Private Sub cmdSendViaGlobalVariable_Click()
     If Not Len(txtValue) = 0 Then
         strGlobal = txtValue
         frmGlobalVariable.Show
     Else
         MsgBox "Textfeld ist leer."
     End If
End Sub

Dieser prüft, ob überhaupt ein Text enthalten ist – falls nicht, erscheint eine entsprechende Meldung. Anderenfalls schreibt die Prozedur den Inhalt des Textfeldes in die Variable strGlobal und ruft die Form frmGlobalVariable auf. Diese Form enthält ebenfalls ein Textfeld namens txtValue sowie eine Schaltfläche namens cmdOK. Das Textfeld txtValue soll mit dem Wert aus dem gleichnamigen Textfeld des aufrufenden Formulars gefüllt werden.

Dazu legen wir in der aufgerufenen Form eine Ereignisprozedur für das Ereignis Load an. Dieses sieht wie folgt aus:

Private Sub Form_Load()
     Me.txtValue = strGlobal
End Sub

Damit erhalten wir das Ergebnis aus Bild 2.

Bild 2: Text per globaler Variable zum aufgerufenen Formular übertragen

Auslesen des zu übergebenden Wertes aus einem Steuerelement

Die nächste Möglichkeit setzt voraus, dass der zu übergebende Wert in einem Steuerelement im aufrufenden Form-Element angezeigt wird – wie in unserem Beispiel im Textfeld txtValue. Wir rufen dann die zweite Form auf und können dann von dort aus dem Wert des Textfeldes auslesen und in das Textfeld der Zielform eintragen. Dazu fügen wir frmMain eine zweite Schaltfläche namens cmdReadValueFromControl zu, die folgende Prozedur aufruft:

Private Sub cmdReadValueFromControl_Click()
     If Not Len(txtValue) = 0 Then
         frmReadValueFromControl.Show
     Else
         MsgBox "Textfeld ist leer."
     End If
End Sub

Sie soll also einfach die Form frmReadValueFromControl aufrufen. Für die Load-Ereigniseigenschaft dieser Form könnten wir einfach die folgende Ereignisprozedur hinterlegen:

Private Sub Form_Load()
     Me.txtValue.Text = frmMain.txtValue
End Sub

Das funktioniert, sofern die aufrufende Form frmMain aktuell geöffnet ist. Wenn die aufgerufene Form frmReadValueFromControl allerdings von einem anderen Form-Objekt geöffnet wird und frmMain nicht geöffnet ist, erhalten wir einen Fehler.

Diesen können wir allerdings umgehen, indem wir prüfen, ob die Form geöffnet ist. Dazu erweitern wir die Prozedur wie folgt:

Private Sub Form_Load()
     If IsFormOpen("frmMain") Then
         Me.txtValue.Text = frmMain.txtValue
     End If
End Sub

Die Funktion IsFormOpen ist allerdings keine eingebaute Funktion, wir müssen diese selbst programmieren. Die Funktion erwartet den Namen des zu untersuchenden Formulars und gibt den Wert True zurück, wenn es geöffnet ist. Sie durchläuft in einer For…Next-Schleife alle Zahlen von 0 bis zur Anzahl der geöffneten Formulare minus 1. In dieser Schleife vergleicht sie den Namen des aktuell durchlaufenen Formulars mit dem zu untersuchenden. Sind beide gleich, ist das Formular geöffnet und die Funktion kann den Wert True zurückgeben, bevor sie beendet wird.

Public Function IsFormOpen(strForm As String) As Boolean
     Dim i As Integer
     For i = 0 To Forms.Count - 1
         If Forms(i).Name = strForm Then
             Return True
             Exit Function
         End If
     Next i
End Function

Username or Email

Passwort

Angemeldet bleiben