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