Visual Basic Grundlagen - · PDF file4 12 grundlagen der programmierung.....41 12.1...
Transcript of Visual Basic Grundlagen - · PDF file4 12 grundlagen der programmierung.....41 12.1...
Universitätsrechenzentrum
Johannes GogolokAbt. Wiss. Anwendungen
URZ B/009/9911
Visual BasicGrundlagen
2
R E I H E : I N T E G R I E R T E S Y S T E M E
Visual Basic Grundlagen
© FernUniversität HagenNovember 1999
3
Inhaltsangabe1 VORWORT ....................................................................................................................................... 6
2 PROGRAMMENTWICKLUNG MIT VISUAL BASIC ....................................................................... 7
3 AUFBAU EINES VISUAL BASIC - PROGRAMMS ......................................................................... 7
4 DIE WICHTIGSTEN BEDIENUNGSELEMENTE............................................................................. 84.1 DIE OBERFLÄCHE ........................................................................................................................ 84.2 DAS PROJEKTFENSTER................................................................................................................ 84.3 DAS FORMULARENTWURFSFENSTER ............................................................................................ 94.4 DAS EIGENSCHAFTEN - FENSTER ................................................................................................. 94.5 DIE WERKZEUGSAMMLUNG / TOOLBOX....................................................................................... 104.6 DIE MENÜ- UND SYMBOLLEISTE ................................................................................................. 104.7 DAS FARBPALETTEN - FENSTER ................................................................................................. 104.8 DAS MENÜENTWURFS - FENSTER............................................................................................... 114.9 DAS PROGRAMMCODE - FENSTER .............................................................................................. 11
5 ZWEI BEISPIELPROGRAMME ..................................................................................................... 125.1 BEISPIEL 1 ................................................................................................................................ 125.2 BEISPIEL 2 ................................................................................................................................ 12
6 VISUAL BASIC SCHRITT FÜR SCHRITT (TEIL 1 - FORMULARENTWURF)............................. 136.1 EINFÜGEN VON STEUERELEMENTEN IN EIN FORMULAR ................................................................ 136.2 STEUERELEMENTE BESCHRIFTEN ............................................................................................... 136.3 FORMULAREIGENSCHAFTEN SETZEN........................................................................................... 136.4 DER MENÜENTWURF ................................................................................................................. 14
7 DEN PROGRAMMCODE SCHREIBEN......................................................................................... 15
8 VISUAL BASIC SCHRITT FÜR SCHRITT (TEIL2 - EREIGNISPROZEDUREN).......................... 178.1 STEUERUNG ÜBER BEFEHLSSCHALTFLÄCHEN.............................................................................. 178.2 STEUERUNG ÜBER MENÜLEISTE ................................................................................................. 17
9 VISUAL BASIC SCHRITT FÜR SCHRITT (TEIL3 - PROGRAMMAUFRUF)................................ 19
10 VISUAL BASIC SCHRITT FÜR SCHRITT (TEIL4 - EXE-DATEI ERSTELLEN) ....................... 19
11 FORMULARGESTALTUNG....................................................................................................... 2011.1 GRUNDEIGENSCHAFTEN............................................................................................................. 2011.2 FORMULARSTEUERELEMENTE..................................................................................................... 20
11.2.1 Zeiger ............................................................................................................................... 2111.2.2 Linie.................................................................................................................................. 2111.2.3 Figur ................................................................................................................................. 2111.2.4 Bezeichnungsfeld ............................................................................................................. 2111.2.5 Textfeld............................................................................................................................. 2111.2.6 Befehlsschaltfläche .......................................................................................................... 2211.2.7 Programmbeispiel 1 ......................................................................................................... 2311.2.8 Bildlaufleisten ................................................................................................................... 2611.2.9 Programmbeispiel 2 ......................................................................................................... 2611.2.10 Kontroll- und Optionsfelder ........................................................................................... 2711.2.11 Programmbeispiel 3...................................................................................................... 2811.2.12 Listen- und Kombinationsfelder .................................................................................... 3111.2.13 Programmbeispiel 4...................................................................................................... 3111.2.14 Programmbeispiel 5...................................................................................................... 34
11.3 ARRAYS VON STEUERELEMENTEN .............................................................................................. 3711.3.1 Erstellung im Entwurfsmodus........................................................................................... 3711.3.2 Erstellung zur Laufzeit ...................................................................................................... 3811.3.3 Programmbeispiel 6 ......................................................................................................... 38
4
12 GRUNDLAGEN DER PROGRAMMIERUNG............................................................................. 4112.1 KONVENTIONEN FÜR EIN VISUAL BASIC - PROGRAMM.................................................................. 4112.2 ANWEISUNGEN .......................................................................................................................... 4112.3 VARIABLEN................................................................................................................................ 42
12.3.1 Variablendeklaration......................................................................................................... 4212.3.2 Geltungsbereich der Variablen......................................................................................... 42
12.4 KONSTANTEN ............................................................................................................................ 4312.4.1 Integrierte Konstanten ...................................................................................................... 4312.4.2 Symbolische Konstanten.................................................................................................. 43
12.5 VARIABLENTYPEN ...................................................................................................................... 4412.5.1 Datentyp Variant............................................................................................................... 4412.5.2 Grunddatentypen.............................................................................................................. 4412.5.3 Numerische Datentypen................................................................................................... 4512.5.4 Datentyp String................................................................................................................. 4612.5.5 Datentyp Boolean............................................................................................................. 4612.5.6 Datentyp Date .................................................................................................................. 4612.5.7 Datentyp Objekt................................................................................................................ 46
12.6 DATENFELDER (ARRAYS) ........................................................................................................... 4712.6.1 Dynamische Datenfelder .................................................................................................. 4712.6.2 Programmbeispiel 7 ......................................................................................................... 48
12.7 BENUTZERDEFINIERTE DATENTYPEN .......................................................................................... 50
13 OPERATOREN, FUNKTIONEN, ANWEISUNGEN.................................................................... 5113.1 ARITHMETISCHE OPERATOREN................................................................................................... 5113.2 VERGLEICHSOPERATOREN ......................................................................................................... 5113.3 LOGISCHE OPERATOREN............................................................................................................ 5213.4 VERKETTUNGSOPERATOREN ...................................................................................................... 5313.5 INTERNE FUNKTIONEN................................................................................................................ 53
13.5.1 Mathematische Funktionen .............................................................................................. 5313.5.2 Zeichenfolge - Funktionen................................................................................................ 5413.5.3 Datums- und Zeitfunktionen (Auswahl) ............................................................................ 5513.5.4 Dateifunktionen ................................................................................................................ 5513.5.5 Sonstige Funktionen (Auswahl)........................................................................................ 55
13.6 KONTROLLSTRUKTUREN............................................................................................................. 5613.6.1 Entscheidungen................................................................................................................ 5613.6.2 Schleifen........................................................................................................................... 5813.6.3 Auswahlfunktionen ........................................................................................................... 61
14 EIN- UND AUSGABE.................................................................................................................. 6214.1 DIALOGFELDER.......................................................................................................................... 62
14.1.1 Message Box (MsgBox) ................................................................................................... 6214.1.2 Input Box .......................................................................................................................... 63
14.2 PROGRAMMBEISPIEL 8. .............................................................................................................. 6414.3 MAUSEREIGNISSE...................................................................................................................... 6614.4 PROGRAMMBEISPIEL 9 ............................................................................................................... 6714.5 BEISPIELPROGRAMM 10 ............................................................................................................. 6814.6 TASTATUREREIGNISSE ............................................................................................................... 6914.7 BEISPIELPROGRAMM 11 ............................................................................................................. 70
15 DATEIVERARBEITUNG (GRUNDLAGEN)................................................................................ 7215.1 DATEISYSTEM - STEUERELEMENTE............................................................................................. 7215.2 BEISPIELPROGRAMM 13 ............................................................................................................. 73
15.2.1 Die Attributeigenschaften des Dateilistenfeldes ............................................................... 7615.3 SCHREIBEN UND LESEN IN DATEIEN (AM BEISPIEL SEQUENTIELLER DATEIEN)............................... 76
15.3.1 Schritte des Dateizugriffs ................................................................................................. 7715.4 SEQUENTIELLER DATEIZUGRIFF.................................................................................................. 77
15.4.1 Eine sequentielle Datei zum Lesen öffnen. ...................................................................... 7715.4.2 Eine sequentielle Datei zum Schreiben öffnen................................................................. 7815.4.3 Eine sequentielle Datei zum Anhängen öffnen................................................................. 7815.4.4 Die Anweisungen Write # und Input # .............................................................................. 79
15.5 BEISPIELPROGRAMM 14 ............................................................................................................. 79
5
AbbildungsverzeichnisABBILDUNG 1: DIE VB - OBERFLÄCHE ................................................................................................................... 8ABBILDUNG 2: FENSTER DES PROJEKT - EXPLORERS.......................................................................................... 8ABBILDUNG 3: DAS FORMULARFENSTER ............................................................................................................... 9ABBILDUNG 4: DAS EIGENSCHAFTSFENSTER ........................................................................................................ 9ABBILDUNG 5: DIE WERKZEUGSAMMLUNG .......................................................................................................... 10ABBILDUNG 6: DIE MENÜ- UND SYMBOLLEISTE ................................................................................................... 10ABBILDUNG 7: DIE FARBENPALETTE .................................................................................................................... 10ABBILDUNG 8: DER MENÜ - EDITOR..................................................................................................................... 11ABBILDUNG 9: DAS PROGRAMMCODE - FENSTER ............................................................................................... 11ABBILDUNG 10: EINFACHES PROGRAMM UND DESSEN ERGEBNIS...................................................................... 12ABBILDUNG 11: ERGEBNIS DES ZWEITEN BEISPIELS........................................................................................... 12ABBILDUNG 12: FORMULAR VERSION 1 ............................................................................................................... 13ABBILDUNG 13: FORMULAR VERSION 2 ............................................................................................................... 14ABBILDUNG 14: MENÜDEFINITION ........................................................................................................................ 14ABBILDUNG 15: FERTIGES FORMULAR MIT MENÜLEISTE .................................................................................... 15ABBILDUNG 16: DAS PROGRAMMCODE - FENSTER ............................................................................................. 16ABBILDUNG 17: FORMULAR NACH PROGRAMMDURCHLAUF ................................................................................ 19ABBILDUNG 18: FORMULAR DES PROGRAMMBEISPIELS 1................................................................................... 23ABBILDUNG 19: BEGINN DER VARIABLENDEFINITION........................................................................................... 24ABBILDUNG 20: FORMULAR NACH DER BERECHNUNG......................................................................................... 25ABBILDUNG 21: MODIFIZIERTE OBERFLÄCHE DES BEISPIELS 1.......................................................................... 27ABBILDUNG 22: FORMULAR DES BEISPIELS 3...................................................................................................... 28ABBILDUNG 23: FORMULAR AUS BEISPIEL 3 NACH PROGRAMMAUSFÜHRUNG ................................................... 30ABBILDUNG 24: EIN LISTENFELD .......................................................................................................................... 31ABBILDUNG 25: BEISPIEL ZUR LISTENFELDANWENDUNG .................................................................................... 31ABBILDUNG 26: FORMULAR DES PROGRAMMBEISPIELS 5................................................................................... 35ABBILDUNG 27: INFO - DIALOG BEI GENERIERUNG EINES ELEMENTENARRAYS ................................................. 37ABBILDUNG 28: FORMULAR FÜR ARRAYS VON ELEMENTEN................................................................................ 38ABBILDUNG 29: ZUR LAUFZEIT ERSTELLTES ARRAY VON ELEMENTEN.............................................................. 40ABBILDUNG 30: FORMULAR DES BEISPIELS 7...................................................................................................... 48ABBILDUNG 31: FORMULAR NACH DEM FÜLLEN DER COMBOBOX...................................................................... 49ABBILDUNG 32: REDUKTION OHNE PRESERVE .................................................................................................... 49ABBILDUNG 33: REDUKTION MIT PRESERVE ........................................................................................................ 50ABBILDUNG 34: FORMULAR ZUM TESTEN DER INPUTBOX- UND MSGBOX - FORMEN ....................................... 64ABBILDUNG 35: FORMULAR FÜR MAUS - EREIGNISSE (1) ................................................................................... 67ABBILDUNG 36: REAKTION AUF MAUSEREIGNISSE (2) ........................................................................................ 68ABBILDUNG 37: FORMULAR VOR EINEM TASTATUREREIGNIS.............................................................................. 70ABBILDUNG 38: FORMULAR NACH EINEM TASTATUREREIGNIS............................................................................ 70ABBILDUNG 39: ORDNER UND DATEIAUSWAHL ................................................................................................... 73ABBILDUNG 40: AUSGABE DER DATEIPARAMETER .............................................................................................. 73ABBILDUNG 41: FORMULAR ZUR DATEIBEARBEITUNG ......................................................................................... 79ABBILDUNG 42: FORMULAR FÜR ERSTERFASSUNG ............................................................................................. 81
6
1 Vorwort
Basic (Beginners All Purpose Symbolic Instruction Code) entstand in den sechziger Jahrenals Einsteigerprogrammiersprache.Nach dem Erfolg des 1990 auf dem Markt erschienenen Windows 3.0 wurde aus der bisdahin weiter entwickelten einfachen Programmiersprache mit mittlerweile eigener Entwick-lungsumgebung parallel zu Turbo Pascal für Windows und Quic C für Windows das einfachzu handhabende Programmiersystem für die grafische Benutzeroberfläche - Visual Basic -entwickelt.Im Laufe der letzten 5 Jahre ist aus dem anfangs von professionellen Entwicklern noch mit-leidig belächelten Werkzeug, ein anerkannt sehr mächtiges und universell verwendbaresEntwicklungssystem für Windows - Anwendungen geworden, das nicht nur einfache Appli-kationen, sondern auch professionelle und umfangreiche kommerzielle Anwendungen er-stellen kann.Die hohe Akzeptanz von Visual Basic liegt in seiner Unkompliziertheit bei der Erstellung vonWindows - Applikationen und der relativ leichten Erlernbarkeit seiner Sprache - sowohl fürden Fortgeschrittenen, den Umsteiger als auch für Neueinsteiger ohne Programmierkennt-nisse.Die vorliegende Unterlage führt in die Grundprinzipien der Arbeit mit Visual Basic ein. Siebeschreibt die Grundelemente der Sprache, einfache Methoden und Verfahren der Arbeit mitVisual Basic und stellt eine Reihe von einfachen Problemlösungen vor. Die Erstellung vonOberflächen und einfachen Anwendungen wird an Prozedur- und Programmbeispielen er-läutert.Die im Text der Broschüre zu findenden Symbole kennzeichnen besondere Textabschnitte.Sie haben die folgende Bedeutung:
� Tips - zusätzliche Informationen aus der Praxis �
◆ Hinweise, die besonders beachtet werden sollten.
� Programmbeispiele / Lösungsvorschläge
7
2 Programmentwicklung mit Visual Basic
Die Entwicklung eines Programms in Visual Basic umfaßt zwei Hauptschritte:
• die visuelle Programmierung• die Code - ProgrammierungVisual Basic unterscheidet sich von anderen Programmiersprachen in einigen wesentlichenPunkten:
• es existiert kein Hauptprogramm im wesentlichen Sinne• die Programmentwicklung beginnt nicht mit dem Programmcode, sondern mit der
Erstellung eines Formulars in einem Grafik - Editor.• Visual Basic ist ereignisgesteuert• es existiert ein 64 KB - Limit für Zeichenketten und Felder• über DLL - Funktionen besitzt Visual Basic einen direkten Zugriff auf alle Funktionen des
Betriebssystems.In der Komponente visuelle Programmierung wird unter Verwendung von Visual Basic-Werkzeugen ohne Eingabe eines Codes der Entwurf eines Programms mit Hilfe der Mausund der Tastatur erstellt. Es ist hierfür lediglich die Kenntnis der Werkzeuge, ihrer Funkti-onsweise und der Einsatzart nötig.Bei der Code - Programmierung werden unter Verwendung eines Text - Editors Programm-komponenten in der Programmiersprache Visual Basic erstellt. Die Code - Programmierungist der Programmierung in anderen Programmiersprachen ähnlich, jedoch sehr viel einfa-cher.
3 Aufbau eines Visual Basic - Programms
Ein Visual Basic - Programm besteht aus mindestens einem Formular mit verschiedenenBedienungselementen (Buttons, Options-, Textfelder usw.). Die Bedienungselementewerden Steuerelemente genannt und dienen den Eingaben des Benutzers.Die Reaktion auf die Eingaben erfolgt durch die den Steuerelementen zugeordneteEreignisprozeduren.Die Ereignisprozeduren unterteilen sich in
• generelle Prozeduren, die nur innerhalb eines Formulars verwendet werden (auch lokaleProzeduren genannt)
• globale Prozeduren, die im gesamten Programm verwendet werden können (auchallgemeine Prozeduren genannt).
8
4 Die wichtigsten Bedienungselemente
4.1 Die OberflächeNach dem Start von Visual Basic erscheint die folgende Oberfläche:
Diese ist in einzelne Fenster unterteilt, deren Funktion nachstehend kurz erläutert wird.
4.2 Das ProjektfensterEin in Visual Basic zu generierendes Programm wird als Projekt verwaltet. Ein Projekt setztsich aus mehreren Dateien zusammen, die im Projektfenster
dargestellt werden. Dieses enthält eine Liste sämtlicher Formulardateien, Quelltextmoduleund Steuerelementdateien1.
1 Sollte das Projektfenster nach dem Start nicht sichtbar sein, kann es über die FunktionskombinationAnsicht / Projektexplorer aufgeblendet werden.
Abbildung 1: Die VB - Oberfläche
Abbildung 2: Fensterdes Projekt - Explorers
9
4.3 Das FormularentwurfsfensterZu jedem Projekt gibt es mindestens ein Fenster für den Formularentwurf. Beim Starteneines neuen Projekts wird auf dem Bildschirm automatisch ein erstes Entwurfsformularangezeigt:
Das Entwurfsformular besteht aus Rahmen und Titelleiste (Name = Form1), im Arbeitsbe-reich wird üblicherweise ein Raster bzw. Entwurfsgitter eingeblendet.Formular ist die Bezeichnung eines Visual Basic - Entwurfsfensters. Das Formular wird invielen Visual Basic - Programmen als Platzhalter für Steuerelemente verwendet.
4.4 Das Eigenschaften - FensterJedes Formular und seine Elemente werden durch eine Vielzahl von Parametern (z.B.Position, Höhe, Breite, Hintegrundfarbe usw.) definiert. Diese werden in Visual BasicEigenschaften genannt und in einem eigenen Fenster
als Liste geführt. Über diese Liste werden sämtliche Eigenschaften von Formen und Steue-relementen, die zu einem Projekt gehören, in der Entwurfsphase festgelegt und / odergeändert.
Abbildung 3: Das Formularfenster
Abbildung 4: DasEigenschaftsfenster
10
4.5 Die Werkzeugsammlung / ToolboxPrinzipiell stellt FORM1 schon ein Visual Basic - Programm dar: ein leeres Fenster, welchesmit Windows - Grundfunktionen (Vergrößern, Verkleinern, Schließen) manipuliert werdenkann. Eine solche Anwendung löst allerdings noch kein konkretes Anwenderproblem.Daher muß dieses Fenster noch mit Steuerelementen, die bestimmte Aktionen ausführen,gefüllt werden.Alle Steuerelemente, die zur Ausstattung von Visual Basic gehören, finden sich in derWerkzeugsammlung (Toolbox) am linken Bildschirmrand2:
Es wird unterschieden zwischen Steuerelementen, die standardmäßig zu Visual Basicgehören und solchen, die über zusätzliche Steuerelementdateien eingebunden werdenkönnen.
4.6 Die Menü- und SymbolleisteAllen Fenstern übergeordnet ist das Steuerungsfenster von Visual Basic. Von hier auswerden alle vorhandenen Fenster verwaltet.
Das Steuerungsfenster setzt sich aus der Menüleiste und der Symbolleiste zusammen.Einige Befehle der Menüleiste werden durch ein Symbol in der Symbolleiste repräsentiert.
4.7 Das Farbpaletten - FensterFormulare und Steuerelemente können in Visual Basic farblich gestaltet werden. Über dasFarbpaletten - Fenster:
können Vorder- und Hintergrundfarben im Entwurfsmodus gesetzt werden. Dabei kannentweder aus der vorhandenen Farbpalette gewählt werden oder es können eigene Farbendefiniert werden.
2 Die Anzahl und Art der Elemente ist von der Visual Basic - Version abhängig - hier die Standard – Leiste derVisual Basic 6.0 Professional Edition.
Abbildung 5: Die Werkzeugsammlung
Abbildung 6: Die Menü- und Symbolleiste
Abbildung 7: Die Farbenpalette
11
4.8 Das Menüentwurfs - FensterFür Formulare können individuelle Menüleisten3 definiert werden. Für die Definition vonMenüleisten steht ein eigenes Fenster zur Verfügung:
Ein zu definierendes Menü besteht aus einem Hauptmenü, das einen oder mehrere Einträgeenthält. Die Anwahl eines Haupmenüpunktes öffnet ein evtl. vorhandenes Untermenü mitweiteren Einträgen. Visual Basic unterstützt bis zu 6 Menüebenen (eine Haupt- und 5Untermenüebenen).
4.9 Das Programmcode - FensterSteuerelemente mit den ihnen zugeordneten Eigenschaften müssen zu einem lauffähigenProgramm verbunden werden. Dies geschieht über Programmanweisungen, die in einerfestgeschriebenen Codierung geschrieben werden müssen. Für die Eingabe des Quelltextesgibt es in Visual Basic das Codefenster:
Dieses Fenster arbeitet prozedurorientiert, d.h. es wird immer nur der Teil des Fenstersangezeigt,der zu der ausgewählten Prozedur gehört.
3 Siehe Beispielprogramm Kap. 8.2.
Abbildung 8: Der Menü - Editor
Abbildung 9: Das Programmcode - Fenster
12
5 Zwei Beispielprogramme
5.1 Beispiel 1Private Sub Form Paint ()
'Erstes Beispielprogramm4
ClsPrint "Das erste Beispielprogramm"
End Sub
Für das Formular Form1 tritt das PAINT - Ereignis5, wenn das Formular das erste Mal oderwiederholt auf dem Bildschirm angezeigt wird.Die PRINT - Methode wird zur Ausgabe von Zahlenwerten und Texten direkt ins Formular(nicht in Felder) verwendet.Die CLS - Methode löscht den Formularinhalt und setzt den Startpunkt für Textausgaben indie obere linke Ecke.
5.2 Beispiel 2Private Sub Command1_Click()'Zweites Beispielprogramm'Ausgabe einer Meldung im MeldungsfensterTitel = "Zweites Beispielprogramm"Meldung = "Mein zweites Beispielprogramm"MsgBox Meldung, , TitelEnd Sub
Hier wurde in das Formular eine Schaltfläche eingefügt. Die obige Prozedur wird ausgeführt,wenn diese Schaltfläche aktiviert (angeklickt) wird. Ausgegeben wird der Inhalt der VariablenMeldung. Die Ausgabe erfolgt in einer Meldungs – Box (MSGBOX). Diese Box erhält in derTitelleiste den in der Variablen Titel gespeicherten Text.Die MsgBox wird über die vor der Anweisung END SUB stehende Anweisung ausgegeben.Das Formular bleibt in der Oberfläche sichtbar (in der nachfolgenden Abbildung wurde esausgeschnitten).
4 Beachte: Kommentarzeilen beginnen mit einem Hochkomma5 Ereignisse - siehe Kap. 7
Abbildung 10: Einfaches Programm und dessenErgebnis
Abbildung 11: Ergebnis des zweiten Beispiels
13
6 Visual Basic Schritt für Schritt (Teil 1 - Formularentwurf)Am Beispiel eines einfachen Formulars wird im folgenden an Einzelschritten der Weg zumlauffähigen Visual Basic - Programm erläutert. Demonstriert werden zwei Lösungsalternati-ven:• Formular mit Befehlsschaltflächen
• Formular mit Menübedienung
6.1 Einfügen von Steuerelementen in ein Formular• Visual Basic starten oder, falls schon vorher gestartet und gearbeitet wurde, die
Funktionskombination Datei / Neues Projekt anwählen.
• Aus der Werkzeugsammlung (Toolbox) das Textfeld wählen (Bildsymbol ) unddreimal in der Form plazieren (siehe unten stehende Abbildung).
• Vor jedes Textfeld ein Bezeichnungsfeld (Bildsymbol ) plazieren.
• Im unteren Bereich der Form drei Befehlsschaltflächen (Bildsymbol ) einfügen.
6.2 Steuerelemente beschriften• Nacheinander die Bezeichnungsfelder Label1, Label2, Label3 markieren6 und im
Eigenschaftsfenster die Eigenschaft CAPTION in die Werte Seite a:, Seite b: und Seite c:ändern.
• Nacheinander die Befehlsschaltflächen Command1, Command2 und Command3markieren und im Eigenschaftsfenster die Eigenschaft CAPTION auf Rechnen, Wertelöschen und Beenden setzen.
• Die Texte innerhalb der Textfelder löschen, indem im Eigenschaftsfenster die Werte derEigenschaft TEXT gelöscht werden.
6.3 Formulareigenschaften setzen• Auf das Entwurfsformular klicken und im Eigenschaftsfenster die Eigenschaft CAPTION in
Quader - Volumen und Oberfläche ändern• Die Eigenschaften MINBUTTON und MAXBUTTON auf FALSE setzen - bewirkt das Ausblen-
den der Minimierungs- und Maximierungsfelder der Titelleiste nach dem Programmstart.• Die Eigenschaft BORDERSTYLE auf den Wert 3-FESTER DIALOG setzen - damit kann die
Formgröße während der Laufzeit nicht verändert werden. 6 mit der Maus anklicken
Abbildung 12: Formular Version 1
14
6.4 Der MenüentwurfFormulare können eigene Menüleisten mit Funktionen zur Ablaufsteuerung enthalten.So können beispielsweise die im Kap. 6.1 definierten Befehlsschaltflächen durch Menüein-träge ersetzt werden7.Die Menüentwicklung für das hier beschriebene Musterformular wird in folgenden Schrittendurchgeführt:• Menüentwurfsfenster öffnen (Funktionskombination EXTRAS / MENÜEDITOR ), um die
Menüpositionen Rechnen, Werte löschen und Beenden zu definieren.• Zuerst den Hauptmenüeintrag Quader definieren. Hierzu im Menüentwurfsfenster für
CAPTION den Text &Quader8 und als Elementnamen (NAME) MNU_Quader eingeben.• Zweite Menüebene einrichten - dazu die Schaltfläche Nächstes und danach die Schaltflä-
che � betätigen. Im Listenfeld des Menüentwurfsfensters erscheinen vier Punkte in einerneuen Zeile.
• Der erste Untermenüpunkt wird definiert, indem für CAPTION der Text &Rechnen und alsSteuerelementname MNU_Rechnen eingetragen wird.
• Die Schaltfläche Nächstes betätigen, um den nächsten Untermenüeintrag zu definieren.Für CAPTION &Werte löschen und für den Steuerelementnamen MNU_Löschen eintragen.
7 Beide Formen - Befehlsschaltflächen und Menüeinträge können selbstverständlich auch parallel zueinanderexistieren, auch wenn sie identische Funktionen besitzen.8 Bedeutung des Zeichens & - siehe Kap. 8.2
Abbildung 13: Formular Version 2
Abbildung 14: Menüdefinition
15
• Analog den Untermenüeintrag Ende definieren (CAPTION = &Ende, NAME = MNU_Ende).• Das Menüentwurfsfenster mit OK verlassen.Das Menü mit dazugehörigen Unterfunktionen ist damit eingerichtet und kann unmittelbar imEntwurfsmodus überprüft werden:
Damit ist die Programmoberfläche des Musterprogramms fertiggestellt und kann mit demnoch fehlenden Programmquelltext versehen werden.Bevor dieses geschieht, werden zuerst noch einige Grundregeln des Programmierens mitVisual Basic erklärt9.
7 Den Programmcode schreibenIn Formulare eingesetzte Steuerelemente mit den ihnen zugeordneten Eigenschaften wer-den durch Programmanweisungen zu einem Visual Basic - Programm zusammengebunden.Ein Programm ist eine Aneinanderreihung von Anweisungen.Eine Anweisung ist eine syntaktische Code - Einheit, die eine bestimmte Art von Operation,Definition oder Deklaration ausdrückt.Eine Anweisung kann ausführbar oder nicht ausführbar sein. Ist sie nicht ausführbar, setztsie den logischen Ablauf des Programms nicht fort - sie definiert oder deklariert Elementevon Projekten.In einer Programmzeile steht in der Regel eine Anweisung. Sollen in einer Zeile mehrereAnweisungen stehen, müssen diese durch einen Doppelpunkt voneinander getrennt sein.Visual Basic - Programmanweisungen werden im Codefenster geschrieben. Aus einemFormfenster läßt sich ein Codefenster öffnen durch:• einen Doppelklick auf die Form• einen Doppelklick auf ein Steuerelement• den Befehl Code im Menü Ansicht• die Taste F7Aus einem Projektfenster öffnet man das Codefenster durch:• Markieren des gewünschten Moduls• anschließendes Anklicken der Schaltfläche Code anzeigen
9 Detaillerte Informationen siehe Kap. 12(Grundlagen der Programmierung)
Abbildung 15: Fertiges Formular mit Menüleiste
16
Jedem Objekt sind bestimmte Ereignisse zugeordnet, die mit der Einrichtung des Objektsverfügbar gemacht werden. Ereignisse sind Aktionen des Benutzers oder der Systemkom-ponenten, die von einem Objekt erkannt werden.Jeder Form und jedem Objekt steht eine vordefinierte Gruppe von Ereignissen zurVerfügung, denen jeweils eine Ereignisprozedur zugeordnet sind. Diese Ereignisprozedurist nach dem Erstellen des Objekts noch leer und stellt nur einen formellen Rahmen dar.Wird sie mit einem Programmcode versehen, reagiert das Objekt beim Erkennen einesEreignisses mit der Ausführung des dazugehörigen Codes.In der traditionellen Programmierung übt das Programm die Kontrolle darüber aus, welcherProgrammteil wann ausgeführt wird. Die Ausführung beginnt mit der ersten Zeile desHauptprogramms und folgt dann einem bei der Programmerstellung definierten Weg durchdas Programm.Im Visual Basic, als einer ereignisgesteuerten Anwendung, bestimmen die Aktionen(Ereignisse) auf den Objekten die Ausführung dazugehöriger Ereignisprozeduren, wobei dieReihenfolge der Ausführung von der Reihenfolge der Ereignisse bestimmt wird und diese istbeliebig.Es muß daher jedem gewünschten Ereignis eine Prozedur zugeordnet werden10. Über dasObjektfeld erhält man eine Liste, in der neben der Form selbst alle in ihr enthaltenenSteuerelemente enthalten sind (in alphabetischer Anordnung).Das Prozedurfeld ist eine Liste aller Ereignisse, die im Zusammenhang mit einemSteuerelement während der Programmausführung auftreten können. Die Auswahl einesEreignisses läßt die dazugehörige Ereignisprozedur im Codefenster erscheinen.Visual Basic ordnet jeder Prozedur ein eigenständiges Unterprogramm zu.Ein solches Unterprogramm beginnt mit der Anweisung Sub11 und endet mit End Sub.Hinter Sub steht der Unterprogrammname, der sich aus dem Objektnamen und demzugeordneten Ereignis zusammensetzt. Objektname und Ereignis sind durch einenUnterstrich (_) verbunden.Zwischen den Anweisungen SUB und END SUB wird der Programmcode eingefügt.Beispiel:
Sub Ende_Click()Beep ‘TonausgabeEnd ‘Programmende
End Sub
Ergebnis: wird auf die Schaltfläche Ende geklickt, so wird ein Ton (Beep) ausgegeben und derProgrammablauf beendet.
Der Programmeditor prüft beim Verlassen einer Zeile deren Inhalt. Ist die Anweisungfehlerfrei, bleibt die Farbe der geprüften Anweisung bei schwarz. Ist die Anweisung nachdem Verlassen der Zeile rot, ist sie fehlerhaft. Sollte zusätzlich eine Fehlermeldung auf demBildschirm erscheinen, enthält sie in der Regel einen kurzen Kommentartext zur Fehlerart.Bei der Programmentwicklung ist es empfehlenswert, dem Programmtext dokumentierendeHinweise (Kommentare) beizufügen. Diese können sowohl in eigenen Zeilen als auchzusammen mit den Anweisungen in einer Zeile stehen.Kommentare beginnen mit einem Hochkomma (siehe obiges Beispiel). 10 Prozeduren nicht auftretender Ereignisse bleiben leer.11 Die Bedeutung der dahinter stehenden Klammern () wird weiter im Text erklärt.
Abbildung 16: Das Programmcode - Fenster
Objektfeld Prozedurf
17
8 Visual Basic Schritt für Schritt (Teil2 - Ereignisprozeduren)Für das im Kapitel 6 erstellte Musterformular sollen nun die Ereignisprozeduren für dieSteuerelemente erstellt werden. Da das Formular sowohl über Befehlsschaltflächen als auchüber Menüfunktionen gesteuert werden kann, werden im folgenden beide Alternativenberücksichtigt.
8.1 Steuerung über Befehlsschaltflächen.Für die drei im Formular enthaltenen Schaltflächen können die dazugehörigenEreignisprozeduren die nachfolgen dargestellten Inhalte haben12.
◆ Öffnen des Code - Fensters s. Kap. 6. Ist der Prozedurtext komplett, wird das Code -Fenster über die entsprechende Fenster - Schaltfläche geschlossen.
1. Schaltfläche Beenden:Private Sub Ende_Click()
EndEnd Sub
2. Schaltfläche zum Löschen der Inhalte der Textfelder:Private Sub Löschen_Click()Text1.Text = ""Text2.Text = ""Text3.Text = ""
End Sub
3. Schaltfläche zum Berechnen der Werte von Oberfläche und Volumen:Private Sub Rechnen_Click()
'Werte ausrechnen ohne Fehlerroutinea = Val(Text1.Text)b = Val(Text2.Text)c = Val(Text3.Text)Volumen = a * b * cFlaeche = (2 * a * b) + (2 * b * c) + (2 * a * c)Ergebnis = "Fläche: " + Str(Flaeche) + Chr$(13) + Chr$(10)Ergebnis = Ergebnis + "Volumen: " + Str$(Volumen)MsgBox Ergebnis, 64, "Ergebnis"
End Sub
8.2 Steuerung über MenüleisteDie Menüfunktion Quader mit Ihren Unterfunktionen Rechnen, Werte löschen und Beendenerhält analog zu den Schaltflächen eigene Ereignisprozeduren. Die Code - Fenster derUnterfunktionen werden durch einen Mausklick auf die jeweilige Unterfunktion imEntwurfsmodus des Formulars geöffnet. Die Prozeduren haben fast den gleichen Inhalt, wiedie für die Schaltflächen - der einzige Unterschied liegt im Objektnamen.In der Bedienung besteht allerdings ein Unterschied zur Bedienung über die Schaltflächen:• Die Ausführung ist sowohl über einen Mausklick auf die gewünschte Funktion oder
Unterfunktion, als aber auch über die Tastatur abrufbar. Dabei ist folgendes zu beachten:
12 Das dazugehörige Ereignis ist jeweils ein Mausklick auf die Schaltfläche.Die in den Anweisungen benutzten Konventionen für Variablennamen, Eigenschaftsnamen, Funktionsnamenusw. werden weiter im Broschürentext erläutert.
18
• Bei der Generierung der Menüeinträge wurde durch die Art der Benennung (&Quader,&Ende, &Rechnen usw.) erreicht, daß die hinter dem Zeichen „&“ stehenden Buchstabenim Menü unterstrichen sind13.
Dieses ermöglicht den Aufruf der Menüfunktionen über die Tastatur:� Die Hauptfunktion (Quader) über die Tastenkombination Alt + Q.� Die Unterfunktionen über die Eingabe des unterstrichenen Buchstabens.
1. Menüfunktion Beenden:Private Sub MNU_Ende_Click()End
End Sub
2. Menüfunktion zum Löschen der Inhalte der Textfelder:Private Sub MNU_Löschen_Click()Text1.Text = ""Text2.Text = ""Text3.Text = ""
End Sub
3. Menüfunktion zum Berechnen der Werte von Oberfläche und Volumen:Private Sub MNU_Rechnen_Click()
'Werte ausrechnen ohne Fehlerroutinea = Val(Text1.Text)b = Val(Text2.Text)c = Val(Text3.Text)Volumen = a * b * cFlaeche = (a * c + b * c + a * c) * 2Ergebnis = "Fläche: " + Str(Flaeche) + Chr$(13) + Chr$(10)Ergebnis = Ergebnis + "Volumen: " + Str$(Volumen)MsgBox Ergebnis, 64, "Ergebnis"
End Sub
Hinweis:Die Menüfunktionen können in der Praxis auch noch wesentlich einfacher belegt werden.Da es für die Aktionen Rechnen, Löschen und Beenden schon fertige Prozeduren für dieSchaltflächen gibt, können diese benutzt werden, indem man sie in den Menüprozedurenaufruft.Damit reduzieren sich die Prozeduren für die Menüpunkte zu:
Private Sub MNU_Ende_Click()End
End Sub
Private Sub MNU_Löschen_Click()Löschen_Click
End Sub
Private Sub MNU_Rechnen_Click()Rechnen_Click
End Sub
13 gleiche Technik kann bei der Beschriftung von Schaltelementen (Schaltflächen) verwendet werden.
19
9 Visual Basic Schritt für Schritt (Teil3 - Programmaufruf)Nach der Durchführung bisher beschriebener Schritte zur Formular- und Prozedurerstellungist das Beispielprogramm komplett und kann ausgeführt werden. Dieses kann entweder über
die Funktionskombination AUSFÜHREN / STARTEN oder über die Schaltfläche geschehen.Nach dem Start können in die Textfelder beliebige numerische Werte eingetragen werden,für die dann das Volumen und die Oberfläche des Quaders ausgerechnet werden. DieErgebnisse werden in einer MESSAGE - BOX ausgegeben:
Die Bedienung der Oberfläche kann über Schaltflächen oder Menüfunktionen erfolgen.Beide Alternativen führen zu gleichen (auch optischen) Ergebnissen.
10 Visual Basic Schritt für Schritt (Teil4 - EXE-Datei erstellen)Um das Projekt (Visual Basic - Programm) unabhängig von Visual Basic direkt aus Windowsstarten zu können14, muß es noch in eine ausführbare Datei (EXE - Datei) umgewandeltwerden. In dieser werden die Formmodule, Standardmodule, Klassenmodule undRessourcedateien eines Projekts zusammengefaßt.Eine ausführbare Datei ist lauffähig, ohne daß Visual Basic geöffnet oder gestartet werdenmuß. Zur Ausführung einer ausführbaren Datei muß sich die Laufzeitdatei VB40032.DLL (für32-Bit Betriebssysteme) im Verzeichnis \WINDOWS\SYSTEM oder in einem Verzeichnis imStandardpfad des Benutzers befinden. Je nach Anforderungen der Projekt -.EXE-Dateibenötigt man ggf. noch weitere .DLL-Dateien15.Die Erstellung einer EXE - Datei hat keine Wirkung auf die Projektdateien. Der Projektstandwird in der .EXE „konserviert“, so daß man weiter mit den Originaldateien arbeiten oderdiese verändern kann, ohne daß die ausführbare Datei von den Änderungen betroffen wird.
14 auf Rechnern, auf denen Visual Basic nicht installiert ist.15 Die komplette Liste benötigter Dateien ist dem Visual Basic - Programmierhandbuch zu entnehmen.
Abbildung 17: Formular nach Programmdurchlauf
20
11 FormulargestaltungFür die Entwicklung von Formularen steht in Visual Basic mindestens ein Formularfenster(Form 1) zur Verfügung. Form 1 ist das Hauptformular eines Visual Basic - Programms. Die-ses (und jedes andere Formular) besitzt Standardeigenschaften, die im Eigenschaftsfensterim Entwurfsmodus definiert oder verändert werden können.Die Position und Größe eines Formulars während der Ausführungszeit entspricht denWerten im Entwurfsmodus, es sei denn die Standardwerte werden per Programmanweisungverändert.
11.1 Grundeigenschaften• Name
eine Eigenschaft, die dem Formular einen Namen zuweist, unter dem es imProgrammtext angesprochen werden kann. Prinzipiell spricht nichts gegen die vomSystem vergebenen Standardnamen (Form 1, Form 2 usw.), jedoch sollte derÜbersichtlichkeit wegen einem Formular ein spezifischer Name zugeordnet werden16.Beim Abspeichern des Formulars wird der vergebene Name auch der dazugehörigenDatei zugeordnet (Namenserweiterung FRM).
• Captioneine Eigenschaft, die den Text der Titelleiste eines Formulars festlegt
• Borderstyleeine Eigenschaft, die festlegt, ob das Fenster während der Laufzeit eines Programmsdurch Rahmenanwahl mit der Maus oder über die Option Größe ändern des Systemme-nüs in seiner Größe verändert werden kann.
• Max- / MinButtoneine Eigenschaft, die die Generierung des Vergrößerungs- bzw. Verkleinerungsfeldeseines Fensters beeinflußt.Über das Vergrößerungsfeld kann ein Formularfenster zur Laufzeit auf Vollbildgrößegezoom werden.Das Verkleinerungsfeld setzt ein Formularfenster in Symbolgröße.Soll in einem Formular zur Laufzeit weder das Verkleinerungs- noch das Vergrößerungs-symbol generiert werden, ist die Eigenschaft MaxButton bzw. MinButton auf den WertFalse zu setzen.
11.2 FormularsteuerelementeDie Erstellung einer Visual Basic - Anwendung beginnt i.d.R. damit, daß aus einem Formularund Steuerelementen eine Benutzeroberfläche generiert wird. Alle Objekte erhalten imnächsten Schritt definierte Eigenschaften und werden dann durch einen Visual Basic - Codeso aktiviert, daß sie die Ihnen im Programmkonzept zugewiesenen Funktionen erfüllenkönnen.Steuerelemente dienen dazu, Eingaben der Benutzer entgegenzunehmen und Informationenan die Benutzer auszugeben. Jedes Steuerelement verfügt, ebenso wie Formulare, überEigenschaften, Ereignisse und Methoden.Die verfügbaren Steuerelemente sind in einem eigenem Fenster - der Werkzeugsammlung -untergebracht.Um ein Steuerelement in ein Formular einzufügen, wird es in der Werkzeugleiste entwederdoppelt angeklickt, oder einfach angeklickt und anschließend im Formular bezüglich Positionund Größe definiert (mit der Maus „gezeichnet“).Das Anklicken eines Steuerelements in einem Formular, erlaubt dessen nachträglicheBearbeitung.
16 Insbesondere beim Arbeiten mit mehreren Fenstern innerhalb eines Visual Basic - Programms (MDI-Formen -Multiple Document Interface) ist diese Technik sehr nützlich.
21
Wird ein Steuerelement im Formular angeklickt und die linke Maustaste gehalten, kann dasElement an beliebige Positionen im Formular verschoben werden.Die Anwahl des Rahmens eines Steuerelements (linke Maustaste gehalten) ermöglicht dienachträgliche Größenänderung des Elements.Das Verhalten, Aussehen und Form eines Elements kann über das Eigenschaftsfenster oderüber Anweisungen im Programmtext definiert und / oder verändert werden.
11.2.1 ZeigerEin standardmäßig aktiviertes Bedienungselement (Werkzeug). Einziges Werkzeug,mit dem kein Steuerelement erzeugt wird; es dient lediglich dazu, bereits erstellteSteuerelemente bezüglich ihrer Größe und Position im Formular zu verändern bzw.
in der Formularfläche auszuwählen (aktivieren), um sie zu bearbeiten (s.o.).
11.2.2 LinieDas Liniensteuerelement zum Zeichnen unterschiedlicher Arten von Linien(horizontal, vertikal, diagonal) im Entwurfsmodus eines Formulars, um optische
Strukturierungen der Formulare zu erreichen (z.B. Begrenzungen von Formularbereichen).
11.2.3 FigurEin Steuerelement zum Zeichnen geometrischer Grundformen (Rechtecke, Quadrate,Kreise und Ellipsen) zur Entwurfszeit. In der Regel werden diese Elemente zum
Eingrenzen von Formularbereichen benutzt (siehe auch Linie).
11.2.4 BezeichnungsfeldDas Bezeichnungsfeld wird zur Anzeige von Texten (Informationsausgabe), die derBenutzer zur Ausführungszeit i.d.R. nicht verändert, verwendet. Oft wird es für
Beschriftungen von Steuerelementen benutzt. Bezeichnungsfelder besitzen insbesonderedrei Eigenschaften, die das Erscheinungsbild ihrer Beschriftungen entscheidend bestimmen:
• Alignment - bestimmt die Ausrichtung des Textes:Wert Bedeutung
0 links ausgerichtet (left justify - Voreinstellung)1 rechts ausgerichtet (right justify)2 zentriert (center)
• AutoSize - automatische Anpassung der Elementgröße an den Inhalt (Größe) desanzuzeigenden Textes:
Wert BedeutungTrue Größe automatisch anpassenFalse keine automatische Größenanpassung
(Voreinstellung), überschüssiger Text wirdabgeschnitten.
• WordWrap - Anpassung der Größe des Bezeichnungsfeldes in horizontaler bzw.vertikaler Richtung durch Textumbruch, wenn AutoSize auf True gesetzt ist:
Wert BedeutungTrue Anpassung in der Höhe, mit TextumbruchFalse Anpassung in der Breite, kein Textumbruch
(Voreinstellung)
11.2.5 TextfeldDas Steuerelement Textfeld wird zur Anzeige von Texten, als Eingabefeld oder Abfra-gefeld für Benutzereingaben verwendet (Werte- bzw. Texteingabe oder -änderung).
22
Textfelder können einzeilig oder mehrzeilig sein. Zum Einsatz kommen sie hauptsächlich imBereich von Dialogfeldern und Eingabemasken.Textfelder werden insbesondere durch zwei Eigenschaften entscheidend beeinflußt:
• MultiLine - legt fest, ob ein Textfeld bei der Ein- bzw. Ausgabe von Werten mehrereZeilen akzeptieren soll:
Wert BedeutungTrue mehrere Zeilen möglichFalse nur eine Zeile zulässig (Voreinstellung)
• ScrollBars - definiert vertikale und /oder horizontale Bildlaufleisten für das Textfeld:Wert Bedeutung
0 (Voreinstellung) None - keine Laufleisten1 horizontale Laufleiste (Horizontal)2 vertikale Laufleiste (Vertical)3 beide Laufleisten (Both)
Ist die definierte Größe des Textfeldes bei gesetztem Wert TRUE der Eigenschaft MULTILINEfür die Anzeige oder Eingabe des Textes zu klein, wird der Text umbrochen und nach obenverschoben (oberer Textteil verschwindet aus der Anzeige). Der verschwundene Textteill istnicht mehr einsehbar (besonders ungünstig bei Textausgabe). Um diesen Nachteil zuvermeiden, sollte eine entsprechende Laufleiste über die Eigenschaft SCROLLBARS definiertwerden.
� Soll der Inhalt eines Textfeldes zentriert werden (ALIGNMENT - Eigenschaft), mußMULTILINE auf TRUE gesetzt werden, auch wenn nur eine Zeile im Textfeld dargestellt wird.Mit zwei weiteren Eigenschaften lassen sich Textfelder zusätzlich beeinflußen:
• MaxLength - beschränkt die Anzahl Zeichen in einem Textfeld auf einen vom Benutzerdefinierten Wert. Wird die Obergrenze überschritten, wird der Benutzer akustischgewarnt. Die Voreinstellung 0 bedeutet dabei, daß die Zeichenzahl nicht beschränkt ist -in der Praxis heißt es - unter WINDOWS 95 = 64 KB, unter WINDOWS NT nur durch denverfügbaren Systemspeicher begrenzt.
• PasswordChar - eine Eigenschaft, die oft mit MAXLENGTH kombiniert wird, umPaßwortabfragen zu ermöglichen. Sie bestimmt ein Platzhalterzeichen (meistens einStern *), welches bei der Texteingabe im Textfeld erscheint. Diese Eigenschaft ist nur beieinzeiligen Textfeldern möglich (MULTILINE=FALSE).
11.2.6 BefehlsschaltflächeDie Befehlsschaltfläche ist das Abbild einer Funktionstaste, die nach der Betätigungdie Ausführung definierter Funktionen auslöst. Es existieren mehrere Möglichkeiten,
eine Befehlsschaltfläche zur Laufzeit zu aktivieren:
• Anklicken mit der linken Maustaste• Tastenkombination ALT + unterstrichener Buchstabe der Tastenbeschriftung17.• Aktivieren der Schaltfläche mittels der TAB - Taste und Betätigen der ENTER- Taste• Falls die Schaltfläche eine Standard - Abbruch - Schaltfläche ist - Betätigen der ESCAPE -
Taste.• Falls die Schaltfläche eine Standard - Befehlsschaltfläche ist - Betätigen der ENTER -
Taste• Setzen der VALUE - Eigenschaft im Programmcode. 17 Der unterstrichene Buchstabe wird erzeugt, indem man bei der Definition der Caption - Eigenschaft derSchaltfläche vor den zu unterstreichenden Buchstaben ein kaufmännisches „und“ & setzt. Der unterstricheneBuchstabe muß nicht der Anfangsbuchstabe der Schaltflächenbeschriftung sein.
23
• Alle genannten Aktionen aktivieren die zur Befehlsschaltfläche dazugehörige CLICK -Ereignisprozedur, die den die dazugehörige Operation aktivierenden Programmcodeenthält. Ohne den dazugehörigen Programmcode bleibt eine in ein Formulareingebrachte Schaltfläche ohne Wirkung.
11.2.7 Programmbeispiel 1Es soll ein Formular zur Berechnung der Summe der Zahlen 1 bis n erstellt werden. Diesessoll ein Bezeichnungsfeld, zwei Textfelder und drei Befehlsschaltflächen enthalten:
Nach der Eingabe einer Zahl in das obere Textfeld soll das Programm über die SchaltflächeBerechnen die Summe ermitteln und im mittleren Textfeld das Ergebnis ausgeben. DieSchaltfläche Löschen soll den Inhalt beider Textfelder löschen, das Eingabefeld aktivierenund damit eine neue Berechnung ermöglichen. Die Schaltfläche Ende beendet dieProgrammausführung.Die Eigenschaften der benutzen Objekte werden auf folgende Werte gesetzt:
Objekt Eigenschaft WertForm Caption Programmbeispiel1
Name Beispiel1Bezeichnungsfeld Alignment 2 - Center
BorderStyle 1 - Fixed SingleCaption Summe der Zahlen 1 bisName Beschriftung
oberes Textfeld MaxLength 6Name txtEingabeText leer
unteres Textfeld Alignment 2 - CenterMultiLine TrueName txtAusgabeText leer
linke Schaltfläche Caption &BerechnenDefault TrueName Rechnen
mittlere Schaltfläche Caption &LöschenDefault TrueName Löschen
rechte Schaltfläche Cancel TrueCaption &EndeName Beenden
• Das Bezeichnungsfeld enthält einen erklärenden Text zum Inhalt des oberen Textfeldes.• Die Eingabe in das obere Textfeld ist auf 6 Zeichen beschränkt (MAXLENGTH=6)• Die Ausgabe des Ergebnisses ist mehrzeilig möglich.• Die Schaltflächen Berechnen und Löschen sind Standard-Befehlsschaltflächen.
Abbildung 18: Formular des Programmbeispiels 1
24
• Die Schaltfläche Ende ist eine Standard-Abbruch-Schaltfläche.Die Funktionalität des Programms wird durch drei einfache Ereignisprozedurengewährleistet:• Für die Schaltfläche Berechnen:
Private Sub Rechnen_Click() Dim n, Ergebnis n = Val(Eingabe.Text) Ergebnis = n * (n + 1) / 2 Ausgabe.Text = "Die Summe ist: " & Ergebnis End Sub
Nach der Variablendeklaration wird der Variablen n über die Visual Basic - Funktion VALder Zahlenwert der Eingabe des oberen Textfeldes zugewiesen. Der errechnete Wertwird der Variablen Ergebnis zugewiesen und diese, angehängt an den Textstring „DieSumme beträgt“, in die Text - Eigenschaft des Feldes txtAusgabe übertragen und damitim unteren Textfeld ausgegeben.
◆ Hinweis zur Variablendeklaration: Prinzipiell ist die Zeile mit der Variablendeklaration (DIM .....) überflüssig. Visual Basic nimmti.d.R., wenn es auf unbekannte Bezeichnungen im Programm trifft, an, es handele sich umVariablen (-namen) und behandelt sie im Programmverlauf entsprechend. Eine explizite Variablendeklaration hat jedoch gewisse Vorteile: treten im Programm bei derEingabe von Variablennamen Fehler (Schreibfehler) auf, werden sie vom System angezeigt(z.B. Ergebns= .... statt Ergebnis=...) und moniert. Wird eine Variable nicht deklariert, so wirdder fehlerhaft geschriebene Name als eine neue Variable erkannt und dieser evtl. einErgebnis zugewiesen, was zu unnötigen Folgefehlern führen kann. Empfehlenswert ist deshalb eine generelle Deklaration aller Programmvariablen. Diese wirdim Deklarationsabschnitt eines Visual Basic - Moduls durchgeführt. Dazu muß im Code -Fenster die Kombination (ALLGEMEIN) / (DEKLARATIONEN) im Objekt- und Prozedurfeldangewählt werden und die dazugehörige Prozedur mit der Zeile
Option Explicit
begonnen werden.
Die sicherste Methode, eine solche Deklaration zu erreichen und sie an der richtigen Stelleim Programm einzufügen, ist der Weg über die Funktionskombination EXTRAS / OPTIONENder Menüleiste des Hauptfensters von Visual Basic und anschließendes Aktivieren derOption VARIABLENDEKLARATION ERFORDERLICH in der Registerkarte EDITOR.
Abbildung 19: Beginn der Variablendefinition
25
• Für die Schaltfläche Löschen: Private Sub Löschen_Click() Eingabe.Text = "" Ausgabe.Text = "" Eingabe.SetFocus End Sub
Den Texteigenschaften der Felder Eingabe und Ausgabe werden leere Stringszugewiesen, wodurch die Feldinhalte in der Anzeige gelöscht werden, der Focus wird aufdas Eingabefeld gesetzt.
• Für die Schaltfläche Ende:Private Sub Beenden_Click()
BeepEnd
End Sub
Nach der Ausgabe eines akustischen Signals (Anweisung BEEP) wird das Programmbeendet.
� Das im Beispiel generierte Formular und das Programm weisen einigeUnzulänglichkeiten auf:1. In das Textfeld Ausgabe kann den Benutzer hineinschreiben. Abhilfe schafft:
das Sperren des Steuerelements. Eine generelle Möglichkeit, Eingaben in ein Textfeldzu verhindern ist das Setzen der ENABLED - Eigenschaft des Feldes auf den Wert FALSE.Dieses hat jedoch zur Folge, daß der angezeigte Inhalt in einer blassen Schrift erscheint. Eine günstigere Elternative bietet das Setzen der LOCKED - Eigenschaft auf den WertTRUE. Diese Einstellung verhindert jede Textbearbeitung außer Markierungs- und Kopier-vorgängen.
2. Bei negativen Zahlen ist das Ergebnis falsch - die Formel gilt nur für positive Werte.3. Bei Dezimalzahlen mit einem Komma als Dezimalzeichen übernimmt die Funktion VAL
nur den ganzzahligen Anteil in die Berechnung, wird ein Punkt als Dezimaltrennzeichenbenutzt, ist das Ergebnis falsch.
4. Leerzeichen und Tabulatorzeichen werden ignoriert, andere Zeichen führen zumAbbruch.
Die Unzulänglichkeiten der Punkte 2 - 4 lassen sich durch erweiterte (hier noch nichtangesprochene) Formen von Programmanweisungen vermeiden.
Abbildung 20: Formular nach der Berechnung
26
KeyPress-Ereignis� Die Eingabe im Feld Eingabe läßt sich mittels einer KEYPRESS - Prozedur auf Ziffernbeschränken:
Private Sub Eingabe_KeyPress(KeyAscii As Integer)' Nur Ziffern zulassen
If KeyAscii < 48 Or KeyAscii > 57 ThenKeyAscii = 0Beep
End IfEnd Sub
Die ASCII-Codes der Ziffern 0 - 9, die im Bereich 48 bis 57 liegen, werden hier geprüft. ImFalle einer falschen Eingabe (keine Ziffer) wird der Wert ASCII(0) gesetzt (im Feld erscheintkein Zeichen, Cursor bewegt sich nicht weiter) und es erfolgt eine akustische Warnung18.
11.2.8 BildlaufleistenHorizontale und vertikale Bildlaufleisten werden i.d.R. zum Verschieben vonFensterbereichen (Blättern) benutzt, man kann sie jedoch auch benutzten, um
sich schnell durch große Mengen von Informationen zu bewegen, beispielsweise zur An-zeige oder Eingabe von numerischen Werten oder zur Regelung bzw. Anzeige veränderli-cher Daten, wie Lautstärke oder Zeitanzeige bei Installations- oder Sicherungsvorgängen.Die hier vorzustellenden Bildlaufleisten sind nicht mit der SCROLLBARS - Eigenschaftintegrierter Laufleisten zu verwechseln (siehe beispielsw. Textfelder).Für die Identifikation von Positionsänderungen innerhalb einer Bildlaufleiste werden folgendeEigenschaften benötigt:• VALUE - ganzzahliger Wert für die Position des Lauffeldes innerhalb der Bildlaufleiste.• MAX - maximaler möglicher Wert der VALUE - Eigenschaft (Wertebereich -32.768 bis
32.767).• MIN - minimaler möglicher Wert der VALUE - Eigenschaft (Wertebereich wie MAX).• LARGECHANGE - Schrittweite der Werteänderung beim Mausklick in die Bildlaufleiste
(Wertebereich 1 bis 32.767).• SMALLCHANGE - Schrittweite der Werteänderung beim Mausklick auf einen Bildlaufpfeil
(Wertebereich wie LARGECHANGE).
11.2.9 Programmbeispiel 2Das Programmbeispiel 1 wird um eine horizontale Bildlaufleiste erweitert, die die Eingabevon Werten ermöglichen soll.Die Eigenschaftswerte aller Objekte bleiben unverändert, bis auf folgende Änderungen bzw.Erweiterungen:
• Das obere Textfeld wird für direkte Werteeingabe gesperrt (LOCKED = TRUE):Objekt Eigenschaft Wert
oberes Textfeld Locked TrueMaxLength 6Name txtEingabeText leer
18 Die hier benutzte If - Then - Struktur wird weiter im Text besprochen.
27
• Es wird eine Bildlaufleiste mit den folgenden Eigenschaften definiert:Objekt Eigenschaft Wert
horizontale Bildlaufleiste LargeChange 10Max 99999Min 1Name Leiste1SmalChange 1
Die Bildlaufleiste wird mit zwei Ereignisprozeduren „ausgestattet“.• Für die Übergabe des eingestellten Wertes an das obere Textfeld:
Private Sub Leiste1_Change()txtEingabe.Text = Leiste1.Value
End Sub
Für die kontinuierliche Anzeige des in der Bildlaufleiste erreichten Wertes während desÄnderungsvorganges im oberen Textfeld
Private Sub Leiste1_Scroll()Leiste1_Change
End Sub
Ohne diese Prozedur wird der erreichte Wert erst nach dem Loslassen der Maustasteangezeigt .
11.2.10 Kontroll- und OptionsfelderIn vielen Anwendungen besteht die Notwendigkeit, aus einer Menge von Alternativen eineAuswahl zu treffen. Dieses ist über zwei Steuerelemente möglich:
Kontrollfeld - Steuerelemente bieten eine oder mehrere Wahlmöglichkeiten, vondenen der Benutzer beliebig viele auswählen kann. Die ausgewählten Alternativen
werden durch ein Häkchen im Steuerelement gekennzeichnet.Der Zustand des Steuerelements wird über seine VALUE - Eigenschaft definiert:
Wert Bedeutung0 nicht ausgewählt (Unchecked - Voreinstellung)1 ausgewählt (Checked)2 nicht wählbar, abgeblendet, aber aktiviert(Grayed)
Abbildung 21: Modifizierte Oberfläche des Beispiels 1
28
Optionsfeld - Steuerelemente bieten Wahlmöglichkeiten an, von denen, imUnterschied zu Kontrollkästchen, nur jeweils genau eine ausgewählt werden kann. Dieausgewählte Alternative wird durch einen Punkt im Zentrum des Steuerelements
angezeigt. Die VALUE - Eigenschaft von Optionsfeldern besitzt nur zwei Werte:Wert Bedeutung
True ausgewähltFalse nicht ausgewählt
Die Beschriftungen beider oben genannten Steuerelemente werden über die EigenschaftCAPTION definiert, die Ausrichtung der Beschriftungen über die ALIGNMENT - Eigenschaft:
Wert Bedeutung0 links ausgerichtet (Left Justify - Voreinstellung)1 rechts ausgerichtet (Right Justify)
� Die ALIGNMENT - Eigenschaft beider Steuerelemente bezieht sich auf das Symbol desSteuerelements und nicht auf dessen Beschriftung. So bewirkt beispielsweise der Wert 1(RIGHT JUSTIFY), daß die Beschriftung links vom Steuerelement erscheint.
OptionsfeldgruppenDie Anwahl eines Optionsfeldes hat die Deaktivierung eines evtl. zuvor gewählten zur Folge.Der Grund dafür ist, daß alle in einer Form liegenden Optionsfelder eine Gruppe bilden, ausder nur ein Element ausgewählt werden darf.Es gibt jedoch Anwendungen, in denen mehrere Optionen angegeben werden müssen,wofür jedoch die o.g. Regel ein Hindernis ist. Einen Ausweg bietet die Möglichkeit,Optionsfelder innerhalb eines Formulars in Gruppen zusammenzufassen (sie in eigeneContainer zu packen). Damit bietet sich die Möglichkeit, auf Optionsfelder innerhalb derGruppen zuzugreifen und damit nicht nur eine Alternative innerhalb eines Formulars,sondern je eine Alternative pro gebildete Gruppe auswählen zu können.
Eine Optionsfeldgruppe kann über das Rahmensteuerelement gebildet werden. DieVorgehensweise wird am Beispiel eines Musterprogramms im nächsten Kapitel der
Unterlage erläutert.
11.2.11 Programmbeispiel 3Das Musterprogramm (beispielsweise als Teil einer Anwendung zur Ausgabe vonErgebnissen eines anderen Programms) demonstriert die Verwendung von Kontroll - undOptionsfeldern verbunden mit der Anzeige der ausgewählten Optionen in einemBezeichnungsfeld. Die Optionsfelder sollen in Gruppen zusammengefaßt werden:
Abbildung 22: Formular des Beispiels 3
29
Die im Formular enthaltenen Objekte besitzen die folgenden Eigenschaften:Objekt Eigenschaft Wert
Formular Caption Kontroll- und OptionsfelderName Beispiel3
oberes Kontrollfeld Caption &FarbeName Check1
mittleres Kontrollfeld Caption &TonName Check2
unteres Kontrolfeld Caption &KommentarName Check3
Optionsfeld Mitte oben Caption &BildschirmName Option1Value True19
Optionsfeld Mitte unten Caption &DruckerName Option2
Rahmen Mitte Caption AusgabeName Rahmen1
Optionsfeld rechts oben Caption &MüllerName Option3
Optionsfeld rechts Mitte Caption M&eierName Option4
Optionsfeld rechts unten Caption &OttoName Option5
Rahmen rechts Caption Nachricht anName Rahmen2
Bezeichnungsfeld Alignment 2 - CenterBorderStyle 1 - Fixed SingleText leerName Kontrolle
Befehlsschaltfläche Cancel TrueCaption &EndeDefault TrueName Beenden
Die Kontroll- und Optionsfelder werden mit CLICK - Prozeduren ausgestattet, die einenidentischen Inhalt haben20:
Private Sub Check2_Click()WertAnzeigeEnd Sub
WertAnzeige ist eine allgemeine Prozedur, die in aufeinanderfolgenden IF-Anweisungen dieeingestellten Werte der Kontroll- und Optionsfelder „sammelt“
Public Sub WertAnzeige()Dim ZeileIf Check1.Value = vbChecked ThenZeile = "Farbe: gewählt"
ElseZeile = "Farbe: nicht gewählt"
End If
If Check2.Value = vbChecked ThenZeile = Zeile & vbCrLf & "Ton: gewählt"
ElseZeile = Zeile & vbCrLf & "Ton: nicht gewählt"
End If
If Check3.Value = vbChecked ThenZeile = Zeile & vbCrLf & "Kommentar"
ElseZeile = Zeile & vbCrLf & "kein Kommentar"
End If
If Option1.Value = True Then
19 Durch den Wert VALUE = TRUE wird diese Option als aktiv voreingestellt.20 Hier am Beispiel der Prozedur für das Kontrollfeld Check2
30
Zeile = Zeile & vbCrLf & "Bildschirmausgabe"End IfIf Option2.Value = True ThenZeile = Zeile & vbCrLf & "Druckerausgabe"
End IfIf Option3.Value = True ThenZeile = Zeile & vbCrLf & "Nachricht: Müller"
End IfIf Option4.Value = True ThenZeile = Zeile & vbCrLf & "Nachricht: Meier"
End IfIf Option5.Value = True ThenZeile = Zeile & vbCrLf & "Nachricht: Otto"
End If
Kontrolle.Text = Zeile
End Sub
und in der Variablen Zeile speichert. Diese wird am Prozedurende der Texteigenschaft desBezeichnungsfeldes zugewiesen. Die Prozedur wird im allgemeinen Teil der Form definiert.
� Über die integrierte Konstante VBCRLF (zusammengesetzt aus CARRIAGE RETURN undLINE FEED) wird ein Zeilenumbruch bei der Belegung der Variablen vorgenommen.
� Gruppen von Optionsfeldern können nicht gebildet werden, indem man im Formulardefinierte Optionsfelder nachträglich in einen Rahmen zieht oder nach der Rahmendefinitionversucht, durch einen Doppelklick in die Werkzeugleiste Optionsfelder im Rahmen zuplazieren. Beide Techniken definieren dem Formular (und nicht dem Rahmenelement) zuge-ordnete Felder21.
� Optionsfeldgruppen werden gebildet, indem zuerst der Rahmen (Container) ins Formulareingetragen wird und danach einzeln die Optionsfelder darin plaziert werden.� Sollen bereits existierende Optionsfelder als Gruppe in einem Rahmen zusammengefaßtwerden, sind sie zu markieren, auszuschneiden und in den vorher definierten Rahmeneinzusetzen.
21 Damit ist also ist keine Mehrfachauswahl (aus mehreren Gruppen, wie im Beispielprogramm) möglich !
Abbildung 23: Formular aus Beispiel 3 nachProgrammausführung
31
11.2.12 Listen- und KombinationsfelderKontroll- und Optionsfelder bieten Einzelauswahlen von Alternativen an. Die Anzahlwählbarer Alternativen kann durch die Nutzung von Listen- und Kombinationsfeldernerweitert werden. Die Anzahl Alternativen liegt hier bei 32.768, was sicher in kaum einerAnwendung jemals benötigt wird.
Ein Listenfeld - Steuerelement beinhaltet eine Liste von Einträgen, aus denen ein odermehrere Einträge ausgewählt werden können22. Ist die Anzahl der Einträge in der Liste
so groß, daß sie im definieren Fenster des Listenfeldes nicht dargestellt werden kann, erhältdas Listenfeld automatisch schon in der Entwurfsphase eine Bildlaufleiste.
Das Listenfeld muß nach der Generierung mit Inhalt gefüllt werden. Dafür gibt es zweiMöglichkeiten:• Im Entwurfsmodus werden die Listeneinträge über die LIST - Eigenschaft des Steuerele-
ments definiert. Dazu ist die Pfeilschaltfläche im Einstellungsfeld anzuklicken, um denTextbereich des Definitionsfensters zu öffnen und darin Eingaben vorzunehmen. Nach je-dem Eintrag (jeder Zeile) ist die Tastenkombination STRG + ENTER zu drücken, um in dienächste Zeile zu gelangen. Die Taste ENTER allein schließt das Textfenster desEinstellungsfeldes.
• Zur Laufzeit wird das Füllen bzw. Erweitern der Liste mit der ADDITEM - Methodedurchgeführt23. Die allgemeine Syntax dieser Methode lautet:
Objekt.AddItem Element [, Index]
OBJEKT ist der Name des Steuerelements (hier das Listenfeld) ELEMENT ist der einzutragende / einzufügende Eintrag INDEX (optional) ist die Position des Eintrags in der Liste (erste Position - Index 0)Die Generierung (insbesondere unter Berücksichtigung der ADDITEM-Methode) und Verwen-dung eines Listenfeldes soll das nachstehende Programmbeispiel demonstrieren.
11.2.13 Programmbeispiel 4Das Programm soll eine Liste von Personen anbieten und nach der Auswahl eines Eintragsin einem Bezeichnungsfeld die Telefonnummer der ausgewählten Person anzeigen.
22 siehe dazu MultiSelect - Eigenschaft weiter unten im Programmbeispiel 4.23 Methoden sind vergleichbar mit Prozeduren und Funktionen. Eine Methode führt bestimmte Anweisungen(Operationen) auf einem einzelnen Objekt durch. Aus programmtechnischer Sicht sind es spezielle Prozedurenmit einer spezifischen Syntax.
Abbildung 24:Ein Listenfeld
Abbildung 25: Beispiel zur Listenfeldanwendung
32
Die einzelnen Objekte des Formulars sind mit den folgenden Eigenschaften belegt:Objekt Eigenschaft Wert
Formular Caption ListenfeldanwendungName Beispiel4
Bezeichnungsfeld links Alignment 2 - CenterCaption Mitarbeiter(in)Name Label3
Listenfeld List leerName Liste
Bezeichnungsfeld rechts oben Alignment 2 - CenterCaption TelefonnummerName Label1
Bezeichnungsfeld für TelNr Alignment 2 -CenterBackColor WeißBorderStyle 1 - Fixed SingleMultiLine TrueText leerName TelNr
Befehlsschaltfläche Caption EndeName Beenden
Die Liste wird mittels der ADDITEM - Methode in der Ereignisprozedur LOAD des Formularsgefüllt. Diese Prozedur wird ausgeführt, wenn zur Laufzeit das Formular aktiviert (geladen)wird. Der Inhalt der Liste muß nicht fix sein, vielmehr können an beliebiger Stelle imProgramm über die ADDITEM - Methode Elemente hinzugefügt werden (dynamischeErweiterung, als Reaktion auf bestimmte Aktivitäten der Benutzer)24.
Private Sub Form_Load()Liste.AddItem "Müller"Liste.AddItem "Meier"Liste.AddItem "Mustermann"Liste.AddItem "Audorf"Liste.AddItem "Bond"Liste.AddItem "Castor"Liste.Text = Liste.List(0)
End SubDie vorletzte Programmzeile aktiviert im Listenfeld das Listenelement mit dem INDEX 0, alsodas erste der Liste. Dadurch bleibt das Listenfeld nach der Aktivierung nicht leer.Die CLICK - Prozedur des Listenfeldes übergibt je nach ausgewähltem Listenelement diedazugehörige Telefonnummer an das Bezeichnungsfeld TelNr:25
Private Sub Liste_Click()If Liste.Text = "Müller" Then
TelNr.Text = "2377"ElseIf Liste.Text = "Meier" Then
TelNr.Text = "2376"ElseIf Liste.Text = "Mustermann" Then
TelNr.Text = "0231/2323"ElseIf Liste.Text = "Audorf" Then
TelNr.Text = "19923"ElseIf Liste.Text = "Bond" Then
TelNr.Text = "007/007"ElseIf Liste.Text = "Castor" Then
TelNr.Text = "1111/9999"End If
24 Mittels der RemoveItem- und Clear - Methode (siehe weiter im Text) ist so beispielsweise auch eindynamisches Verkleinern oder sogar Löschen der Liste möglich.25 Die hier benutzte If...Then...ElseIf - Struktur wird weiter unten im Text näher erläutert.
33
� Die Click – Prozedur des Listenfeldes kann mit Hilfe der SELECT CASE – Anweisung auchanders gestaltet werden:
Private Sub Liste_Click()Dim WahlWahl = Liste.Text
Select Case WahlCase "Müller"TelNr.Text = "2377"
Case "Meier"TelNr.Text = "2376"
Case "Mustermann"TelNr.Text = "0231/2323"
Case "Audorf"TelNr.Text = "19923"
Case "Bond"TelNr.Text = "007/007"
Case "Castor"TelNr.Text = "1111/9999"
Case ElseTelNr.Text = "????"
End Select
End Sub
Die Schaltfläche Ende besitzt die in den bisherigen Beispielen verwendete Prozedur für dasCLICK- Ereignis.� Sortierte Liste: Sollen die Listenelemente in der Anzeige in sortierter Reihenfolgeerscheinen, muß durch eine entsprechende Wahl der Indexwerte die Reihenfolge bestimmtwerden. Dieses ist jedoch sehr aufwendig (insbesondere bei der Programmpflege oder gardynamischer Erweiterung der Liste) und fehleranfällig. Besser eignet sich dafür die SORTED -Eigenschaft des Listenfeldes. Wird deren Wert im Entwurfsmodus auf TRUE gesetzt (Default= FALSE), verwaltet Visual Basic die alphabetische Sortierung selbständig, auch nach demEinfügen oder Löschen von Listenelementen.
◆ Ist SORTED auf TRUE gesetzt und wird mittels ADDITEM mit der Angabe eines Indexwerteshinzugefügt, kann die Sortierung durcheinandergeraten - diese Kombination ist also zuvermeiden (möglichst bei ADDITEM keinen Indexwert benutzen).
◆ Die Methoden RemoveItem und ClearListeneinträge können mit der REMOVEITEM - Methode entfernt werden. Anzugeben ist dabeider Indexwert (s. CLICK – Prozedur der Schaltfläche Entfernen im Programmbeispiel 5 weiterunten im Text) des zu entfernenden Eintrags.
Liste.RemoveItem 2
entfernt beispielsweise den dritten Listeneintrag.Um die komplette Liste (alle Einträge) zu löschen, benutzt man die CLEAR - Methode:
Liste.Clear
� Die MultiSelect - EigenschaftEine Mehrfachauswahl aus einem Listenelement ist nach der Aktvierung der MULTISELECT -Eigenschaft des Elements möglich. Dabei sind folgende Werte zu beachten:
Wert Bedeutung0 keine Mehrfachauswahl (None - Voreinstellung)1 Simple - einfache Mehrfachauswahl. Mehrere
Elemente können durch Anklicken oder mit derLeertaste aus- bzw. abgewählt werden.
2 Extended - Erweiterte Mehrfachauswahl. In übli-cher WINDOWS - Technik können beim drückender SHIFT- oder STRG - Taste zusammenhängen-de oder nichtzusammenhängende Blöcke vonListenelementen markiert werden.
34
Ein Kombinationsfeld - Steuerlement ist eine Kombination der Merkmale eines Text-und eines Listenfeldes. Es ermöglicht dem Benutzer, eine Auswahl von
Listenelementen zu treffen, indem ein Text in einem - Eingabefeld eingegeben wird oder einElement aus einer PULLDOWN - Liste ausgewählt wird.Es existieren unterschiedliche Typen von Kombinationsfeldern - je nach dem Wert der STYLE-Eigenschaft (einstellbar nur im Entwurfsmodus) sind folgende Formen möglich:
Wert Bedeutung0 DropDown Combo - im Textbereich des Kombi-
nationsfeldes kann eine Eingabe getätigt werdenoder aus einer DropDown - Liste (öffnet sichnach dem Anklicken des Auswahlpfeiles) kannein Eintrag gewählt werden. Gewähltes Elementerscheint im Textbereich.( Voreinstellung)
1 Simple Combo - einfaches Kombinationsfeld. Eswird immer eine Liste angezeigt. Bei Bedarf wirdeine Bildlaufleiste eingeblendet. Zusätzlichenthält das Feld eine Eingabeleiste fürDirekteingaben von Werten.
2 DropDown List - Elemente können aus eineraufklappbaren Liste ausgewählt werden. Nachder Auswahl wird die Liste geschlossen, ge-wähltes Element erscheint im Textbereich.
Die Entscheidung darüber, welche Form des Kombinationsfeldes gewählt wird ist vomPlatzbedarf und / oder den Modalitäten der Alternativenauswahl abhängig:• Besteht die Auswahl aus einem unveränderbaren Vorrat an Alternativen, kann die Form
mit STYLE = 2 gewählt werden. Sie benötigt im Formular weniger Platz, da die Liste nurbei Bedarf geöffnet wird.
• Soll dem Nutzer die Möglichkeit geboten werden, neben den festgelegten Alternativenauch eigene Angaben zu tätigen, ist eine der beiden anderen Alternativen günstiger. DieForm mit STYLE = 0 ist dabei die günstigere, weil sie ebenfalls weniger Platz im Formularbeansprucht.
An einer einfachen Anwendung soll nun die Benutzung unterschiedlicher Typen vonKombinationsfeldern demonstriert werden. Gleichzeitig wird hier die Verwendung derMethoden ADDITEM, REMOVEITEM und CLEAR, sowie der Eigenschaften LISTCOUNT undLISTINDEX demonstriert.
◆ LISTCOUNT ist eine Eigenschaft, welche die Anzahl der in einer Liste enthaltenenElemente zurückgibt.
◆ LISTINDEX bestimmt den Index eines in einer Liste gewählten Elements (Wertebereich 0bis LISTCOUNT -1).Beide Eigenschaften sind im Entwurfsmodus nicht verfügbar.
11.2.14 Programmbeispiel 5Das Beispielprogramm soll eine Mannschaftsaufstellung ermöglichen. Die Mannschaftsmit-glieder sollen aus drei Leistungsgruppen stammen. Jede Leistungsgruppe ist in der Listeeines Kombinationsfeldes gespeichert. Die aus den Listen gewählten Positionen(Mannschaftsaufstellung) sollen in einem Listenfeld angezeigt werden. Aus der Mann-schaftsliste sollen einzelne Positionen entfernt oder aber die komplette Liste soll gelöschtwerden können. Die Anzahl der Mannschaftsmitglieder soll in einem gesonderten Feld an-gezeigt werden.
35
Die im Formular benutzten Objekte besitzen die folgenden Eigenschaften (Schaltflächen,Bezeichnungsfelder für Beschriftungen und das Formular sind nicht aufgeführt):
Objekt Eigenschaft Wertoberes Kombinationsfeld Name Combo1
Sorted TrueStyle DropDown Combo (0)Text leer
mittleres Kombinationsfeld Name Combo2Sorted TrueStyle Simple Combo (1)
unteres Kombinationsfeld Name Combo3Sorted TrueStyle DropDown List (2)
Listenfeld Name AnzeigeSorted True
Bezeichnungsfeld für Anzahl Alignment 2 -CenterBorderStyle 1 - Fixed SingleText leerName Zähler
� Die Höhe des mittleren Kombinationsfeldes muß bei der Erstellung „nachreguliert“werden. Standardmäßig ist das Feld nur so hoch, daß nur die Textkomponente sichtbar ist26.In den Kombinationsfeldern ist die automatische Sortierung voreingestellt.In den beiden oberen Kombinationsfeldern können neben Listenpositionen eigene Eingabenin die Textfelder getätigt werden.Über die Schaltfläche Hinzufügen werden die ausgewählten Positionen in die mittlere Listeübertragen, die Schaltfläche Entfernen löscht eine in der Liste markierte Position (auch überDoppelklick möglich), die Schaltfläche Löschen löscht die komplette Liste, die SchaltflächeEnde beendet die Programmausführung.Die Funktionsfähigkeit des Formulars wird durch die folgenden Programmcodesgewährleistet:• Im Deklarationsteil wird eine Variable Eingabe deklariert (und somit für alle Prozeduren
verfügbar gemacht):Option Explicit
Dim Eingabe
Sie nimmt in den LostFocus27 - Prozeduren der Kombinationsfelder den Wert deren Text -Eigenschaften an hier am Beispiel des Combo1 - Feldes):
Private Sub Combo1_LostFocus()Eingabe = Combo1.Text
End Sub
26 Der Wert kann auch über die Height - Eigenschaft eingestellt werden.27 Das LostFocus - Ereignis eines Elements trifft ein, wenn das Element verlassen wird (den Focus verliert).
Abbildung 26: Formular des Programmbeispiels 5
36
• Die Kombinationsfelder werden in der LOAD - Prozedur des Formulars gefüllt, dasAnzeigefeld wird „geputzt“:
Private Sub Form_Load()Combo1.AddItem "Müller"Combo2.AddItem "Anton"Combo3.AddItem "Bertha"Combo1.AddItem "Meier"Combo2.AddItem "August"Combo3.AddItem "Britta"Combo1.AddItem "Moser"Combo2.AddItem "Artus"Combo3.AddItem "Bogumil"Anzeige.Clear
End Sub
• Die Schaltfläche Hinzufügen besitzt eine CLICK - Prozedur der Form:Private Sub Command1_Click()
If Trim(Eingabe) <> "" ThenAnzeige.AddItem Eingabe
Eingabe = ""Zähler.Text = Anzeige.ListCount
ElseBeep
End IfEnd Sub
Die hier benutzte Funktion TRIM entfernt alle vor- und nachgestellten Blanks aus der Zei-chenkette in der Variablen Eingabe. Ist das Ergebnis dieser Operation nicht leer, wird derWert dem Listenfeld hinzugefügt und Eingabe auf Blank gesetzt. Im Feld Zähler wird die An-zahl der Listenelemente angezeigt. Ist das TRIM - Ergebnis leer, findet keine Übernahmestatt und es wird akustisch gewarnt.Die Schaltfläche Entfernen ist mit der folgenden CLICK - Prozedur versehen:
Private Sub Command2_Click()Dim IndexWertIndexWert = Anzeige.ListIndexIf IndexWert > -1 Then
Anzeige.RemoveItem IndexWertZähler.Text = Anzeige.ListCount
ElseBeep
End IfIf Anzeige.ListCount = 0 Then
Command2.Enabled = FalseEnd If
End Sub
In der lokal deklarierten Variablen IndexWert wird der Index der im Listenfeld ausgewähltenPosition gespeichert und soweit dieser größer ist als -1, wird das gewählte Element überREMOVEITEM gelöscht28. Ist das Listenfeld leer, wird die Schaltfläche gesperrt.Die Schaltfläche Löschen löscht den kompletten Inhalt des Listenfeldes und verändertentsprechend die Anzeige im Feld Anzahl. Gleichzeitig sperrt sie die Schaltfläche Entfernen.
Private Sub Command3_Click()Anzeige.ClearCommand2.Enabled = FalseZähler.Text = Anzeige.ListCount
End Sub
Findet anschließend mindestens ein neuer Eintrag in das Listenfeld statt, wird über dieGOTFOCUS - Prozedur29 des Listenfeldes diese Schaltfläche wieder entsperrt:
28 Ein Indexwert -1 bedeutet - keine Auswahl stattgefunden.
37
Private Sub Anzeige_GotFocus()If Anzeige.ListCount > 0 Then
Command2.Enabled = TrueEnd If
End SubDas Entfernen von Elementen aus dem Listenfeld über einen Doppelklick wird über dieDBLCLICK - Prozedur des Listenfeldes gesteuert30:
Private Sub Anzeige_DblClick()Command2.Value = True
End Sub
11.3 Arrays von SteuerelementenSteuerelemente gleichen Typs können in Arrays (Feldern) zusammengefaßt werden. DieEinzelelemente eines solchen Arrays haben gleiche Namen und benutzen die gleichenEreignisprozeduren. Unterscheidungsmerkmal der Elemente ist ihr Indexwert.Für die Benutzung von Steuerelementarrays sprechen insbesondere drei Gründe:• Im Array zusammengefaßte Steuerelemente benötigen weniger Systemressourcen als
die gleiche Anzahl von Einzelementen.• Gleicher Programmcode kann von mehreren Steuerelementen genutzt werden.• Sollen zur Laufzeit neue Steuerelemente erzeugt (dem Formular hinzugefügt) werden, ist
die Verwendung von Arrays sogar zwingend. Zur Laufzeit hinzugefügte Steuerelementebesitzen nämlich nur dann Ereignisprozeduren, wenn diese von bereits vorhandenenElementen übernommen werden können.
11.3.1 Erstellung im EntwurfsmodusDie einfachste Art der Erstellung eines Arrays von gleichen Steuerelementen im Entwurfs-modus ist die folgende:
1. Schrittweise Erstellung• erstes Steuerelement nach der üblichen Methode (s. weiter oben im Text) erstellen.• zweites in gleicher Form erstellen und die Eigenschaft NAME auf den gleichen Wert, wie
die des ersten Elements setzen. Visual Basic blendet danach ein Dialogfeld ein, in demdie Bestätigung für das Erstellen gefordert wird:
• Nach dem Betätigen der Schaltfläche Ja erhält das neue Steuerelement den Indexwert 1(das erste behält seinen Indexwert 0).
• Jedes weitere hinzugefügte Steuerelement gleicher Art erhält - bei gleicher Benennungden jeweils höheren Indexwert. Eine erneute Abfrage (s.o.) erfolgt nicht.
� So erzeugte Elemente besitzen nur die gleiche NAME - Eigenschaft, alle anderenEigenschaften können individuell konfiguriert werden.
29 GotFocus ist das Gegenstück zu LostFocus - das Ereignis tritt ein, wenn ein Element den Focus erhält.30 Die Schaltfläche Entfernen wird aktiviert (Value = True) und damit die ihr zugeordnete Klick - Prozedurausgeführt.
Abbildung 27: Info - Dialog bei Generierung eines Elementenarrays
38
2. Erstellung durch KopierenEin ins Formular eingefügte Element wird „vervielfältigt“ durch Kopieren und Einfügen. Nachdem ersten Einfügen erscheint die o.g. Abfrage. Weitere Einfügungen ziehen keine Abfragenach sich. Die Indexwerte eingefügter Elemente werden schrittweise in der Reihenfolge desEinfügens erhöht.
� Mit dieser Methode erstellte Steuerelemente besitzen optische Eigenschaften des erstenElements. Einheitliche Eigenschaften sollten also für dieses Element vor dem Kopierendefiniert werden.
11.3.2 Erstellung zur LaufzeitArrays von Steuerelementen können auch zur Laufzeit erstellt werden. Hierzu bedarf esjedoch einer besonderen Technik im Programmablauf:• Das Hinzufügen von Steuerelementen zu einem Array geschieht mittels der Anweisung
Load Objekt(Index)
OBJEKT ist der Name des einzufügenden Steuerelements, INDEX der Indexwert.• Das Entfernen eines Steuerelements aus einem Array ist über die Anweisung
Unload Objekt(Index)
möglich.Mit UNLOAD lassen sich allerdings nur Steuerelemente entfernen, die mit LOAD hinzugefügtwurden. Falsche Angaben beim Indexwert (schon vergebener Wert bei LOAD oder nichtvorhandener Wert bei UNLOAD) werden von Visual Basic mit einer Fehlermeldung quittiert.
� Das Laden von Steuerelementen über die LOAD - Anweisung macht diese nicht imFormular automatisch sichtbar. Hierzu muß zusätzlich im Programm die VISIBLE -Eigenschaft des geladenen Steuerelements auf den Wert TRUE gesetzt werden.Beide hier beschriebenen Techniken zur Erstellung und Handling von Steuerelemen - Arrayssollen im folgenden an einem Beispielprogramm demonstriert werden.
11.3.3 Programmbeispiel 6Das Formular des Programms enthält zwei Arrays von Steuerelementen:• Drei Schaltflächen im rechten Teil, erstellt im Entwurfsmodus durch Kopieren eines
„Grundelements“ (obere Schaltfläche).• Textfelder im linken Teil (hier max. 5), die zur Laufzeit erstellt und entfernt werden
können.Die Textfelder werden mit einem Standardtext versehen, der nach einem einfachen Maus-klick auf das Textfeld erschienen soll. Ein Doppelklick auf ein Textfeld soll dessen Inhalt lö-schen. Der Inhalt der Textfelder soll nur per Programm, nicht jedoch durch Benutzerangabenverändert werden können.
Abbildung 28: Formular für Arrays vonElementen
39
Die im Formular enthaltenen Steuerelemente erhalten folgende Standardeigenschaften:Objekt Eigenschaft Wert
Formular Caption Arrays von SteuerelementenName Beispiel6
Textfeld Index 0Locked TrueName Feld1Text leer
obere Schaltfläche Caption &EinfügenIndex 0Name SFläche
mittlere Schaltfläche Caption &LöschenIndex 1Name SFläche
untere Schaltfläche Cancel TrueCaption &BeendenIndex 2Name SFläche
Im Programmcode wird die Variable TextIndex explizit deklariert und in der LOAD - Prozedurdes Formulars auf den Wert 0 gesetzt:
Option ExplicitDim TextIndex
Private Sub Form_Load()TextIndex = 0
End Sub
Die Schaltflächen SFläche mit den Indexwerten 0 - 2 benutzen gemeinsame Ereignisproze-duren. Im Programmcode der CLICK - Prozedur wird daher in einer IF...THEN...ELSEIF -Struktur (auf der Basis des Indexwertes) geprüft, welche der Schaltflächen betätigt wurde:
Private Sub SFläche_Click(Index As Integer)Dim Meldung$
If Index = 0 ThenIf TextIndex >= 4 Then
Meldung = "Maximale Anzahl Felder erreicht !"MsgBox Meldung$, 16, "Achtung"
Exit SubEnd IfTextIndex = TextIndex + 1Load Feld1(TextIndex)Feld1(TextIndex).Top = Feld1(TextIndex - 1).Top _+ Feld1(TextIndex - 1).Height + 160Feld1(TextIndex).Visible = TrueFeld1(TextIndex).Text = ""
ElseIf Index = 1 ThenIf TextIndex < 1 Then
Meldung = "Letztes Feld wird nicht entfernt"MsgBox Meldung$, 16, "Achtung"Exit Sub
End IfUnload Feld1(TextIndex)TextIndex = TextIndex - 1
ElseEnd
End If
End SubFür die Schaltfläche Einfügen wird im ersten Schritt geprüft, ob die Anzahl im Formularenthaltener Textfelder die Maximalzahl (=5) überschritten hat (Indexzählung beginnt bei 0,daher die Prüfung auf den Wert 4 !). Ist dies der Fall, wird eine Warnmeldung in einerMSGBOX31 ausgegeben und die Prozedur über EXIT SUB verlassen.
31 Der Aufbau und Funktionsweise einer MsgBox wird weiter unten im Text erklärt
40
Ist die Maximalanzahl nicht überschritten, wird ein neues Textfeld erstellt und dessen Indexgesetzt, wobei die Position des neuen Elements vor dem Erscheinen im Formular (VISIBLE =TRUE) so gesetzt wird, daß es schon vorhandene Elemente nicht überdeckt (...HEIGHT +160).Wird die Schaltfläche Löschen betätigt, erfolgt eine Prüfung auf Anzahl Textfelder imFormular und soweit nur eins vorhanden, wird die Prozedur wieder über EXIT SUB verlassen(vorher Ausgabe einer Meldung über MSGBOX). Ist mehr als ein Textfeld im Formularenthalten, wird das zuletzt generierte entfernt und der Indexwert entsprechend angepaßt.
Die CLICK - Prozeduren der Textfelder enthalten entsprechende Anweisungen zum Anzeigenbzw. Löschen des Feldinhalts:
Private Sub Feld1_Click(Index As Integer)Feld1(Index).Text = "eingefügtes Feld # " & Index
End Sub
Private Sub Feld1_DblClick(Index As Integer)Feld1(Index).Text = ""
End SubIm Beispielprogramm ist der Programmcode für die Schaltflächen unterschiedlich, was nichtunbedingt einen Gewinn an Ressourcen bedeutet32, bei den Textfeldern wird es jedochdeutlicher zu erkennen sein - statt mehrerer (hier 10) einzelner Prozeduren mit identischenFunktionen werden hier nur zwei, für alle Indexwerte gültige, benötigt.
32 Außer, daß die Prozedur nur einmal (für eine Schaltfläche) generiert werden muß.
Abbildung 29: Zur Laufzeit erstelltes Arrayvon Elementen
41
12 Grundlagen der Programmierung
12.1 Konventionen für ein Visual Basic - ProgrammStandardmäßig wird von Visual Basic das erste Formular (Form) einer Anwendung alsStartform verwendet. Nach dem Programmstart erscheint diese auf dem Bildschirm, wobeizuerst die Anweisungen der FORM_LOAD - Ereignisprozedur ausgeführt werden. Besteht dasProjekt aus mehreren Formen und soll eine andere Form als Startform gelten, muß dieses inder Registerkarte PROJEKT (Funktionskombination OPTIONEN - EXTRAS) angezeigt werden.Die zweite, in dieser Registerkarte wählbare Alternative - SUB MAIN - wird gewählt, wennbeim Starten eines Projekts nicht sofort eine Form geladen werden soll.
◆ Soll eine Anwendung nicht mit einer Form gestartet werden, muß zwingend eineProzedur mit dem Namen SUB MAIN erstellt und in der genannten Registerkarte als einesog. Pseudo-Startform definiert werden.Eine Anwendung kann beendet werden mit der Anweisung END. Die Ausführung wird un-mittelbar beendet, ohne daß noch ein Ereignis eintreten kann oder irgendein Code abgear-beitet wird.Zur Unterbrechung einer Anwendung dient die Anweisung STOP. Sie wirkt im Ausführungs-modus wie ein Haltepunkt und wird in der Regel beim Testen von Programmen verwendet.
12.2 AnweisungenEine Anweisung ist eine syntaktisch richtige Codeeinheit für eine bestimmte Art vonDefinitionen, Deklarationen oder Operationen.• Pro Programmzeile wird normalerweise eine Anweisung geschrieben.• Soll eine Programmzeile mehrere Anweisungen enthalten, müssen diese durch einen
Doppelpunkt (:) voneinander getrennt sein.• Eine Anweisung kann ausführbar oder nicht ausführbar sein. Nicht ausführbare
Anweisungen setzen den logischen Programmablauf nicht fort, da sie i.d.R. nurDefinitionen bzw. Deklarationen enthalten.
Die syntaktische Hauptkomponente einer Zuweisungsanweisung bildet das Gleichheitszei-chen (=). Eine Anweisung der Form:
zielwert = quellwert
teilt einem Visual Basic - Programm mit, daß ein Wert vom quellwert zum zielwert übertra-gen werden soll. Dabei gilt:• zielwert ist eine Variable oder eine Eigenschaft eines Objekts• quellwert ist ein gültiger AusdruckDie rechte Seite der Anweisung (quellwert) muss dabei aus einer Zeichenfolge oder einemnumerischen Wert bestehen.
42
12.3 VariablenVariablen sind Platzhalter für Daten (Zahlen, Textstrings), die im Programmverlauf verändertwerden können. Jede Variable besitzt einen Namen, mit dem auf sie im ProgrammverlaufBezug genommen werden kann und einen Typ (Datentyp), der bestimmt, welche ArtInformationen in der Variablen gespeichert werden kann.Die Variablennamen unterliegen den folgenden Regeln:
• Ein Variablenname beginnt immer mit einem Buchstaben.• Ein Variablenname kann maximal 255 Zeichen lang sein.• Ein Variablenname muß innerhalb des Gültigkeitsbereichs eindeutig sein.• Ein Variablenname darf keinen Punkt, kein Leerzeichen und kein Typkennzeichen33
enthalten.
12.3.1 VariablendeklarationWie schon beschrieben, muß eine Variable vor ihrer Verwendung nicht explizit deklariertwerden, weil beim Antreffen eines unbekannten Namens im Programm automatisch eineVariable mit diesem Namen deklariert wird (implizite Variablendeklaration). Dies kann jedochleicht zu den im Kap. 11.2.7 erwähnten Fehlern führen.Es wird deshalb empfohlen, eine explizite Variablendefinition aller benutzten Variablen imDeklarationsabschnitt eines Moduls mittels der Anweisung
Option Explicit
zu erzwingen.Eine explizite Variablendeklaration kann auch erzwungen werden, indem auf derRegisterkarte EDITOR (erreichbar über die Funktionskombination EXTRAS - OPTIONEN derMenüleiste) die entsprechende Option aktiviert wird.Zur Definition der Variablen wird die Anweisung
Dim Variablenname [As Typ]
verwendet. Mit der optionalen Angabe AS TYPE kann der Variablentyp festgelegt werden (s.weiter im Text).Weitere mögliche Deklarationsvarianten - siehe Folgekapitel.
12.3.2 Geltungsbereich der VariablenAuf Prozedurebene deklarierte Variablen stehen nur in der jeweiligen Prozedur zurVerfügung. Sie werden lokale Variablen genannt.Lokale Variablen werden entweder mittels der DIM - Anweisung
Dim Zahl1 As Integer
oder mittels der STATIC - AnweisungStatic Zahl1 As Integer
deklariert.Die mittels der STATIC - Anweisung deklarierten Variablen (statische Variablen) behalten iherGültigkeit während der gesamten Laufzeit der Anwendung (im Unterschied zu den mittelsDIM deklarierten, die nach dem Verlassen der Prozedur ihre Gültigkeit verlieren).Auf Modulebene (im Deklarationsabschnitt) deklarierte Variablen stehen allen Prozedureneines Moduls zur Verfügung. Sollen sie auch Prozeduren anderer Forms zur Verfügunggestellt werden, müssen sie über
Public Variable [As Typ]
33 Typkennzeichen sind an einen Variablennamen angehängte Sonderzeichen zur Charakterisierung desDatentyps, den die Variable aufnehmen kann (siehe auch weiter im Text).
43
deklariert werden (öffentliche Variable).Variable, die nur in einem Modul generell bekannt sein sollen, können auch mit
Private Variable [As Typ]
deklariert werden. Auf Modulebene ist diese Deklarationsform der Deklaration mit DIMäquivalent, wird aber oft wegen dem Unterschied zu PUBLIC der DIM - Deklarationvorgezogen.
12.4 KonstantenKonstante sind feste, vordefinierte Werte (Zahlen oder Zeichenfolgen), die zur Laufzeit nichtgeändert werden dürfen. Die Verwendung von Konstanten erlaubt eine einfachere undleichtere Handhabung von Werten (Wert wird nur einmal gesetzt und bei Bedarf nur überden Namen der Konstanten abgerufen) und führt zur besseren Lesbarkeit eines Programms.
12.4.1 Integrierte KonstantenSystemdefinierte Konstanten (integrierte Konstanten) bilden eine Gruppe von Konstanten,die von Steuerelementen und Anwendungen bereitgestellt werden. Der zur Verfügungstehende Vorrat ist im Objektkatalog von Visual Basic einzusehen.◆ Der Präfix des Namens einer integrierten Konstanten deutet auf ihre Herkunft.Konstanten mit dem Präfix vb stammen aus der Objekt-Library von Visual Basic, solche mitdem Präfix grd gehören zum Tabellen-Steuerelement.
12.4.2 Symbolische KonstantenSymbolische Konstanten (auch benutzerdefinierte Konstanten genannt) werden mit derAnweisung
[Public | Private ] Const Konstantenname [As Typ] = Ausdruck
als numerische oder alphanumerische Konstanten deklariert.KONSTANTENNAME unterliegt den Regeln für Visual Basic - Variablennamen.AUSDRUCK kann aus Konstanten und Operatoren bestehen.
Const Pi = 3,14159264
Const WortKette = "kleine Zahlen"
In einer CONST - Anweisung können, durch ein Komma voneinander getrennt, mehrereKonstanten definiert werden:
Const Pi = 3,14159264 , WortKette = "kleine Zahlen"
Bereits definierte Konstanten dürfen zur Bildung anderer benutzt werden:Const Pi = 3,14159264 , PiQuadrat = Pi * Pi
Der Gültigkeitsbereich integrierter Konstanten ist öffentlich, der der symbolischenKonstanten hängt, wie bei Variablen, vom Ort ihrer Deklaration ab34.
34 Beachte: PUBLIC CONST muß (im Unterschied zur Variablendeklaration) im Deklarationsabschnitt einesStandarmoduls und nicht in einem Formmodul verwendet werden !
44
12.5 VariablentypenVariable und Konstanten können neben dem zwingend erforderlichen Namen auch miteinem Datentyp versehen werden. Visual Basic untescheidet für diesen Zweck einenuniversellen und mehrere spezifische Datentypen.
12.5.1 Datentyp VariantWird bei der Deklaration einer Variablen kein Datentyp angegeben, verwendet Visual Basicden Datentyp VARIANT. Es ist ein universeller Datentyp, der alle in Visual Basicverwendbaren Arten von Daten speichern kann. Umwandlungen von Datentypen fürBerechnungen oder Ausgabevorgänge müssen bei diesem Datentyp nicht vorgenommenwerden, da sie von Visual Basic automatisch durchgeführt werden:
Dim Variable1Variable1 = "123"
.Variable1 = Variable1 + 20
.Variable1 = "ABC" & Variable1
Nach der ersten Zuweisung enthält Variable1 die Zeichenkette 123 (ist alsoalphanumerisch), nach der zweiten den Zahlenwert 143 (numerisch) und nach der drittenwiederum eine Zeichenkette ABC143 (alphanumerisch).Ein solcher Komfort geht jedoch zu Lasten des Speicherplatzbedarfs und derVerarbeitungsgeschwindigkeit.Intern werden von VARIANT - Variablen die Grunddatentypen (s. Weiter im Text) verwendet,wobei Visual Basic jeweils den Typ mit dem geringsten Speicherplatzbedarf verwendet. BeiBedarf wird der zugeordnete Datentyp geändert (s. obiges Beispiel).
12.5.2 GrunddatentypenDen mit den Anweisungen DIM, STATIC, PUBLIC und PRIVATE deklarierten Variablen kannüber die Klassifikation AS ein Datentyp zugewiesen werden.Folgende Grunddatentypen werden dafür von Visual Basic verwendet:
Typ Platzbedarf /Bytes) WertebereichBYTE 1 0 bis 255BOOLEAN 2 True / FalseCURRENCY 8 -922.337.203.685.477,5808 bis
922.337.203.685.477,5807DATE 8 01.01.0100 bis 31.12.9999DOUBLE 8 -1,7*10308 bis -4,9*10-324 und 4,9*10-324 bis
1,7*10308
INTEGER 2 -32.768 bis 32.768LONG 4 -2.147.483.648 bis 2.147.483.647OBJEKT 4 Jeder ObjektverweisSINGLE 4 -3,4*1038 bis -1,4*10-45 und 1,4*10-45 bis -
3,4*1038
STRING (fest) Textlänge 1 bis 2.147.483.648STRING (variabel) 10 + Textlänge 0 bis 2.147.483.648VARIANT (numerisch) 16 s. DoubleVARIANT (alphanumerisch) 22 + Textlänge s. String variabelBenutzerdefiniert wie Einzelelemente wie Einzelelemente
45
Für einige Datentypen werden in Visual Basic an Variablennamen angehängteTypkennzeichen verwendet:
Datentyp TypkennzeichenCurrency @Double #Integer %Long &Single !String $
◆ Diese Art der Notation entstammt allerdings den älteren Versionen von Visual Basic undsollte deshalb vermieden werden.Zur Verwendung:die Anweisungen
Dim Meldung As String
undDim Meldung$
sind identisch, sie deklarieren die Variable Meldung als STRING - Variable.
12.5.3 Numerische DatentypenNumerische Werte werden Variablen mit numerischen Datentypen zugewiesen. Dabei geltendie folgenden allgemeinen Richtlinien:• Variablen für ganzzahlige Werte sollten, je nach benötigtem Wertebereich, als BYTE,
INTEGER oder LONG deklariert werden.• Variablen für Zahlenwerte mit Nachkommastellen sollte der Typ SINGLE, DOUBLE oder
CURRENCY zugewiesen werden. CURRENCY bildet maximal 15 Vor- und 4Nachkommastellen ab, SINGLE und DOUBLE besitzen wesentlich größere Wertebereiche.
• SINGLE - Variablen lassen auch eine „wissenschaftliche Notation“ in der Form mmmEeeezu (z.B. 1,4E-2 = 1,5 * 10-2). In der Form mmmDeee (1,5D-2) wird der Wert als DOUBLEinterpretiert.
• BYTE - Variable sind vorzeichenlose 8 Bit - Werte im Bereich 0 - 255.Numerische Variablen werden bei der Deklaration auf den Wert 0 gesetzt. Ob sie im Verlaufeines Programms numerische Werte enthalten35, kann mit
IsNumeric(Ausdruck)
geprüft werden. Die Funktion liefert den Wert TRUE, wenn der Ausdruck insgesamt als Zahlinterpretiert werden kann, andernfalls wird FALSE zurückgegeben.Der Typ VARIANT wird nicht automatisch initialisiert. Zu Beginn einer Prozedur hat eineVariable vom Typ VARIANT den Wert EMPTY. Die Funktion
IsEmpty(Variable)
prüft, ob eine Variable initialisiert ist.VARIANT - Variablen können einen speziellen Wert NULL enthalten. Dieser wird insbesonderein Datenbankanwendungen zur Anzeige fehlender oder fehlerhafter Daten benutzt.
IsNull(Ausdruck)
prüft in solchen Fällen, ab Ausdruck ungültige Daten enthält.Beide Werte (EMPTY und NULL) können im Programmablauf explizit einer Variablenzugewiesen werden.
35 insbesondere beim Typ Variant evtl. wichtig.
46
12.5.4 Datentyp StringAlphanumerische Zeichenketten werden in Variablen mit dem Typ STRING gespeichert.STRING - Variablen haben standardmäßig eine variable Länge - sie passen sich deraufzunehmenden Zeichenkette längenmäßig an.Eine feste Länge für STRING - Variable kann mit
String * Länge
definiert werden, wobei Länge eine ganze Zahl ist.Dim Nachname As String * 25
definiert eine STRING - Variable Nachname mit der Länge 25.◆ Ist die in der Variablen Nachname abzuspeichernde Zeichenkette kürzer als 25 Zeichen,wird nach hinten mit Leerzeichen aufgefüllt, ist die Zeichenkette länger, wird sie nach dem25. Zeichen abgeschnitten.
12.5.5 Datentyp BooleanVariable mit dem Datentyp BOOLEAN nehmen zweiwertige Daten der Form WAHR / UNWAHR,JA / NEIN oder AN / AUS auf. Initialisiert werden sie mit dem Wert FALSE.
12.5.6 Datentyp DateZum Speichern von Datums oder Zeitwerten werden Variable des Typs DATE verwendet. EinDatums- oder Zeitliteral muß links und rechts durch das Zeichen # eingeschlossen sein:
#January 1, 1993# oder #1 Jan 93#.
Variablen vom Datentyp DATE verwenden zur Darstellung des Datums das auf demComputer eingestellte kurze Datumsformat. Zeitangaben werden mit dem auf demComputer eingestellten Zeitformat (entweder 12- oder 24-Stunden-Format) dargestellt.� Beim Umwandeln anderer numerischer Datentypen in Werte des Datentyps DATErepräsentieren die Vorkommastellen das Datum und die Nachkommastellen die Uhrzeit.Mitternacht entspricht dem Wert 0, und Mittag entspricht den Nachkommawert 0,5. Negativeganze Zahlen repräsentieren ein Datum vor dem 30. Dezember 1899.
◆ Bei der Darstellung des Datums im Programmcode darf als Trennzeichen kein Punkt (.)verwendet werden. Zulässig sind die Formen #tt/mm/jj# oder #tt-mm-jj# , z.B.
Dim Datum As DateDatum = DateIf Datum = #15/05/97# Then.....
12.5.7 Datentyp ObjektEine als 32-Bit - Adresse gespeicherte variable des Typs OBJECT verweist auf interne oderexterne Objekte. Einer OBJECT - Variablen wird mit einer Set - Anweisung ein auf einexistentes, von der Anwendung erkanntes Objekt, verweisender Wert zugewiesen.Variable dieses Typs werden im Bereich von Multimedia - Anwendungen und OLE -Automatisierung verwendet. In dieser Broschüre wird auf diese Themenbereich nicht nähereingegangen.
47
12.6 Datenfelder (Arrays)Ähnlich wie Steuerelemente können auch Variable zu Feldern (Arrays) zusammengefaßtwerden. Im Daten - Array existieren mehrere Variablen gleichen Namens, Unterschei-dungsmerkmal ist je nach Dimension eines Arrays ein Index oder mehrere Indizes.Datenfelder können eine feste Größe besitzen oder dynamisch aufgebaut sein.Deklarationsformen und Gültigkeitsbereiche von Datenfeldern entsprechen denen derVariablen, mit dem Unterschied, daß bei Datenfeldern bei der Deklaration die Anzahl Felder(Indexwert für Unter- und Obergrenze) angegeben wird. Wird bei der Indexdefinition keinspezieller Wert angegeben, hat der untere Index den Wert 0.
Dim DaFeld(30) As Integer
definiert ein Datenfeld mit dem Namen DaFeld, dem Typ INTEGER, bestehend aus 31Elementen.Unter- und Obergrenze der Indexwerte lassen sich auch direkt definieren:
Dim DaFeld (10 TO 30) As Integer
definiert beispielsweise ein Datenfeld mit den Indexwerten 10 bis 30 (bestehend aus 21Elementen).In der Regel besitzen alle Elemente eines Datenfeldes den gleichen Typ. Bei Datenfelderndes Typs VARIANT können jedoch einzelne Elemente unterschiedliche Datentypen enthalten.Neben den oben beschriebenen eindimensionalen Datenfeldern können auch mehrdimen-sionale Gebilde definiert werden (theoretisch sind max. 60 Dimensionen möglich):
DIM DaFeld (4, 1 TO 10, 1 TO 10) As Integer
definiert ein Datenfeld mit 5 * 10 * 10 Elementen.
◆ Der Speicherbedarf steigt bei mehrdimensionalen Feldern rapide an, insbesondere beiFeldern des Typs VARIANT, die sehr speicherintensiv sind. Abhilfe - siehe dynamischeDatenfelder.
12.6.1 Dynamische DatenfelderDer hohe Speicherbedarf von Datenfeldern oder die Tatsache, daß deren Größe erst zurLaufzeit bekannt wird, macht es zweckmäßig, ihre Größe zur Laufzeit eines Programms jenach Bedarf zu ändern (anzupassen). Um dieses zu erreichen, wird zuerst ein Datenfelddefiniert, dessen Dimensionsliste leer ist, z.B.:
Dim DaFeld () As Integer
Die Anzahl benötigter Elemente wird mit der Anweisung36
ReDim DaFeld (Anzahl) As Integer
oderReDim DaFeld (n TO m) As Integer
festgelegt.◆ Die REDIM - Anweisung kann nur auf Prozedurebene verwendet werden (keineVerwendung im Deklarationsteil eines Moduls möglich !).
Die Anweisung kann im Programmablauf beliebig oft verwendet werden und damit beliebigoft die Dimension eines Datenfeldes neu gesetzt werden.◆ Bei jeder Verwendung der REDIM - Anweisung werden die Elemente eines Datenfeldesneu initialisiert, wodurch die darin enthaltenen Daten verloren gehen. Der Datenverlust läßt
36 Hier am Beispiel des schon weiter oben genannten Feldes DaFeld.
48
sich vermeiden, wenn die REDIM - Anweisung um das Schlüsselwort PRESERVE erweitertwird:
ReDim Preserve DaFeld (n To m) As Integer
PRESERVE bewirkt, daß Elemente im genannten Indexbereich bei der Neuinitialisierung ihreWerte behalten.Die Behandlung dynamischer Datenfelder demonstriert das folgende Programmbeispiel.
12.6.2 Programmbeispiel 7
Das Beispielprogramm soll den Gebrauch der REDIM - Anweisung demonstrieren. Das überdiese Anweisung definierte Datenfeld mit 10 Elementen soll gefüllt werden37 undanschließend mit und ohne PRESERVE umdefiniert werden können.
Um die hierfür benutzten Techniken zu demonstrieren, werden die entsprechendenAnweisungsgruppen in die CLICK - Prozeduren entsprechender Schaltflächen gelegt.Die Objekteigenschaften des Formulars und seiner Elemente werden hier nicht aufgelistet.Sie besitzen Standardwerte, die Namen und CAPTION - Eigenschaften sind denProzedurauszügen zu entnehmen.Im allgemeinen Deklarationsteil des Formulars wird zuerst ein dimensionsloses Datenfelddeklariert:
Option ExplicitDim WerteArray() As Integer
Die obere Schaltfläche besitzt eine CLICK - Prozedur, welche die COMBO - BOX mit 10 Ele-menten füllt. Als Identifizierungswerte werden die Indexwerte eingesetzt:
Private Sub Füllen_Click()ReDim WerteArray(1 To 10) As IntegerDim Zähler
For Zähler = 1 To 10 Step 1WerteArray(Zähler) = Zähler
Next ZählerCombo1.ClearFor Zähler = 0 To 9 Step 1
Combo1.AddItem Str(WerteArray(Zähler + 1))Next Zähler
End Sub
37 Die hierfür benutzte Struktur wird weiter im Text detailliert beschrieben.
Abbildung 30: Formular des Beispiels 7
49
Nach einem Mausklick auf den Pfeil der COMBO-BOX kann die Belegung des Datenfeldeskontrolliert werden:
Die Prozedur zur Redefinition des Datenfeldes auf einen Umfang von 5 Elementen, alsCLICK - Prozedur der mittleren Schaltfläche hat die Form:
Private Sub Kurz1_Click()ReDim WerteArray(1 To 5) As IntegerDim Zähler
Combo1.ClearFor Zähler = 0 To 4 Step 1
Combo1.AddItem Str(WerteArray(Zähler + 1))Next Zähler
End Sub
Das Ergebnis ist ein neu initialisiertes Datenfeld mit 5 Elementen (alle mit dem Wert 0):
Ein Gegenbeispiel dazu ist die gleiche Prozedur (allerdings mit PRESERVE), als CLICK -Prozedur der Schaltfläche darunter,
Private Sub Kurz2_Click()ReDim Preserve WerteArray(1 To 5) As IntegerDim Zähler
Combo1.ClearFor Zähler = 0 To 4 Step 1
Combo1.AddItem Str(WerteArray(Zähler + 1))Next Zähler
End Sub
Abbildung 31: Formular nach dem Füllender COMBOBOX
Abbildung 32: Reduktion ohne PRESERVE
50
die das folgende Ergebnis liefert:
Das Schlüsselwort PRESERVE bewirkt, daß die Elemente mit den Indexwerten 1 bis 5 ihreWerte behalten.Über die Schaltfläche Beenden wird das Programm verlassen.
12.7 Benutzerdefinierte DatentypenEine Variable, die unterschiedliche, thematisch zusammengehörende und als ein Informati-onsblock zu behandelnde Informationen aufnehmen soll, wird deklariert mit einembenutzerdefinierten Datentyp.Variable dieses Typs werden im Deklarationsabschnitt eines Moduls oder einer Sub mit Hilfeder TYPE - Anweisung generiert und können mittels der Schlüsselwörter PRIVATE oderPUBLIC bezüglich ihres Geltungsbereichs festgelegt werden.Benutzerdefinierte Datentypen können neben unterschiedlichen einzelnen Typen von Datenauch Datenfelder oder andere benutzerdefinierte Datentypen aufnehmen.Sollen beispielsweise Angaben zur Person gespeichert werden, bietet sich dafür einbenutzerdefinierter Datentyp mit dem Namen PersAngaben in der Form:
Public Type PersAngabenLfdNr As IntegerVorname As String * 15Name As String * 20Titel As String * 10Männlich As BooleanKfzKz As String * 3PLZ As String * 5Strasse As String * 20Ort As String * 20GebDatum As DateKinder As IntegerVerdienst As Currency
End Type
Auf der Basis eines so gebildeten benutzerdefinierten Datentyps können Variablen definiertwerden, deren Struktur gleich diesem Datentyp ist, beispielsweise:
Dim Klubmitglied As PersAngaben, Dim Senioren As Persangaben
Auf die einzelnen Elemente dieses Datentyps wird zugegriffen wie auf Objekteigenschaften:PersAngaben.PLZ ="12345"Land = PersAngaben.KfzKz
Nach der ZuweisungKlubmitglied = PersAngaben
erhalten alle Elemente von Klubmitglied die gleichen Werte wie die von PersAngaben.
Abbildung 33: Reduktion mit PRESERVE
51
13 Operatoren, Funktionen, AnweisungenWerden in Prozeduren Berechnungen durchgeführt oder wird mit Zeichenfolgen gearbeitet,so werden in der Regel Ausdrücke und Operatoren verwendet.Ein Ausdruck besteht aus Konstanten, Variablen, Funktionen oder anderen Ausdrücken, diemit Hilfe von Operatoren gebildet werden.Im Visual Basic existieren vier Kategorien von Operatoren, die bestimmten Vorrangregelnunterliegen. Diese bestimmen die Reihenfolge der Ausführung der Operationen, insbeson-dere wenn im Ausdruck mehrere Operatoren vorkommen.Generell gilt beispielsweise die Regel „Punktrechnung vor Strichrechnung“, allerdings ist eskaum möglich, generelle Regeln für die Rangfolge der Operationen festzulegen, insbeson-dere wenn in Ausdrücken Operatoren verschiedenen Kategorien vorkommen. In Zweifels-fällen ist die Online - Hilfe heranzuziehen (Stichwort Operatorvorrang).
13.1 Arithmetische OperatorenVisual Basic unterscheidet insgesamt sieben arithmetische Operatoren:
Operator Bedeutung+ Addition- Subtraktion / Negation* Multiplikation/ reguläre Division\ ganzzahlige Division^ Potenzierung
Mod Modulo
Die ganzzahlige Division liefert als Ergebnis eine ganze Zahl, Dividend und Divisor werden(falls nötig) vor der Ausführung der Operation zu ganzzahligen Werten gerundet. ImQuotienten der Ganzzahldivision werden die Dezimalstellen abgeschnitten, nicht gerundet.
◆ Der bei der Ganzzahldivision verlorengehende Divisionsrest kann mittels der Modulo -Arithmetik bestimmt werden. Dies ist mit Hilfe des MOD - Operators möglich.Das Ergebnis einer arithmetischen Operation übernimmt den Datentyp des Operanden mitder größten Genauigket (in der Reihenfolge: CURRENCY, DOUBLE, SINGLE, LONG, INTEGER)
13.2 Vergleichsoperatoren
Vergleichsoperationen können im Visual Basic mit Hilfe folgender Operatoren durchgeführtwerden:
Operator Bedeutung< kleiner als
<= kleiner oder gleich> größer als
>= größer oder gleich= gleich
<> ungleich
Die zu vergleichenden Ausdrücke müssen vom Typ her verträglich sein. Das Ergebnis istentweder TRUE oder FALSE. Besitzt einer der zu vergleichenden Ausdrücke den Wert NULList das Ergebnis des Vergleichs ebenfalls NULL.Zusätzlich gehören in den Bereich der Vergleichsoperatoren noch zwei, in der Tabelle nichtaufgeführte Operatoren:• IS vergleicht zwei Variablen in Bezug darauf, ob sie auf dasselbe Objekt verweisen:
Ergebnis = Objekt1 Is Objekt2
Wenn sowohl Objekt1 als auch Objekt2 auf dasselbe Objekt verweisen, ist das ErgebnisTRUE, andernfalls ist das Ergebnis FALSE.
• LIKE dient dem Vergleich einer Zeichenfolge mit einem Muster:
52
Ergebnis = Zeichenfolge Like Muster
Das Argument Muster kann unterschiedliche Zeichen, Listen mit Zeichen, Platzhalterzei-chen oder Zeichenbereiche enthalten38:
Test1 = "aBBBa" Like "a*a" ' Liefert True.Test1 = "F" Like "[A-Z]" ' Liefert True.Test1 = "F" Like "[!A-Z]" ' Liefert False.Test1 = "a2a" Like "a#a" ' Liefert True.Test1 = "aM5b" Like "a[L-P]#[!c-e]" ' Liefert True.Test1 = "BAT123khg" Like "B?T*" ' Liefert True.Test1 = "CAT123khg" Like "B?T*" ' Liefert False.
Wegen der recht umfangreichen Beschreibung, insbesondere zur Benutzung von Sonder-und Ersatzzeichen, sei hier auf die Online - Hilfe verwiesen.
13.3 Logische OperatorenBoolsche Ausdrücke verwenden häufig einen der in Visual Basic bekannten sechs logischenOperatoren, mit deren Hilfe mehrfache Prüfungen von Ausdrücken vorgenommen werdenkönnen.Die allgemeine Syntax von Anweisungen mit logischen Operatoren lautet:
Ergebnis = [Ausdruck1] Operator Ausdruck2
Die Operatoren und Ihre Funktionen:
Operator Bedeutung Ergebnis = True, wennNot Negation / Nicht Ausdruck = FalseAnd Konjunktion / Und beide Ausdrücke = TrueOr Disjunktion / inklusives Oder mindestens ein Ausdruck = TrueXor Exklusion / exklusives Oder genau ein Ausdruck = TrueEqv Äquivalenz beide Ausdrücke = True oder FalseImp Implikation außer wenn Ausdruck1=True und
Ausdruck2=False
Der NOT - Operator wirkt nur auf Operanden, alle anderen logischen Operatoren werden zurVerknüpfung von Ausdrücken verwendet.Anwendungsbeispiele:
Zahl1=1, Zahl2=5, Zahl3=10Erg = Not(Zahl1 < Zahl2) ergibt FalseErg = (Zahl2 > Zahl1) And (Zahl3 > Zahl2) ergibt TrueErg = (Zahl2 < Zahl1) Or (Zahl3 < Zahl2) ergibt FalseErg = (Zahl2 < Zahl1) Xor (Zahl3 > Zahl2) ergibt TrueErg = (Zahl2 < Zahl1) Eqv (Zahl3 < Zahl2) ergibt TrueErg = (Zahl2 > Zahl1) Imp (Zahl3 < Zahl2) ergibt False
◆ In bestimmten Fällen (Behandlung von Tastatur- und Mausereignissen) werden logischeOperatoren in Vergleichen von Bitfeld - Werten eingesetzt. Solche Vergleiche werdenbitweise durchgeführt - verglichen werden Bits, die jeweils an gleichen Positionen in derBitkette von Ausdrücken stehen. Der NOT - Operator invertiert in solchen Vergleichen jedesBit eines Operanden (aus 0 wird 1 und umgekehrt).Anwendungsbeispiel:
Wert1 = 4 0000 0100Wert2 = 7 0000 0111Erg = Wert1 And Wert2 0000 0100
38 Beispiele sind der Visual Basic -Online Hilfe entnommen.
53
13.4 Verkettungsoperatoren
Verkettungsoperatoren werden zur Verknüpfung von Zeichenfolgen verwendet. Verkettenlassen sich sowohl Ausdrücke mit alphanumerischen Inhalten als auch gemischte, mitalphanumerischen und numerischen Inhalten.
Für Verkettungen von Zeichenfolgen wird der Operator & benutzt.
So wurden beispielsweise in einigen bisherigen Beispielen Verkettungen der Form:Dim Nr As IntegerNR = 23Ergebnis = "Laufende Nr.: " & NR
verwendet, in denen eine STRING - Konstante mit einer numerischen Variablen verkettetwird. Verkettungen dieser Art bleiben durchaus fehlerfrei, da in solchen Fällen Ausdrücke,die keine alphanumerische Kette darstellen, in den Typ VARIANT umgewandelt werden unddem Ergebnis der Verkettung ebenfalls dieser Typ zugewiesen wird.
Ein zweiter möglicher Verkettungsoperator ist das Zeichen „+“. Da jedoch das gleicheZeichen für Additionen benutzt wird und bei Verkettungen nur Verknüpfungen von STRING-und VARIANT - Typen (hier nur mit alphanumerischem Inhalt) fehlerfrei möglich sind, sollteman, um unnötige Fehler zu vermeiden, von der Verwendung dieses Operators beiVerkettungen absehen.
13.5 Interne FunktionenVisual Basic stellt eine Vielzahl interner Funktionen zur Verfügung. Diese lassen sich unter-schiedlichen Klassen zuordnen, wobei allerdings einige der internen Funktionen so unter-schiedliche Operationen durchführen können, daß sie durchaus auch klassenübergreifendzu betrachten sind. Die hier vorgestellten und in Gruppen eingeteilten internen Funktionenstellen nicht die gesamte verfügbare Menge dar, sondern bilden hauptsächlich die in denProgrammbeispielen und Übungsaufgaben benutzten Funktionen und Gruppen ab.
13.5.1 Mathematische Funktionen
Funktion BeschreibungAbs AbsolutwertAtn ArcusTangensCos CosinusExp Potenz zur Basis eFix ganzzahliger Anteil (Abschneiden der Nachkommastellen !)Int größte ganze Zahl <= AusdruckLog Natürlicher LogarithmusRnd Zufallszahl einfacher Genauigkeit zwischen 0 und 1Sgn VorzeichenwertSin SinusSqr QuadratwurzelTan Tangens
Das Argument einer Funktion wird in Klammern gesetzt:SeiteC = Sqr(SeiteA ^ 2 + SeiteB ^ 2)
Durch Kombinationen von Funktionen lassen sich andere, nicht in Visual Basic -Standardvorrat enthaltene Funktionen ableiten:Logarithmus zur Basis N LogN(X) = Log(X) / Log(N)Hyperb. Arkuskosekans HArkuskosekans(X) = Log((Sgn(X) * Sqr(X * X + 1) +1) / X)
Das folgende Beispiel zeigt die Verwendung der Funktion RND. Simuliert wird das Werfenvon zwei Würfeln (Zufallswerte zwischen 1 und 6). Die hier benutzte Anweisung RANDOMIZE,die den Zufallszahlengenerator initialisiert, wird wegen ihrer inhaltlichen Zusammengehörig-keit zu RND oft auch im Bereich der mathematischen Funktionen von Visual Basic genannt.
54
�
Private Sub Command1_Click()Dim Wert1, Wert2, Msg
RandomizeWert1 = Int(6 * Rnd + 1)Wert2 = Int(6 * Rnd + 1)Msg = "Gewürfelt wurde " & Wert1 & " und " & Wert2 & ". "Msg = Msg & "Gewürfelt insgesamt: " & (Wert1 + Wert2) & " Augen"MsgBox Msg
End Sub
13.5.2 Zeichenfolge - FunktionenFunktion Beschreibung
Format[$] Formatieren eines AusdrucksInstr[B] Position einer Zeichenfolge in einer anderen bestimmenLcase[$] Umwandeln in KleinbuchstabenLen[B] Länge (Anzahl Zeichen) einer ZeichenfolgeLeft[B][$] bestimmte Anzahl vorderer Zeichen ausgebenLtrim[$] führende Blanks entfernenMid[B][$] bestimmte Anzahl Zeichen einer Zeichenfolge zurückgebenRight[B][$] bestimmte Anzahl hinterer Zeichen ausgebenRtrim[$] nachgestellte Blanks entfernenSpace[$] Zeichenfolge mit Blanks erzeugenStrConv Zeichenfolge konvertierenStrComp zwei Zeichenfolgen vergleichenString[$] Zeichenfolge mit gleichen Zeichen erzeugenTrim[$] führende und nachgestellte Blanks entfernenUcase[$] Umwandeln in Großbuchstaben
◆ Funktionen, deren Name mit $ endet, geben einen Wert des Typs STRING zurück. Istkein $ an den Funktionsnamen angehängt, liefert die Funktion einen Wert des Typs VARIANTzurück.
◆ Bei einigen Funktionen besteht die Möglichkeit, ein „B“ an den Namen anzuhängen -solche Funktionen operieren nicht auf einzelnen Zeichen sondern auf Bytes einerZeichenkette.
� Beispiel zur Anwendung der Funktion MID:Dim MittelWort, Msg, TestText, LeerZ1, LeerZ2, WordLen
TestText = "Bitte Rauchen einstellen"LeerZ1 = InStr(1, TestText, " ")LeerZ2 = InStr(LeerZ1 + 1, TestText, " ")WordLen = (LeerZ2 - LeerZ1) - 1MittelWort = Mid(TestText, LeerZ1 + 1, WordLen)Msg = "Das mittlere Wort: " & MittelWortMsgBox Msg, 0, TestText
� Beispiele zur Anwendung der Funktion FORMAT:Format$(Summe, "#,###,##0“)
Format $(3,55, "#.00 DM")
Die Funktion Format$ benutzt für die Formatangabe (die immer in Hochkommataeinzuschließen ist) bestimmte Zeichen als Platzhalter, so z.B.:
# Platzhalter für eine Ziffer (mit Unterdrückung führender Nullen)0 Platzhalter für eine Ziffer (ohne Unterdrückung führender Nullen), Trennzeichen für Tausenderstellen@ Platzhalter für ein alphanumerisches Zeichen (einschl. Leerzeichen)& Platzhalter für ein alphanumerisches Zeichen (ohne Leerzeichen)< alle Zeichen als Kleinbuchstaben anzeigen> alle Zeichen als Großbuchstaben anzeigen
55
13.5.3 Datums- und Zeitfunktionen (Auswahl)Funktion BeschreibungDate[$] SystemdatumDateAdd Addition Zeitintervall + DatumDateDiff Differenz zweier DatumswerteDay Tag des Monats (Zahl)Month Monat (als Zahl)Time[$] SystemzeitTimeSerial Uhrzeit (Stunden, Minuten, Sekunden)WeekDay Wochentag (Zahl)Year Jahreszahl
13.5.4 DateifunktionenDateifunktionen werden bei Operationen auf Dateien (Verwaltung von Dateien, Dateiinfor-mationen, Steuerung von Lese- und Schreibvorgängen usw.) verwendet.
Funktion BeschreibungCurDir[$] aktueller Pfad (des aktuellen Laufwerks)Dir[$] Dateiname oder LaufwerksbezeichnungEOF Prüfung auf DateiendeFileAttr ZugriffsmodusFileDateTime Datum und Uhrzeit der Dateierstellung bzw. letzten ÄnderungFileLen Dateigröße in BytesGetAttr DateiattributeInput[B][$] Rückgabe von Zeichen aus sequentieller DateiLoc aktuelle Schreib- / Leseposition in einer DateiLOF Größe einer geöffneten Datei in BytesSeek aktuelle Position in einer DateiSpc Positionierung über Leerzeichen (bei Print - Anweisung)Tab Positionierung über Spaltenangabe (bei Print - Anweisung)
13.5.5 Sonstige Funktionen (Auswahl)Funktion BeschreibungError[$] Liefert Meldung zu vorgegebener FehlernummerIs Array Prüft af DatenfeldIsError Prüft numerischen Ausdruck auf FehlerwertQBColor Farbcode für eine von 16 FarbenRGB Farbcode für Kombinationen von Rot, Grün und BlauShell Ausführen einer anderen Anwendung
56
13.6 KontrollstrukturenKontrollstrukturen werden in der Programmierung benutzt, um die physikalische Reihenfolgeder Anweisungen im Programmablauf zu verändern. Zu Kontrollstrukturen gehören:• Entscheidungsstrukturen, in denen ein Programm zu einem von mehreren alternativen
Anweisungsblöcken verzweigen kann.• Schleifenstrukturen, die die wiederholte Ausführung von Anweisungsgruppen erlauben.
13.6.1 EntscheidungenEntscheidungen erlauben es, in Abhängigkeit von einer Bedingung, unterschiedliche Pro-grammteile auszuführen. Das Programm verzweigt in mehrere Äste, von denen allerdingsimmer nur einer ausgeführt werden kann.
13.6.1.1 If...Then ...Else - AnweisungDie einfachste Form dieser Anweisung ist die einzeilige IF - Anweisung in der Form:
If Bedingung Then Anweisungen1 [Else Anweisungen2]
Bedingung ist ein Ausdruck, dessen Auswertung die Werte TRUE oder FALSE liefert. Ist dasErgebnis TRUE, wird der THEN - Zweig ausgeführt (Anweisungen1), andernfalls der ELSE -Zweig (Anweisungen2). Beide Anweisungsteile können aus Einzelanweisungen odermehreren Anweisungen bestehen. Bestehen sie aus mehr als einer Anweisung, müssen dieEinzelanweisungen voneinander durch Doppelpunkte (:) getrennt sein und unbedingt ineiner Programmzeile untergebracht werden können:If Zahl1 > 5 Then Meldung = "über 5"If Zahl1 > 5 Then Meldung = "über 5" Else Meldung = "unter 5"If Zahl1 < 5 Then Erg1 = Zahl1 + 1 : Erg2 = Zahl1 - 3 : Erg3 = Zahl1 Mod 2
Die gleiche Anweisung kann auch in der Blockform angewandt werden:If A1 = 1 Then
...diese Anweisungen werden nur ausgeführt,
...wenn A1 = 1 ist
EndIfoder
If A1 = 1 Then
...diese Anweisungen werden nur ausgeführt,
...wenn A1 gleich 1 ist
Else
...diese Anweisungen werden nur ausgeführt,
...wenn A1 ungleich 1 ist
EndIf
Eine erweiterte Form dieser Blockanweisung hat die Syntax:If Bedingung1 Then... [Anweisungsblock1]
... [ElseIf Bedingung2 ThenAnweisungsblock2]] ....
[Else[Anweisungsblock n]]
EndIfHier werden die Bedingungen hinter IF oder ELSEIF von oben beginnend solange geprüft undeventuell der dazugehörige Anweisungsblock solange übersprungen, bis eine Bedingungden Wert TRUE liefert. In solchen Fällen wird der entsprechende Anweisungsblockausgeführt und anschließend zur ersten Anweisung hinter ENDIF gesprungen. Trifft keine
57
Bedingung zu, werden die Anweisungen im ELSE - Zweig ausgeführt und dieProgrammausführung hinter ENDIF fortgesetzt.◆ Treffen Bedingungen in mehreren ELSE - Zweigen zu, wird nur der Anweisungsblockausgeführt, der auf die erste zutreffende Bedingung folgt und anschließend wird derProgrammablauf hinter ENDIF fortgesetzt.
13.6.1.2 Die Select Case - AnweisungEine Alternative zur Blockform der IF - Anweisung bildet die SELECT CASE -Anweisung. IhrVorteil gegenüber der IF - Anweisung liegt darin, daß sie in einfacherer und übersichtlichererForm die Definition von Anweisungsgruppen erlaubt. Intern wird sie vom System in eineneffizienteren Code umgesetzt und beschleunigt dadurch die Programmausführung.Ihre Syntax lautet:
Select Case Testausdruck[Case Werteliste1..[Anweisungen1]]
[Case Werteliste2..[Anweisungen2]]...
.[Case Else..[Anweisungen n]]
End Select
Testausdruck ist die auszuwertende Struktur.Wertelisten können aus einzelnen Werten bestehen, oder aus Ausdrücken der Form:
Ausdruck1, Ausdruck2[...,Ausdruck n]
Liste von Werten, durch Kommatagetrennt
Ausdruck1 To Ausdruck n Werte mit Unter- und ObergrenzeIs Vergleichsoperator Ausdruck Wertebereich
Anwendungsbeispiel:Select Case Zahl1Case Is <= 0
Meldung = "Zahl ist zu klein"Case 1, 2, 3
Meldung = "Zahl ist kleiner 4"Case 4 To 7
Meldung = "Zahl ist zwischen 4 und 7"Case Is > 8 And Zahl1 < 11
Meldung = "Zahl ist 9 oder 10"Case Else
Meldung = "Zahl außerhalb des Bereichs"End Select
58
13.6.2 SchleifenMit Hilfe von Schleifenstrukturen lassen sich bestimmte Anweisungsfolgen mehrmals,abhängig von einer bestimmten Bedingung abarbeiten. Die Anzahl der Schleifendurchläufewird durch den Wahrheitswert eines Ausdrucks - der Schleifenbedingung - oder durch denWert eines numerischen Ausdrucks - des Schleifenzählers - definieren.
13.6.2.1 Do...Loop - AnweisungDO...LOOP wird verwendet, um Anweisungen auszuführen, solange oder bis bestimmteBedingungen erfüllt sind. In der Form:
Do While Bedingung.Anweisung(en).Loop
werden die Anweisungen ausgeführt, solange Bedingung erfüllt ist (hier Zahlen 1 bis 1000):Zähler = 1Do While Zähler < 1001
Zähler = Zähler + 2Loop
In der Form:Do Until Bedingung.Anweisung(en).Loop
werden die Anweisungen ausgeführt bis die Bedingung erfüllt wird:Do Until Zähler = 1000
Zähler = Zähler + 2Loop
In bestimmten Situationen wird eine DO - Schleife nach der Prüfung der Bedingung nichtdurchlaufen, weil Bedingung wahr ist.Solen die Anweisungen in der Schleife dennoch mindestens einmal durchlaufen werden,wird eine andere Variante der DO...LOOP - Anweisung benutzt:
Do... [Anweisungen...]Loop [{While | Until} Bedingung]
� In der Anweisungsfolge:Zähler = 2500Do While Zähler < 1001
Zähler = Zähler + 1Anw.Text = Zähler
Loop
werden die Anweisungen der DO - Schleife nicht ausgeführt.
59
In der Form:Zähler = 2500Do
Zähler = Zähler + 1Anw.Text = Zähler
Loop While Zähler < 1001
werden sie einmal ausgeführt, anschließend die Bedingung geprüft und die Schleifeverlassen.Die Anweisungsfolge:
Zähler = 80DoZähler = Zähler + 1Anw.Text = ZählerLoop While Zähler < 301
zählt beispielsweise von 81 bis 301.
13.6.2.2 For ... Next - AnweisungDie FOR ... NEXT - Schleife wird verwendet, wenn, im Unterschied zur DO - Schleife, dieAnzahl der Wiederholungen des Anweisungsblocks der Schleife feststeht.Die allgemeine Form des Anweisung lautet:
For Zähler = Anfangswert To Endwert [ Step Schrittweite].
AnweisungenNext [Zähler]
Die numerische Variable Zähler39 wird bei jedem Schleifendurchlauf um den Wert vonSchrittweite inkrementiert oder dekrementiert (je nach Vorzeichen von Schrittweite).Vor dem ersten Schleifendurchlauf wird der Wert von Zähler auf Anfangswert gesetzt unddie Anweisungen solange wiederholt, bis der Wert von Zähler größer (positive Schrittweite)oder kleiner (negative Schrittweite) als Endwert ist.
◆ Wird Schrittweite nicht angegeben, gilt Schrittweite = 1.
� Der Wert von Zähler sollte innerhalb der Schleife der FOR ... NEXT - Anweisung nichtverändert werden, weil es i.d.R. zu unnötigen Fehlern führt.
�Dim N As IntegerFor N = 1 To 21 Step 2
FeldA.AddItem = N ^ 2Next
berechnet die Quadrate der Zahlen 1, 3, 5, 7, ..., 19, 21.
13.6.2.3 For Each ... Next - AnweisungWährend bei der FOR ... NEXT - Schleife die Anzahl der Durchläufe explizit angegeben wird,legt Visual Basic in der FOR .. EACH - Anweisung diese Zahl selbst implizit fest.Diese Schleife wiederholt Anweisungen für alle Elemente eines Datenfeldes, wobei dieAnzahl der Durchläufe gleich der Anzahl der Elemente ist.Die Syntax der Anweisung lautet:
For Each Element In Datenfeld.[Anweisungen ...]
Next [Element]
39 Kann auch Element eines benutzerdefinierten Datentyps sein.
60
� Das im Programmbeispiel6 behandelte Problem der Erstellung von Textfeldern zurLaufzeit, könnte mittels der EACH ... NEXT - Methode in folgender Form gelöst werden:
Private Sub Sfläche_Click()Dim N As Integer, TElement
For N = 1 To 4Load Feld1(N)Feld1(n).Top = Feld1(N).Top + 160
NextFor Each TElement In Feld1
TElement.Visible = TrueTElement.Text = "Eingefügtes Feld # " & TElement.Index
NextEnd Sub
Die in der FOR ... NEXT - Schleife zur Laufzeit generierten Textfelder werden in der FOR ...EACH - Struktur sichtbar gemacht und mit Textstrings belegt.
13.6.2.4 Die With - AnweisungMit Hilfe der WITH - Anweisung, die als eine Schleife mit nur einem Durchlauf verstandenwerden kann, können mehrere Eigenschaften eines Objekts gesetzt werden, ohne daßjedesmal der Objektname angegeben werden muß.Ihre Syntax:
With Objekt.. [Anweisungen..]
End With
� Die folgende WITH - Anweisung setzt mehrere Eigenschaften einer Befehlsschaltflächemit dem Namen Einfügen:
With Einfügen.Heigth = 300.Width = 900.Left = 280.Top = 800.MultiLine = True.Caption = "Einfügen eines Wertes"
End With
13.6.2.5 Die Exit For- und Exit Do - AnweisungMit Hilfe dieser beiden Anweisungen können die DO- bzw. FOR - Schleifen beim Eintreteneiner bestimmten Bedingung vorzeitig verlassen werden.
�For N = 1 To 50
Erg.Text = Str(N)Zahl1 = N ^2If Zahl1 > VerglWert ThenExit For
End IfZahl2 = N
Next
�N = 1Do While N < 51
Erg.Text = Str(N)Zahl1 = N ^2If Zahl1 > VergWert ThenExit Do
End IfZahl2 = N
61
N = N + 1Loop
13.6.3 AuswahlfunktionenDie Auswahlfunktionen sind spezielle Entscheidungswerkzeuge, die eigentlich nicht in denBereich der Entscheidungsstrukturen gehören, deren Funktionsweise jedoch durchaus mitder einer Entscheidungsstruktur vergleichbar ist.
Die ILF - Funktion:Ilf (Bedingung, True-Ausdruck, False-Ausdruck)
mit der Funktionalität einer einfachen IF-THEN - Struktur:Meldung = Ilf(Zahl >= 0, "positiv", "negativ")
gibt im TRUE - Fall den ersten, sonst den zweiten Wert zurück40.
Die SWITCH - Funktion
Switch (Bedingung1, Ausdruck1 [, Bedingung2, Ausdruck2]....)
vergleichbar mit der SELECT CASE - Struktur:FamStand = Switch(Kenn = 1, "ledig", Kenn = 2 , "verheiratet", Kenn = 3,"verwitwet")
wertet eine Liste von Bedingungen aus und verarbeitet den Ausdruck der zutreffendenBedingung.
Die CHOOSE - Funktion
Choose(Index, Ausdruck1 [, Ausdruck2]...)
ebenfalls mit der SELECT CASE - Konstruktion vergleichbar:PersGrösse = Choose(GRIndex, "klein", "mittel", "gross", "riesig")
gibt in Abhängigkeit von Wert eines ganzzahligen Indexes den Wert aus einer Liste derAlternativen aus, dessen Listenposition dem Indexwert entspricht.
40 An dieser Stelle sind auch Ausdrücke möglich.
62
14 Ein- und Ausgabe
14.1 DialogfelderEin Mittel zum Austausch von Informationen zwischen dem Benutzer und einem Programmsind Dialogfelder. Visual Basic unterscheidet drei Typen von Dialogfeldern• Vordefinierte Dialogfelder, mit MSGBOX - Funktion und INPUTBOX - Funktion.• Benutzerdefinierte Dialogfelder• Standarddialogfelder (z.B. Speichern unter, Schriftart,)In diesem Teil der Unterlage werden nur die vordefinierten Dialogfelder behandelt, diebeiden anderen Formen sind u.A. Gegenstand des Kurses Visual Basic Erweiterungen I.
14.1.1 Message Box (MsgBox)Mit Hilfe der Funktion MSGBOX() können vom Programm aus Meldungen an den Benutzerausgegeben und seine Reaktionen darauf ermittelt werden.Die MSGBOX - Funktion hat die allgemeine Syntaxform:
MsgBox(Meldung [, Dialogtyp] [, Titel])
• MELDUNG ist ein Zeichenfolgeausdruck (max. 1000 Zeichen lang), der den Meldungstextdefiniert. Soll der Meldungstext umbrochen werden (Zeilenumbruch), ist an der ge-wünschten Stelle das Steuerzeichen vbCrLf einzufügen.
Die beiden anderen Argumente sind optional:
• TITEL definiert den Text, der in der Titelleiste der Box erscheinen soll. Wird kein TITELangegeben, setzt Visual Basic dort den Namen der Anwendung ein.
• DIALOGTYP bietet die Möglichkeit der Definition des Typs und Anzahl von Schaltflächen inder Box, der Art des angezeigten Symbols, der Festlegung der Standard - Schaltflächeund der Art der Bindung des Dialogfelds.
Dazu gehören die folgenden Argumente:
♦ Typ und Anzahl Schaltflächen:
Konstante Wert SchaltflächevbOKOnly 0 nur OK (Defaultwert)vbOKCancel 1 OK und AbbrechenVbAbortRertryIgnore 2 Abbrechen, Wiederholen, IgnorierenvbYesNoCancel 3 Ja, Nein, AbbrechenvbYesNo 4 Ja, NeinvbRetryCancel 5 Wiederholen, Abbrechen
♦ Angezeigtes Symbol:
Konstante Wert SymbolVbCritical 16 Stop-ZeichenvbQuestion 32 FragezeichenvbExclamation 48 AusrufezeichenvbInformation 64 Info-Symbol
♦ Festlegen der Standard- Schaltfläche (aktivierte Schaltfläche):
Konstante Wert aktivierte Schaltfläche (von links)vbDefaultButton1 0 1. Schaltfläche (Defaultwert)vbDefaultButton2 256 2. SchaltflächevbDefaultButton3 512 3. Schaltfläche
63
♦ Festlegen der Dialogfeldbindung
Konstante Wert Dialogfeld gebunden anvbApplicationModal 0 Anwendung (Defaultwert)vbSystemModal 4096 System
� Die Argumente für Dialogtyp können sowohl in der numerischen Form (Spalte Wert) alsauch in der Konstantenform (Spalte Konstante) angegeben werden. Durch Summen vonWerten aus den einzelnen Gruppen kann ein Gesamtwert gebildet werden, der mehrereEinstellungen kombiniert (siehe nächstes Beispielprogramm).Die Rückgabewerte der Funktion geben Auskunft über die betätigte Schaltfläche:
Konstante Wert betätigte SchaltflächevbOK 1 OKvbCancel 2 AbbrechenvbAbort 3 AbbruchvbRetry 4 WiederholenvbIgnore 5 IgnorierenvbYes 6 JavbNo 7 Nein
◆ Applikationsmodal / Systemmodal
• Ist ein Dialogfeld applikationsmodal, kann die aktuelle Applikation erst fortgesetztwerden, wenn seitens des Benutzers eine Reaktion auf das Dialogfeld erfolgt ist. AndereApplikationen können jedoch bedient werden.
• Ist ein Dialogfeld systemmodal, kann mit keiner Applikation gearbeitet werden bis eineReaktion auf das Dialogfeld erfolgt ist. Solange das Dialogfeld in der Anzeige verbleibt,kann weder die aktuelle noch eine andere Applikation fortgesetzt werden.
� Die Dialogfelder der MSGBOX - Funktion sind applikationsmodal.
14.1.2 Input BoxDie Funktion INPUTBOX() generiert eine Eingabeaufforderung. Sie zeigt ein Dialogfeld miteiner Meldung, einem Textfeld, einer OK- und ABBRECHEN - Schaltfläche und in dererweiterten Form41 eine HILFE - Schaltfläche.Ihre Syntax:InputBox(prompt [, title][, default][, xpos][, ypos][, helpfile, context])
◆ Die Funktion verwendet benannte Argumente. Bei Belegungen der Argumente mittelsProgrammanweisungen muß unbedingt die Syntax vorgegebener Bezeichner (die Namen )eingehalten werden.
• PROMPT ist ein Zeichenfolgeausdruck (max. 1000 Zeichen) für den Meldungstext42.• TITLE gibt den Text der Titelleiste an43.• DEFAULT ist der Vorgabewert des Textfeldes.• XPOS, YPOS sind Koordinaten des Dialogfeldes auf dem Bildschirm. Werden keine
angegeben, erscheint das Textfeld horizontal in der Mitte, vertikal auf einem Drittel derGesamthöhe.
41 Wird im Erweiterungsteil des Kurses behandelt.42 Evtl. benötigter Zeilenumbruch siehe MsgBox.43 Defaultwert - siehe MsgBox
64
• HELPFILE ist der Name der Datei mit kontextbezogener Hilfe, CONTEXT die numerischeKennung des Hilfetextes. Beide Argumente können nur gemeinsam angegeben werden.Werden sie benutzt, wird eine zusätzliche Schaltfläche HILFE eingeblendet.
� Beim betätigen der Abbruch – Taste wird eine leere Zeichenkette zurückgegeben.
14.2 Programmbeispiel 8.Das Programm soll die Anwendung der Funktionen INPUTBOX und MSGBOX demonstrieren.Die Dialogfenster sind hier nicht grafisch dargestellt - dies sei dem Leser überlassen.Das Formular dieses Programms besteht aus zwei Arrays von Steuerelementen:• eine Gruppe für das Handling der Input - Boxen• eine zweite Gruppe für das Handling der Message - Boxen:
Die Schaltfläche BEENDEN gehört zum Array der INPUT - Box -Elemente und wird programm-technisch zusammen mit dieser Gruppe behandelt.Die CLICK - Prozedur der INPUT - BOX Gruppe hat die Form:
Private Sub IBox_Click(Index As Integer)Const Titel = "InputBox - Beispiel"
Dim Meldung As String, Nachr As StringDim WTag As String
Select Case IndexCase 3
If MsgBox("Ende ??", vbYesNo + vbQuestion _+ vbDefaultButton2) = vbYes ThenUnload Me
End IfExit Sub
Case 0Meldung = InputBox("Bitte eine beliebige Eingabe:", _Titel)
Case 1Meldung = InputBox("Bitte Eingabe einer Zahl:", _
Titel)Case 2
Meldung = InputBox("Bitte Eingabe eines Datums:", _Titel)
End Select
If Meldung = "" ThenMsgBox "Keine Eingabe" & vbCrLf & _
Abbildung 34: Formular zum Testen der INPUTBOX-und MSGBOX - Formen
65
"oder <Abbrechen> betätigt", vbExclamationElseIf Index = 1 Then
If Not IsNumeric(Meldung) ThenMsgBox "keine Zahl !!"
End IfMsgBox "Ihre Eingabe war: " & Meldung
ElseIf Index = 2 ThenIf Not IsDate(Meldung) Then
MsgBox "Kein richtiges Datum !"MsgBox "Ihre Eingabe war: " & Meldung
ElseWTag = Format$(DateValue(Meldung), "dddd")Nachr = "Eingegebenes Datum war: " & _
Meldung & vbCrLfNachr = Nachr & "Der Wochentag: " & WTagMsgBox Nachr, vbInformation
End IfElse
MsgBox "Die Eingabe: " & MeldungEnd If
End Sub
Die Click Prozedur der Gruppe der MsgBox - Steuerelemente hat die Form:Private Sub MBox_Click(Index As Integer)Dim Antwort As ByteDim Typ As IntegerDim Meldung As String, Knopf As String
Select Case IndexCase 0Typ = vbOKCancel + vbExclamationMeldung = "Soll fortgesetzt werden ?"
Case 1Typ = vbAbortRetryIgnore + vbCritical + _
vbDefaultButton2Meldung = "Achtung kritischer Fehler !"
Case 2Typ = vbYesNoCancel + vbExclamation + _
vbDefaultButton3Meldung = "Lass uns weiter gehen !"
Case 3Typ = vbYesNo + vbQuestionMeldung = "Weiter ?"
Case 4Typ = vbRetryCancel + vbExclamationMeldung = "Noch ein Versuch ?"
End Select
Antwort = MsgBox(Meldung, Typ, _"Funktion der MsgBox")
Select Case AntwortCase vbOK
Knopf = "<OK>"Case vbCancel
Knopf = "<Abbrechen>"Case vbAbort
Knopf = "<Abbruch>"Case vbIgnore
Knopf = "<Ignorieren>"Case vbRetry
Knopf = "<Wiederholen>"Case vbYes
Knopf = "<Ja>"Case vbNo
Knopf = "<Nein>"
66
End Select
MsgBox "Der betätigte Knopf war: " & Knopf, _vbInformation
End Sub
14.3 MausereignisseDie Bedienung von Steuerelementen (z.B. Befehlsschaltflächen) durch Anklicken mit derMaus ist kein Mausereignis im direkten Sinne. Direkte Mausereignisse sind Ereignisse, dieInformationen über die Maus (Mausbewegung, Position des Mauszeigers) liefern.Voraussetzung dafür, daß ein Objekt ein Mausereignis erkennt, ist, daß sich der Mauszeigerzum Zeitpunkt des Ereignisses44 innerhalb des Objekts befindet (innerhalb der Begren-zung).Eine Form registriert ein Mausereignis nur dann, wenn sich der Mauszeiger an einer freienStelle der Form befindet (nicht innerhalb eines Steuerelements).Visual Basic unterscheidet fünf Mausereignisse:
Ereignis wird ausgelöst durchMouseDown Maustaste drückenMouseUp Maustaste loslassenMouseMove Mauszeiger bewegenDragDrop Steuerelement auf einem Objekt ablegenDragOver Steuerelement über ein Objekt ziehen
Die Syntax der Deklaration der ersten drei lautet:Private Sub Objekt_{MouseDown | MouseUp | MouseMove} ([Index As Integer,] _
Button As Integer, Shift As Integer, X As Single, Y As Single
• Objekt ist der Name des registrierenden Objekts• Index ist der Index des registrierenden Objekts• Button steht für einen Bitfeld - Wert, dessen unterste drei Bits eine Information über den
Zustand der drei Maustasten liefern:− Bit 0 gesetzt - linke Maustaste gedrückt (Bitwert 1)− Bit 1 gesetzt - rechte Maustaste gedrückt (Bitwert 2)− Bit 2 gesetzt - mittlere Maustaste gedrückt (Bitwert 4)45
In der Praxis empfiehlt es sich, statt der numerischen Werte (1, 2, 4) die entsprechendenintegrierten Konstanten zu benutzen:
Konstante Wert BedeutungvbLeftButton 1 linke MaustastevbRightButton 2 rechte MaustastevbMiddleButton 4 mittlere Maustaste
• Shift funktioniert ähnlich wie Button, gibt jedoch den Zustand bestimmter Umschalttastender Tastatur wieder:
Konstante Wert BedeutungvbShiftMask 1 Umschalt - TastevbCtrlMask 2 Strg - TastevbAltMask 4 Alt - Taste
• X und Y sind die Koordinaten der aktuellen Position des Mauszeigers.
44 genauer gesagt zum Zeitpunkt des Eintretens des Ereignisses45 bei Mäusen mit zwei Tasten ist dieses Bit immer gleich 0
67
◆ Form - KoordinatenDie Koordinaten einer Form können in unterschiedlichen Einheiten angegeben werden. Diebenutzten Einheiten werden in der Eigenschaft SCALEMODE festgelegt.Die von Visual Basic verwendete Standardeinheit ist ein TWIP.Die SCALEMODE - Eigenschaft kann folgende Einheiten definieren:• Twips (1 Inch = 1440 Twips)• Points (1 Inch = 72 Points)• Inches• Character• Milimeter• ZentimeterDer Ursprung des Koordinatensystems wird durch die Eigenschaften SCALETOP undSCALELEFT definiert. Der Standardwert beider Eigenschaften ist 0, d.h. der Ursprung liegt inder oberen linken Ecke des Formbereichs.Dabei ist der Formbereich der verwendbare Bereich einer Form, d.h. der nach dem Ab-schneiden des Rahmens und der Titelleiste verbleibende Rest der Form.Die Behandlung von Mausereignissen demonstrieren die beiden nachfolgenden Beispielpro-gramme.
14.4 Programmbeispiel 9Das Programm demonstriert die Verlagerung von Objekten innerhalb einer Form alsReaktion auf Mausereignisse.Die im oberen Bereich der Form angeordneten IMAGE - Felder :
werden nach Auswahl des gewünschten Feldes über ein Optionsfeld innerhalb der Form andie Position des Mauszeigers verschoben (Klick mit der Maus in den freien Bereich derForm).Die MouseDown - Ereignisprozedur des Formulars hat die Form:Private Sub Form_MouseDown(Button As Integer, _
Shift As Integer, X As Single, Y As Single)If OptL.Value = True Then
BLinks.Move X, YElseIf OptM.Value = True Then
BMitte.Move X, YElseIf OptR.Value = True Then
BRechts.Move X, YElse
cmdSprung.Move X, YEnd If
End Sub
OptL, OptM, OptR sind Namen der Optionsschaltflächen,BLinks, BMitte, BRechts sind Namen der Image – Felder, cmdSprung ist der Name derSchaltfläche Schalter 1.
Abbildung 35: Formular für Maus - Ereignisse (1)
68
14.5 Beispielprogramm 10In das Formular des Programms wird ein rotes Rechteck gezeichnet, in dessen Mitte dieEnde - Schaltfläche plaziert wird. In Abhängigkeit von gedrückter Maustaste bzw. derKombination von Maus- und SHIFT-, STRG- und ALT-Taste soll das Rechteck seine Form,Farbe und Rahmenstärke ändern:
Die MouseDown - Ereignisprozedur des Formulars hat die Form:Private Sub Form_MouseDown(Button As Integer, Shift As Integer,_
X As Single, Y As Single)Dim ZeichenFarbe As LongIf Button = vbLeftButton Then
ZeichenFarbe = vbYellowRechteck.BorderColor = ZeichenFarbeRechteck = 2cmd2.Visible = False
ElseIf Button = vbRightButton ThenZeichenFarbe = vbBlueRechteck.BorderColor = ZeichenFarbeRechteck = 3cmd2.Visible = Truecmd2.Caption = "bin da"
ElseIf Button = vbMiddleButton ThenZeichenFarbe = vbGreenRechteck.BorderColor = ZeichenFarbeRechteck = 4
End If
If Shift = vbCtrlMask ThenRechteck.BorderWidth = 5
ElseIf Shift = vbShiftMask ThenRechteck.BorderWidth = 10
ElseIf Shift = vbAltMask ThenRechteck.BorderWidth = 20
End If
End Sub
Rechteck ist der Name des in das Formular eingezeichneten Rechtecks. Die AnweisungenRECHTECK.SHAPE = n verändern die Form des Rechtecks (0 = Rechteck, 1 = Quadrat,2 = Oval usw.). Beim Betätigen der linken Maustaste wird die rechts unten liegendenSchaltfläche mit der CAPTION weg ausgeblendet (die Eigenschaft VISIBLE = FALSE gesetzt),beim Betätigen der rechten Maustaste wird diese Schaltfläche wieder eingeblendet, wobeidie CAPTION (Beschriftung) auf bin da verändert wird.
� Die If – Zweige für die mittlere Maustaste funktionieren nur bei Mäusen, deren mittlereTaste aktiviert ist (Treiberprogramm „bedient“ die mittlere Maustaste).
Abbildung 36: Reaktion auf Mausereignisse (2)
69
14.6 TastaturereignisseBei Objekten, die Tastatureingaben akzeptieren, löst die Bewegung einer Taste der Tastaturein Tastaturereignis aus. Auf Tastaturereignisse können nur Objekte reagieren, welche denFocus besitzen.Es gibt in Visual Basic drei, den Aktivitäten der Tastatur entsprechende Ereignisse:
Ereignis wird ausgelöst durchKeyDown Drücken einer TasteKeyUp Loslassen einer TasteKeyPress Drücken einer ANSI - Taste
ANSI -Taste ist eine Taste der Tastatur, für die es ein ASCII - Zeichen gibt (Funktionstastenerzeugen beispielsweise keine ASCII - Zeichen).◆ Ein Formular kann nur dann den Focus erhalten, wenn keines seiner Steuerelemente ihnbesitzt. Dies ist nur in leeren Formularen oder in Formularen, deren alle Steuerelementegesperrt sind, der Fall.� Das Setzen der KEYPREVIEW - Eigenschaft eines Formulars auf TRUE bewirkt, daßTastaturereignisse zuerst an die Form und anschließend erst an das Steuerelement mit demFocus gesendet werden.Die Ereignisprozedur KEYPRESS hat die allgemeine Syntax:Private Sub Objekt_KeyPress([Index As Integer, ] KeyAscii As Integer)
KEYASCII ist der Code des Zeichens der gedrückten Taste. Der Wert kann im Programmabgefragt werden und, wenn nötig, geändert werden.Ungültige Zeichen können mit
KeyAscii = 0
in NULL - Zeichen umgewandelt werden.Mit der Anweisungsfolge:
If KeyAscii = Asc("a") Then KeyAscii=("e")If KeyAscii = Asc("i") Then KeyAscii=("y")
in der KEYPRESS - Prozedur eines Textfeldes kann beispielsweise die Eingabe „Maier“ in„Meyer“ umgewandelt werden.Die Ereignisprozeduren KEYDOWN und KEYUP registrieren die physikalische Bewegung derTasten:
Private Sub Objekt_{KeyDown | KeyUp} ([Index As Integer,] _KeyCode As Integer, Shift As Integer
• KEYCODE enthält den numerischen Code der gedrückten Taste. Erkannt werden alleTasten incl. Der Funktions- , Pfeil-, und Sondertasten. Visual Basic kennt sämtliche dieser Codes auch als Konstante. Ihre Namen beginnen mitVBKEY, angehängt wird der jeweilige Tastenname (VBKEYA, VBKEY8, VBKEYF3 u.ä.).
• Shift ist identisch mit dem Argument gleichen Namens bei Mausereignissen. DieFunktionsweise ist ebenfalls identisch.
70
14.7 Beispielprogramm 11Das Programm demonstriert die Erkennung von Tastaturereignissen. Die Form besteht ausdrei Textfeldern für die Anzeige (von oben beginnend) von folgenden Ereignissen:
• Taste gedrückt• ASCII - Wert gedrückter Taste• Taste losgelassen
Wird die Start - Schaltfläche angeklickt, ändert sie Ihre Beschriftung in die Aufforderung,eine Taste der Tastatur zu drücken. Das Niederdrücken, der ASCII - Wert (so vorhanden)und das Loslassen der Taste werden entsprechend quittiert. Die Schaltfläche Löschen löschtden Inhalt der Textfelder und verändert die Eigenschaft Caption der Startschaltfläche in denUrsprungswert, womit das Formular wieder in den Grundzustand vor dem Tastendruckversetzt wird:
Die Anwendung ist mit den folgenden Programmcodes versehen (Schaltfläche Beendenvernachlässigt):Click - Prozedur der Startschaltfläche
Private Sub cmdFläche_Click()cmdFläche.Caption = "Bitte jetzt eine beliebige Taste drücken"
End Sub
KeyPress - Prozedur der StartschaltflächePrivate Sub cmdFläche_KeyPress(KeyAscii As Integer)
Dim CharChar = Chr(KeyAscii)FeldA.Text = "ASCII-Zeichen = " + Str(KeyAscii) + _
" Zeichen: " + CharEnd Sub
Abbildung 37: Formular vor einem Tastaturereignis
Abbildung 38: Formular nach einem Tastaturereignis
71
KeyDown - Prozedur der StartschaltflächePrivate Sub cmdFläche_KeyDown(KeyCode As Integer, Shift As Integer)
FeldB.Text = "Tastencode gedrückter Taste: " + _Str(KeyCode) + " Shift = " + _Str(Shift)
End Sub
KeyUp - Prozedur der StartschaltflächePrivate Sub cmdFläche_KeyUp(KeyCode As Integer, Shift As Integer)
FeldC.Text = "Taste losgelassen: " + Str(KeyCode) + _" Shift = " + Str(Shift)
End Sub
Da die Start - Schaltfläche den Focus behält erfolgt die Steuerung ausschließlich überEreignisprozeduren dieser Fläche.
Click - Prozedur der Schaltfläche LöschenPrivate Sub cmdLösch_Click()
FeldA.Text = ""FeldB.Text = ""FeldC.Text = ""cmdFläche.Caption = "Zum Starten bitte mit der Maus anklicken"
End Sub
72
15 Dateiverarbeitung (Grundlagen)Visual Basic besitzt eine Reihe von Befehlen und Funktionen zur Dateiverwaltung sowie zumSpeichern und Lesen von Daten.Um eine Datei zu bearbeiten, d.h. sie zu öffnen, zu schließen, ihren Inhalt einzulesen oder indie Datei zu schreiben, müssen Laufwerk, Ordner, Dateiname und Dateityp bestimmtwerden. Für diesen Zweck besitzt Visual Basic eine Gruppe von Steuerelementen.
15.1 Dateisystem - SteuerelementeFür die Auswahl von Laufwerken, Ordnern und Dateien gibt es die folgendenSteuerelemente:
Das Laufwerkslistenfeld, welches alle gültigen Laufwerke des Systems (incl.eventueller Netzwerklaufwerke) in einer alphabetisch sortierten Liste (als Dropdown -
Listenfeld) anzeigt und dem Benutzer eine beliebige Auswahl gestattet.
Das Verzeichnislistenfeld46, welches die Ordnerstruktur des aktuellen Laufwerks inder Form einer hierarchischen Liste anzeigt. Der aktuelle Ordner ist markiert. Ein
einfacher Mausklick auf ein Element der Liste markiert dieses Element, ein Doppelklicköffnet die Sicht auf eventuell vorhandene Unterordner47.
Das Dateilistenfeld zeigt zur Laufzeit die Dateien des Ordners, der imVerzeichnislistenfeld als aktueller Ordner angezeigt wurde. Der voreingestellte
Eigenschaftswert für die Dateien ist „*.*“, d.h. es werden alle Dateien des Ordners angezeigt.Alle drei Listenfelder besitzen, wie andere Steuerelemente auch, eine Reihe vonEigenschaften, von denen insbesondere die folgenden für das Dateihandling von Interessesind:
Die Eigenschaft DRIVE, die das ausgewählte Laufwerk (den Laufwerksnamen) enthält.Standardmäßig wird hier der Zugriffsbuchstabe des aktuellen Laufwerks registriert, was
auch im Textfeld des Listenfeldes angezeigt wird.Über diese Eigenschaft läßt sich ein beliebiges anderes (im System existentes) Laufwerkzuweisen, z.B. für ein Laufwerkslistenfeld mit dem Namen LWFeld in der Form:
LWFeld.Drive = "E:\ "
wobei jeweils nur der erste Buchstabe der angegebenen Kette ausgewertet wird (ohneGroß- / Klein - Unterscheidung), so daß die gleiche Angabe auch in der Form:
LWFeld.Drive = "e"
erfolgen könnte.Die Auswahl eines Laufwerks aus der Liste oder über die obigen Anweisungen im Programmbewirkt nicht den Wechsel zu diesem Laufwerk. Dieser muß mittels der Anweisung ChDrivein der Form:
ChDrive LWFeld.Drive
vorgenommen werden.Die Eigenschaft PATH enthält den kompletten Suchpfad des ausgewählten (durchDoppelklick) Ordners inclusive Laufwerksname, beginnend mit den Namen des
Hauptordners.Der Wechsel zum angezeigten Ordner muß im Programm über die Anweisung ChDirvorgenommen werden:
ChDir OrdFeld.Path
Die PATTERN - Eigenschaft bietet die Möglichkeit, die Dateiliste auf bestimmte Dateien 46 Eigentlich „Ordnerlistenfeld“47 gleichzeitig wird die komplette Pfadangabe der Eigenschaft Path des Feldes zugewiesen (siehe weiter imText).
73
zu beschränken. Statt des voreingestellten Wertes „*.*“ kann beispielsweiseFdatei.Pattern = "*.BAT; *.BAK"
angegeben und damit die Dateiliste auf BAT- und BAK - Dateien reduziert werden.Die Eigenschaft FILENAME enthält den Namen der in der Liste ausgewählten (markierten)Datei.Das Nachfolgende Beispielprogramm demonstriert die Anwendung der Dateisteuerelemente.
15.2 Beispielprogramm 13Das Programm soll die folgenden Funktionen in sich vereinen:• Nach dem Start soll ein Formular aufgebaut werden, welches Laufwerks-, ordner- und
Dateiauswahlen möglich macht:
• Wird im Laufwerkslistenfeld ein Laufwerk ausgewählt, soll im Ordnerlistenfeld seineOrdnerstruktur erscheinen.
• Wird im Ordnerlistenfeld ein Ordner ausgewählt, soll im Dateilistenfeld sein Inhalt(Dateien) erscheinen.
• Die Form soll neben den drei Standardelementen ein zusätzliches KombinationsfeldDateityp enthalten, das der Auswahl des gewünschten Dateityps dienen soll (Generierungsiehe Programmlisting).
• Nur der in diesem Kombinationsfeld gewählte Dateityp soll im Dateilistenfeld erscheinen.• Die Namen der ausgewählten Datei und des ausgewählten Ordners sollen in zusätzlichen
Textfeldern oberhalb des Datei- und Ordnerlistenfeldes erscheinen.• Wird auf die Schaltfläche OK geklickt, soll die Größe der ausgewählten Datei in einer
MSGBOX angezeigt werden. Dabei soll der vollqualifizierte Name der Datei (Laufwerk,Pfad - endend mit „\“ und der Dateiname incl. Erweiterung) angezeigt werden.
• Die Schaltfläche Ende beendet das Programm.
Abbildung 39: Ordner und Dateiauswahl
Abbildung 40: Ausgabe der Dateiparameter
74
Die Funktionsfähigkeit dieses Beispielprogramms wird durch die folgenden Prozedurengewährleistet:• Die Prozedur Form_Load() des Formulars hat die Form:
Private Sub Form_Load()DTyp.AddItem "Alle Dateien (*.*)"DTyp.AddItem "Textdateien (*.TXT)"DTyp.AddItem "Word-Dateien (*.DOC)"DTyp.AddItem "VB-Formulare (*.FRM)"
DTyp.ListIndex = 0txtOrdner.Text = Ordner.Path
End Sub
hier wird das Feld Dtyp für die Auswahl des Dateityps belegt und seinem Textfeld derEintrag mit dem Indexwert 0 zugewiesen (Alle Dateien (*.*)). Dem über dem Verzeichnislistenfeld liegenden Textfeld txtOrdner wird der Wert der PATH- Eigenschaft des Verzeichnislistenfeldes zugewiesen.
• Das Laufwerklistenfeld (Name = Laufwerk) besitzt die Prozedur:Private Sub Laufwerk_Change()On Error GoTo FehlerOrdner.Path = Laufwerk.DriveExit Sub
Fehler: MsgBox "Laufwerksfehler", vbExclamation, "Error"Laufwerk.Drive = Ordner.Path
End Sub
hier wird der Eigenschaft PATH des Ordnerlistenfeldes der Wert der Eigenschaft DRIVEdes Laufwerklistenfeldes zugewiesen, um beim Wechsel des Laufwerks die Ordnerlistezu aktualisieren. Ein Zugriff auf ein ungültiges Laufwerk führt zu einem Fehler, der miteiner MSGEBOx quitiert wird.
• Die Prozedur Ordner_Change() des Ordnerlistenfeldes hat die Form:Private Sub Ordner_Change()
Datei.Path = Ordner.PathtxtOrdner.Text = Ordner.Path
End Sub
hier wird die Eigenschaft PATH des Dateilistenfeldes mit dem Wert der PATH - Eigenschaftdes Lauwerkslistenfeldes belegt, um die Dateiliste zu aktualisieren. Gleichzeitig wird derText des Textfeldes oberhalb des Laufwerklistenfeldes mit dem aktuellen Ordnernamenversorgt.
• Die Click - Prozedur der ComboBox Dtyp zur Auswahl des Dateityps hat die Form:Private Sub DTyp_Click()
Select Case DTyp.ListIndexCase 0Datei.Pattern = "*.*"
Case 1Datei.Pattern = "*.TXT"
Case 2Datei.Pattern = "*.DOC"
Case 3Datei.Pattern = "*.FRM"
End SelectEnd Sub
hier wird, je nach ausgewählten Dateityp die Pattern - Eigenschaft des Dateilistenfeldesindexabhängig mit dem entsprechenden Wert belegt.
75
• Die Click - Prozedur des Dateilistenfeldes enthält die Anweisung:Private Sub Datei_Click()
txtDatei.Text = Datei.FileNameEnd Sub
Diese Anweisung belegt die Text - Eigenschaft des Textfeldes oberhalb des Dateilisten-feldes mit dem Wert der Eigenschaft FileName dieses Listenfeldes, um den Namen derausgewählten Datei zu übernehmen.
• Die DblClick - Prozedur des gleichen Feldes:Private Sub Datei_DblClick()
txtDatei.Text = Datei.FileNamecmdOK_Click
End Sub
belegt die Text - Eigenschaft des darüber liegenden Textfeldes mit dem Wert der FileName- Eigenschaft und ruft die Click - Prozedur der OK - Schaltfläche (Zeigen) auf.
• Die Schaltfläche OK erhält die folgende Click - Prozedur:Private Sub Zeigen_Click()Dim VollerName As StringDim DSize As StringDim Pfad As String
If txtDatei.Text = "" ThenMsgBox "Keine Datei ausgewählt !"Exit Sub
End If
'Prüfen, ab Pfadangabe mit Backslash endetIf Right(Datei.Path, 1) <> "\" Then
Pfad = Datei.Path + "\"Else
Pfad = Datei.PathEnd If
If txtDatei.Text = Datei.FileName ThenVollerPfad = Pfad + Datei.FileName
ElseVollerPfad = txtDatei.Text
End If
'DateigrößeOn Error GoTo LFehlerDSize = Str(FileLen(VollerPfad))MsgBox "Größe von " + VollerPfad + ": " + DSize + "Bytes"Exit Sub
LFehler:MsgBox "Größe von " + VollerPfad + " kann nichtfestgestellt werden"Exit SubEnd Sub
Wurde im Dateilistenfeld keine Datei ausgewählt, wird eine Warnung ausgegeben (1). Die Pfadangabe wird geprüft. Endet sie nicht mit einem Backslash (\), so wird sie umdieses Zeichen erweitert (2) und an die Variable Pfad übergeben. Die Variable VollerPfadwird mit den Werten der Variablen Pfad und dem der FILENAME - Eigenschaft belegt. Anschließend wird die Dateigröße der ausgewählten Datei ermittelt, in der VariablenDsize gespeichert und zusammen mit der Pfadangabe in einer MSGBOX ausgegeben(3). Läßt sich die Dateigröße nicht ermitteln, wird eine Fehlerroutine Meldung durchlaufen undeine Fehlermeldung ausgegeben.
1
2
3
76
15.2.1 Die Attributeigenschaften des DateilistenfeldesNeben Dateitypen (i.d.R. an der Namenserweiterung erkennbar) besitzen Dateien zusätzlichdefinierte Attribute. Um Dateien mit bestimmten Attributen im Dateilistenfeld anzuzeigen,müssen entweder manuell die entsprechenden Werte im Eigenschaftsfenster des Feldes aufdie Werte TRUE gesetzt werden, oder im Programm die Werte der gewünschtenEigenschaften gesetzt werden (hier am Beispiel des Feldes Datei und der Anzeige dernormalen und der Systemdateien):
Datei.ReadOnly = FalseDatei.Archive = FalseDatei.Normal = TrueDatei.System = TrueDatei.Hidden = False
15.3 Schreiben und Lesen in Dateien (am Beispiel sequentieller Dateien)Um mit Daten in Dateien zu arbeiten, müssen diese geöffnet, gelesen, beschrieben undgeschlossen werden. Visual Basic bietet drei Methoden für den Dateizugriff:• sequentieller Zugriff• wahlfreier Zugriff (Random - Zugriff)• binärer Zugriff.In diesem Teil des Kurses wird direkt nur auf den sequentiellen Zugriff eingegangen. Diebeiden anderen genannten Zugriffsarten werden im Erweiterungskurs besprochen.Der erste Schritt zum Lesen oder Beschreiben einer Datei besteht aus dem Öffnen der Dateimittels der OPEN - Anweisung:
Open Datei [For Modus] [Access Zugriff][Sperre] As Datei# [Len = Satzlänge]
mit den Argumenten:• Datei : vollqualifizierter Name der Datei (incl. Laufwerk und Pfad).• Modus: Zugriffsart - APPEND, BINARY, INPUT, OUTPUT, RANDOM• Zugriff:: Zulässige Operation auf der geöffneten Datei - READ, WRITE, READWRITE.• Sperre: Zulässige Operationen für andere Prozesse - LOCK READ, LOCK WRITE, LOCK
READWRITE, SHARED.• Datei#: eine der Identifizierung der Datei dienende Ganzzahl mit Werten im Bereich
von 1 bis 511. Die Werte 1 bis 255 werden für Dateien benutzt, auf die andereAnwendungen nicht zugreifen sollen, Dateien mit höheren Dateinummern sindallen Anwendungen zugänglich.
� Vor dem Öffnen einer Datei sollte evtl. die nächste freie Dateinummer ermitteltwerden. Dieses kann über die Funktion
FreeFile[(Bereich)]
geschehen. Hat Bereich den Wert 0 (Voreinstellung), oder wird nichtangegeben, gibt die Funktion eine Dateinummer bis 255 zurück, ist der Wertvon Bereich gleich 1, wird eine Dateinummer über 255 zurückgegeben.
� Es wird empfohlen, das Öffnen von Dateien immer mit der Ermittlung einerfreien Dateinummer zu verknüpfen, beispielsweise in der Form:
FileNum = FreeFileOpen File "DATEN.TXT" For Output As FileNum
Nach der Bearbeitung werden Dateien mit der CLOSE - Anweisung geschlossen:Close [FileNum1] [, FileNum2 ...]
Wird in dieser Anweisung kein Argument übergeben, so werden alle geöffneten Dateiengeschlossen.
77
15.3.1 Schritte des DateizugriffsDer Dateizugriff wird immer in der gleichen Schrittreihenfolge durchgeführt:• Auswählen eines Dateinamens• Zuweisen einer freien Dateinummer• Öffnen der Datei• Ein- oder Auslesen der Daten• Schließen der DateiVor dem Zuweisen der Dateinummer sollte evtl. die nächste freie Nummer durch eineentsprechende Programmanweisung ermittelt werden (s.o.).
15.4 Sequentieller DateizugriffDer sequentielle Dateizugriff eignet sich am besten für Dateien, die nur aus reinem ASCII -Text bestehen. Der sequentielle Zugriff erfolgt zeilenweise.Es gibt drei Möglichkeiten, eine sequentielle Datei zu öffnen:• Lesen - Ausgabe des Dateiinhalts (FOR INPUT)• Eingabe von Textzeilen / Generieren neuer Dateien (FOR OUTPUT)• Erweiterung bestehender Dateien (FOR APPEND)
15.4.1 Eine sequentielle Datei zum Lesen öffnen.Um den Inhalt einer sequentiellen Datei zu lesen, muß diese zur Eingabe geöffnet werden.• Mit der Funktion INPUT() kann anschließend der gesamte Dateiinhalt in ein Textfeld oder
eine String - Variable eingelesen werden:FileNum = FreeFileOpen "BEISP.TXT" For Input As FileNumTextFeld.Text = Input(LOF(FileNum), FileNum)Close FileNum
Wird, wie im Beispiel, in ein Textfeld eingelesen, sollte der Wert der EigenschaftMULTILINE auf TRUE gesetzt und das Textfeld mit Bildlaufleisten versehen werden(Eigenschaften), um den gesamten Dateiinhalt im Textfeld überblicken zu können.
• Zeilenweise kann mit der Anweisung LINE INPUT # eingelesen werden:Dim Zeile As String, Ausgabe As StringDo Until EOF(FileNum)Line Input #FileNum, ZeileDebug.Print ZeileLoop
Ausgabe erfolgt im Standardfall ins Testfenster des Visual Basic.• Die Funktion Input(n,FileNum) ermöglicht das Einlesen definierter Anzahl (n) von Zeichen
einer sequentiellen Datei (hier z.B. 3 weniger als die Gesamtlänge der Datei in Bytes):Dim Zeile As String
Dim Lang As IntegerFileNum = FreeFileOpen "c:\work\daten1.txt" For Input As FileNum
Lang = LOF(FileNum)Zeile = Input(Lang - 3, FileNum)Ausgabe.Text = Zeile
Close FileNum
78
15.4.2 Eine sequentielle Datei zum Schreiben öffnen.Um eine sequentielle Datei zum Schreiben zu öffnen, muß diese zur Ausgabe geöffnetwerden. Mit der Anweisungsfolge:
FileNum = FreeFileOpen "c:\daten\datei1.txt" For Output As FileName
wird eine Datei mit dem Namen DATEI1.TXT für den schreibenden Zugriff geöffnet. Dabeiist jedoch unbedingt folgendes zu beachten:• Existiert die angegebene Datei nicht, wird sie vor dem Öffnen angelegt.• Wird eine existierende Datei für die sequentielle Bearbeitung zum Schreiben geöffnet, so
wird sie gelöscht und eine neue unter dem angegebenen Namen angelegt.
� Zur Vorsicht sollte vor dem Öffnen mittels der DIR$ - Funktion die Existenz der zuöffnenden Datei überprüft werden:
If Dir$(Dateiname) = ″″ Then .....
Mit Hilfe der PRINT # - Anweisung kann in die geöffnete Datei geschrieben werden:Print #FileNum, Zeile
so kann beispielsweise mit der AnweisungsfolgeFileNum = FreeFileOpen ″daten.txt″ For Output As FileNumPrint #FileNum, Eingabe.TextClose FileNum
der Inhalt des Textfeldes Eingabe in die Datei DATEN.TXT geschrieben werden.
◆ Bei sequentieller Dateiverarbeitung ist ein gleichzeitiges Öffnen einer Datei für Lese- undSchreibvorgänge nicht möglich.Um den Modus der Bearbeitung zu wechseln, muß eine Datei vorher geschlossen undanschließend im neuen Modus geöffnet werden (z.B. Editieren des Dateiinhalts = öffnenzum Lesen, einlesen des Inhalts in ein Textfeld, schließen der Datei, verändern des Inhaltsim Textfeld, öffnen der Datei zum Schreiben, übertragen des Inhalts des Textfeldes in dieDatei, schließen der Datei).
15.4.3 Eine sequentielle Datei zum Anhängen öffnenSoll eine Datei zum Erweitern des Inhalts geöffnet werden, wird sie wie zum Schreibengeöffnet, allerdings im APPEND - Modus. Handelt es sich dabei um eine nicht vorhandeneDatei, so wird diese angelegt, existente Dateien werden beim Öffnen nicht gelöscht.Ausgabebefehle hängen Zeilen an den Inhalt der geöffneten Datei an.Die Anweisungsfolge
FileNum = FreeFileOpen ″daten.text″ For Append As FileNumPrint #FileNum, Eingabe.TextClose FileNum
fügt den Inhalt eines Textfeldes an den Inhalt der Datei DATEN.TXT an.
79
15.4.4 Die Anweisungen Write # und Input #Die Anweisungen Input und Print # lesen oder schreiben Daten in sequentielle Dateiensatzweise, die Input() - Funktion liest zeichenweise.Für Lese- und Schreiboperationen können zusätzlich auch die Anweisungen Write # undInput # in einer an Write # angelehnten Version verwendet werden.Die Anweisung Write # ermöglicht es, Werte einer Liste von Variablen in eine Datei zuschreiben:
Write #DateiNr , [Ausgabeliste]
• Ausgabeliste ist eine Auflistung von, durch Kommata voneinander getrenntennumerischen Ausdrücken, Zeichenfolgeausdrücken oder Variablennamen, die in eineDatei geschrieben werden sollen. Wird Ausgabeliste nicht angegeben (Komma nachDateiNr setzen !), so wird eine leere Zeile in die Datei geschrieben. Die in die Datei geschriebenen Datenwerte sind voneinander durch Kommata getrennt,Zeichenfolgen sind in Anführungszeichen eingeschlossen. Nach dem letztengeschriebenen Element der Ausgabeliste setzt Write # die Zeichen Chr(13) und Chr(10)ans Ende der Zeile (Wagenrücklauf und Zeilenvorschub).
• Die dem Write # ähnliche Input # - AnweisungInput #DateiNr, [Varliste]
ermöglicht es, Daten aus einer sequentiellen Datei, welche die Struktur der Varliste hat,zu lesen. Die Datenelemente der Datei müssen dieselbe Reihenfolge haben wie in Varlisteangegeben und denselben Datentyp aufweisen.
◆ Mit dieser Form der Input # - Anweisung zu lesende Daten, sollten mit Write # erstelltworden sein. Mit Print # erstellte Dateien sollten über diese Anweisung nicht eingelesenwerden.
15.5 Beispielprogramm 14Das kleine Beispielprogramm soll eine einfache Technik des Beschreibens von sequentiellenDateien mittels der Write # - Anweisung demonstrieren. Die Form:
enthält Schaltflächen zum erstmaligen Beschreiben und zum Fortsetzen einer Datei sowieeine Schaltfläche zum Browsen des Dateiinhalts (Beenden obligat).In die Textfelder können Zeichenketten (oberes Textfeld) oder INTEGER - Werte (unteresTextfeld) eingetragen werden. Die Felder sind bei der Erstellung über entsprechendeEigenschaften so generiert, daß sie die genannten Datenformate aufnehmen.Zusätzlich findet im Programm eine Prüfung des im Zahlenfeld eingegebenen Wertes mitentsprechender Fehlermeldung statt.
Abbildung 41: Formular zur Dateibearbeitung
80
Für die Dateiexistenz und Dateibehandlung (erstmaliges Öffnen und / oder Erweitern) sindebenfalls entsprechende Prüfungenim Programm vorgesehen.Der Dateiname ist in einer Konstanten festgelegt.Die Prozeduren der Schaltflächen haben die Form:
Dim V1 As String, V2 As IntegerConst Dateiname As String = "c:\work\daten.txt"
Private Sub cmdOpen_Click()cmdAppend.Visible = TruecmdInhalt.Visible = TrueV1 = txtFeld1.Text
If IsNumeric(txtFeld2.Text) ThenV2 = txtFeld2.Text
ElseMsgBox "Falsche Angabe im Feld 2, bitte wiederholen !",
vbOKOnlyEnd If
FileNum = FreeFileIf Dir$(Dateiname) = "" ThenOpen Dateiname For Output As FileNum
Write #FileNum, V1, V2Close FileNum
txtFeld1.Text = ""txtFeld2.Text = ""txtFeld1.SetFocus
ElsecmdAppend_ClickMsgBox "Datei existiert schon, wurde erweitert"
End IfEnd SubPrivate Sub cmdAppend_Click()
V1 = txtFeld1.TextIf IsNumeric(txtFeld2.Text) ThenV2 = txtFeld2.Text
ElseMsgBox "Falsche Angabe im Feld 2, bitte wiederholen !",
vbOKOnlyEnd IfFileNum = FreeFile
Open Dateiname For Append As FileNumWrite #FileNum, V1, V2
Close FileNumtxtFeld1.Text = ""txtFeld2.Text = ""txtFeld1.SetFocus
End Sub
Private Sub cmdEnde_Click()End
End Sub
Private Sub cmdInhalt_Click()FileNum = FreeFileIf Dir$(Dateiname) = "" Then
MsgBox "Datei existiert nicht"txtFeld1.SetFocuscmdAppend.Visible = FalsecmdInhalt.Visible = FalseExit Sub
ElseOpen "c:\work\daten.txt" For Input As FileNum
txtAusgabe.Text = Input(LOF(FileNum), FileNum)Close FileNum
End IfEnd Sub
81
Beim Versuch, den Inhalt einer nicht existenten Datei anzuzeigen, wird eine Fehlermeldungausgegeben und das Formular in einen Zustand versetzt, der nur das Beenden oder eineNeueingabe in eine automatisch anzulegende Datei gestattet:
Wird der Versuch unternommen, eine schon existente Datei über Öffnen neu anzulegen,verzweigt das Programm nach eine Fehlermeldung automatisch zur Erweiterung der Datei.
Abbildung 42: Formular für Ersterfassung
82