Visual Basic 6 Lernen

Visual Basic 6 lernen
Dirk Abels
Visual Basic 6 lernen

Anfangen, anwenden, verstehen
An imprint of Addison Wesley Longman, Inc.

Bonn • Reading, Massachusetts • Menlo Park, California
New York • Harlow, England • Don Mills, Ontario
Sydney • Mexico City • Madrid • Amsterdam
Die Deutsche Bibliothek – CIP-Einheitsaufnahme
Dirk Abels
Visual Basic 6 lernen / Dirk Abels. - 1 Aufl. -
Bonn ; Reading, Mass. [u.a.] : Addison-Wesley-Longman, 1999
ISBN 3-8273-1371-6
© 1999 Addison Wesley Longman GmbH

1. Auflage 1999
Satz: mediaService, Siegen. Gesetzt aus der Stone Serif 9,5 pt.
Belichtung, Druck und Bindung: Bercker Grafische Betriebe, Kavelaer
Lektorat: Tomas Wehren, Judith Stevens
Korrektorat: Boris Karnikowski, Münster
Produktion: Petra Strauch, Bonn
Umschlaggestaltung: Barbara Thoben, Köln
Illustrationen: Elisabeth Herzel, Hamburg
Das verwendete Papier ist aus chlorfrei gebleichten Rohstoffen hergestellt und alterungsbeständig. Die
Produktion erfolgt mit Hilfe umweltschonender Technologien und unter strengsten Auflagen
in einem geschlossenen Wasserkreislauf unter Wiederverwertung unbedruckter,
zurückgeführter Papiere.
Text, Abbildungen und Programme wurden mit größter Sorgfalt erarbeitet. Verlag, Übersetzer und
Autoren können jedoch für eventuell verbliebene fehlerhafte Angaben und deren Folgen weder eine
juristische Verantwortung noch irgendeine Haftung übernehmen.
Die vorliegende Publikation ist urheberrechtlich geschützt. Alle Rechte vorbehalten. Kein Teil dieses Bu-
ches darf ohne schriftliche Genehmigung des Verlages in irgendeiner Form durch Fotokopie, Mikrofilm
oder andere Verfahren reproduziert oder in eine für Maschinen, insbesondere
Datenverarbeitungsanlagen, verwendbare Sprache übertragen werden. Auch die Rechte der Wiedergabe
durch Vortrag, Funk und Fernsehen sind vorbehalten.
Die in diesem Buch erwähnten Software- und Hardwarebezeichnungen sind in den meisten Fällen auch
eingetragene Warenzeichen und unterliegen als solche den gesetzlichen Bestimmungen.
I Inhaltsverzeichnis
I Inhaltsverzeichnis ............................................................................ 5
V Vorwort ........................................................................................... 13
V.1 Icons und typographische Vereinbarungen des Handbuches ............ 15
1 Installation von Visual Basic 6.0 ................................................... 17

1.1 Systemvoraussetzungen....................................................................... 21
Hardware ............................................................................................. 21
Betriebssystem ..................................................................................... 22
2 Einführung in die Entwicklungsumgebung.................................. 23

2.1 Starten von Visual Basic 6.0 ................................................................ 23
2.2 Die Programmoberfläche von Visual Basic 6.0 ................................... 23
2.3 Wichtige Grundlagen .......................................................................... 24
Zeichen, die nicht verwendet werden sollten..................................... 24
Programmdokumentation................................................................... 24
Befehlszeilen über mehrere Zeilen ...................................................... 25
Steuerelemente .................................................................................... 26
Direkte Sprünge mit Goto ................................................................... 26
Lange Funktionen „Spaghetti-Code“ .................................................. 27
Variablenbenennung........................................................................... 28
2.4 Die verschiedenen Programmfenster .................................................. 28
Das Hauptfenster ................................................................................. 28
Das Projekt-Fenster .............................................................................. 29
Das Werkzeugfenster Toolbox............................................................. 30
Das Eigenschaftsfenster Properties ...................................................... 30
Das Fenster für den Programmcode .................................................... 31
Der Debugger....................................................................................... 31
Das Formularfenster ............................................................................ 33
Aufbringen der Steuerelemente auf eine Form ................................... 34
Die Visual Basic-Menüleiste ................................................................ 34
Das Datei-Menü................................................................................... 34
Das Bearbeiten-Menü .......................................................................... 36
5
Das Ansicht-Menü .............................................................................. 38
Das Projekt-Menü ............................................................................... 40
Das Format-Menü ............................................................................... 42
Das Debuggen-Menü .......................................................................... 43
Das Ausführen-Menü .......................................................................... 45
Das Extras-Menü ................................................................................. 46
Das Add-In-Menü................................................................................ 46
3 Die Programmentwicklung ............................................................ 47

3.1 Das einfachste Visual Basic-Programm............................................... 47
3.2 Grundlegende Programmstrukturen .................................................. 48
Kurzüberblick ...................................................................................... 48
Variablen............................................................................................. 48
Konstanten.......................................................................................... 53
Mehrdimensionale Felder ................................................................... 55
Selbstdefinierte Datentypen ............................................................... 62
Schleifen.............................................................................................. 63
Verzweigungen ................................................................................... 65
Funktionen und Prozeduren............................................................... 67
3.3 Das erste Programm ............................................................................ 71
Eingabe................................................................................................ 72
Ausgabe ............................................................................................... 73
Buttons (Programmsteuerungen) ....................................................... 74
Der Programmcode zum Algorithmus................................................ 75
Größere Benutzerfreundlichkeit ......................................................... 81
4 Standardsteuerelemente ................................................................. 85
4.1 Das Formular Form ............................................................................. 85
Aufgabe ............................................................................................... 87
Lösung................................................................................................. 87
4.2 Das Textelement Label........................................................................ 88
Aufgabe ............................................................................................... 88
Lösung................................................................................................. 88
4.3 Die Schaltfläche Button ...................................................................... 89
Aufgabe ............................................................................................... 89
Lösung................................................................................................. 90
4.4 Das Texteingabeelement TextBox ...................................................... 92
Aufgabe ............................................................................................... 92
Lösung................................................................................................. 93
4.5 Das Bildfeldsteuerelement PictureBox................................................ 93
4.6 Das Anzeigesteuerelement Image ....................................................... 95
4.7 Das Rahmensteuerelement Frame ...................................................... 95
4.8 Das Kontrollkästchen CheckBox ........................................................ 96
Aufgabe ............................................................................................... 97
Lösung................................................................................................. 97
6

4.9 Das Optionsfeld OptionButton ........................................................... 98
Aufgabe................................................................................................ 99
Lösung ................................................................................................. 99
4.10 Das Listenfeld ListBox ....................................................................... 100
Einen neuen Datensatz eintragen ..................................................... 101
Einen Datensatz löschen ................................................................... 101
Den gesamten Inhalt des Listenfeld-Steuerelements löschen .......... 101
Aufgabe.............................................................................................. 101
Lösung ............................................................................................... 101
4.11 Das Kombinationsfeld Combobox.................................................... 102
Aufgabe.............................................................................................. 103
Lösung ............................................................................................... 103
4.12 Die Bildlaufleisten ScrollBar .............................................................. 104
Aufgabe.............................................................................................. 105
Lösung ............................................................................................... 105
4.13 Das Datei-, Verzeichnis- und Laufwerklistenfeld .............................. 105
Aufgabe.............................................................................................. 106
Lösung ............................................................................................... 106
4.14 Der Zeitgeber Timer........................................................................... 108
Aufgabe.............................................................................................. 109
Lösung ............................................................................................... 109
4.15 Das Liniensteuerelement Linie.......................................................... 111
4.16 Das Figurensteuerelement Shape ...................................................... 111
Beispiel zum Figurensteuerelement Shape ........................................ 111
4.17 Hinzufügen weiterer Steuerelemente ................................................ 115
4.18 Der Standarddialog mit dem CommonDialog.................................. 116
Die Eigenschaften des Dialogs Datei öffnen/speichern .................... 117
Die Eigenschaften des Dialogs Farbpalette........................................ 119
Die Eigenschaften des Dialogs Schriftart .......................................... 120
Die Eigenschaften des Dialogs Drucken............................................ 121
Die Eigenschaften des Dialogs Hilfe.................................................. 122
Zusammenfassung ............................................................................. 123
4.19 Das Registerblättersteuerelement SSTab............................................ 124
Aufgabe.............................................................................................. 125
Lösung ............................................................................................... 125
4.20 Das MDI-Formular............................................................................. 125
Aufgabe.............................................................................................. 126
Lösung ............................................................................................... 126
5 Wichtige Eigenschaften der Steuerelemente............................... 129

5.1 Die Eigenschaft (Name)..................................................................... 130
5.2 Die Eigenschaft Appearance .............................................................. 130
5.3 Die Eigenschaft Caption.................................................................... 130
5.4 Die Eigenschaft Cancel...................................................................... 131
5.5 Die Eigenschaft Default..................................................................... 131
5.6 Die Eigenschaft Enabled.................................................................... 132
Hintergrund- und Vordergrundfarbe ................................................ 132
7
5.7 Die Eigenschaft MousePointer.......................................................... 133
5.8 Die Eigenschaft TabIndex ................................................................. 134
5.9 Die Eigenschaft TabStop ................................................................... 134
5.10 Die Eigenschaft Tag .......................................................................... 134
5.11 Die Eigenschaft Text ......................................................................... 134
5.12 Die Eigenschaft ToolTipText ............................................................ 135
5.13 Die Eigenschaft Visible ..................................................................... 135
5.14 Die Eigenschaft WindowState .......................................................... 135
6 Wichtige Ereignisse der Steuerelemente ...................................... 137

6.1 Click – der einfache Mausklick ......................................................... 138
6.2 Der doppelte Mausklick: DblClick.................................................... 138
6.3 Das Laden eines Formulars durch Load............................................ 138
6.4 GotFocus ........................................................................................... 139
6.5 KeyDown und KeyUp – Drücken und Loslassen einer
Tastaturtaste...................................................................................... 140
6.6 Drücken und Loslassen einer Maustaste mit MouseDown
und MouseUp ................................................................................... 140
6.7 Mit MouseMove die Maus über ein Steuerelement bewegen........... 141
Beispiel zum Ereignis MouseMove ................................................... 142
6.8 Den Fokus verlieren: LostFocus ........................................................ 145
7 Fehlerbehandlung in Visual Basic ............................................... 147

7.1 Vorgehensweise beim Auftreten eines Laufzeitfehlers ..................... 147
Der Befehl On Error .......................................................................... 148
Der Befehl Error ................................................................................ 151
7.2 Ein Programm zum Erstellen der Fehlercodetabelle......................... 151
7.3 Die Fehlercodetabelle........................................................................ 153
8 Meldungen anzeigen .................................................................... 157
9 Grafikprogrammierung ................................................................ 161

9.1 Grundlagen zur Grafikausgabe ......................................................... 161
Farben ............................................................................................... 161
Die Line-Methode ............................................................................. 162
Die Methode Circle........................................................................... 164
9.2 Grafische Beispiele ............................................................................ 165
RGB-Farbenbeispiel ........................................................................... 165
Chaos auf dem Bildschirm – das „fraktale Apfelmännchen“........... 169
10 Der Menüdesigner......................................................................... 173

10.1 Aufgabe ............................................................................................. 175
10.2 Lösung............................................................................................... 175
8

11 Aufbau eines Visual Basic-Projekts .............................................. 177
11.1 Ablaufgesteuerte Programmierung.................................................... 177
11.2 Ereignisgesteuerte Programmierung ................................................. 178
12 Entwicklung einer komplexen Applikation ............................... 181

12.1 Beschreibung des Programms „Stack-Taschenrechner“.................... 181
12.2 Planung des Projekts ......................................................................... 182
12.3 Die verwendeten Steuerelemente und ihre Eigenschaften ............... 183
12.4 Programmglobale Definitionen ........................................................ 184
12.5 Funktionen im Formular ................................................................... 185
Formularglobale Definitionen........................................................... 185
Initialisieren der Variablen................................................................ 185
Speichern des letzten Zustandes ....................................................... 185
Vorbereitung der Berechnung ........................................................... 186
Eingabe von der Tastatur................................................................... 187
Den Stack aktualisieren ..................................................................... 188
Programm beenden ........................................................................... 190
Gesamten Stack löschen.................................................................... 190
Den letzten Wert auf dem Stack löschen .......................................... 190
Bestätigung einer Eingabe ................................................................. 191
Farben definieren .............................................................................. 191
Berechnungsfunktionen.................................................................... 192
Die letzte Aktion widerrufen ............................................................. 193
Die Eingabe der Ziffern...................................................................... 194
12.6 Das Modul für die Berechnungen ..................................................... 194
Funktion zum Überprüfen eines Operanden .................................... 194
Berechnungen mit einem Operanden .............................................. 195
Arithmetische Funktionen ................................................................ 196
Berechnungen mit zwei Operanden ................................................. 197
12.7 Das Modul zur Fehlerbehandlung..................................................... 197
13 Weitere Programmiergrundlagen ................................................ 199

13.1 Arbeiten mit Dateien......................................................................... 199
Dateien öffnen................................................................................... 199
Lesen und Schreiben in Dateien ....................................................... 201
Dateien schließen .............................................................................. 202
Umbenennen von Dateien................................................................ 202
Löschen von Dateien......................................................................... 203
Formatieren von Dateien .................................................................. 203
Beispiel zu „Arbeiten mit Dateien“ ................................................... 205
Testen des Programms....................................................................... 208
Weitere Funktionen für das Arbeiten mit Dateien ........................... 209
Funktionen für das Arbeiten mit Verzeichnissen ............................. 211
13.2 Ziehen und Fallenlassen – „Drag and Drop“ .................................... 212
Verschieben von Objekten ................................................................ 212
Verschieben von Objekten mit anschließender Reaktion ................ 217
9
13.3 Einführung in die Objektorientierung ............................................. 222
Was ist ein Objekt? ........................................................................... 223
Was sind Eigenschaften? .................................................................. 224
Was sind Ereignisse? ......................................................................... 224
Was sind Methoden? ........................................................................ 225
Was ist eine Klasse?........................................................................... 225
Erzeugen einer Klasse........................................................................ 226
Datenelemente.................................................................................. 227
13.4 Das Arbeiten mit zwei Formularen ................................................... 231
Laden und Anzeigen eines Formulars .............................................. 232
Beispiel zum Arbeiten mit zwei Formularen .................................... 235
Die Programmentwicklung............................................................... 240
13.5 Rekursive Programmierung .............................................................. 246
Einfache Rekursion ........................................................................... 246
Mehrfache Rekursion........................................................................ 248
13.6 Die Registrierdatenbank.................................................................... 250
Die Schlüssel der Registrierdatenbank.............................................. 251
Der Zugriff auf die Registrierdatenbank ........................................... 252
Das Arbeiten mit der Registrierdatenbank ....................................... 254
14 Tools .............................................................................................. 257

14.1 Verzeichnisgröße .............................................................................. 257
Die Programmoberfläche .................................................................. 257
Der Programmcode zum Verzeichnis-Informationsprogramm........ 259
14.2 Berechnungen mit dem Zufallsgenerator ......................................... 267
Der Zufallsgenerator ......................................................................... 269
Der Algorithmus zum Gleichungssystem ......................................... 270
Auflösung des Gleichungssystems.................................................... 275
Zusammenfassung ............................................................................ 276
14.3 Das Spiel MasterMind ....................................................................... 277
Die Spielregeln von MasterMind ...................................................... 277
Der Programmcode zu MasterMind.................................................. 279
15 Der Installationsassistent ............................................................. 287

15.1 Starten des Installationsassistenten .................................................. 288
15.2 Das Erstellen von Installationsdisketten .......................................... 288
Festlegen des Programmes (Projekts)................................................ 288
Die Optionen des Installationsassistenten ....................................... 288
Generieren der Installationsdatei ..................................................... 289
Das Zielverzeichnis bestimmen ........................................................ 290
Das Festlegen von zusätzlichen Treibern.......................................... 290
CAB-Optionen .................................................................................. 291
Festlegen des Installationstitels ........................................................ 292
Festlegen der Menüeinträge.............................................................. 292
10

Installationsorte der Dateien............................................................. 293
Skriptdatei.......................................................................................... 294
Verpackungsbericht........................................................................... 294
16 Das Erstellen eines Hilfesystems .................................................. 295

16.1 Was ist kontextsensitive Hilfe? ......................................................... 296
16.2 Grundlegende Begriffe für das Erstellen einer Hilfedatei.................. 296
16.3 Der Hilfecompiler HCW .................................................................... 297
Die Installation des HelpCompilers .................................................. 298
16.4 Die Formatierungen des Hilfetexts.................................................... 300
16.5 Erstellen einer Hilfedatei ................................................................... 301
16.6 Schreiben der Hilfedatei .................................................................... 302
Einführen eines Titels in die Hilfedatei............................................. 302
Erzeugen von Querverweisen ............................................................ 302
Erzeugen von Begriffserklärungen .................................................... 303
Erzeugen von Hilfesequenzen ........................................................... 304
Einbinden von Grafiken.................................................................... 304
16.7 Erzeugen einer ersten Hilfe mit dem Help Workshop ...................... 306
Einbinden der RTF-Textdatei ............................................................ 307
Einbinden der Grafikdateien............................................................. 308
Eigenschaften des Hilfefensters......................................................... 308
Hinzufügen der HelpContext-ID in dem Hilfeprojekt...................... 310
Das Einbinden der Hilfedatei in ein Visual Basic-Projekt ................. 312
16.8 Erstellen des Hilfeindexes.................................................................. 312
Hinzufügen von Indexeinträgen....................................................... 313
Das Bearbeiten von Indexeinträgen .................................................. 314
17 Datenbankanbindung .................................................................. 317

17.1 Standardabfragesprache .................................................................... 318
17.2 Erlernen von SQL .............................................................................. 318
Die Abfragesprache............................................................................ 321
17.3 Arbeiten mit den SQL-Kommandos .................................................. 324
Abfrage aus einer Tabelle................................................................... 324
Abfragen über mehrere Tabellen....................................................... 326
Berechnungen mit SQL-Abfragen ..................................................... 328
Abfragen zum Manipulieren des Datenbestandes ............................ 330
17.4 Datenbankprogrammierung.............................................................. 332
DAO-Bibliothek ................................................................................. 333
Datengebundene Steuerelemente ..................................................... 333
Der Datenzugriff im Programmcode ................................................. 339
Beispiele zum Datenbankzugriff ....................................................... 343
A Anhang.......................................................................................... 351
A.1 Inhalt der Diskette............................................................................. 351
A.2 Standardbefehle................................................................................. 353
11
A.3 Glossar............................................................................................... 355
A.4 Von Visual Basic 5.0 verwendete Dateitypen................................... 357
A.5 Zeichentabellen................................................................................. 358
S Stichwortverzeichnis .................................................................... 363
12

V Vorwort
Es gibt eine Vielzahl von Programmiersprachen, doch finden sie nur

selten eine so starke Verbreitung wie Visual Basic. Warum gerade Vi-
sual Basic? Weil dies eine Programmiersprache ist, mit der man sehr
schnell ein Programm entwickeln kann.
Visual Basic existiert nun schon in der sechsten Generation und er-
freut sich einer immer größeren Beliebtheit. Der wesentliche Vorteil
dieser Programmiersprache liegt in der Möglichkeit, mit geringem
Aufwand eine einfache Applikation zu erstellen. In diesem Buch sol-
len einfache Programmbeispiele den Umgang mit Visual Basic 6.0 er-
klären und das Grundverständnis für das Programmieren unter Win-
dows vermitteln.
Visual Basic 6.0 hat sein Aussehen gegenüber der Version 5.0 nur ge-
ringfügig verändert. In den Versionen bis 4.0 waren alle Module in ei-
genen Fenstern untergebracht. Seit der Version 5.0 sind aber alle Mo-
dule in ein Visual Basic-Fenster integriert. Für Visual Basic-Umsteiger,
die von der Version 4.0 oder früher auf 6.0 umsteigen, ist dieses De-
sign zwar eine Umstellung, doch ist die Entwicklungsumgebung
dank der neuen Oberfläche nun auch deutlich übersichtlicher. Um
diese Übersichtlichkeit auch voll ausnutzen zu können, empfiehlt es
sich, mit einer Grafikauflösung von mindestens 1024x768 auf einem
17"-Bildschirm zu arbeiten.
Seit der Version 5.0 gibt es auch einen Compiler, der in der Version
6.0 noch weiter optimiert wurde, damit er schnelleren, vom Prozes-
sor ausführbaren Programmcode erzeugt. Bis zur Version 4.0 wurde
der Programmcode immer nur von einem Interpreter verarbeitet; seit
der Version 5.0 können richtige, ausführbare Programme (.EXE) er-
zeugt werden. Der Anwender merkt bei der Bedienung keinen direk-
ten Unterschied. Die Programme, die jedoch mit einem Compiler
übersetzt wurden, sind in der Ausführung merklich schneller. Dieser
Umstand erlaubt es auch, größere Programme unter Visual Basic 6.0
13
zu realisieren, was bis zur Version 4.0 aus Performancegründen nicht
möglich war.
Eine weitere Novität ist, daß unter Visual Basic auch teilweise objekt-
orientiert entwickelt werden kann. In diesem Buch werde ich darauf
jedoch nur oberflächlich eingehen, weil dies den Rahmen eindeutig
sprengen und den Einstieg deutlich erschweren würde. Über die ob-
jektorientierte Programmierung in Visual Basic ließe sich leicht ein
eigenes Buch schreiben. (Für den fortgeschrittenen Visual Basic-Pro-
grammierer empfehle ich hierzu das Buch „Visual Basic 6.0. Effektive
Programmentwicklung unter Windows 98“ von Michael Kofler, in
dem die objektorientierte Programmierung fundiert erklärt und an-
hand vieler Beispiele erläutert wird.)
Mit diesem Buch möchte ich dem Leser anhand einiger Beispiele die
Möglichkeit bieten, sich von Grund auf in die Programmierung mit
Visual Basic 6.0 einzuarbeiten. Es werden Grundbegriffe der Program-
mierung sowie grundlegende Programmstrukturen ausführlich erläu-
tert. Ebenso wird der Umgang mit der grafischen Oberfläche von Vi-
sual Basic demonstriert, um die bestmögliche Grundlage zum
Erstellen von Anwendungen zu bieten.
Das Buch wendet sich an interessierte Einsteiger sowie an Anwender,

die bereits Kenntnisse im Programmieren erworben haben und sich
nun mit der Programmiersprache Visual Basic vertraut machen wol-
len. Die Bedeutung von Fachbegriffen wird dem Leser anhand von
ausführlichen Erläuterungen und, wo angebracht, mit praktischen
Beispielen nahegebracht. Ganz nach dem Prinzip „learning by
doing“ möchte dieses Buch Orientierung zu einem Thema bieten, das
in der Fachpresse leider oft nur eine unzugängliche Darstellung fin-
det.
Das Schreiben dieses Buches hat mir viel Freude bereitet, da ich
meine eigenen Ideen und Vorstellungen darin einbringen konnte.
Dirk Abels
14

V.1 Icons und typographische
Vereinbarungen des Handbuches
In diesem Buch wird eine Reihe von Icons verwendet, deren Bedeu-
tung Sie hier finden:
Beispiele helfen Ihnen, sich schneller und sicher im Feld der Visual
Basic-Programmierung zu orientieren. Sie werden darum mit diesem
Icon gekennzeichnet.
Übung – so werden praktische Übungen gekennzeichnet, mit deren
Hilfe Sie Ihre neuerworbenen Kenntnisse trainieren können. Sie wer-
den dieses Icon in diesem Buch sehr oft finden!
Hinweis – damit möchten wir Sie auf Textpassagen hinweisen, die
Ihre besondere Aufmerksamkeit verdienen.
Warnung – hier zeigen wir Ihnen, wie Sie häufig gemachte Fehler
vermeiden und nicht in verborgene Fallen tappen.
Tips und Tricks – hier geben wir Ihnen einige Tips, wie Sie sich die
Arbeit erleichtern können.
Um Ihnen die Übersicht im Text zu erleichtern, werden bestimmte

Textformatierungen verwendet, die in der folgenden Tabelle aufgeli-
stet sind:
Schriftart mit Beispiel Bedeutung

Kursiv (Button1) Bestandteile der Programmiersprache,
wichtige Passagen, Verzeichnisse
Kapitälchen (UNIT.PAS) Menübefehle, Schaltflächen, Dateinamen
Nichtproportional (GetMessage) Programmtexte (Listings)
Nichtproportional, fett (string) Reservierte Wörter in Listings
Fett (Button) Icon-Bezeichnungen
Tastenkappen (F9) Tasten, Tastenkombinationen

15
1 Installation von
Visual Basic 6.0
Für die Installation von Visual Basic 6.0 legen Sie die CD-ROM mit
der Software von Microsoft in das CD-Laufwerk ein. Im Normalfall
wird das Installationsprogramm daraufhin automatisch gestartet. Be-
ginnt das System nicht automatisch mit der Installation, kann die In-
stallation manuell gestartet werden. Hierfür wählen sie aus der Start-
leiste das Menü START und darin die Option AUSFÜHREN.
Abbildung 1.1: Das Start-Menü von Windows 95
Geben Sie in die Befehlszeile zunächst den Buchstaben des Lauf-

werks, in dem sich die Installations-CD befindet (z.B. d:), und danach
\Setup ein (Abbildung 1.1). Nach Bestätigung der Eingabe durch
Drücken des Buttons OK wird die Installation gestartet, und es er-
scheint der Bildschirm aus Abbildung 1.2.
17
Abbildung 1.2: Der Installationsbildschirm
Hier können Sie sich über die Schaltfläche INFO-DATEI ANZEIGEN wei-
tere Information, über die neue Entwicklungsumgebung im Internet-
Browser anzeigen lassen. Während der gesamten Installation werden
drei Schaltflächen im unteren Bereich des Fensters angezeigt:
1. ZURÜCK: Wird verwendet, um zu dem vorhergehenden Bildschirm

zu gelangen. Da es beim Startbildschirm keinen vorhergehenden
Bildschirm gibt, ist die Schaltfläche nicht verfügbar.
2. WEITER: Hiermit werden die gemachten Einstellungen übernom-
men und der nächste Bildschirm aktiviert.
3. BEENDEN: Hiermit kann jederzeit die Installation von Visual Basic
6.0 abgebrochen werden. Wenn schon einige Dateien auf die Fest-
platte kopiert wurden, werden diese auch wieder gelöscht und die
erzeugten Verzeichnisse entfernt.
Durch Betätigen der Schaltfläche WEITER wird nun der Lizenzvertrag

eingeblendet, und die Schaltfläche WEITER ist deaktiviert. Um den
nächsten Installationsschritt durchführen zu können, muß einer der
beiden Optionsschalter:
1. ICH STIMME DEM LIZENZVERTRAG ZU

2. ICH LEHNE DEN LIZENZVERTRAG AB
selektiert werden. Beim Ablehnen des Lizenzvertrages wird die Installa-

tion beendet, ohne Visual Basic 6.0 installiert zu haben. Wenn Sie dem
Lizenzvertrag zustimmen, erscheint der nächste Installationsschritt.
18

Hier werden Sie aufgefordert, die ID-Nummer des Produktes, Ihren
Namen und evtl. den Ihrer Firma einzutragen. Die ID-Nummer fin-
den Sie auf der Rückseite der CD-Hülle, der Sie die Installationsdis-
kette entnommen haben. Mit Betätigen der Schaltfläche WEITER wird
wieder ein neues Fenster angezeigt.
Wenn auf Ihrem Rechner Komponenten von Visual Studio 97 instal-

liert sind, kann hier selektiert werden, welche dieser Applikationen
deinstalliert werden sollen. Es ist jedoch nicht nötig, Visual Studio 97
zu deinstallieren, da sich die alten und die neuen Versionen nicht be-
hindern.
Mit WEITER wird nun der Installationsschritt für die Art der Installa-
tion von Visual Basic aktiviert. Im allgemeinen kann die voreinge-
stellte Option VISUAL BASIC 6.0 ... INSTALLIEREN übernommen werden.
Jetzt wird das eigentliche Installationsprogramm von Visual Basic ge-

startet. Bis zu diesem Zeitpunkt hatten Sie es lediglich mit der Instal-
lationssoftware für das Komplettpaket Visual Studio 6.0 zu tun.
Jetzt werden zunächst noch einmal die Lizenzvereinbarung (doppelt

hält besser) und im nächsten Fenster die ProduktID angezeigt.
Nach Betätigung der WEITER-Taste wird wieder Ihre Interaktion ver-

langt. Es muß festgelegt werden, auf welche Art die Installation
durchgeführt und wohin die Entwicklungsumgebung installiert wer-
den soll. Im folgenden werden die einzelnen Installationsoptionen
beschrieben.
Standard
Visual Basic 6.0 wird mit den Einstellungen installiert, die für die mei-
sten Fälle ausreichend sind. Ich empfehle diese Installationsart, da
zum Erlernen einer Programmiersprache die Standardeinstellungen
völlig ausreichend sind. Wenn bei der Programmierung weitere Op-
tionen oder Programmteile benötigt werden, läßt sich die Installa-
tion jederzeit anpassen und erweitern.
Benutzerdefiniert
Bei der benutzerdefinierten Installation müssen Sie selbst die zu instal-

lierenden Optionen festlegen, d. h. Sie geben an, welche Optionen Sie
brauchen und welche nicht. Da beim Erlernen einer Programmierspra-
che meist nur selten Kenntnisse über die Bedeutung der einzelnen Mo-
dule vorhanden sind, sollten Sie diese Installationsart nur wählen,
wenn Sie Visual Basic schon aus früheren Versionen kennen.
19
Ordner wechseln...
Über diesen Button können Sie ein anderes Verzeichnis auswählen,

in das Visual Basic 6.0 installiert werden soll. Vom System wird im all-
gemeinen ein Verzeichnis auf dem Laufwerk vorgeschlagen, auf dem
sich auch das Betriebssystem befindet.
Ich empfehle für den Anfang die Option STANDARDINSTALLATION aus-

zuwählen, da mit ihrer Hilfe alle wichtigen Elemente installiert wer-
den. Der Vollständigkeit halber werde ich aber noch auf die BENUT-
ZERDEFINIERTE INSTALLATION eingehen.
Wenn sie die Option BENUTZERDEFINIERTE INSTALLATION gewählt ha-

ben, erscheint als nächstes Fenster ein Auswahldialog, in dem die ver-
schiedenen Module, die installiert werden sollen, selektiert werden
können.
Abbildung 1.3: Die Optionen zur benutzerdefinierten Installation
Die meisten der angezeigten Optionen teilen sich ebenfalls in klei-

nere Komponenten auf. Sind alle Komponenten aus einer Gruppe
ausgewählt, so erscheint ein Haken vor der entsprechenden Option.
Sind nur einige Komponenten einer Gruppe gewählt, so ist das Käst-
chen mit dem Haken grau eingefärbt. Wenn aus einer Gruppe kein
Modul installiert werden soll, so ist das Kästchen vor der entspre-
chenden Option leer.
20

Um festzustellen, welche Komponenten einer Gruppe selektiert sind,
muß mit dem Markierungsbalken die gewünschte Option markiert
werden. Danach wird durch Betätigen der Schaltfläche OPTION ÄN-
DERN... das Fenster angezeigt, das die selektierten Module auflistet.
Mit der Schaltfläche ALLE AUSWÄHLEN werden alle Optionen mit den je-
weiligen Modulen markiert und dann auch installiert. Voreingestellt
sind die Module, die bei der Standardinstallation auf die Festplatte ko-
piert werden. Jetzt beginnt der eigentliche Installationsvorgang. Die
Zeit, die für das Kopieren und Konfigurieren der Entwicklungsumge-
bung gebraucht wird, hängt jetzt nur noch von der Computerhard-
ware und von den ausgewählten Modulen ab.
1.1 Systemvoraussetzungen
1.1.1 Hardware
Folgende Hardwarekonfiguration ist für die Installation von Visual
Basic 6.0 als minimales Basissystem erforderlich:
Prozessor
Ein PC mit einem 486DX/66 MHz oder einem schnelleren Pro-
zessor.
Hauptspeicher
Mindestens 16 MB unter Windows 95.
Mindestens 24 MB unter Windows NT.
Festplatte
76 MB für die typische Installation.
94 MB für die komplette Installation.
CD-ROM-Laufwerk
Monitor
Ein VGA-Monitor oder ein Monitor mit einer höheren Auflö-
sung.
Maus
Eine serielle oder entsprechend kompatible Maus.
Um Visual Basic 6.0 aber möglichst effizient einsetzen zu können,

empfehle ich Ihnen folgende Hardwarekonfiguration:
Prozessor
PC mit Pentium-Prozessor.
21

Hauptspeicher
32 MB unter Windows 95.
64 MB unter Windows NT.
Festplatte
Auf der Festplatte sollten Sie über mindestens 650 MB freien
Speicher verfügen, um die Komplettinstallation einschließlich
der mitgelieferten Zusatzprodukte durchführen zu können.
CD-ROM-Laufwerk
Monitor
17"-Monitor mit einer Auflösung von 1024x768 Bildpunkten.
Maus
serielle oder entsprechend kompatible Maus.
1.1.2 Betriebssystem
Microsoft Windows 95 oder höher.
Microsoft Windows NT Workstation Version 4.0 (mit Service Pack 3).
22

2 Einführung in die
Entwicklungsumgebung
2.1 Starten von Visual Basic 6.0

Nach der Installation von Visual Basic 6.0 befindet sich ein neuer Me-
nüeintrag unter START x PROGRAMME. Wenn der Eintrag, der vom In-
stallationsprogramm vorgeschlagen wurde, übernommen worden ist,
dann heißt das Menü VISUAL BASIC 6.0. In diesem Menü können sich
die in Abbildung 2.1 ersichtlichen Einträge befinden, die von der In-
stallationsart abhängig sind:
Abbildung 2.1: Programme im Menü „Visual Basic 6.0“
Um die Entwicklungsumgebung von Visual Basic 6.0 zu starten, muß

der Menüeintrag VISUAL BASIC 6.0 angeklickt werden. Danach wird
die Entwicklungsumgebung geladen, und es erscheint das Auswahl-
fenster, in dem festgelegt werden muß, welche Art von Applikation
entwickelt werden soll. In diesem Buch werden jedoch nur Standard-
EXE-Projekte dargestellt.
2.2 Die Programmoberfläche von

Visual Basic 6.0
Um unter Visual Basic 6.0 effiziente Programme zu entwickeln, wird
eine gute, übersichtliche Entwicklungsumgebung zur Verfügung ge-
stellt (Abbildung 2.2). Beim ersten Starten des Programms werden au-
tomatisch die Menüleiste, das Projektfenster, die Toolbox und eine
leere Form angezeigt, nachdem im Abfragefenster die Option Stan-
dard-EXE ausgewählt wurde.

23
Abbildung 2.2: Die Visual Basic-Entwicklungsumgebung nach dem Start
2.3 Wichtige Grundlagen

Im folgenden werden die einzelnen Fenstertypen, die auf der Visual
Basic-Oberfläche angezeigt werden, sowie die Menübefehle und
wichtigsten Grundbegriffe beschrieben.
2.3.1 Zeichen, die nicht verwendet werden sollten

Im Programmcode sollten Zeichen wie z.B. Umlaute, Sonderzeichen
sowie das „ß“ vermieden werden. Die deutsche Version von Visual
Basic unterstützt zwar derartige Zeichen in Funktionen und Varia-
blen, doch kann es zu Kommunikationsproblemen kommen, wenn
Visual Basic an andere Applikationen angebunden wird. Unter Um-
ständen kommt es vor, daß solche Applikationen mit den genannten
Sonderzeichen Probleme haben.
2.3.2 Programmdokumentation
Wie in allen Programmiersprachen ist es auch in Visual Basic wichtig,
daß der zu entwickelnde Programmcode vernünftig dokumentiert
wird. Oft werden Programme gar nicht, falsch oder sinnlos dokumen-
tiert (Abbildung 2.3). Es ist offenkundig, daß die Variable Anzahl den
24

Wert 1 zugewiesen bekommt und um 1 erhöht wird. Es wäre aller-
dings interessant zu wissen, welche Aufgabe die Variablen Anzahl
und Wert haben.
Abbildung 2.3: Fehlerhafte Dokumentation eines Programmteils
Für eine solide Dokumentation des Programmcodes empfehle ich,

zuerst die Funktion in Pseudocode (fast umgangssprachlich) zu
schreiben. Wenn die Funktion dann in Visual Basic programmiert
wird, liegt eine sehr gute Beschreibung vor. Je besser eine Programm-
beschreibung ist, desto schneller versteht man den Programmcode,
und ein Programmierer kann sich dann der eigentlichen Aufgabe –
dem Programmieren – widmen.
Bemerkungen können unter Visual Basic immer mit dem Zeichen „'“
oder dem Befehl REM eingeleitet werden. Alle nachfolgenden Zei-
chen haben keinen Einfluß mehr auf das Programm und werden so-
mit auch nicht mehr berücksichtigt. Nach diesen Kommentarzei-
chen kann in dieser Zeile kein Programmcode mehr folgen.
2.3.3 Befehlszeilen über mehrere Zeilen

Damit übersichtlich programmiert werden kann, bietet Visual Basic
die Möglichkeit, sehr lange Befehlszeilen auf mehrere Zeilen zu ver-
teilen. Um Visual Basic mitzuteilen, daß eine Befehlszeile umgebro-
chen wird, muß ein Unterstrich „_“, dem ein Leerzeichen vorangeht,
an die Befehlszeile angehängt werden.
Das Beispiel in Tabelle 2.1 verdeutlicht dies: Die beiden Programm-

zeilen sind zwar identisch, die Programmzeile im linken Fenster ist je-
doch auf drei Zeilen verteilt worden.
Mit Zeilenumbruch Ohne Zeilenumbruch

Datensatz = _ Datensatz = "System ausgelastet"
"System " & _
"ausgelastet"
Tabelle 2.1: Zeilenumbruch in einer Programmzeile
!" 25

2.3.4 Steuerelemente
Steuerelemente sind für die Darstellung der Information oder die Ein-
gabe durch Benutzer zuständig. Sie werden auf Formulare aufge-
bracht und gestalten somit das Aussehen der Programmfenster.
Wichtige Steuerelemente sind z.B. Schaltflächen und Listenele-
mente.
2.3.5 Direkte Sprünge mit Goto

Wie andere Programmiersprachen auch, ist Visual Basic mit der Zeit
gewachsen und moderner geworden. Um aber kompatibel zu blei-
ben, wurden sogenannte Altlasten mit in die neueren Versionen
übernommen.
Visual Basic beruht auf der älteren Sprache Basic, die schon beim
C641 Verwendung gefunden hat. Auf dem PC unter DOS wurde
GW-Basic mitgeliefert. Diese Sprachen kannten keine Funktionen
oder Prozeduren, sondern bestanden aus einer Liste aneinanderge-
reihter Befehle (Abbildung 2.4), bei denen jede Zeile eine Nummer
hatte. Um nun eine bestimmte Befehlsfolge auszuführen, gab es den
direkten Sprungbefehl Goto.
5 Clr
10 For I=3 To 10
20 If I<5 Then Goto 42
30 Next I
40 I=20
41 Goto 45
42 Print I
43 Goto 30
45 Print I
Abbildung 2.4: Ein altes BASIC-Programmlisting
Mit dem Befehl Goto kann man direkt zu einer beliebigen Zeile im Pro-
gramm springen. Auch Visual Basic kennt diesen Befehl; jedoch gilt
es allgemein als unschöner Programmierstil, wenn dieser Befehl ver-
wendet wird (Ausnahme: Kapitel 7 ab Seite 147). Es läßt sich in Visual
Basic immer eine Programmierlösung finden, in welcher der Befehl
Goto vermieden werden kann.
1. Homecomputer, der in den 80er Jahren sehr verbreitet war.
26

2.3.6 Lange Funktionen „Spaghetti-Code“
Programmteile, die als einzelne Funktionen und Prozeduren zusam-
mengefaßt werden können, sollte man als eigenständige Funktionen
darstellen, um den Code übersichtlicher zu gestalten.
Damit ein Programm auch dann verständlich bleibt, wenn man den
Programmcode seit einigen Wochen nicht mehr bearbeitet hat oder
sich ein anderer Anwender in dieses Programm einarbeiten muß,
sollte übersichtlich programmiert werden. Aus diesem Grund ist die
Verwendung von Funktionen zu vermeiden, die sehr viele Pro-
grammzeilen enthalten. Vielmehr ist es besser, eine sehr lange Funk-
tion oder Prozedur in mehrere Bestandteile zu unterteilen.
Eine lange Funktion Aufteilung in einzelne Funktionen

Function Lang Function Kurz
Dim I As Integer Dim I As Integer
'prüfe jedes Zeichen Funktion:
'ist Leerzeichen dann 'Entferne Leerzeichen
'lösche es Funktion:
'Ende Prüfen 'Wandele alle Klein- in
'prüfe jedes Zeichen 'Großbuchstaben um
'ist es Kleinbuchst. Funktion:
'Umw. Großbuchst. 'Prüfe, ob alle Zeichen
'Ende Prüfen 'gleich sind
'Vergleiche alle Zeichen End Function
'Ende Vergleich
End Function
Tabelle 2.2: Umwandlung einer langen Funktion in einzelne Module
Wie in Tabelle 2.2 zu sehen ist, läßt sich die Funktion, in der der ge-
samte Programmcode in kleinere Funktionen ausgelagert wurde, wie
ein Programm in Pseudocode lesen. Der Code wirkt eher umgangs-
sprachlich.
Heißt eine Funktion z. B. Selektiere_Anwender, läßt sich schon zumeist

aus dem Kontext erkennen, was diese Funktion macht. Der Entwick-
ler kann sich viel schneller in die Funktion hineindenken, die die
Funktion Selektiere_Anwender aufruft, und so wesentlich effektiver
Fehler suchen bzw. Erweiterungen einbauen. Auch lassen sich ein-
zelne Funktionen, die im Rahmen großer Funktionen entstanden
sind, wieder von anderen Funktionen und Prozeduren aufrufen. So-
mit wird auch der redundante Code reduziert.
!" 27

2.3.7 Variablenbenennung
Eine weitere Verdeutlichung des Programmcodes bringt die Verwen-
dung von sogenannten sprechenden Variablen mit sich. So sollte bei
der Vergabe des Namens für eine Variable darauf geachtet werden,
daß allein schon mit ihrem Namen dem Programmierer klar wird,
wofür diese Variable steht. Soll eine Variable z.B. als Zwischenspei-
cher in einem Programmteil gelten, könnte man sie auch Zwischen-
speicher oder zumindest Speicher nennen. Eine Abkürzung wie ZS (für
Zwischenspeicher) ist schneller geschrieben, aber nach einem Monat
werden Sie sich kaum noch erinnern können, was dieser kryptische
Name eigentlich bedeuten soll.
2.4 Die verschiedenen Programmfenster

In den folgenden Abschnitten werden die einzelnen Fenster, die in
der Entwicklungsumgebung zu sehen sind, vorgestellt.
2.4.1 Das Hauptfenster
Abbildung 2.5: Das Hauptfenster
28

Das Hauptfenster ist die sogenannte Schaltzentrale von Visual Basic.
Hiermit lassen sich die anderen Fenster aktivieren sowie Projekte
(Programme) öffnen, starten und stoppen. Es lassen sich Hilfetexte
laden, und auch die gesamte Entwicklungsumgebung kann hier kon-
figuriert werden. Unterhalb der Menüleiste befindet sich die Symbol-
leiste, mit deren Symbole sich einige Funktionen wie z. B. Programm
starten, Programm anhalten und Programm beenden direkt ausführen las-
sen.
2.4.2 Das Projekt-Fenster
Abbildung 2.6: Das Projekt-Fenster
Das Fenster Projekt enthält alle Dateien, die für die Erstellung der Pro-
gramme benötigt werden. In diesem Fenster werden drei Sorten von
Dateien dargestellt.
Dateityp Dateiendung Beschreibung

Formulare *.FRM Enthalten die Steuerelemente und den dazugehörigen Programm-
code. Sie sind die Benutzerschnittstelle zwischen Benutzer und
Programm.
Programmdateien *.BAS Enthalten den Programmcode für Prozeduren und Funktionen, die
beispielsweise mit anderen Anwendungen ausgetauscht werden
können oder bestimmte Funktionalitäten umschreiben.
Klassendefinitionen *.CLS Enthalten Klassendefinitionen, die etwa mit anderen Anwendun-
gen ausgetauscht werden können oder bestimmte Funktionalitä-
ten umschreiben.
Tabelle 2.3: Dateitypen im Projekt-Fenster
Jeder dieser Dateitypen kann mehrfach vorkommen. Zu jeder Datei

werden zwei Angaben gemacht: Links steht zunächst der Dateiname
(Form1), rechts die Beschreibung, unter welchem Namen die Datei be-
kannt ist (Form1). Diese Angaben können bei jeder Datei geändert wer-
den. Aber Vorsicht: Wenn ein Modul auf ein anderes Modul über den
rechten Namen zugreift und dieser geändert wird, schlägt dieser Auf-
ruf bei einem erneuten Programmstart fehl.
#$ 29

2.4.3 Das Werkzeugfenster Toolbox
In diesem Werkzeugfenster werden die Steuerelemente von Visual Ba-
sic dargestellt, die auf eine Form aufgebracht werden können. Ein
Steuerelement läßt sich wie folgt auf ein Formular einfügen und be-
wegen:
1. Zunächst klicken Sie das gewünschte Steuerelement in der Tool-

box mit der linken Maustaste an.
2. Dann muß der Mauszeiger auf die Stelle des Formulars bewegt wer-
den, an der das Steuerelement aufgebracht werden soll.
3. Danach drücken Sie die linke Maustaste und halten sie gedrückt.
Durch Ziehen eines rechteckigen Rahmens kann die Größe des
Steuerelements bestimmt werden.
4. Ist die gewünschte Größe des Steuerelements definiert, lassen Sie
die Maustaste einfach wieder los.
5. Wenn sich das Steuerelement noch nicht an der richtigen Position
befindet, kann es durch Verschieben auf dem Formular neu posi-
tioniert werden.
6. Ein Steuerelement wird auf einem Formular verschoben, in dem
der Mauszeiger über das Steuerelement bewegt wird. Durch drük-
ken und gedrückthalten der linken Maustaste folgt das Steuerele-
ment der Bewegung des Mauszeigers über dem Formular. Befindet
sich das Steuerelement an der neuen Position kann die Maustaste
losgelassen werden.
Abbildung 2.7:
Das Werkzeugfenster
„Toolbox“ 2.4.4 Das Eigenschaftsfenster Properties
Abbildung 2.8: Das Eigenschaftsfenster „Property“
30

Das Fenster Property enthält die Eigenschaften des jeweils ausgewähl-
ten Steuerelements oder des aktiven Formulars. Mit Hilfe des Eigen-
schaftsfensters lassen sich alle Eigenschaften des zugehörigen Ele-
ments einstellen. So können etwa der Name, die Farbe und das
Aussehen eines Steuerelements voreingestellt werden. Ein Teil der Ei-
genschaften kann auch noch während der Ausführung des Pro-
gramms mit Hilfe der Visual Basic-Befehle geändert werden.
2.4.5 Das Fenster für den Programmcode
Abbildung 2.9: Das Fenster für den Programmcode
Das Fenster in Abbildung 2.9 stellt den Editor dar. Hier wird der Pro-
grammcode der einzelnen Formulare und Programmdateien (Bas-
Files) erstellt und bearbeitet. In der ListBox Object (linke obere List-
Box des Formularfensters) ist das aktive Formular oder das aktive
Steuerelement angegeben, in der ListBox Proc (rechte obere ListBox
des Formularfensters) dagegen die aktuelle Ereignisprozedur des Steu-
erelements, zu dem der Programmcode gehört.
2.4.6 Der Debugger

Um jede Anweisung des Programms während der Ausführung ein-
zeln zu überprüfen – z. B. ob richtig gerechnet oder an der richtigen
Stelle verzweigt wird –, gibt es den sogenannten Debugger. Er ermög-
licht, den Inhalt einer Variablen oder den Programmablauf zu kon-
trollieren, um so Fehlermodule zu lokalisieren und Fehler zu finden.
Der Name des Tools kommt von „debuggen“ = „entmotten“. Dem er-
#$ 31

sten Anschein nach haben diese Insekten nichts mit dem hier vorge-
stellten Tool zu tun. Dieser Begriff ist zu einer Zeit geprägt worden, als
die Computer noch nicht auf der Basis von Transistortechnik gebaut
wurden, sondern noch aus Tausenden von mechanischen Relais be-
standen. Diese Relais schalteten über ein Magnetfeld einen mechani-
schen Kontakt. Wenn sich nun in so einem Kontakt eine Motte ver-
klemmt hatte, mußte das fehlerhafte Relais gefunden und der
Computer „entmottet“ werden. Den Debugger benötigen wir heute
lediglich zur Fehleranalyse des Programmablaufs.
Mit den Funktionstasten (F8) (RUN | STEP INTO) und (ª)+(F8) (RUN |
STEP OVER) läßt sich das Programm Schritt für Schritt abarbeiten, wo-
bei die Taste (F8) bei der Ausführung eines Funktionsaufrufs in die
Funktion verzweigt und dort weiterarbeitet, während die Taste
(ª)+(F8) die aufzurufende Funktion ausführt.
Um ein Programm nicht komplett Schritt für Schritt durcharbeiten

zu müssen, bis man an der vermuteten Fehlerstelle ankommt, besteht
die Möglichkeit, über das Menü DEBUGGEN | HALTEPUNKT EIN/AUS oder
die Funktionstaste (F9) einen Haltepunkt an die aktuelle Cursorposi-
tion zu setzen. Das Programm kann nun gestartet werden. Beim Errei-
chen eines Haltepunkts wechselt das Programm dann automatisch in
den Debugmodus.
Mit DEBUGGEN | ÜBERWACHUNG HINZUFÜGEN... kann der aktuelle Wert

einer Variablen im Debug-Modus überprüft und angezeigt werden.
Des weiteren kann der Wert mit dem Befehl DEBUG.PRINT in das Debug-
fenster (Abbildung 2.10) geschrieben werden.
Abbildung 2.10: Das Debugfenster
Im folgenden ist der Programmcode abgebildet, der die berechnete

Zahl erzeugt und dessen Variable im Debugfenster ausgegeben wer-
den soll.
Sub Beispiel
Dim x As Integer
x = 2 * 123
Debug.Print x
End Sub
32

In diesem Beispiel wurde der Variablen x ein Wert zugewiesen, der
sich aus 2 x 123 errechnet. Das Ergebnis wird in das Debugfenster ge-
schrieben. Dieses kleine Beispiel weist zuerst x den Wert 246 zu und
schreibt diesen dann in das Fenster (Abbildung 2.10).
Abbildung 2.11: Das Fenster zum Anzeigen der Variablendaten
2.4.7 Das Formularfenster
Abbildung 2.12: Das Formularfenster
Im allgemeinen ist nach dem Programmstart ein leeres Formular ge-

öffnet (Abbildung 2.12). Sollte dies nicht der Fall sein, so kann ein
Formular auf folgende Arten geöffnet werden:
1. Doppelklicken Sie mit der linken Maustaste auf den Formularna-

men im Projektfenster (Abbildung 2.6).
2. Selektieren Sie das zu öffnende Formular im Projektfenster durch
Anklicken des Formularnamens mit der linken Maustaste und Be-
tätigen des Buttons VIEW FORM.
3. Wählen Sie das zu öffnende Formular im Projektfenster durch An-
klicken des Formularnamens mit der linken Maustaste und über
das Menü VIEW | FORM aus.
Das Formular ist das Fenster unter Windows. Auf ihm werden die
Steuerelemente untergebracht; ebenso wird auch der Programmcode,
der zu den Steuerelementen gehört, hier gespeichert.
#$ 33

2.4.8 Aufbringen der Steuerelemente auf eine Form
Um eine TextBox oder einen Schaltknopf auf die Oberfläche eines
Formulars zu bringen, muß in der Toolbox das jeweilige Steuerele-
ment aktiviert werden (Das Werkzeugfenster „Toolbox“). Nun muß
der Mauszeiger an die Position gebracht werden, an der das Element
positioniert werden soll. Durch Klicken der rechten Maustaste wird
die Position der TEXTBOX auf dem Formular festgelegt; die Größe des
Steuerelements kann durch Ziehen mit gedrückter rechter Maustaste
definiert werden.
2.4.9 Die Visual Basic-Menüleiste

In diesem Abschnitt werden das Menü von Visual Basic (Abbildung
2.13) und dessen Funktionen kurz und prägnant erklärt.
Abbildung 2.13: Die Visual Basic-Menüleiste
2.4.10 Das Datei-Menü

Dieses Menü enthält alle Funktionen, die für das Arbeiten mit Da-
teien benötigt werden.
Neues Projekt erstellen oder ein bestehendes öffnen

(Strg)+(N) Mit diesen Optionen erstellen Sie ein neues Visual Basic-Projekt oder
(Strg)+(O) öffnen ein existierendes. Nachdem Sie diese Optionen ausgewählt
haben, wird das offene Projekt geschlossen. Bei Wunsch werden auch
die Änderungen gespeichert.
Projekt hinzufügen/entfernen
Um mehrere Projekte gleichzeitig bearbeiten zu können, gibt es die

Möglichkeit, über PROJEKT HINZUFÜGEN weitere Projekte in der Visual
Basic-Oberfläche zu öffnen. Dies ist vergleichbar mit mehreren
gleichzeitig geöffneten Dokumenten in einer Textverarbeitung. Mit
PROJEKT ENTFERNEN kann ein geöffnetes Projekt wieder aus der Ent-
wicklungsumgebung entfernt werden.
34

Projekt speichern/speichern unter
Um ein Projekt zu speichern, gibt es den Menüeintrag PROJEKT SPEI-

CHERN. Ist dem Projekt vom Benutzer noch kein Name zugewiesen
worden, dann muß der Projektname vor dem Speichern vergeben
werden. Besitzt das Projekt einen vom Benutzer definierten Namen,
dann wird das Projekt ohne jede Bestätigung gespeichert. Mit PROJEKT
SPEICHERN UNTER kann eine Kopie des aktuellen Projekts mit einem
anderen Namen und einem anderen Verzeichnis erstellt werden.
<Datei> speichern/Speichern von <Datei> unter (Strg)+(S)
Diese Option ist gleichbedeutend mit PROJEKT SPEICHERN/SPEICHERN

UNTER,gilt jedoch nur für die aktuelle Datei des aktiven Projekts der
Entwicklungsumgebung.
Drucken/Druckereinrichtung (Strg)+(P)
Mit dem Menübefehl DRUCKEN können die im Projekt enthaltenen

Programmteile gedruckt werden. Für die einzelnen Druckereinstel-
lungen steht das Menü DRUCKEREINRICHTUNG zur Verfügung.
<Projekt> erstellen
Mit diesem Menüpunkt wird eine ausführbare Programmdatei er-

zeugt, die unabhängig von der Entwicklungsumgebung läuft.
Projektgruppe anlegen
Um mehrere Projekte zusammenzufassen, können Projektgruppen

erstellt werden. Öffnet man eine Projektgruppe, werden automatisch
alle zugehörigen Projekte in die Entwicklungsumgebung geladen
und können bearbeitet werden.
Beenden (Alt)+(Q)
Dieser Befehl beendet das Arbeiten mit der Visual Basic-Oberfläche

und schließt die Anwendung sowie alle geöffneten Projektdateien.
#$ 35

2.4.11 Das Bearbeiten-Menü
(Strg)+(Z) Rückgängig/Wiederholen
Mit der Option RÜCKGÄNGIG können die Änderungen nach dem letz-
ten Speichern wieder rückgängig gemacht werden. Wurden zu viele
Schritte rückgängig gemacht, lassen sie sich mit WIEDERHOLEN wie-
derherstellen.
(Strg)+(X) Ausschneiden/Kopieren
Diese Option kopiert den markierten Bereich in die Zwischenablage.

Bei dem Menübefehl AUSSCHNEIDEN wird der markierte Bereich ge-
löscht, bei dem Menübefehl KOPIEREN bleibt er bestehen.
(Strg)+(V) Einfügen/Verknüpfung einfügen
Diese Menübefehle fügen den Inhalt der Zwischenablage an der aktu-

ellen Position der Einfügemarke ein bzw. erstellen eine Verknüpfung
zu der Anwendung mit den einzufügenden Daten.
(Entf) Löschen
Mit Hilfe dieses Befehls löscht man den markierten Bereich.
(Strg)+(A) Alles auswählen
Diese Option markiert alle Daten auf dem aktuellen Arbeitsblatt.
(Strg)+(F) Suchen/Weitersuchen/Ersetzen
Diese Befehle verwenden Sie, um nach einer bestimmten Textstelle im

(F3)
angegebenen Bereich zu suchen. Bei den Menüeinträgen SUCHEN und
(Strg)+(H)
ERSETZEN müssen die zu suchenden Textstellen definiert werden, bei
WEITERSUCHEN werden die zuletzt mit SUCHEN oder ERSETZEN definier-
ten Texte gesucht. Mit ERSETZEN schließlich können die gefundenen
Textstellen auch automatisch mit einem neuen Text ersetzt werden.
(ÿ) Einzug vergrößern/verkleinern
Diese Optionen vergrößern oder verkleinern den Abstand des Textan-

(ª)+(ÿ)
fangs zum linken Rand. Dies wird benötigt, um eine bessere Über-
sichtlichkeit im Programmcode zu erhalten.
36

Datei einfügen
Mit diesem Befehl fügen Sie eine Datei in das aktuelle Projekt ein.
Eigenschaften/Methoden anzeigen (Strg)+(J)
Diese Optionen zeigen die Eigenschaften und Methoden des Objekts

an, die für das Objekt vor dem „.“ zur Verfügung stehen.
Mit den Tasten (½) und (¼) kann die Liste durchsucht werden.
Mit (¢) oder einem Doppelklick wird der Eintrag ausgewählt.
Konstanten anzeigen (Strg)+(ª)+(J)
Mit diesem Befehl werden Ihnen alle Konstanten angezeigt, die für
die Eigenschaften gültig bzw. erlaubt sind, die links vom Gleichheits-
zeichen (=) stehen.
Mit den Tasten (½) und (¼) kann die Liste durchsucht werden.
Mit (¢) oder einem Doppelklick wird der Eintrag ausgewählt.
QuickInfo (Strg)+(I)
Diese Option zeigt die gesamte Syntax des aktuellen Elements an und
markiert den aktuellen Parameter durch Fettschrift.
Parameterinfo (Strg)+(ª)+(I)
Um Informationen zum aktuellen Parameter einer Funktion oder ei-

ner Anweisung zu erhalten, wählen Sie diese Option.
Wort vervollständigen (Strg)+

(Leerzeichen)
Sind genügend Zeichen zur Identifikation des Wortes eingegeben
worden, ergänzt Visual Basic den Rest des Wortes automatisch.
Lesezeichen
Um bestimmte Programmteile oder Zeilen schnell wiederzufinden,

können Lesezeichen gesetzt werden. Diese können dann wahlweise
angesprungen, gesucht und wieder gelöscht werden.
#$ 37

2.4.12 Das Ansicht-Menü
Code
Diese Option zeigt das Codefenster für das aktuell ausgewählte Ob-
jekt an.
(ª)+(F7) Objekt
Dieser Befehl ist nur zur Entwurfszeit verfügbar. Wenn sich der Cur-
sor dann auf einem zulässigen Objekt befindet, wird das zugehörige
aktive Element angezeigt.
(ª)+(F2) Definition
Durch diesen Befehl erfolgt der Sprung an diejenige Position im

Code, an der die Variable bzw. Prozedur definiert ist, auf der die Ein-
fügemarke steht.
(Strg)+(ª)+(F2) Letzte Position
Damit wechseln Sie an die Position im Code, an der die letzte Ände-
rung durchgeführt wurde.
(F2) Objektkatalog
Hiermit erhalten Sie Zugang zum Objektkatalog mit den Objektbi-

bliotheken, Klassenbibliotheken, Klassen, Methoden, Eigenschaften,
Ereignissen und Konstanten, die im Code verwendet werden kön-
nen. Des weiteren werden die Module und Prozeduren angezeigt, die
für das Projekt definiert wurden.
(Strg)+(G) Direktfenster
In einem solchen Direktfenster können Anweisungen, Funktionsauf-

rufe, Variablenwerte und Eigenschaften geändert und kontrolliert
werden. Das Direktfenster dient zur Unterstützung bei der Fehlerbe-
seitigung im Code.
Dieser Befehl ist nur im Haltemodus verfügbar.
38

Lokal-Fenster
Hierdurch werden alle aktuellen lokalen Variablen und deren Werte

im Lokal-Fenster angezeigt. Das Lokal-Fenster wird beim Wechsel
von PROGRAMM AUSFÜHREN in den Haltemodus und bei jeder Ände-
rung des Prozedurkontextes automatisch aktualisiert.
Überwachungsfenster
Mit dieser Option werden das Überwachungsfenster und die aktuel-

len Überwachungsausdrücke angezeigt. Das Überwachungsfenster
wird automatisch angezeigt, wenn Überwachungsausdrücke im Pro-
jekt definiert sind.
Aufrufliste (Strg)+(L)
Hiermit wird das Dialogfeld AUFRUFE angezeigt. Beim Programmab-

lauf wird eine Liste generiert, in die alle Prozeduren aufgenommen
werden, die bis zu diesem Zeitpunkt aufgerufen wurden. Wenn eine
Prozedur eine andere Prozedur aufruft, wird die zweite Prozedur so-
lange in die Liste aufgenommen, bis das Programm wieder zu der auf-
rufenden Prozedur zurückkehrt.
Projekt-Explorer (Strg)+(G)
Diese Option präsentiert Ihnen eine hierarchische Liste aller geöffne-

ten Projekte einschließlich ihrer Inhalte. Mit dem Projekt-Explorer
bewegen Sie sich innerhalb der Projekte und verwalten diese. Sie kön-
nen hier jedoch keine Anwendungen erstellen, sondern nur entfer-
nen.
Eigenschaftsfenster (F4)
Damit erhalten Sie Einblick in das Eigenschaftsfenster für das aktive

Objekt. Dieses kann ein Steuerelement, ein Formular oder aber eine
Klasse sein.
Formular-Layout-Fenster
Das Fenster Formular-Layout legt die Position eines Formulars fest.

Die im Formular-Layout-Fenster festgelegte Position ist diejenige, die
das Formular während des Programmlaufs auf der Oberfäche ein-
nimmt.
#$ 39

(ª)(F4) Eigenschaftsseiten
Dieser Befehl zeigt die Eigenschaftsseiten eines Steuerelements an,

die zur Designzeit geändert werden können.
Werkzeugsammlung
Diese Option zeigt das Fenster mit allen zur Verfügung stehenden
Steuerelementen an.
Farbpalette
Hiermit gelangen Sie zur Farbpalette, mit der die Farben von Steuer-
elementen oder Formularen verändert werden können.
Symbolleisten
Damit können Sie alle in Visual Basic zur Verfügung stehenden Sym-
bolleisten aufrufen, die unter der Menüleiste eingeblendet werden
können.
2.4.13 Das Projekt-Menü
Formular hinzufügen
Damit fügen Sie ein neues oder ein existierendes Formular dem aktu-
ellen Projekt hinzu.
MDI-Formular hinzufügen
Damit fügen Sie ein neues oder ein existierendes MDI-Formular dem
aktuellen Projekt hinzu.
Modul hinzufügen
Damit fügen Sie ein neues oder ein existierendes Visual Basic-Modul
dem aktuellen Projekt hinzu.
Klassenmodul hinzufügen
Damit fügen Sie ein neues oder ein existierendes Klassenmodul dem
40

Benutzersteuerelement hinzufügen
Damit fügen Sie ein neues oder ein existierendes Steuerelement dem
Eigenschaftenseite hinzufügen
Damit fügen Sie eine neue oder eine existierende Eigenschaftenseite

dem aktuellen Projekt hinzu. Um neue Eigenschaften zu erstellen,
sollte der Eigenschaftenseiten-Assistent benutzt werden.
Benutzerdokument hinzufügen
Damit fügen Sie ein neues oder ein existierendes Benutzerdokument

dem aktuellen Projekt hinzu. Dieser Befehl ist nur verfügbar, wenn es
sich bei dem Projekt um eine ActiveX-EXE- oder - DLL-Datei handelt.
AktiveX-Designer hinzufügen
Dieser Befehl ist erst verfügbar, nachdem ein ActiveX-Designer im

Menü PROJEKT mit dem Befehl Komponenten hinzugefügt worden ist. Er
zeigt eine Liste mit allen verfügbaren ActiveX-Designern an, aus der
dann einer ausgewählt werden kann.
Datei hinzufügen (Strg)+(D)
Mit diesem Menü wird dem aktuellen Projekt eine Datei zugeordnet.
Da eine Datei mehreren Objekten zugeordnet werden kann, wirken
sich die Änderungen, die an dieser Datei durchgeführt werden, auf
alle Projekte aus.
Entfernen von <Element>
Diese Option entfernt ein Element aus dem aktuellen Projekt. Han-
delt es sich bei dem Element um eine Datei, wird diese nur aus dem
Projekt entfernt, nicht jedoch vom Datenträger.
Beim Entfernen von Elementen muß unbedingt darauf geachtet wer-
den, daß kein verbleibendes Element mehr das zu entfernende Ele-
ment benötigt. Visual Basic prüft diese Abhängigkeit nicht.
#$ 41

Verweise
Mit diesem Befehl können Verweise auf Objektbibliotheken, Klassen-

bibliotheken oder auf ein Projekt aus anderen Projekten eingerichtet
werden, die dann ebenfalls dem aktuellen Projekt zur Verfügung ste-
hen. Die Projekte, auf die ein Verweis erzeugt wurde, werden im Ob-
jektkatalog angezeigt.
(Strg)(T) Komponenten
Mit diesem Befehl können Steuerelemente, Designer oder einfügbare

Objekte (z. B. Word-Dokumente) in die Werkzeugliste aufgenommen
werden.
Eigenschaften von <Projekt>
In dem zugehörigen Dialog werden die Einstellungen für das aktuelle

Projekt vorgenommen.
2.4.14 Das Format-Menü
Ausrichten
Mit diesem Befehl richten Sie die markierten Objekte aneinander aus
(linksbündig, rechtsbündig, zentriert usw.).
Größe angleichen
Anhand der Maße, die das zuletzt ausgewählte Objekt besaß, werden
für alle ausgewählten Objekte dieselben vorgegebenen Objektmaße
eingestellt. Das Ursprungsobjekt wird mit einem farbigen Ziehpunkt
markiert.
Größe an Raster anpassen
Mit Hilfe dieses Befehls können Sie die Objektgröße des Objekts an
den Rasterlinien ausrichten.
Horizontaler Abstand/Vertikaler Abstand
Hierdurch richten Sie den horizontalen bzw. vertikalen Abstand zwi-

schen den einzelnen Objekten aus.
42

Im Formular zentrieren
Die Verwendung dieses Befehls ermöglicht es Ihnen, die markierten

Objekte an der Mittellinie des Formulars auszurichten.
Reihenfolge
Durch diesen Befehl wird die Reihenfolge von Objekten verändert, so

daß dadurch z.B. ein Objekt, das von einem anderen verdeckt wird,
auf diese Weise nach vorne geholt werden kann.
Steuerelemente sperren
Hiermit sperren Sie alle Steuerelemente auf dem aktuellen Formular –

und nur hier! – gegen ein versehentliches Verschieben.
2.4.15 Das Debuggen-Menü
Einzelschritt (F8)
Mit diesem Befehl führen Sie die aktuelle Programmzeile aus. Enthält
die aktuelle Anweisung eine oder mehrere Prozeduren, wird in die
nächste auszuführende Prozedur verzweigt. Die Anweisung gilt als
ausgeführt, wenn alle enthaltenen Prozeduren abgearbeitet sind. Be-
findet sich das Programm im Design- und nicht im Haltemodus, wird
das Programm gestartet.
Prozedurschritt (ª)+(F8)
Dieser Befehl führt die aktuelle Programmzeile aus, jedoch ohne in

die Prozeduren, die in der Programmzeile enthalten sind, zu verzwei-
gen. Ist das Programm im Designmodus und nicht im Haltemodus,
wird das Programm gestartet.
Prozedur abschließen (Strg)+(ª)+(F8)
Dieser nur im Haltemodus verfügbare Befehl führt die gesamte Proze-

dur aus und hält bei der nächsten auszuführenden Programmzeile
wieder an.
#$ 43

(Strg)(F8) Ausführen bis Cursor-Position
Damit können Sie den aktuellen Programmcode bis zur aktuellen

Cursorposition ausführen. Auch dieser Befehl ist nur im Haltemodus
verfügbar.
Überwachung hinzufügen
Dieser Befehl zeigt das Dialogfeld ÜBERWACHUNG HINZUFÜGEN an, in

das ein Überwachungsausdruck eingegeben werden kann. Dabei
muß es sich um einen gültigen Visual Basic-Ausdruck handeln. So-
bald der Haltemodus aktiviert wird, werden Überwachungsausdrücke
im Überwachungsfenster aktualisiert.
(Strg)(W) Überwachung bearbeiten
Mit diesem Dialog können Überwachungsausdrücke bearbeitet und

gelöscht werden.
(ª)(F9) Aktuellen Wert anzeigen
Dieser Befehl zur Anzeige des aktuellen Werts eines Ausdrucks ist aus-
schließlich im Haltemodus verfügbar.
(F9) Haltepunkt ein/aus
Hiermit fügen Sie an der aktuellen Cursorposition einen Haltepunkt

in den Programmcode ein, an dem das Programm bei der Ausführung
in den Haltemodus wechseln soll. Wird dieser Befehl auf einer Zeile
ausgeführt, auf der bereits ein Haltepunkt existiert, wird dieser ent-
fernt.
(Strg)(ª)(F9) Alle Haltepunkte löschen
Dieser Befehl löscht alle Haltepunkte, die mit dem Menübefehl HAL-
TEPUNKTE EIN/AUS im aktuellen Projekt eingefügt wurden.
(Strg)+(F9) Nächste Anweisung festlegen
Um einige Anweisungen zu überspringen oder zu wiederholen, kann

mit diesem Menübefehl die nächste auszuführende Anweisung fest-
gelegt werden. Danach wird der Programmcode wieder sequentiell
abgearbeitet.
44

Nächste Anweisung anzeigen
Markieren Sie hiermit die nächste auszuführende Anweisung. Der Be-

fehl wird verwendet, um den Cursor in der Zeile zu positionieren, die
als nächste ausgeführt wird.
2.4.16 Das Ausführen-Menü
Starten (F5)
Dieser Befehl dient der Ausführung des aktuellen Projekts in der Ent-
wicklungsumgebung.
Starten, vollständige Kompilierung (Strg)(F5)
Hierdurch wird ebenfalls das aktuelle Projekt in der Entwicklungsum-

gebung ausgeführt. Zusätzlich wird aber gleichzeitig eine ausführbare
Datei erzeugt.
Unterbrechen (Strg)(Untbr)
Mit diesem Befehl halten Sie die Ausführung des Programms an der
aktuellen Stelle an und wechseln in den Haltemodus. Wurde gerade
eine bestimmte Programmzeile abgearbeitet, wird diese automatisch
als die nächste auszuführende Anweisung markiert.
Beenden
Das aktuelle Programm wird hiermit beendet, und es wird in den De-
signmodus gewechselt.
Neu starten (ª)(F5)
Diesen Befehl verwenden Sie, um alle Ausdrücke des Projekts auf ihre
Initialwerte zurückzusetzen und das Visual Basic-Projekt erneut zu
starten.
#$ 45

2.4.17 Das Extras-Menü
Prozedur hinzufügen
Auf diese Weise wird in das aktuelle Modul eine neue Prozedur einge-
fügt.
Prozedurattribute
Hiermit öffnen Sie das Dialogfeld PROZEDURATTRIBUTE, in dem Sie die

Attribute für jede Eigenschaft und Methode eines Elements festlegen
können.
(Strg)(E) Menü-Editor
Dieser Befehl wird verwendet, um den Editor zur Erstellung eines Me-
nüs im aktuellen Formular zu öffnen.
Optionen
Hier können die Einstellungen für die folgenden Visual Basic-Kom-

ponenten vorgenommen und an die persönlichen Bedürfnisse ange-
paßt werden:
Editor
Editorformat
Allgemein
Verankern
Umgebung
Weitere Optionen
2.4.18 Das Add-In-Menü
Daten-Manager
Hiermit aktivieren Sie die Anwendung Daten-Manager.
Bericht-Designer
Mit diesem Befehl wird die Anwendung Bericht-Designer geöffnet.
Add-In-Manager
Dieser Menübefehl dient zum Laden und Entfernen von Add-Ins, die
die Visual Basic-Entwicklungsumgebung erweitern.
46

3 Die Programmentwicklung
Abbildung 3.1: Auswahl nach dem Programmstart
3.1 Das einfachste Visual Basic-Programm

Nach dem Aufruf des Start-Menüs von Windows 95 und der Menü- Ein Programm ohne
punkte PROGRAMME | VISUAL BASIC 6.0 kann durch Anklicken von VI- Programmieraufwand
SUAL BASIC 6.0 die Entwicklungsumgebung gestartet werden. In dem
Dialog NEUES PROJEKT WÄHLEN Sie die Option STANDARD-EXE aus. Jetzt
ist die Grundlage für das erste Programm erstellt worden. Die Ent-
wicklungsumgebung enthält ein Grundprogramm. Durch Drücken
der Taste (F5) oder über die Menübefehle RUN | START wird das aktuelle
Programm gestartet. Dieses einfachste Visual Basic-Programm ent-
hält ein leeres Formularfenster, da bis zu diesem Zeitpunkt noch
keine Programmierung erfolgt ist.

47
Dennoch ist das Programm in diesem Stadium bereits leistungsfähig.
Das Fenster kann vergrößert oder verkleinert, auf der Oberfläche ver-
schoben und sogar beendet werden; es entspricht dem Windows-
Standard. Die genannten Befehle können durch Anklicken des Sym-
bols in der linken oberen Ecke ausgeführt werden. Wenn man das
Programm jedoch über einen Button beenden will, muß dieser Befehl
(end) explizit programmiert werden.
3.2 Grundlegende Programmstrukturen
3.2.1 Kurzüberblick
Dieses Kapitel erläutert die verschiedenen Variablentypen und Kon-
stanten. Es wird gezeigt, welche Wertebereiche Variablen einnehmen,
und erklärt, wie man für eine bestimmte Aufgabe die richtige Variable
findet. Weiterhin wird der Einsatzbereich der Konstanten erklärt.
3.2.2 Variablen
Variablen sind über einen Namen gekennzeichnete und ansprech-
bare Größen. Sie bestehen aus zwei Elementen, dem Variablennamen
und dem Eigenwert der Variablen. Der Name der Variablen kann
während der Programmlaufzeit nicht verändert werden, der Eigen-
wert dagegen sehr wohl. Variablen werden benötigt, um z.B. Ergeb-
nisse von Berechnungen oder Eingaben von Benutzern zu speichern
und zu verarbeiten. In Visual Basic ist es nicht zwingend erforderlich,
daß eine Variable deklariert1 wird. Es wird jedoch empfohlen, im
Menü EXTRAS OPTIONEN... auf dem Tabulator EDITOR die Option VA-
RIABLENDEKLARATION ERFORDERLICH zu aktivieren, damit grundsätzlich
alle Variablen deklariert werden müssen. Ansonsten können Pro-
grammfehler entstehen, deren Ursachen nur sehr schwer zu finden
sind (Tabelle 3.1).
Das folgende Beispiel soll die Summe aller Zahlen von 1 bis 100 ad-
dieren und das Ergebnis an die aufrufende Funktion zurückliefern.
Die Unterschiede des Programmcodes (Erg und Erk) in den Spalten
„richtig“ und „falsch“ sind grau hinterlegt.
1. Vor der Benutzung wird dem Programm bekanntgegeben, um welchen Varia-

blentyp (Zeichenkette, Zahl usw.) es sich handelt.
48
richtig falsch
Programm function Summe(Zahl as integer) as function Summe(Zahl as integer) as
integer integer
dim i as integer dim i as integer

dim Erg as integer dim Erg as integer
Erg = Erg + i Erg = Erk + i

for i = 0 to Zahl for i = 0 to Zahl
Erg = Erg + i Erg = Erk + i
next i next i
Summe = Erg Summe = Erg
end Function end Function
Übergabewert Zahl = 100 Zahl = 100
Ausgabe Summe = 5050 Summe = 100
Tabelle 3.1: Möglicher Fehler aufgrund fehlender Deklarationen von Variablen
Das Programm wird, wenn nicht explizit eine Deklaration der Varia-
blen gefordert ist, keine Fehlermeldung ausgeben. Der Unterschied
besteht nur darin, daß bei der Version „Falsch“ mit einem falschen
Ergebnis weitergerechnet wird. In diesem kleinen Beispiel ist der Feh-
ler relativ einfach zu lokalisieren. In sehr umfangreichen Program-
men dagegen ist die Suche sehr zeitaufwendig. Unter Umständen
sucht man den Fehler sogar an der falschen Stelle.
Variablentypen
In Visual Basic stehen für die Programmierung folgende Variablenty-

pen zur Verfügung:
Typ Wertebereich Beschreibung

Byte 0 bis 255 Byte sind ganze Zahlen, die hauptsächlich bei
1 Byte Berechnungen und Ausgaben verwendet werden, die aus
den ASCII-Werten einzelner Zeichen aus dem ASCII-
Zeichensatz bestehen (siehe Anhang).
Boolean True, False Signalisiert den Zustand Boolscher Ausdrücke oder Varia-
2 Byte blen.
Achtung: In Visual Basic entspricht der Wert -1 dem
Zustand True/Wahr und der Wert 0 dem Zustand False/
Falsch.
Integer –32768 bis +32767 Die Variablentypen Integer und Long sind Ganzzahl-
2 Byte Variablentypen. Sie werden dort eingesetzt, wo keine
Nachkommastellen benötigt werden.
49
Typ Wertebereich Beschreibung
Long –2`147`483`648 bis Die beiden Variablentypen unterscheiden sich darin, daß
2`147`483`647 der Wertebereich von Long deutlich größer als der von
4 Byte Integer ist. Eine Variable vom Typ Long nimmt im Vergleich
zu einer vom Typ Integer auch doppelt soviel Speicherplatz
ein.
Single Im negativen Bereich: Single und Double sind Fließkommazahlen, die sich darin
3`3,402823*1038 bis – unterscheiden, daß Double einen weitaus größeren
Wertebereich hat als Single, allerdings doppelt soviel
1.401298*10–45
Speicher benötigt wie eine Variable vom Typ Single. Diese
Im positiven Bereich: Variablentypen werden bei Berechnungen eingesetzt, die
1,401298*10–45 bis sehr genau sein müssen.
3,402823*1038
4 Byte
Double Im negativen Bereich:
–1.79769313486232*10308
bis
–4.94065645841247*10–324
Im positiven Bereich:
4.94065645841247*10–324
bis
1.79769313486232*10308
8 Byte
Currency –922`337`203`685`477.5808 Currency ist eine Mischung aus einer Ganz- und einer
bis Fließkommazahl. Damit lassen sich Berechnungen bis zur
922`337`203`685`477.5807 vierten Stelle nach dem Komma durchführen.
8 Byte
Date Datum Wird benutzt für Datums- und Uhrzeitangaben, wobei die
1. Januar 100 bis im Wertebereich angegebenen Begrenzungen gelten.
31. Dezember 9999
Uhrzeit
00:00 bis 23:59:59
8 Byte
String 10 Byte + 2 Byte pro Zeichen Zeichenketten bestehen aus der Aneinanderreihung
einzelner Zeichen aus dem ASCII-Zeichensatz (siehe ASCII-
Tabellen im Anhang). Seit der Visual Basic-Version 4.0 ist die
Länge einer Zeichenkette nur noch durch den
Hauptspeicher begrenzt (2.147.483.647 Zeichen).
Object 4 Byte Die Variable speichert einen Verweis auf ein Objekt. Es kann
sich hierbei um einen Button oder ein Formular handeln. Sie
wird eingesetzt, um Zugriffe auf Objekte übersichtlicher zu
gestalten.
Variant Bei Numerischen Werten: Variant ist ein Default-Variablentyp, der jeden beliebigen Typ
16 Byte aus der obigen Tabelle annehmen kann. Variablen werden
Bei Zeichenketten: automatisch konvertiert. Dieser Variablentyp wird dort
22 Byte + 2 Byte pro Zeichen eingesetzt, wo sich der Typ einer Variable bei der
Programmausführung ändern kann.
Tabelle 3.2: Variablentypen und ihre Beschreibung
50
Im folgenden sollen einige Beispiele zur Deklaration von Variablen
gezeigt werden.
Code Beschreibung
Dim i As Integer Deklariert i als Ganzzahl
Dim Zeichenkette As String Deklariert Zeichenkette als Zeichenkette
Dim abcdefg Kein Variablentyp angegeben, also wird der
allgemeine Variablentyp Variant verwendet
Tabelle 3.3: Beispiele zur Variablendeklaration
Alle Deklarationen der Tabelle 3.3 sind erlaubt, auch Deklarationen

ohne Angabe des Variablentyps – Visual Basic sucht für die Variable
automatisch den richtigen Variablentyp heraus. Jedoch ist diese Art
von Deklaration nicht zu empfehlen, da sich die Suche negativ auf
die Geschwindigkeit der Programmabarbeitung auswirkt.
Es gibt eine zusätzliche Kurzschreibweise, um den Typ einer Varia-

blen festzulegen. In Tabelle 3.4 sind Zeichen aufgelistet, die eine Va-
riable eindeutig einem bestimmten Variablentyp zuordnen.
Zeichen Variablentyp
% Integer
& Long
! Single
# Double
@ Currency
$ String
Tabelle 3.4: Symbole für die Variablendeklaration
Wenn man bei der Deklaration der Variablen die in Tabelle 3.6 vorge-
stellten Zeichen für die Bestimmung des Variablentyps verwendet, ist
der Programmcode für den Programmierer, der sich zunächst in den
Programmfluß hineindenken muß, sehr viel einfacher zu verstehen,
da er den Variablentyp bereits an der Namensgebung der Variablen
erkennt.
Code Beschreibung
Dim i% Deklariert i als Ganzzahl
Dim Zeichenkette$ Deklariert Zeichenkette als Zeichenkette
Dim Wert% As Integer Keine gültige Deklaration der Variablen, da sonst
Dim Wert& As Integer die Variablen doppelt deklariert wären.
Tabelle 3.5: Beispiele zur Variablendeklaration durch den Variablennamen
51
Der allgemeine Variablentyp Variant
In Tabelle 4.2 wurde eine Variable ohne Typangabe deklariert. Dieser

Variablen wird automatisch der Variablentyp Variant zugewiesen. Mit
den so deklarierten Variablen lassen sich alle anderen Datentypen
speichern. Diese Variablen sind deshalb sehr flexibel und natürlich
auch sehr bequem zu handhaben. Das folgende Beispiel soll die Ein-
fachheit dieser Variablentypen veranschaulichen.
Es soll eine Funktion geschrieben werden, die das Quadrat einer Va-
riablen berechnet.
Function Quadrat(Satz As Variant) As Variant

Quadrat = Satz * Satz
End Function
Sub Beispiel_1()
Dim Satz$
Dim Zahl%
Dim Komma!
Satz$ = "25 DM"

Zahl% = 20
Komma! = 4.25
Zahl% = Quadrat(Zahl%)
Debug.Print "Zahl = " & Zahl%
Komma! = Quadrat(Komma!)
Debug.Print "Komma = " & Komma!
Satz$ = Quadrat(Satz$)
Debug.Print "Satz = " & Satz$
End Sub
Abbildung 3.2: Ausgabe des Variant-Beispiels in das Debugfenster
In Abbildung 3.3 ist die Ausgabe des kurzen Beispielprogrammes im

Debugfenster dargestellt. In der Funktion Quadrat wurde keine expli-
zite Typkonvertierung programmiert. Allerdings multipliziert sie den
Zahlenanteil (die 25) des String (25 DM) mit sich selbst und liefert das
Ergebnis wieder im richtigen Datentyp zurück. Der Stringanteil (DM)
geht verloren, weil intern eine Typkonvertierung durchgeführt wird.
52
Das folgende Beispielprogramm liefert das gleiche Ergebnis wie das
vorherige Beispiel, jedoch arbeitet die Funktion mit dem Variablen-
typ Long.
Function Quadrat_2(Satz As Long) As Long
Quadrat_2 = Satz * Satz
End Function
Sub Beispiel_2()
Dim Satz$
Dim Zahl%
Dim Komma!
Satz$ = "25 DM"

Zahl% = 20
Komma! = 4.25
Zahl% = Quadrat_2(Zahl%)
Debug.Print "Zahl = " & Zahl%
Komma! = CSng(Quadrat_2(CLng(Komma!)))
Debug.Print "Komma = " & Komma!
Satz$ = CStr(Quadrat_2(CLng(Satz$)))
Debug.Print "Satz = " & Satz$
End Sub
Abbildung 3.3: Ausgabe der zweiten Programmlösung zu Variant in das Debugfenster
Beim Vergleich der beiden Programme fällt zum einen auf, daß das
Programm mit dem Variablentyp Variant weniger komplex ist als das
mit dem Variablentyp Long. Des weiteren ist die Berechnung des Qua-
drats einer Kommazahl im zweiten Beispiel falsch, denn bei der Über-
gabe der Variablen an die Funktion Quadrat wird der Nachkommateil
einfach abgeschnitten.
3.2.3 Konstanten
Konstanten bestehen wie die Variablen aus zwei Einheiten, dem Kon-
stantennamen und dem Eigenwert. Im Gegensatz zu den Variablen
kann weder der Eigenname noch der Wert der Konstanten während
der Laufzeit verändert werden. Dies ist auch der Zweck ihrer Verwen-
53
dung: Wenn im Programm Variablen eingesetzt werden, deren Werte
nicht verändert werden, und die Werte auch schon zur Zeit der Pro-
grammierung bekannt sind, handelt es sich bei diesen Werten um
Konstanten. Eine Konstante kann von jedem beliebigen Variablentyp
sein, denn jede Variable kann als Konstante definiert werden, indem
vor den Ausdruck der Variablendeklaration der Befehl const gestellt
wird.
Const Maximum = 181

Const Maximum As Long = 181
Const Maximum As Double = 181
Const Pi As Double = 3.1415
Es ist sogar folgender Ausdruck möglich, wobei Pi (p) dann nur der
Wert 3 zugewiesen wird.
Const Pi As Integer = 3.1415
Eine typische Konstante für ein Programm ist z.B. die Versionsnum-
mer. Sie darf während der Programmlaufzeit nicht verändert werden,
muß aber immer wieder vom Programmierer angepaßt werden.
Weitere Beispiele für Konstanten sind:
Umrechnungsfaktoren für physikalische Masse

Mathematische Konstanten (z.B. p, Eulersche Zahl)
Temporäre Dateinamen, die für Auslagerungszwecke benutzt wer-
den
Maximum- und Minimumwerte, die für bestimmte Berechnungen
nicht über- oder unterschritten werden dürfen
Das folgende Programm verwendet eine Konstante Maximum, um zu

prüfen, ob die Zahl, deren Quadrat berechnet werden soll, kleiner ist
als der größte erlaubte Wert.
Function Quadrat(Zahl As integer) As Integer

If ABS(Zahl) <= Maximum Then
Quadrat = Zahl * Zahl
Else
Quadrat = -1
Endif
End Function
54
3.2.4 Mehrdimensionale Felder
Felder sind Listen von Variablen. Betrachtet man ein Zeichen als ei-
nen Datentyp, so ist die Zeichenkette vom Typ String ein Feld von Zei-
chen. Demnach wäre eine Variable Satz, die als
Dim Satz As Char[100]
deklariert wird, eine Zeichenkette mit 100 Zeichen. Felder werden

also immer dort eingesetzt, wo mehrere Informationen vom gleichen
Datentyp gespeichert werden. Die Felder finden beispielsweise An-
wendung in der Vektorrechnung.
Statische Felder
Wenn die Größe eines Feldes konstant bleibt, spricht man von stati-
schen Feldern. Der Inhalt der einzelnen Feldvariablen kann jederzeit
geändert werden, aber die Anzahl der Felder, die zu der Variablen ge-
hören, ist konstant. Im folgenden wird eine Variable Woche dekla-
riert, die alle Wochentage enthält.
Dim Woche(7)
Woche = Array("Sonntag", "Montag", "Dienstag", _
"Mittwoch", "Donnerstag", "Freitag", _
"Samstag")
Die Variable Woche ist nun ein Feld und enthält sieben Werte vom
Typ String. Alle Werte sind bei der Deklaration initialisiert worden.
Ausgelesen wird jeder Wert über seine Position in dem Feld.
Abbildung 3.4: Eindimensionales Feld „Woche“
Wie in Abbildung 3.4 zu sehen ist, sind die Variablen aneinanderge-

reiht, und jeder Position ist eine eindeutige Nummer zugeordnet.
Folgende Programmzeile weist einer Variablen den dritten Wochen-
tag, den Dienstag, zu:
Dim Tag As String

Tag = Woche(3)
55
Wenn zur Programmierzeit der Inhalt der Variablen noch nicht be-
kannt ist, sieht die Deklaration eines Feldes wie folgt aus:
Dim Woche(7) As String
Der Inhalt aller Felder kann jederzeit über den Zugriff des Index geän-
dert werden.
Woche(2) = "Monday"
Mehrdimensionale Felder
In Abbildung 3.4 wurde ein eindimensionales Feld dargestellt. In

dem Beispiel mit dem Feld Woche wurde allerdings die ganze Zeit auf
einem zweidimensionalen Feld gearbeitet, wenn man davon ausgeht,
daß ein String schon ein eindimensionales Feld ist. In Abbildung 3.5
ist nun ein zweidimensionales Feld dargestellt, mit dem zugehörigen
Index für jede Zelle.
Abbildung 3.5: Zweidimensionales Feld
Abbildung 3.5 zeigt, daß nun zwei Werte nötig sind, um ein Feld ein-
deutig zu identifizieren: zum einen der Index der horizontalen, der
x-Achse, und zum anderen der Index der vertikalen, der y-Achse. Die
Deklaration einer zweidimensionalen Feldvariablen sieht wie folgt
aus:
Dim Feld(4, 5) As Integer
Der Zugriff auf das dritte Feld horizontal und das zweite Feld vertikal
erfolgt über den Befehl:
Feld(4, 5)
56
Die nächste Steigerung ist nun das dreidimensionale Feld. Es ist die
letzte Stufe, die sich noch recht übersichtlich darstellen läßt (Abbil-
dung 3.6).
Abbildung 3.6: Darstellung eines dreidimensionalen Feldes
Auch hier erhöht sich nun wieder die Komplexität der Parameter, um
auf eine bestimmte Zelle zugreifen zu können. Die Komplexität der
Felder läßt sich noch weiter steigern, jedoch wird es mit jeder neuen
Komplexitätsgröße schwieriger, sich diese Datenstruktur vorzustel-
len.
Das folgende Beispiel initialisiert ein zweidimensionales Feld der

Größe 5 x 3 mit den Produkten der Indexwerte.
Dim i, j As Integer
Dim Feld(5, 3) As Integer
for i= 0 to 4
for j = 0 to 2
Feld(i, j) = i * j
next j
next i
57
Abbildung 3.7: Zweidimensionales Feld mit berechneten Feldwerten
Benutzerdefinierter Indexbereich
Bei den bisherigen Felddeklarationen wurde die Indexnumerierung

von Visual Basic vorgegeben. Es ist auch möglich, den eigenen Index-
bereich vorzugeben. Wenn ein eindimensionales Feld deklariert wird,
das 101 Werte enthalten soll, so verläuft der Index von 0 bis 100.
Wenn jedoch ein Index der Feldvariablen von –50 bis +50 nötig ist, so
muß diese wie folgt deklariert werden:
Dim Feld(-50 to 50)
Dies funktioniert ebenfalls bei mehrdimensionalen Feldern, deren

Indexbereich vom Programmierer festgelegt werden muß.
Dim Feld(-3 To 20, 30 To 32) As Integer
Dynamische Felder
Bisher sind wir immer davon ausgegangen, daß die Feldgröße, also
die Anzahl der Elemente, die eine Feldvariable enthalten soll, be-
kannt ist. Es gibt aber auch Aufgaben, bei denen die Feldgröße nicht
bekannt ist. Ein Beispiel hierfür ist das Rechnen mit Vektoren und
Matrizen. Die Deklaration der dynamischen Feldvariablen erfolgt wie
die Deklaration der statischen Feldvariablen mit dem Befehl Dim und
optional mit dem Variablentyp. Im Unterschied zur statischen Feld-
deklaration wird keine Größe des Feldes angegeben.
Dim Vektor() As Double

Dim Matrix() As Double
Dim Hyper()
58
Die Definition der Größe des Feldes erfolgt erst im Programm, wenn
die Feldvariable gebraucht wird. Diese neue Dimensionierung der Va-
riablen erfolgt über den Befehl ReDim. Er wird wie der Befehl Dim zur
Felddeklaration verwendet, jedoch immer ohne Variablentyp.
ReDim Vektor(10)
ReDim Matrix(4, 3)
ReDim Hyper(2, 2, 2, 2, 2, 2, 2, 2)
ReDim Hyper(2, 2, 2, 2, 2, 2, 2, 2) As Integer 'Ist nicht möglich
Die Feldvariable Vektor ist ein eindimensionales Feld mit zehn Ele-
menten vom Typ Double. Matrix ist schon ein zweidimensionales Feld
vom Typ Double, enthält also
4 x 3 = 12
Variablen vom Typ Double. Die Variable Hyper ist eine achtdimensio-
nale Feldvariable vom Typ Variant und enthält
2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 = 256
Variablen. Die Werte, die die Feldgröße definieren, können selbst

wieder Variablen sein.
Dim Anzahl As Integer

Dim Feld()
...
Anzahl = 20
...
ReDim Feld(Anzahl)
Nach der ReDim-Anweisung können die Größe eines Feldes und die Di-
mensionierung jederzeit geändert werden. Wenn sich die Größe des
Feldes während der Programmlaufzeit verändern muß, ist auch dieses
mit der ReDim-Anweisung zu lösen (zum Ablauf sei auf die oben be-
schriebenen Beispiele verwiesen).
Dim Feld() 'Deklaration der Variablen

...
ReDim Feld(3) 'Erstes Festlegen der Feldgröße
...
ReDim Feld(5) 'n-tes Festlegen der Feldgröße
Bei der Neudimensionierung von dynamischen Feldern kann die

Feldgröße jederzeit geändert werden, jedoch nicht die Anzahl der Di-
mensionen. Die folgende Programmzeile erzeugt aus dem dynami-
schen Feld
59
ein mehrdimensionales Feld:
ReDim Feld(4, 2) 'm-tes Festlegen der Feldgröße
Nachdem die Anzahl der Dimensionen eines dynamischen Feldes

einmal festgelegt wurde, kann diese nicht mehr geändert werden.
Es ist bei der Redeklaration eines Feldes darauf zu achten, daß der In-
halt der Felder verlorengeht, wenn die Änderung der Felddimension
wie oben durchgeführt wird. Um den Inhalt der einzelnen Feldwerte
bei der Größenänderung der Feldvariablen beizubehalten, muß der
Befehl Preserve wie folgt verwendet werden:

...
ReDim Feld(3) 'Erstes Festlegen der Feldgröße
...
ReDim Preserve Feld(5) 'n-tes Festlegen der Feldgröße
Löschen des Feldinhalts
Um alle Felder einer Feldvariablen zu löschen, gibt es unter Visual Ba-

sic den Befehl Erase.
Erase Feld
Erase gibt bei dynamischen Feldern den Speicher der Feldvariablen

wieder frei, d.h., um einem Feld wieder einen Wert zuzuweisen, muß
die Feldgröße der Variablen neu mit ReDim dimensioniert werden. Bei
statischen Feldern hängt der Inhalt der Feldvariablen vom Variablen-
typ ab (Tabelle 4.6).
Variablentyp Neuer Wert

Byte 0
Boolean False
Integer, Long 0
Single, Double 0
Currency 0
Date 00:00:00
String ""
Objekt Nothing
Variant Empty
Tabelle 3.6: Inhalt der Feldvariablen nach dem Löschen mit Erase
60
Ermitteln des Indexbereiches eines Feldes
Um bei Feldern den kleinsten und größten erlaubten Index zu ermit-

teln, gibt es die Funktionen LBound (untere Grenze) und UBound
(obere Grenze).
Min = LBound(Feld)
Max = UBound(Feld)
Bei mehrdimensionalen Feldern muß die Dimension, deren Grenzen

bestimmt werden sollen, auch in der Parameterliste angegeben wer-
den.
Min = LBound(Feld, 2)
Max = UBound(Feld, 2)
Es gibt leider noch keinen Befehl, mit dem sich ermitteln läßt, wie
viele Dimensionen ein Feld hat.
Eigenheiten der Felder vom Typ Variant
In Abschnitt „Der allgemeine Variablentyp Variant“ stellten wir fest,

daß der Variablentyp Variant alle anderen Variablentypen darstellen
kann. Diese Aussage trifft auch auf jedes Feld einer Feldvariablen vom
Typ Variant zu. Ein Element dieser Feldvariablen enthält eine Zahl
und ein anderes Feld, einen String.
Dim Feld(2)
Feld(0) = "Dies ist eine Zeichenkette"

Feld(1) = 3.1415
Debug.Print Feld(0)
Debug.Print "PI = " & Feld(1)
...
Feld(1) = Feld(1) * 2
Feld(0) = Feld(0) & " die verlängert wurde"
Debug.Print Feld(0)
Debug.Print "2 * PI = " & Feld(1)
61
Das in das Debugfenster geschriebene Ergebnis sieht folgendermaßen
aus:
Abbildung 3.8: Ausgabe des Feldbeispiels vom Typ „Variant“
Wie in Abbildung 3.8 zu sehen ist, können somit verschiedene Varia-

blentypen in einer Feldvariablen enthalten sein.
3.2.5 Selbstdefinierte Datentypen

Trotz der Vielfalt an angebotenen Datentypen ist es dennoch bei
manchen Anwendungen nötig, eigene Datentypen zu entwickeln.
Ein wichtiger Datentyp der Mathematik, der nicht von Visual Basic
unterstützt wird, ist der Datentyp Koordinate. Um in einem Koordina-
tensystem mit zwei Achsen die Position eines Punkts genau festzule-
gen, sind zwei Angaben notwendig: die x-Koordinate und die y-Koor-
dinate (siehe Abbildunb 3.9).
Abbildung 3.9: Ein Punkt in einem Koordinatensystem
62
Im folgenden wird der Datentyp Koordinate für ein zweidimensiona-
les Koordinatensystem definiert.
Type Koordinate
x As Integer
y As Integer
End Type
Auf die einzelnen Komponenten des selbstdefinierten Datentyps

greift man über den Datentypnamen und die Datentypkomponen-
ten zu, die durch einen Punkt voneinander getrennt sind.
Dim Punkt As Koordinate
Punkt.x = 2
Punkt.y = 3
Tabelle 3.7 enthält weitere mögliche Datentypen.
Datentyp Enthält folgende Felder

Name Vorname As String
Nachname As String
Adresse Kunde As Name
Strasse As String
Ort As String
Adressenliste Ort As String
Adressen() As Adresse
Komplex Real As Double
Imaginaer As Double
Tabelle 3.7: Weitere mögliche Datentypen
3.2.6 Schleifen
For-Schleife
Die For-Schleife ist eine sogenannte Zählschleife. Ein Startwert, ein

Zielwert und die Schrittweite sind vorgegeben. Dabei kann die
Schrittweite je nach Bedarf positiv oder negativ sein. Es können auch
mehrere Schleifen ineinander verschachtelt werden, um zum Beispiel
mehrdimensionale Felder zu berechnen. Das folgende Beispiel be-
rechnet die Summe aller ganzen Zahlen von 0 bis 100.
Ergebnis = 0
For i=0 To 100
Ergebnis = Ergebnis + i
Next i
63
Um die Summe aller ganzen geraden Zahlen zu berechnen, muß die
im obigen Beispiel verwendete Schleife um den Parameter Schritt-
weite erweitert werden, da von Null ab nur jede zweite Zahl gerade ist.
Man erhält folgenden Programmcode:
Ergebnis = 0
For i=0 To 100 Step 2
Ergebnis = Ergebnis + i
Next i
Mit Exit For kann eine Schleife vorzeitig abgebrochen werden. Die
entsprechende Syntax lautet:
For Variable = Startwert To Endwert [Step Schrittweite]

...
Exit ForSchleife vorzeitig beenden
...
Next Variable
While-Schleife
Die While-Schleife ist eine Boolsche Schleife, d.h. solange der Aus-
druck wahr ist, wird sie auch durchlaufen. Dies birgt die Gefahr, daß
diese Schleife nicht endet, wenn der Boolsche Ausdruck niemals
„Falsch“ werden kann. Im Gegensatz zur For-Schleife wird die Anzahl
der Schleifendurchläufe nicht automatisch mitgezählt. Das folgende
Beispiel rechnet eine ganze Zahl in ein Bitmuster um, indem der Rest
der Division in eine Zeichenkette gespeichert wird.
Zahl = 7
Ergebnis = "0"
While Zahl<1
Ergebnis = (Zahl Mod 2) & Ergebnis
Zahl = Zahl / 2
Wend
Syntax:
While Bedingung
...
Wend
Do-Schleife
Die Do-Schleife ist wie die While-Schleife ebenfalls eine Boolsche

Schleife, jedoch wird der Programmcode im Gegensatz zur While-
Schleife immer mindestens einmal durchlaufen, da erst am Ende der
64
Schleife eine Überprüfung auf weitere Durchläufe erfolgt. Die ein-
fachste Form der Do-Schleife ist eine Endlosschleife.
Do
Loop
Die Syntax der Do-Schleife ist wie folgt aufgebaut:
Do [While/Until Bedingung]
...
Exit DoSchleife vorzeitig verlassen
...
Loop
oder:
Do
...
Exit Do Schleife vorzeitig verlassen
...
Loop [While/Until Bedingung]
3.2.7 Verzweigungen
Verzweigungen werden gebraucht, um im Programm verschiedene
Fälle zu unterscheiden. Bei Wahr/Falsch- oder Ja/Nein-Entscheidun-
gen wird im allgemeinen die If-Then-Else-Verzweigung gewählt. Bei
mehreren Auswahlmöglichkeiten greift man auf den Typus der
Select Case-Entscheidung zurück.
IF-THEN-ELSE
Die Verzweigung If-Then-Else ist eine sogenannte scharfe Entschei-

dung, da sie nur zwischen zwei Zuständen unterscheiden kann: Ent-
weder ist der Ausdruck wahr, oder er ist falsch. Die Syntax einer sol-
chen Verzweigung lautet:
If Bedingung Then Kommando

If Bedingung Then Kommando Else Kommando
If Bedingung Then
...
Elseif Bedingung Then
...
Else
...
End If
65
Diese Art von Entscheidungsmöglichkeit wird benötigt, um Fälle zu
unterscheiden, die nur zwei Zustände kennen (Tabelle 3.8). Soll z.B.
eine Zahl durch eine Variable dividiert werden, so muß zuvor geprüft
werden, ob die Variable nicht 0 ist, da bei einer Division nicht durch
0 dividiert werden darf.
Nachfolgend sind einige prägnante Beispiele zu Ja/Nein-Entschei-

dungen aufgeführt:
Boolscher Ausdruck Der Ausdruck ist wahr, wenn...

X > 0 ...X größer als 0 ist.
X <> 0 ...X nicht 0 ist.
Not X ...X nicht wahr ist.
X < 0 AND X > 0 Kann nie wahr werden, da X nicht kleiner als 0 und
gleichzeitig größer als 0 sein kann
Tabelle 3.8: Beispiel Boolscher Ausdrücke in If-Then-Else-Abfragen
SELECT CASE
Die Verzweigung Select Case ist eine Fallunterscheidung, da sie für

mehrere verschiedene Fälle auch unterschiedliche Entscheidungs-
spielräume zur Verfügung stellt.
Select Case Ausdruck

Case Fall1:
...
Case Fall2:
...
Case Falln:
...
[Case ELSE]
...
End Select
Diese Art von Verzweigung wird u.a. verwendet, wenn das Programm
abhängig vom Wochentag unterschiedliche Programmteile ausfüh-
ren muß.
Das folgende Beispiel schreibt in eine Variable vom Typ String den
Namen des Wochentages, wobei die Woche bei Sonntag beginnt, und
Sonntag dem Wert 1 entspricht.
Dim Tag As Integer

Dim Wochentag As String
'Der Variablen Tag eine Zahl zwischen
'1 und 7 zuweisen
66
Tag = 1
Select Case Tag
Case 1:
Wochentag = "Sonntag"
Case 2:
Wochentag = "Montag"
Case 3:
Wochentag = "Dienstag"
Case 4:
Wochentag = "Mittwoch"
Case 5:
Wochentag = "Donnerstag"
Case 6:
Wochentag = "Freitag"
Case 7:
Wochentag = "Samstag"
Case ELSE
Wochentag = "Falsche Eingabe"
End Select
3.2.8 Funktionen und Prozeduren
Prozeduren (Sub – End Sub)
Prozeduren haben stets den folgenden Aufbau:
Sub Prozedurname (Param1 As Vartyp, _

..., Paramn As Vartyp)
...
End Sub
Als Beispiel wählen wir eine Prozedur, die die Summe zweier Zahlen
ermittelt:
Sub Summe(Variable1 As Integer, _

Variable2 As Integer)
Dim Ergebnis As Integer
...
Ergebnis = Variable1 + Variable2
...
End Sub
67
Funktionen (Function – End Function)
Funktionen sind Prozeduren, die einen Wert an die Funktion zurück-

geben, von der sie aufgerufen wurden. Der Aufbau von Funktionen
sieht wie folgt aus:
Function Name (Param1 As Vartyp, _

..., Paramn As Vartyp) AS Vartyp
...
Name = Wert
...
End Function
Auch hier wieder ein kurzes Beispiel, nämlich eine Funktion, die die
Summe zweier Zahlen ermittelt:
Function Summe(Variable1 As Integer, _

Variable2 As Integer) AS Integer
Summe= Variable1 + Variable2
End Function
Call-by-Value
Call-by-Value bedeutet, daß der Inhalt der Variablen an die aufzuru-

fende Funktion oder Prozedur übergeben wird. Ändert man also den
Inhalt der Variablen in der aufgerufenen Funktion oder Prozedur, hat
dies keinen Einfluß auf den Inhalt der Variablen der aufrufenden
Funktion.
Soll bei einer Funktion oder Prozedur eine Variable durch die Me-
thode Call-by-Value übergeben werden, muß dies explizit bei der De-
klaration der Funktion angegeben werden.
Sub Procedure(ByVal Variablenname As Variablentyp)

Function Function(ByVal Variablenname As Variablentyp)
Das folgende Beispiel berechnet die Fakultät einer Zahl. Damit der
Variableninhalt in der aufrufenden Funktion nicht verändert wird,
wird das Verfahren Call-by-Value gewählt.
Function Fakultaet(ByVal x As Long) As Long

Dim i As Integer
If x > 0 Then
For i = x – 1 To 2 Step –1
x = x * i
Next i
68
Fakultaet = x
Else
Fakultaet = 0
End If
End Function
Call-by-Reference
Bei der Methode Call-by-Reference wird – im Gegensatz zur Methode

Call-by-Value – nicht der Inhalt der Variablen übergeben, sondern de-
ren Speicheradresse. Wird der Inhalt der Variablen in der aufgerufe-
nen Funktion oder Prozedur geändert, so ändert sich auch der Inhalt
der Variablen in der aufrufenden Funktion. Durch diese Art der Para-
meterübergabe ist es nun möglich, daß eine Funktion mehrere ver-
schiedene Variablen an die aufrufende Funktion zurückliefert (sog.
indirekte Parameterrückgabe).
Call-by-Reference muß nicht explizit definiert werden, da diese Art der

Variablenübergabe in Visual Basic voreingestellt ist.
Das folgende Beispiel berechnet die Fakultät einer Zahl (vgl. mit Call-
by-Value). Diesmal wird die Parameterübergabe jedoch nach dem
Prinzip Call-by-Reference programmiert.
Function Fakultaet(x As Long) As Long

Dim i As Integer
If x > 0 Then
For i = x – 1 To 2 Step –1
x = x * i
Next i
Fakultaet = x
Else
Fakultaet = 0
End If
End Function
In dem Beispiel Call-By-Reference ist der Inhalt der Variablen der auf-
rufenden Funktion verändert worden. Er entspricht nicht mehr dem
Wert, der der Berechnung zugrundeliegt, sondern dem Ergebnis. In
Tabelle 3.9 werden die Variableninhalte der beiden Verfahren noch-
mals anhand der einzelnen Programmschritte verdeutlicht.
69
Call-by-Value Call-by-Reference
Schritt 1: Initialisierung Zahl = 4 Zahl = 4
Schritt 2: Aufruf der Fakultäts- Erg = Fakultaet(Zahl) Erg = Fakultaet(Zahl)
funktion
Variableninhalte nach dem Erg = 24 Erg = 24
Zurückkehren aus der Fakultäts- Zahl = 4 Zahl = 24
funktion
Tabelle 3.9: Schrittweiser Vergleich von Call-by-Value und Call-by-Reference
Wird der Inhalt der Variablen in der aufgerufenen Funktion nicht ge-
ändert, so ist es nicht relevant, ob die Parameterübergabe mit der Me-
thode Call-by-Value oder Call-by-Reference erfolgt.
Wird der Inhalt der Variablen jedoch in der aufgerufenen Funktion

geändert, so muß bereits bei der Deklaration bekannt sein, ob die auf-
gerufene Funktion den neuen Wert verwerfen (Call-by-Value) oder an
die aufrufende Funktion zurückliefern soll (Call-by-Reference).
Aufgabe
Das erste Programmbeispiel, das im folgenden entwickelt werden soll,
ist eine mathematische Spielerei. Alle natürlichen Zahlen2 lassen sich
in die Zahl 123 umrechnen, indem man sowohl die geraden und unge-
raden Ziffern als auch die Anzahl der Stellen ermittelt. Wird dieser Al-
gorithmus oft genug ausgeführt, so lautet das Endergebnis immer 123.
Theoretisches Beispiel mit den Zahlen 3 und 12345
gerade ungerade Anzahl
Zahl Ziffern Ziffern Stellen
Beispiel 1 3 0 1 1
11 0 2 2
22 2 0 2
202 3 0 3
303 1 2 3
123 1 2 3
123 1 2 3
Beispiel 2 12345 2 3 5
235 1 2 3
123 1 2 3
123 1 2 3
Tabelle 3.10: Beispiele zum Algorithmus des Zahlenbeispiels „123“
2. Zahlen, die größer als 0 sind und keine Nachkommastellen haben, also nicht
gebrochen sind.
70
3.3 Das erste Programm
Auf dem leeren Formularfenster werden die Steuerelemente, über die
Programm und Benutzer kommunizieren, untergebracht. Hier wer-
den die Buttons, Labelfelder usw. positioniert und der Code für das
Formular implementiert. Jedes Formularfenster kann wiederum ein
anderes Formularfenster aufrufen. Im Eigenschaftsfenster kann nun
der Name des Fensters geänder werden. Hiefür ändern Sie die Eigen-
schaft Name in Zahlenloch.
Abbildung 3.10: Ein leeres Formularfenster
Wenn man mit der linken Maustaste auf dem Formular einen Dop- Entwickeln einer ersten
pelklick ausführt, gelangt man in den Programmeditor von Visual Ba- Applikation mit Visual
sic. Jede Funktion oder Prozedur kann nun wiederum eine andere Basic 6.0
Funktion oder Prozedur aufrufen.
Um den Programmcode dem aktuellen Fenster zuzuordnen, ist es am

einfachsten, wenn mit der linken Maustaste ein Doppelklick auf die
Form ausgeführt wird. Nach dem Doppelklick wird das Programmedi-
torfenster geöffnet und der Cursor in der Funktion Sub Form_Load()
positioniert (Abbildung 3.11). Hier kann nun z.B. dem Fenster ein
neuer Titelleistentext zugewiesen werden.
Private Sub Form_Load()

Zahlenloch.Caption = "Zahlenloch 123 Version 1.0"
End Sub
71
Abbildung 3.11: Programmeditor nach dem Doppelklick auf das Formularfenster
Wird das Programm nun nochmals gestartet, erscheint der eingege-

bene Satz in der Titelleiste des Fensters. Des weiteren hat das Fenster
Eigenschaften wie z.B. einen Namen, Aussehen usw. Diese Eigen-
schaften lassen sich im Eigenschaftenfenster einstellen. In dem Bei-
spiel „Zahlenloch 123“ erhält das Fenster den Namen „Zahlenloch“,
d.h. in dem Property-Fenster wird bei der Eigenschaft Name der Name
„Zahlenloch“ eingetragen. Die Eigenschaft Caption wird beim Pro-
grammstart in der Funktion Form_Load initialisiert, sie braucht also
nicht geändert zu werden. Um zu zeigen, daß diese Eigenschaft kei-
nen Einfluß auf das Programmfenster hat, kann der voreingestellte
Eintrag FORM1 gelöscht werden.
3.3.1 Eingabe
Die Dateneingabe in Für das Beispiel wird eine Eingabemöglichkeit benötigt, um die zu be-
das Programm rechnende Zahl frei wählen zu können. Zur Eingabe von Daten über
Zahlenloch die Tastatur steht unter Visual Basic das Texteingabeelement TextBox
zur Verfügung.
Abbildung 3.12: Das Texteingabeelement „TextBox“
Um eine TextBox oder einen Schaltknopf auf die Oberfläche eines

Formulars zu bringen, muß in dem Werkzeugfenster das jeweilige
Steuerelement aktiviert werden. Nun muß der Mauszeiger an die
Stelle bewegt werden, an der das Element positioniert werden soll.
Durch Klicken mit der rechten Maustaste wird die Position des Text-
eingabeelements auf dem Formular festgelegt. Die Größe des Steuer-
elements kann durch Ziehen mit gedrückter linker Maustaste defi-
niert werden. Um die Eigenschaften nun für das Beispielprogramm
Zahlenloch einzustellen, muß das Steuerelement durch einmaliges
Anklicken aktiviert werden. Die Eigenschaft Name erhält den Wert
72
Zahl, bei der Eigenschaft Tag wird die Zeichenkette „Die zu prüfende
Zahl eingeben“ eingegeben. Der Inhalt in der Eigenschaft Text wird
gelöscht. Bei einem Programmstart kann nun in der TextBox eine
Eingabe vorgenommen werden.
3.3.2 Ausgabe
Natürlich wird auch ein Steuerelement benötigt, mit dessen Hilfe die Ausgabe des
ermittelten Daten dem Benutzer dargestellt werden. Es gibt dazu Programmergebnisses
mehrere Möglichkeiten, von denen man die jeweils beste wählen
kann. Anhand des Beispiels zur Berechnung der Zahl 123 sollen drei
Ausgabemöglichkeiten verglichen werden, um das Vorgehen zur Ent-
scheidung zwischen verschiedenen Steuerelementen zu verdeutli-
chen.
Label TextBox ListBox
Ausgabe von Text möglich Ja Ja Ja

Eingabe von Text während des Nein Ja Nein
Programmablaufs möglich
Ausgabe von mehreren Zeilen Text möglich Nein Nein Ja
(Möglichkeit zum Verschieben des
sichtbaren Textes mittels Bildlaufleiste)
Tabelle 3.11: Vergleich von drei Ausgabe-Steuerelementen
Wie Tabelle 3.11 zeigt, ist es nicht eindeutig, wie viele Schritte not-
wendig sind, um das Ziel zu erreichen. Es ist aber dennoch sinnvoll,
alle Zwischenergebnisse dem Benutzer auszugeben, damit er die Be-
rechnung nachvollziehen kann. Aus der Vergleichstabelle (Tabelle
3.11) ist ersichtlich, daß nur die ListBox mehrere Datenzeilen ausge-
ben kann. Daher wird in diesem Beispiel die ListBox eingesetzt.
Um eine ListBox auf die Oberfläche eines Formulars zu bringen, muß

in der Toolbox das Steuerelement ListBox aktiviert werden. Nun muß
der Mauszeiger an die Stelle bewegt werden, an der das Element posi-
tioniert werden soll. Durch Klicken der rechten Maustaste wird die
Position der ListBox auf dem Formularfenster festgelegt. Die Größe
der ListBox kann durch Ziehen mit gedrückter rechter Maustaste defi-
niert werden. Die Eigenschaft Name erhält die Definition Wertigkeit.
73
3.3.3 Buttons (Programmsteuerungen)
Ausführen von Um in einem Programm einen bestimmten Programmteil zu starten,
Programmodulen werden CommandButtons, kurz Buttons oder Schaltflächen genannt,
eingesetzt. Im Beispiel zur Berechnung der Zahl 123 werden zwei
Schaltflächen benötigt – eine zum Starten der Berechnung, eine zum
Beenden des Programms.
Abbildung 3.13: Die Schaltfläche „Button“
Um einen Button oder Schaltknopf auf die Oberfläche einer Form zu

bringen, muß im Werkzeugfenster das Steuerelement Button aktiviert
werden. Nun muß der Mauszeiger an die Stelle bewegt werden, an der
das Element positioniert werden soll. Durch Klicken der rechten
Maustaste wird die Position des Buttons auf dem Formular festgelegt.
Die Größe des Buttons kann durch Ziehen mit gedrückter rechter
Maustaste definiert werden.
Die Eigenschaft Name des Buttons erhält den Wert OK, die Eigen-
schaft Caption den Wert Berechnen. Auf die gleiche Weise muß der
Button zum Beenden des Programms auf das Formular aufgebracht
werden. Die Eigenschaft Name erhält nun den Wert Abbruch, und die
Eigenschaft Caption erhält den Wert Beenden.
Im Zusammenhang mit der Schaltflächenprogrammierung kann man

gleich auch noch eine nützlichen Funktion einrichten – den sog.
ShortKey3. Damit ein Button mit einem solchen ShortKey aktiviert
werden kann, muß in Visual Basic das Zeichen „&“ vor denjenigen
Buchstaben gesetzt werden, der als ShortKey aktiviert werden soll.
Wird zum Beispiel das „&“ vor den Buchstaben „d“ bei Beenden gesetzt,
erscheint ein unterstrichenes „d“ auf dem Button; das Programm
kann nun mit der Tastenkombination (Alt)-(D) beendet werden.
Es muß jedoch darauf geachtet werden, daß jeder ShortKey nur ein-
mal benutzt wird, da sonst nicht eindeutig definiert werden kann,
welche Funktion als erste ausgeführt wird. Um auch dieses Beispiel-
programm an den Windows-Standard anzupassen, erhält der Button
OK bei der Eigenschaft Caption die Zeichenkette Be&rechnen und der
3. Eine Tastenkombination, die das Ausführen einer Menüoption oder einer

Funktion ermöglicht, ohne zuvor das Steuerelement aktiviert zu haben.
74
Button ABBRECHEN – ebenfalls bei der Eigenschaft Caption – die Zei-
chenkette &Beenden.
Wenn das Programm neu gestartet wird, können beide Buttons betä-
tigt werden. Dennoch geschieht nichts. Weder wird eine Fehlermel-
dung ausgegeben, noch wird durch Betätigen des Buttons Beenden das
Programm abgebrochen. Um das Programm zu beenden, muß immer
noch das Tastenkürzel (Alt)+(F4) oder das Visual Basic-Menü AUSFÜH-
REN | BEENDEN benutzt werden.
Als erstes wird der Button ABBRECHEN programmiert. Durch Doppel-

klick auf den Button ABBRECHEN wird der Programmeditor mit der
Funktion Abbrechen_Click() geöffnet. Zwischen dem Funktionsaufruf
von Abbrechen_Click() und dem Funktionsende END SUB kann nun der
abzuarbeitende Programmcode eingefügt werden. In diesem konkre-
ten Fall ist das die Funktion END. Die Funktion sieht also wie folgt
aus:
private Sub Abbrechen_Click()

End
End Sub
3.3.4 Der Programmcode zum Algorithmus

Der zweite Button soll die eigentliche Berechnungsroutine auslösen. Entwickeln des
Im folgenden Abschnitt soll diese Funktion programmiert werden. Programmcodes auf
Zum besseren Verständnis wird der Programmablauf zuerst in einem der Basis des Vorgabe-
Pseudocode entwickelt und danach mit der jeweiligen Erklärung in algorithmus
einen richtigen Visual Basic-Programmcode umgewandelt.
Initialisiere alle Variablen

Solange die Zahl 123 nicht gefunden wurde, durchlaufe diese Schleife
Zähle alle geraden Zahlen
Zähle alle ungeraden Zahlen
Zähle die Anzahl der Ziffern
Rechne die Ergebnisse in eine neue Zahl um
Gebe die ermittelte Zahl in der ListBox aus
Ende der Solange-Schleife
Die Initialisierung der Variablen

Nachdem der Startbutton aktiviert wurde, muß zuerst geprüft wer- Vorbelegen der
den, ob es sich bei den eingegebenen Daten um eine erlaubte Zahl Variablen mit den
handelt. Wenn das zutrifft, wird diese Zahl einer Variablen zugewie- Startwerten
sen und der Algorithmus zum Umwandeln der Zahl gestartet.
75
Der folgende Programmcode führt die Zeile Initialisiere alle Varia-
blen aus dem Pseudocode-Listing aus.
Dim Ergebnis As String

Dim Gerade As Integer
Dim Ungerade As Integer
Dim i As Integer
If IsNumeric(Zahl.Text) then 'Wenn die Zahl vom Typ
'Long ist
Ergebnis = Zahl.Text
Else
Exit Sub
End If
Wertigkeit.Clear
Die While-Schleife
Ausführen einer Nachdem alle Variablen initialisiert wurden, muß die While-Schleife
Schleife bis zur realisiert werden. Als Kriterium für die einzusetzende Schleife gilt fol-
Erfüllung des gendes:
Abbruchkriteriums
1. Es muß zu Beginn der Schleife geprüft werden, ob die Zahl 123
schon gefunden wurde, denn wenn 123 als zu modifizierende Zahl
eingegeben wird, ist es nicht nötig, den Algorithmus abzuarbeiten.
2. Es ist nicht bekannt, wie oft die Schleife durchlaufen wird. In Ta-
belle 3.12 ist gut zu erkennen, daß die Größe der Zahl nicht in Zu-
sammenhang mit der Anzahl der Schleifendurchläufe steht, die
für das Erreichen der Zahl 123 nötig sind.
Mit einer While-Schleife können genau diese Anforderungen erfüllt

werden. Der Programmcode in der While-Schleife wird solange abge-
arbeitet, bis das Abbruchkriterium der Schleife wahr ist.
Der Bereich der While-Schleife des Pseudocodes stellt sich in Visual Ba-
sic wie folgt dar:
While Val(Ergebnis) <> 123

'Zähle alle geraden Zahlen
'Zähle alle ungeraden Zahlen
'Zähle die Anzahl der Ziffern
'Berechne die neue Zahl anhand der Ergebnisse
Wend
76
Zählen der geraden und ungeraden Zahlen
Um Ziffern in einer Zahl zu analysieren, ist es sinnvoll, die Zahl in Analysieren aller
eine Zeichenkette umzuwandeln und jedes Zeichen (bzw. jede Ziffer) Ziffern der einge-
auf das Kriterium „gerade“ bzw. „ungerade“ zu überprüfen. Für die gebenen Zahl
Umwandlung eines Variablentypen in einen anderen existieren fol-
gende Funktionen:
Funktion Beschreibung
Asc(s) Liefert den ASCII-Code des ersten Zeichens von s.
CBool(x) Wandelt einen beliebigen Datentyp x in den Datentyp Boolean um.
CByte(x) Wandelt einen beliebigen Datentyp x in den Datentyp Byte um.
CCur(x) Wandelt einen beliebigen Datentyp x in den Datentyp Currency um.
CDate(x) Wandelt einen beliebigen Datentyp x in den Datentyp Date um.
CDbl(x) Wandelt einen beliebigen Datentyp x in den Datentyp Double um.
Chr(n) Liefert das n-te Zeichen des ASCII-Zeichensatzes.
CInt(x) Wandelt einen beliebigen Datentyp x in den Datentyp Integer um.
CLng(x) Wandelt einen beliebigen Datentyp x in den Datentyp Long um.
CSng(x) Wandelt einen beliebigen Datentyp x in den Datentyp Single um.
CStr(x) Wandelt einen beliebigen Datentyp x in den Datentyp String um.
CVar(x) Wandelt einen beliebigen Datentyp x in den Datentyp Variant um.
Format(n, "xxx") Wandelt n in eine Zeichenkette unter Berücksichtigung des Formats xxx um.
Str(n) Wandelt n in eine Zeichenkette um.
Val(s) Liefert den Wert der numerischen Zeichenkette s.
Tabelle 3.12: Funktionen zur Umwandlung von Datentypen
Im konkreten Fall des Zahlenlochbeispiels wird eine Umwandlungs-

funktion von String nach Integer benötigt, also die Funktion CInt. Es
ist in diesem Fall nicht relevant, welche der drei Umwandlungsfunk-
tionen eingesetzt wird, da der Eingabewert immer ein Zeichen, also
vom Typ String ist. Könnte der Eingabewert auch vom Typ Date sein,
müßte die Funktion CStr gewählt werden, da allein die Funktionen
Str und Format numerische Variablen in Zeichenketten umwandeln
können.
Um nun die gesamte Zahl Ziffer für Ziffer zu analysieren, muß jede
Stelle mit einer Schleife geprüft werden. Hier bietet sich nun eine For-
Schleife an, da die Anzahl der Schleifendurchläufe bekannt ist. Die
Menge der Durchläufe muß mit der Menge der Ziffern, die die Zahl
hat, identisch sein. Im Programm ist die Zahl aber als Zeichenkette
bekannt, wobei die Anzahl der Zeichen mit der Anzahl der Ziffern der
Ausgangszahl identisch ist.
77
Um nun die Anzahl der Zeichen einer Zeichenkette zu ermitteln,
kann die Funktion Len(s) eingesetzt werden, die die Anzahl der Zei-
chen der Zeichenkette s zurückliefert.
Der folgende Programmcode ermittelt die Anzahl der geraden und

ungeraden Zahlen:
Ungerade = 0 'Setze die Variablen zum Zählen der

'geraden
Gerade = 0 'und ungeraden Zahlen auf 0
for i = 1 to Len(Ergebnis) 'Solange das Ende der

'Zeichenkette nicht erreicht
'ist,
if CInt(Mid(Ergebnis, i, 1)) Mod 2 = 0 Then
'prüfe, ob es sich bei der
'Ziffer um eine
Gerade = Gerade + 1 'gerade Zahl
Else 'oder
Ungerade = Ungerade + 1 'um eine ungerade Zahl
'handelt
End If
next i 'Prüfe die nächste Ziffer
Die in diesem Programmcode enthaltene Funktion Mid$(s, i, l) dient

dazu, einen Teil der Zeichenkette s zurückzuliefern. Dabei handelt es
sich um den Teil, der sich in der Zeichenkette s ab Position i befindet
und die Länge l hat.
Befehl Ergebnis
Mid$("Dies ist eine Zeichenkette", 2, 9) ies ist e
Mid$("Dies ist eine Zeichenkette", 23, 8) ette
Mid$("Dies ist eine Zeichenkette", 3, 0)
Tabelle 3.13: Beispiel für die Funktion „Mid$“
Die Funktion Mod der folgenden Befehlszeile
if CInt(Mid$(Ergebnis, i, 1)) Mod 2 = 0 Then
entspricht der Funktion Modulo. Die Funktion Modulo liefert immer

den Restwert einer Division zurück. Hierzu ein Beispiel:
7
--- = 3 Rest 1 7 Modulo 2 = 1
2
8
--- = 4 Rest 0 8 Modulo 2 = 0
2
78
Ermitteln des Ergebnisses und Berechnen der neuen Zahl
An dieser Stelle des Programms sind alle drei Werte, die zur Berech- Berechnen der neuen
nung der neuen Zahl benötigt werden, bekannt: die Anzahl der unge- Zahl anhand der
raden und geraden Zahlen sowie – mit Hilfe der Funktion Len – die analysierten Ziffern
Anzahl der Ziffern der Ausgangszahl. Diese Daten bilden nun die der Ausgangszahl
neue Zahl. Die einzelnen Zahlen müssen jedoch nicht nach einem
bestimmten Algorithmus addiert, sondern wie einzelne Zeichenket-
ten aneinandergereiht werden.
Die folgende Programmzeile führt diese Aneinanderreihung aus:
Ergebnis = CLng(CStr(Gerade) & CStr(Ungerade) & CStr(Len(Ergebnis)))
Abbildung 3.14: Verknüpfung der ermittelten Ergebnisse
Ausgabe des Ergebnisses
Zu guter Letzt muß das Ergebnis auch noch auf dem Bildschirm des
Benutzers ausgegeben werden. Wenn bei jedem Schleifendurchlauf
die ermittelte Zahl in die ListBox geschrieben wird, sind alle Berech-
nungen über die Zwischenschritte nachvollziehbar. Die folgende Pro-
grammzeile schreibt das neu berechnete Ergebnis immer in die erste
Zeile der ListBox Ergebnis:
Wertigkeit.Additem CStr(Ergebnis), 0
Die gesamte Funktion zur Berechnung des Zahlenloches 123
Nun sind alle Befehlszeilen des Pseudocodes in Visual Basic-Pro-

grammcode umgewandelt worden. Im folgenden ist nun die gesamte
Funktion, die zum Button OK gehört, abgebildet.
79
Private Sub Ok_Click()
Dim Ergebnis As String
Dim Gerade As Integer
Dim Ungerade As Integer
Dim i As Integer
If IsNumeric(Zahl.Text) then 'Wenn die Zahl
' vom Typ Long ist
Ergebnis = Zahl.Text
Else
Exit Sub
End If
While Val(Ergebnis) <> 123

Ungerade = 0 'Setze die Variablen zum
' Zählen der geraden
Gerade = 0 'und ungeraden Zahlen auf 0
for i = 1 to Len(Ergebnis) 'Solange das Ende

'der Zeichenkette nicht
'erreicht ist,
if CInt(Mid(Ergebnis, i, 1)) Mod 2 = 0 Then
'prüfe, ob es sich bei der
'Ziffer um eine
Gerade = Gerade + 1 'gerade Zahl
Else 'oder
Ungerade = Ungerade + 1 'um eine
'ungerade Zahl handelt
End If
next i 'Prüfe die nächste Ziffer
Ergebnis = CLng(CStr(Gerade) & _

CStr(Ungerade) & _
CStr(Len(Ergebnis)))
Wertigkeit.Additem CStr(Ergebnis), 0
Wend
End Sub
Wenn das Programm gestartet wird, kann die Oberfläche wie in Ab-
bildung 3.15 dargestellt aussehen.
80
Abbildung 3.15: Mögliche Oberfläche des Programms „Zahlenloch 123“
Um das Programm zu testen, ist es sinnvoll, Werte zu wählen, bei de-

nen das Ergebnis und die Zwischenschritte bekannt sind. In diesem
Fall bieten sich die Zahlen aus der Abbildung 3.15 an, da für diese
Zahlen schon alle Zwischenschritte berechnet wurden. In der ListBox
müssen alle Zahlen in der gleichen Reihenfolge wie in der Beispielta-
belle auftreten.
3.3.5 Größere Benutzerfreundlichkeit

Bei vielen Programmen erhält man in Form einer sog. Statusleiste für Erhöhen der Benutzer-
die meisten Steuerelemente auf der Programmoberfläche eine freundlichkeit durch
schnelle Hilfe. In Visual Basic ist diese schnelle Hilfe recht einfach zu Einsatz einer
realisieren. Statuszeile
Als Statusleiste wird ein Steuerelement benötigt, das der Ausgabe

dient, in dem aber keine Eingabe gemacht werden darf. Darüber hin-
aus ist es nicht möglich, mehrere Datensätze darzustellen. In der Ta-
belle 4.11 wurden verschiedene Ausgabesteuerelemente verglichen.
Aus diesem Grund wird für die Statusleiste das Steuerelement Label
verwendet.
Wie alle anderen Steuerelemente wird die Statusleiste durch Aktivie-

ren des Symbols im Werkzeugfenster und durch Festlegen der Posi-
tion und Größe infolge von Anklicken und Ziehen des Steuerele-
ments mit Hilfe der Maus erzeugt. Die Statusleiste läßt sich optisch
hervorheben, indem bei der Eigenschaft BorderStyle die Option 1-
FestEinfach (Abbildung 3.15) eingestellt wird.
Mit der Statusleiste wird erreicht, daß zu jedem Steuerelement eine

Hilfetext ausgegeben werden kann, wenn der Mauszeiger über das je-
weilige Steuerelement bewegt wird.
81
Fast jedes Steuerelement besitzt die Eigenschaft Tag, die keinen Ein-
fluß auf das Steuerelement selbst hat. In dieser Eigenschaft kann zu
jedem Steuerelement ein kurzer Beschreibungstext eingegeben wer-
den.
Steuerelement Beschreibungstext
Button OK Hiermit wird das Programm gestartet.
Button ABBRECHEN Hiermit wird die Berechnung beendet.
ListBox Hier sind alle Zwischenschritte der Berechnung enthalten.
TextBox Bitte geben Sie hier die zu berechnende Zahl ein.
Form
Tabelle 3.14: Beschreibungstexte der Steuerelemente4
Der Eigenschaft Tag des Formularfensters Form ist eine sog. leere Zei-
chenkette zugewiesen worden, da in der Statuszeile auch kein Hilfe-
text ausgegeben werden soll, wenn der Mauszeiger auf keines der
Steuerelemente zeigt. Um den Inhalt der Eigenschaft Tag eines jeden
Steuerelements der Eigenschaft Caption der Statusleiste zuzuweisen,
wird die Funktion MouseMove benötigt. MouseMove wird dann ausge-
führt, wenn das jeweilige Steuerelement mit der Maus angesteuert
wird. Für jedes Steuerelement, das in der Statusleiste einen Hilfetext
enthalten soll, muß die Funktion MouseMove wie folgt angepaßt wer-
den:
Form
Private Sub Form_MouseMove(Button As Integer, Shift As Integer, X As Sin-
gle, Y As Single)
Status.Caption = Form.Tag
End Sub
Der Button OK
Private Sub Ok_MouseMove(Button As Integer, Shift As Integer, X As Single,
Y As Single)
Status.Caption = Ok.Tag
End Sub
4. In der Eigenschaft Tag der Form ist eine Zeichenkette mit der Länge 0
eingetragen
82
Der Button ABBRECHEN
Private Sub Abbruch_MouseMove(Button As Integer, Shift As Integer, X As
Single, Y As Single)
Status.Caption = Abbruch.Tag
End Sub
Die ListBox zur Ausgabe der Zwischenschritte

Private Sub Wertigkeit_MouseMove(Button As Integer, Shift As Integer, X As
Single, Y As Single)
Status.Caption = Wertigkeit.Tag
End Sub
Die TextBox zur Eingabe der Ausgangszahl

Private Sub Zahl_MouseMove(Button As Integer, Shift As Integer, X As Sin-
gle, Y As Single)
Status.Caption = Zahl.Tag
End Sub
83
4 Standardsteuerelemente
In diesem Kapitel wird ein kurzer Überblick über einen Teil der Steu- Elemente für die
erelemente gegeben, die von Visual Basic standardmäßig mitgeliefert Programmsteuerung,
werden. Mit kleinen Beispielprogrammen zu jedem Steuerelement Dateieingabe und
werden dessen jeweiligen Aufgaben erklärt. Dabei wird auch auf die -ausgabe sowie die
wichtigsten Funktionen und Eigenschaften der Steuerelemente ein- Gestaltung der
gegangen. Formulare
Das entstandene Programm aus den Beispielen der Objekte Form, But-
ton und Label soll in einem eigenen Verzeichnis unter dem Namen
VORGABE gespeichert werden. Es wird als Grundlage für alle anderen
Beispiele gelten, um den Programmieraufwand so gering wie möglich
zu halten.
4.1 Das Formular Form

Das Fenster eines
Programmes
Abbildung 4.1: Das Formular im Designmodus
Auf Formularen (siehe Abbildung 4.1) werden die Steuerelemente,

die zur Programmsteuerung und Darstellung der Informationen ge-
braucht werden, aufgebracht. Sie sind die Fenster des Programms. Je-
des Visual Basic-Programm benötigt mindestens ein Formular: das

85
Startformular. Ein Programm kann aber auch aus mehreren Formula-
ren bestehen. Um für ein Formular den Programmcode zu entwik-
keln, muß der Editor (siehe Abbildung 4.1) geöffnet werden. Mit ei-
nem Doppelklick der linken Maustaste auf das Formular oder auf ein
Steuerelement, das sich auf dem Formular befindet, wird das Fenster
zur Eingabe des Programmcodes geöffnet. In der ListBox Object läßt
sich das Objekt, zu dem der Programmcode gehören soll, auswählen.
Nach dem Programmstart ist das einzige Objekt jedoch nur das For-
mular Form.
Unter General werden alle Funktionen, Prozeduren, Konstanten und

Variablen abgelegt, auf die alle Steuerelemente des Formulars zugrei-
fen sollen. Hier wird auch definiert, ob alle Variablen, die in dem For-
mular verwendet werden, vor der ersten Anwendung auch deklariert
sein müssen. Um diese Einstellung zu aktivieren, muß die folgende
Zeile
Option Explicit
in den Abschnitt Object = General und Proc = declarations eingegeben

werden. Nun müssen alle Variablen, die in diesem Formular verwen-
det werden, auch deklariert werden.
Eigenschaft mögliche Wert Beschreibung

(Name) String Der Name identifiziert das Fenster im Programmcode.
Appearance 0 - Flat Mit dieser Eigenschaft wird angegeben, ob das Fenster im
1 - 3D neuen 3D-Design von Windows 95 oder in der alten Dar-
stellung gezeigt wird.
AutoRedraw True/False Diese Eigenschaft gibt an, ob das Fenster nach jedem Akti-
vieren neu gezeichnet werden soll.
BackColor 0 - 16777,215 Mit dieser Eigenschaft wird die Hintergrundfarbe des Fen-
(&HFFFFFF) sters eingestellt (Abschnitt ).
Caption String In Caption wird die Beschriftung des Fensters eingetragen,
(Max 255. Zeichen) die während des Programmlaufs sichtbar ist.
MDIChild True/False Diese Eigenschaft gibt an, ob es sich bei dem aktuellen Fen-
ster um ein Fenster im Fenster handelt.
Tag String Steht zur freien Verfügung, d. h. es hat keinen direkten Ein-
fluß auf das Steuerelement, sondern kann z.B. als Zwischen-
speicher für das Steuerelement dienen.
ToolTipText String Der Inhalt dieser Eigenschaft wird in einer Sprechblase als
Erklärung zu einem Steuerelement ausgegeben, wenn sich
die Maus über dem Steuerelement befindet.
Tabelle 4.1: Die wichtigsten Eigenschaften des Fensters
Eine der wichtigsten Ereignisprozeduren des Formulars ist die Funk-

tion Load. Deren wichtigste Eigenschaften sind Caption und Name.
86

In der Eigenschaft Name wird der Name des Formulars angegeben,
unter dem es den anderen Objekten in diesem Programm bekannt
sein soll. Bei der Namensvergabe sollte darauf geachtet werden, daß
die Objektart in den Namen aufgenommen wird, beispielsweise in-
dem die ersten drei Buchstaben das Objekt beschreiben. Bei einem
Formular bietet sich die Abkürzung frm an. Der festgelegte Name fin-
det sich auch rechts im Projektfenster wieder. Der Name, der vom Sy-
stem beim Erstellen eines neuen Programms vorgegeben wird, ist
Form1.
Die Eigenschaft Caption enthält den Titel oder die Beschreibung des
Fensters. Der hier angegebene Text wird in der blauen Titelleiste des
Fensters angezeigt. Der standardmäßige Parameter für die Eigen-
schaft Caption ist Form1.
4.1.1 Aufgabe
Das folgende Programmbeispiel soll beim Starten des Programms den Eine Aufgabe zum
Titel „Beispiel” in die Kopfzeile des Fensters schreiben. Formular
4.1.2 Lösung
Als erstes wird der Name des Formulars festgelegt; wir wählen hierzu Die Lösung zur
frm_Beispiel. Der Eigenschaft Caption braucht kein Parameter zuge- Formularaufgabe
wiesen zu werden, da in diesem Fall mit einer Konstanten gearbeitet
werden soll. Weitere formularglobale Konstanten und Variablen wer-
den nicht gebraucht. Also ergeben sich für den Abschnitt
Object = General und Proc = declarations
folgende Programmzeilen:
Option Explicit
Const Titel = "Beispiel"
Um das Programm beim Starten etwas ausführen zu lassen, besitzt

das Formular die Funktion Form_Load(). Diese Funktion wird bei je-
dem Programmstart ausgeführt, daher muß hier der Programmcode
geschrieben werden, um den Titel des Fensters zu beschriften.

frm_Beispiel.Caption = Titel
End Sub
Wenn das Programm jetzt gestartet wird, erscheint in der Titelzeile des
Fensters der Titel „Beispiel”. Das Programm kann mit der Tastenkom-
bination (Alt)+(F4) oder über das Menü RUN | END beendet werden.

87
4.2 Das Textelement Label
Abbildung 4.2: Das Textelement „Label”
Das Textelement Label dient für die Beschriftung anderer Steuerele-

mente oder zur Ausgabe von Texten. Es kann nicht zur Texteingabe
genutzt werden. Ein weiterer wichtiger Anwendungsbereich für Label
ist die Verwendung der Statusleiste. In vielen Programmen ist es Stan-
dard, daß zu jedem Steuerelement ein Hilfetext in der Statuszeile aus-
gegeben wird. Um ein Steuerelement als Label zu markieren, bieten
sich hier die drei Anfangsbuchstaben lab als Kennzeichnung des Na-
mens an.
4.2.1 Aufgabe
Eine Aufgabe zum Zur Ausgabe eines Hilfetextes soll eine Statuszeile auf das aktuelle For-
Textelement mular aufgebracht werden. Der Text, der in der Statuszeile dargestellt
wird, soll zentriert sein, und das Label soll optisch den Eindruck er-
wecken, als sei es in das Formular eingelassen.
4.2.2 Lösung
Die Lösung zur Zunächst muß ein Label auf das geöffnete Formular als Fußzeile auf
Textelementaufgabe das Fenster aufgebracht werden. Um die gestellte Aufgabe zu lösen,
ist kein Programmieraufwand nötig, sondern es müssen die richtigen
Eigenschaften eingestellt werden.
Vergessen Sie nicht die Kennzeichnung als Label im Objektnamen.
Deshalb erhält das Steuerelement den Namen lab_Status. Damit nach
dem Programmstart kein Text in der Statuszeile steht, muß die Eigen-
schaft Caption des Labels leer sein. Für die Ausrichtung des Textes in
einem Label ist die Eigenschaft Alignment zuständig. Um den Text
zentriert auszugeben, muß hier der Wert 2 – Center eingestellt wer-
den. Dieser kann entweder über die Eingabe einer 2 oder das Auswäh-
len dieser Option über die angebotene ListBox erfolgen. Als letzte Ei-
genschaft wird nun der 3D-Effekt eingeschaltet, damit die Statuszeile
optisch versenkt auf dem Bildschirm erscheint. Dazu muß die Eigen-
schaft Border Style den Wert 1 – Fixed Single bekommen.
88

Um nach dem Programmstart mit Sicherheit auszuschließen, daß
Text in der Eigenschaft Caption enthalten ist, kann die Funktion Load
des Formulars wie folgt angepaßt werden.

lab_Status.Caption = ""
End Sub
Nun ist sichergestellt, daß es keinen Eintrag in der Statuszeile gibt,

wenn das Programm gestartet wird. Selbst in der Eigenschaft Caption
könnte ein Wert eingetragen sein.
4.3 Die Schaltfläche Button
Abbildung 4.3: Die Schaltfläche „Button“
Ein Button wird z.B. für das Bestätigen von Eingaben oder für das
Starten von Prozessen eingesetzt. Die bekanntesten Schaltflächen
sind die Buttons OK und ABBRECHEN. Auch im vorliegenden Beispiel
wird dieses Steuerelement für beide Buttons verwendet. Die wichtig-
ste Funktion der Schaltfläche ist die Ereignisprozedur Click. Diese Er-
eignis reagiert auf das Aktivieren der Schaltfläche. Bei den Eigen-
schaften ist außer Name und Caption die Eigenschaft Tag von großer
Bedeutung. Sie hat zwar keinen Einfluß auf das Aussehen oder die
Darstellung des Steuerelements, man kann dort aber die Beschrei-
bung des Steuerelements ablegen. Für die Kennzeichnung des But-
tons als Steuerelement im Namen wird im weiteren Verlauf btn ver-
wendet.
4.3.1 Aufgabe
Es sollen zwei Schaltflächen auf das Formular aufgebracht werden. Eine Aufgabe zur
Die eine Schaltfläche ABBRUCH dient zum Beenden des Programms, Schaltfläche
die andere Schaltfläche OK dient zum Starten einer Aufgabe. In die-
sem Fall soll die Aufgabe darin bestehen, zu zählen, wie oft die Schalt-
fläche OK betätigt wurde, und den ermittelten Wert in der Titelleiste
des Fensters auszugeben. Außerdem soll in der Statuszeile eine Be-
schreibung zu der Aufgabe der jeweiligen Schaltfläche ausgegeben
werden.

89
4.3.2 Lösung
Die Lösung zur Zuerst werden die beiden Schaltflächen auf die Form gebracht. Die er-
Aufgabe Schaltfläche ste Schaltfläche erhält bei der Eigenschaft Namen den Wert btn_Ok
und bei der Eigenschaft Caption den Wert Ok. Die andere Schaltfläche
erhält den Namen btn_Abbrechen und die Beschriftung ABBRECHEN.
Die wichtigste Funktion aller Programme, die leider viel zu oft verges-
sen wird, ist das Beenden eines Programms. Aus diesem Grund wird
hier mit diesem Teil begonnen. Um ein Programm zu beenden, gibt
es den Befehl End. Er beendet das Programm von jeder Prozedur aus,
von der er aufgerufen wird. Da die Schaltfläche durch Betätigen der
Maustaste das Programm beenden soll, erhält die Funktion Click der
Schaltfläche btn_Abbrechen den Befehl End.
Private Sub btn_Abbrechen_Click()

End
End Sub
Die Aufgabe des Buttons btn_Ok besteht darin, zu zählen, wie oft der
Button gedrückt wurde, und anschließend die ermittelte Anzahl in
der Titelleiste des Fensters auszugeben. Diese Aufgabe wird ebenfalls
über die Funktion Click gelöst, jedoch dieses Mal über das Click-Ereig-
nis des Schaltelements mit Namen btn_Ok.
Private Sub btn_Ok_Click()

Anzahl = Anzahl + 1 'Registriert einen neuen
'Tastendruck
'Aktualisiert den Inhalt der Fenstertitelleiste
Fenster.Caption = Titel & " Anzahl = " & Anzahl
End Sub
Die Variable Anzahl, die zum Zählen der OK-Tastenanschläge ge-

braucht wird, ist eine globale Variable. Ihr Wert muß auch nach Ver-
lassen der Funktion Click dem Programm bekannt sein, um beim
nächsten Betätigen den alten Wert um eins erhöhen zu können. Die
folgende Programmzeile muß im globalen Funktionsteil des Formu-
lars eingetragen werden.
Dim Anzahl As Integer 'Zählt die Anzahl der

'Tastendrücke OK
Initialisiert wird die Variable beim Programmstart mit dem Standard-

wert 0. Visual Basic initialisiert zwar selbständig alle numerischen Va-
riablen mit 0; jedoch ist es für die Übersichtlichkeit des Programmco-
des besser, diese Zuweisung nochmals in der Ereignisprozedur Load
des Formulars auszuführen.
90

lab_Status.Caption = ""
Anzahl = 0
End Sub
Wenn das Programm nun gestartet und mit der Maus auf die Schalt-
fläche Ok gedrückt wird, so erscheint die geforderte Ausgabe in der Ti-
telleiste des Fensters. Mit Betätigung der Schaltfläche Abbrechen wird
das Programm sinngemäß beendet. Jetzt fehlt noch die Ausgabe des
Hilfetextes zu der jeweiligen Schaltfläche in der Statuszeile. Die mei-
sten Steuerelemente bieten hierfür die Funktion MouseMove an. Die
Funktion MouseMove wird aktiviert, wenn die Maus über das jeweilige
Steuerelement bewegt wird. Für den Hilfetext, der in der Statuszeile
ausgegeben werden soll, kann man die Eigenschaft Tag, die ebenfalls
von den meisten Steuerelementen unterstützt wird, nutzen. Die
Schaltfläche btn_Ok erhält in der Eigenschaft Tag den Wert „Hiermit
werden die Eingaben bestätigt.”, und die Schaltfläche btn_Abbrechen
erhält den Wert „Hiermit wird das Programm beendet.”.
Private Sub btn_Ok_MouseMove(Button As Integer, _

Shift As Integer, X As Single, Y As Single)
lab_Status.Caption = btn_Ok.Tag
End Sub
Private Sub btn_Abbrechen_MouseMove(Button As Integer,

lab_Status.Caption = btn_Abbrechen.Tag
End Sub
Mit diesen Funktionen werden nun die Hilfetexte der Schaltelemente

in der Statuszeile ausgegeben, wenn die Maus über das jeweilige Steu-
erelement bewegt wird. Wenn aber einmal ein Text in der Statuszeile
ausgegeben wurde, wird dieser nur noch geändert, wenn die Maus
über ein anderes Steuerelement bewegt wird, welches ebenfalls die
Funktion MouseMove verwendet. In diesem konkreten Fall heißt das:
wird die Maus über den Button OK bewegt, ändert sich der Text in der
Statuszeile erst, wenn die Maus über den Button ABBRECHEN bewegt
wird. Um nun den Inhalt der Statuszeile jedesmal zu löschen, wenn
das Steuerelement wieder verlassen wird, muß die Statuszeile mit ei-
ner Funktion gelöscht werden. Dazu eignet sich die Funktion Mouse-
Move des Formulars, da sich die Maus entweder auf einem Steuerele-
ment befindet, d. h. Statustext anzeigt, oder auf dem Formular, d. h.
keinen Statustext anzeigt.

91
Private Sub Form_MouseMove(Button As Integer, _
lab_Status.Caption = frm_Beispiel.Tag
End Sub
Bewegt man die Maus über ein Steuerelement, wird in der Statuszeile
der Text ausgegeben, der in der Eigenschaft Tag enthalten ist. Da hier
der Inhalt fehlt, fehlt auch der Text in der Statuszeile.
Um eine vergleichbare Oberfläche zu haben, sollte sie wie in Abbil-

dung 4.4 aussehen.
Abbildung 4.4: Das Standardformular für die weiteren Beispiele
4.4 Das Texteingabeelement TextBox
Abbildung 4.5: Das Texteingabeelement „TextBox”
Das Texteingabeelement TextBox dient dem Benutzer zur Eingabe von

Daten, also zur Kommunikation mit dem Programm über die Tasta-
tur. Für die Identifizierung des Steuerelements im Programmcode
wird im folgenden die Kennung txt verwendet.
4.4.1 Aufgabe
Eine Aufgabe Es soll ein Programm entwickelt werden, mit dem Längenmaße um-
zum Textelement gerechnet werden können. Dafür werden zwei Texteingabeelemente
benötigt. Das erste Element txt_Wert dient zum Erfassen des Ur-
sprungsmaßes, beispielsweise Kilometer. In das zweite Element
txt_Faktor wird der Umrechnungsfaktor eingegeben. Bei der Umrech-
92

nung z.B. von Kilometer in Seemeilen beträgt dieser Faktor 1,852. Das
Ergebnis wird beim Drücken des Buttons OK berechnet und in ein La-
bel lab_Ergebnis geschrieben. Wird ein Eingabewert verändert, soll der
Inhalt des Labels lab_Ergebnis gelöscht werden.
4.4.2 Lösung
Option Explicit Die Lösung zur Auf-
gabe Textelement
If txt_Wert.Text<>"" And txt_Faktor.Text<>"" Then
lab_Ergebnis.Caption = CDbl(txt_Wert.Text) * _
CDbl(txt_Faktor.Text)
End If
End Sub
Private Sub txt_Faktor_Change()

lab_Ergebnis.Caption = ""
End Sub
Private Sub txt_Wert_Change()

End Sub
4.5 Das Bildfeldsteuerelement PictureBox
Abbildung 4.6: Das Bildfeldsteuerelement „PictureBox”
Um auf einem Formular Grafiken anzuzeigen, stellt Ihnen Visual Ba-

sic das Steuerelement PictureBox zur Verfügung. In diesem Grafikfen-
ster können Grafiken folgender Typen dargestellt werden:
Bitmap (*.bmp; *.dib)

Windows-Metafile (*.wmf)
Icon (*.ico; *.cur)
Es können aber nicht nur Bilder eingebunden, sondern auch eigene

Zeichnungen erstellt werden. Das folgende Programm zeichnet ein
paar Linien in verschiedenen Farben in die PictureBox. Für die Identi-
fizierung des Steuerelements wird die Kennung pic für Picture ver-

93
wendet. Daraus ergibt sich der Name pic_Bild für das folgende Bei-
spiel.
Sub Linien_Zeichen()
Const Anzahl_Linien = 15 'Anzahl der zu zeichnenden
'Linien
Dim i As Integer
Dim Breite As Integer 'Breite der PictureBox
Dim Hoehe As Integer 'Höhe der PictureBox
Dim delta_x As Double 'Größe der horizontalen
'Schrittweite
Dim delta_y As Double 'Größe der vertikalen
'Schrittweite
If Anzahl Mod 2 = 0 Then 'Wenn die PictureBox
'gelöscht werden soll
pic_Bild.Cls 'Lösche den Inhalt der
'PictureBox
Exit Sub 'Beende die Prozedur
End If
Breite = pic_Bild.ScaleWidth 'Ermittle die Breite
'der PictureBox
Hoehe = pic_Bild.ScaleHeight 'Ermittle die Höhe
'der PictureBox
delta_y = Hoehe / Anzahl_Linien 'Berechne die
'vertikale Schrittweite
For i = 0 To Anzahl_Linien 'Zeichne Anzahl_Linien
pic_Bild.ForeColor = QBColor(i Mod 15) 'Setze
' die Zeichenfarbe
'Zeichne eine Linie
pic_Bild.Line (0, i * delta_y)- _
(Breite, Hoehe - (i * (delta_y / 3)))
Next i 'Zeichne die nächste Linie
End Sub
Um die Funktion aus der Funktion btn_Ok_Click() aufzurufen, gibt es

die beiden folgenden Möglichkeiten:
1. Linien_Zeichen
2. Call Linien_Zeichen
Für die Übersichtlichkeit des Programmcodes empfiehlt es sich, den

zweiten Funktionsaufruf zu verwenden, da er den Programmcode
übersichtlicher gestaltet.
Damit die Grafik nicht verlorengeht, wenn ein anderes Fenster über
das Grafikprogramm gelegt wird, muß die Eigenschaft AutoRedraw den
Wahrheitswert TRUE erhalten.
94

Ist die Grafik größer als das Steuerelement, werden die Seiten abge-
schnitten. Um die Größe eines Bildfeldsteuerelements an die Grafik
anzupassen, muß der Eigenschaft AutoSize der Wert True zugewiesen
werden.
4.6 Das Anzeigesteuerelement Image
Abbildung 4.7: Das Anzeigesteuerelement „Image”
Das Anzeigesteuerelement Image dient – wie zuvor bereits das Bild-

feldsteuerelement – der Anzeige von Grafiken folgender Formate:
Bitmap (*.bmp; *.dib)

Windows-Metafile (*.wmf)
Icon (*.ico; *.cur)
In Abbildung 4.7 ist dem Anzeigesteuerelement schon eine Grafikda-

tei zugeordnet. Es handelt sich um die Datei BANNER.GIF. Diese Datei
befindet sich unter dem Visual Basic-Stammverzeichnis im Ordner
SAMPLES\PGUIDE\PALMODE.
Das Anzeigesteuerelement hat den Vorteil, daß es weniger Systemres-

sourcen benötigt und schneller dargestellt werden kann als das Bild-
feldsteuerelement. Es unterstützt jedoch nicht den gleichen Umfang
an Ereignissen, Eigenschaften und Methoden wie das Bildfeldsteuer-
element. Um die Größe einer Grafik an das Steuerelement anzupassen,
gibt es die Eigenschaft Stretch. Mit dieser Eigenschaft wird definiert,
ob das Steuerelement an die Größe der Grafik angepaßt oder die Gra-
fik an die Größe des Steuerelements angepaßt wird.
4.7 Das Rahmensteuerelement Frame
Abbildung 4.8: Das Rahmensteuerelement „Frame”

95
In das Rahmensteuerelement werden keine Daten eingegeben. Es
dient dazu, andere Steuerelemente zusammenzufassen und diese als
eine Einheit auf dem aktuellen Fenster zu behandeln. Es wird verwen-
det, um z.B. Steuerelemente mit der Eigenschaft Enabled = False zu
sperren oder um die Zusammengehörigkeit einzelner Steuerelemente
zu verdeutlichen.
4.8 Das Kontrollkästchen CheckBox
Abbildung 4.9: Das Kontrollkästchen-Steuerelement „CheckBox”
Mit dem Kontrollkästchen-Steuerelement lassen sich zum Beispiel

Berechtigungen erteilen oder Optionen ein- und ausschalten. Um die
Übersichtlichkeit von Programmen zu erhöhen, können mehrere
Steuerelemente zu einzelnen Gruppen zusammengefaßt werden.
Wenn ein Kontrollkästchen vom Anwender angeklickt wird, ändert
sich der Zustand. Eine CheckBox kann entweder im Zustand „Wahr”
oder „Falsch ” sein. Ist die Eigenschaft Value „Wahr”, befindet sich in
dem Kästchen des Steuerelements ein Kreuz. Ist die Eigenschaft Value
„Falsch”, so ist das Kästchen leer. Diesen Schalter kann man sich wie
einen Schalter bei einem Kassettenrecorder vorstellen: Der Kassetten-
recorder ist entweder eingeschaltet oder nicht eingeschaltet. Die
Kontrollkästchen einer Gruppe haben keinen direkten Einfluß auf-
einander. Für die Identifizierung des Steuerelements CheckBox im
Programmcode wird die Kennung cbx im weiteren Verlauf verwendet.
Eigenschaft mögliche Werte Beschreibung

(Name) String Über den Namen wird das Steuerelement im Programmcode
angesprochen.
Caption String Diese Eigenschaft beinhaltet den Beschreibungstext rechts neben
der CheckBox.
Tag String Diese Eigenschaft steht zur freien Verfügung, d. h. sie hat keinen
direkten Einfluß auf das Steuerelement, sondern kann z.B. als
Zwischenspeicher für das Steuerelement dienen.
ToolTipText String Der Inhalt dieser Eigenschaft wird in einer Sprechblase als Erklä-
rung zu einem Steuerelement ausgegeben, wenn die Maus eine
bestimmte Zeit über dem Steuerelement stehenbleibt.
Value 0 nicht aktiviert Mit dieser Eigenschaft wird festgelegt oder geprüft, ob das Kon-
1 aktiviert trollkästchen aktiviert oder deaktiviert ist.
Tabelle 4.2: Die wichtigsten Eigenschaften des Kontrollkästchens
96

4.8.1 Aufgabe
Es soll ein Programm erstellt werden, in dem per Schalter die Sicht- Eine Aufgabe zum
barkeit eines Textfensters eingestellt wird. Der zweite Button gibt sei- Kontrollkästchen-
nen aktuellen Zustand in diesem Textfenster aus, d.h. das Kontroll- steuerelement
kästchen-Steuerelement schreibt den Wert „Wahr” in das Textfeld,
wenn es aktiviert ist; ist es nicht aktiviert, erscheint der Wert „Falsch”.
4.8.2 Lösung
Um ein Steuerelement unsichtbar zu machen, muß man auf die Lösung zur Aufgabe
Eigenschaft Visible (sichtbar) zurückgreifen. Enthält die Eigenschaft Kontrollkästchen-
Visible den Wert „Falsch”, ist das Steuerelement während der steuerelement
Programmausführung nicht sichtbar.

cbx_Sichtbar.Value = 1 'Textelement ist sichtbar
cbx_wahr.Value = 1 'In das Textelement "Wahr"
'schreiben
End Sub
Private Sub cbx_Sichtbar_Click()

If cbx_Sichtbar.Value = 1 Then 'Wenn das Kontroll-
'kästchen aktiv ist
lab_Ausgabe.Visible = True 'zeige die TextBox,
Else 'sonst
lab_Ausgabe.Visible = False 'verstecke sie
End If
End Sub
Private Sub cbx_wahr_Click()

If cbx_wahr.Value = 1 Then 'Wenn das Kontroll-
'kästchen aktiv ist,
lab_Ausgabe.Caption = "Wahr" 'schreibe "Wahr" in
'das Textelement,
Else
lab_Ausgabe.Caption = "Falsch" 'sonst schreibe
'"Falsch"
End If
End Sub

97
4.9 Das Optionsfeld OptionButton
Abbildung 4.10: Das Optionsfeld „OptionButton”
Das Optionsfeld ist wie die CheckBox ein Schalter, der nur die Eigen-
schaften Wahr oder Falsch annehmen kann. Jedoch sind alle Options-
feldsteuerelemente einer Gruppe, z.B. gruppiert durch ein Frame,
voneinander abhängig. Immer nur ein Optionsschalter kann den
Wert Wahr haben. Selektiert der Anwender einen Schalter, der den
Zustand Falsch hat, wird der Schalter mit dem Zustand Wahr auf
Falsch gesetzt, und dem selektierten Schalter wird der Zustand Wahr
zugewiesen. Ein Schalter, der den Zustand Wahr hat, kann nicht
durch nochmaliges Anklicken wieder auf Falsch gesetzt werden. Man
kann sich diese Art von Schaltung wie bei einem Radio vorstellen: Es
kann immer nur ein Programmschalter auf einmal ausgewählt sein,
wobei auch immer einer der möglichen Programmschalter ausge-
wählt ist. In Visual Basic können damit auch verschiedene Berechti-
gungsstufen erteilt werden, so z.B.:
1. Der Anwender darf ein bestimmtes Textfeld nicht sehen.

2. Der Anwender darf ein bestimmtes Textfeld sehen, aber nicht ver-
ändern.
3. Der Anwender darf ein Textfeld sehen und ändern.
Um mehrere Optionsschalter zusammenzufassen, sollte immer ein

Frame verwendet werden, um dem Benutzer zu signalisieren: „Diese
Optionsschalter sind voneinander abhängig.” Ebenfalls lassen sich
somit auch mehrere unabhängige Schalterleisten auf einem Fenster
realisieren. Für die Identifizierung des Steuerelements Optionsschalter
im Programmcode wird die Kennung obt empfohlen.

(Name) String Über den Namen wird das Steuerelement
im Programmcode angesprochen.
Caption String Diese Eigenschaft beinhaltet die Beschrei-
bung rechts neben dem Schalter (Aus-
gabe für den Anwender).
Tag String Diese Eigenschaft steht zur freien Verfü-
gung, d. h sie hat keinen direkten Einfluß
auf das Steuerelement, sondern kann z.B.
als Zwischenspeicher für das Steuerele-
ment dienen.
98

ToolTipText String Der Inhalt dieser Eigenschaft wird in einer
Sprechblase als Erklärung zu einem Steu-
erelement ausgegeben, wenn die Maus
eine bestimmte Zeit über dem Steuerele-
ment stehenbleibt.
Tabelle 4.3: Die wichtigsten Eigenschaften des Optionenschalters
4.9.1 Aufgabe
Es soll ein Programm erstellt werden, in dem über drei Optionen- Eine Aufgabe zum
schalter festgelegt wird, ob der Schalter OK unsichtbar, sichtbar oder Optionenschalter
verfügbar sein soll. Dazu werden drei Steuerelemente benötigt. We-
gen der besseren Übersichtlichkeit sollen sie in einem Frame zusam-
mengefaßt werden.
4.9.2 Lösung
Um ein Steuerelement für die Eingabe des Benutzers zu sperren, gibt Die Lösung zur Auf-
es die Eigenschaft Enabled (verfügbar). Ist der Wert der Eigenschaft gabe Optionenschalter
Enabled „Wahr”, kann das Steuerelement für eine Eingabe genutzt
werden, ist der Wert „Falsch”, so ist das Steuerelement zwar sichtbar,
jedoch kann keine Eingabe gemacht werden.

obt_Unsichtbar.Value = True
call obt_Unsichtbar_Click 'Der Ok-Button wird
'unsichtbar
End Sub
Private Sub obt_Sichtbar_Click()

btn_Ok.Enabled = False 'Ok-Button nicht verfügbar
btn_Ok.Visible = True 'Ok-Button sichtbar
End Sub
Private Sub obt_Unsichtbar_Click()

btn_Ok.Enabled = False 'Ok-Button nicht verfügbar
btn_Ok.Visible = False 'Ok-Button nicht sichtbar
End Sub
Private Sub obt_Verfügbar_Click()

btn_Ok.Enabled = True 'Ok-Button verfügbar
btn_Ok.Visible = True 'Ok-Button sichtbar
End Sub
!
! 99
4.10 Das Listenfeld ListBox
Abbildung 4.11: Das Listenfeldsteuerelement „ListBox”
In einer ListBox können, wie der Name schon sagt, Listen angezeigt
werden. Die einzelnen Zeilen der Liste können auch mehrspaltige
Datensätze enthalten, die durch ein bestimmtes Zeichen getrennt
werden. Die Listen können über Bildlaufleisten gescrollt, einzelne Li-
stenelemente dabei ausgewählt werden; direkte Eingabe von Daten
in das Listenfeld-Steuerelement ist jedoch nicht möglich. Diese Steu-
erelemente werden z.B. verwendet, um Dateien in einem Verzeichnis
anzuzeigen. Die Liste mit den Dateien kann gescrollt werden, und es
lassen sich auch Dateien auswählen. Um aber z.B. den Dateinamen
zu ändern, muß ein anderes Steuerelement verwendet werden. Für
die Verwaltung der Datensätze eines Listenfeld-Steuerelements ste-
hen einige Befehle zur Verfügung. Im folgenden werden die wichtig-
sten Befehle aufgeführt.

angesprochen.
ColCharacter Byte Diese Eigenschaft gibt an, welches Zeichen aus der ASCII-Tabelle
als Spaltentrennzeichen genommen werden soll.
ListCount Integer Diese Eigenschaft enthält die Anzahl der in die Liste eingetrage-
nen Zeilen; sie kann nur gelesen werden.
Listindex Integer Diese Eigenschaft enthält die Nummer der momentan selektier-
ten Zeile des Listenelements; sie kann gelesen und geändert wer-
den.
Text String Diese Eigenschaft enthält die Zeichenkette des markierten Daten-
satzes in dem Listenelement.
ToolTipText String Der Inhalt dieser Eigenschaft wird in einer Sprechblase als Erklä-
rung zu einem Steuerelement ausgegeben, wenn die Maus eine
bestimmte Zeit über dem Steuerelement stehenbleibt.
Tabelle 4.4: Die wichtigsten Eigenschaften des Listenfeldsteuerelements
100

4.10.1 Einen neuen Datensatz eintragen
Mit dem Befehl AddItem können neue Datensätze dem Listenfeld- Eintragen eines neuen
Steuerelement hinzugefügt werden. Datensatzes in ein
Listenfeldsteuerelement
[ListBoxname].AddItem Datensatz[, Position]
Bei dem Datensatz kann es sich um einen einfachen String oder um

eine Zahl handeln, die zu einem String konvertiert wird. Es kann sich
aber auch um einen komplexeren Datensatz handeln, dessen Spalten
mit einem Sonderzeichen getrennt sind.
4.10.2 Einen Datensatz löschen

Mit dem Befehl RemoveItem wird ein Datensatz aus dem Listenfeld- Löschen eines Daten-
Steuerelement entfernt. Durch Angabe einer Datensatznummer kann satzes im Listenfeld-
gezielt ein Datensatz aus der gesamten Liste zum Löschen ausgewählt steuerelement
werden.
4.10.3 Den gesamten Inhalt des Listenfeld-

Steuerelements löschen
Mit dem Befehl Clear werden alle Datensätze, die im Listenfeld- Alle Datensätze eines
Steuerelement eingetragen sind, gelöscht. Listenfeldsteuer-
elements löschen
4.10.4 Aufgabe
Eine ListBox soll beim Programmstart mit Namen gefüllt werden. Bei Eine Aufgabe zum
einem Doppelklick auf einen bestimmten Namen wird dieser in eine Steuerelement
zweite ListBox verschoben. Mit dem Button OK werden alle Namen Listenfeld
aus der zweiten ListBox entfernt und wieder zurück in die erste ver-
schoben. Bei jedem Namen, der mit Ok zurückverschoben wird, er-
scheint für kurze Zeit ein Meldungsfenster mit folgender Meldung:
„Der Brief für Name wird soeben gedruckt.” Die Reihenfolge, in der
die Briefe „gedruckt” werden, entspricht der, in der die Namen in die
zweite ListBox eingetragen wurden. Um einen Namen, der versehent-
lich in die zweite ListBox kopiert wurde, wieder zu entfernen, muß
ebenfalls ein Doppelklick auf den zu löschenden Namen erfolgen.
4.10.5 Lösung
Private Sub Form_Load() Die Lösung für die
lst_Namen.AddItem ("Flink Fritze") Aufgabe Listenfeld-
lst_Namen.AddItem ("Hastig Hugo") steuerelement
lst_Namen.AddItem ("Simson Simone")
"
" 101
lst_Namen.AddItem ("Pundy Ale")
lst_Namen.AddItem ("Super Man")
End Sub
Private Sub lst_Namen_DblClick()

lst_Druck.AddItem (lst_Namen.Text)
lst_Namen.RemoveItem (lst_Namen.ListIndex)
End Sub
Private Sub lst_Druck_DblClick()

lst_Namen.AddItem (lst_Druck.Text)
lst_Druck.RemoveItem (lst_Druck.ListIndex)
End Sub

Dim i As Integer
While lst_Druck.ListCount > 0
lst_Druck.ListIndex = 0
For i = 0 To 2000 'Die ersten 2000
'Fehlermeldungen ermitteln
lab_Meldung.Caption = "Der Brief für " & _
lst_Druck.Text & " wird soeben gedruckt"
DoEvents
Next i
Call lst_Druck_DblClick
Wend
lab_Meldung.Caption = ""
End Sub
4.11 Das Kombinationsfeld Combobox
Abbildung 4.12: Das Kombinationsfeld „Combobox”
Die Combobox entspricht einer ListBox mit Eingabefeld. Zum einen

kann durch Aufklappen der Combobox (Drücken des Pfeiles links ne-
ben der ComboBox) eine Liste dargestellt werden, aus der man eine
Zeile auswählen kann, oder es kann ein Text in das Eingabefenster der
Combobox eingegeben werden. Die Befehle der Combobox sind mit
denen der ListBox (siehe Abschnitt „Einen neuen Datensatz eintra-
gen“, „Einen Datensatz löschen“ und „Den gesamten Inhalt des Li-
stenfeld-Steuerelements löschen“) identisch.
102

4.11.1 Aufgabe
Es soll nochmals ein Programm zum Umrechnen eines Wertes in ei- Eine Aufgabe für die
nen anderen erstellt werden. Im Gegensatz zu dem ersten Beispiel soll ComboBox
das Steuerelement für den Umrechnungsfaktor jedoch eine Combo-
box sein, die schon folgende Umrechnungsfaktoren enthält:
Kilometer in Seemeilen,
Seemeilen in Kilometer,
Stunden in Minuten.
Des weiteren können aber auch eigene Faktoren eingegeben werden,

die nicht in die existierende Liste aufgenommen werden. Wenn ein
eigener Faktor eingegeben oder ein Wert verändert wird, muß der
Schalter OK gedrückt werden, um die Rechnung zu aktualisieren.
Wird dagegen ein neuer Faktor aus der Liste ausgewählt, aktualisiert
sich das Ergebnis automatisch.
4.11.2 Lösung
Private Sub Form_Load() Die Lösung zur
'Die Combobox mit Vorgabewerten füllen Aufgabe ComboBox
Call cmb_Faktor.AddItem("1,852", 0)
Call cmb_Faktor.AddItem("0,53996")
Call cmb_Faktor.AddItem("60", 2)
End Sub
Private Sub txt_Wert_Change()

'Löschen des alten Wertes im Ergebnislabel
End Sub
Private Sub cmb_Faktor_Change()

'Löschen des alten Wertes im Ergebnislabel
End Sub

'Sind Zahlen in der TextBox und der Combobox
'eingetragen,
If txt_Wert.Text<>"" And cmb_Faktor.Text<>"" And _
IsNumeric(cmb_Faktor.Text) Then
'berechne das Ergebnis und gebe es im
'Ergebnislabel aus
lab_Ergebnis.Caption=CStr(CDbl(txt_Wert.Text)* _
CDbl(cmb_Faktor.Text))
#

## 103
End If
End Sub
Private Sub cmb_Faktor_Click()

'Inhalt im Ergebnislabel entfernen
'Auslösen der Berechnung mit dem neu gewählten
'Faktor
Call btn_Ok_Click
End Sub
4.12 Die Bildlaufleisten ScrollBar
Abbildung 4.13: Die vertikale und horizontale Bildlaufleiste „ScrollBar”
Für das einfache Bewegen in großen Datenmengen oder auf einer

großen Grafik wird von Visual Basic die Bildlaufleiste ScrollBar unter-
stützt. Diese Bildlaufleiste gibt es für das Bewegen in horizontaler und
vertikaler Richtung. Des weiteren können Bildlaufleisten als Regler
für bestimmte Programmeinstellungen wie
Helligkeit,
Lautstärke und
Geschwindigkeit
eingesetzt werden. Der bewegliche Balken auf der Bildlaufleiste – im

folgenden Markierungsbalken genannt – zeigt dabei an, wie nah der
eingestellte Wert sich am Minimum oder Maximum befindet. Die ak-
tuelle Position des Markierungsbalkens wird programmintern über
die Variable Value abgefragt. Der Wert der Eigenschaft Value kann
eine beliebige ganze Zahl im Bereich von 0 bis einschließlich 32767
sein. Wird die Bildlaufleiste als Eingabe oder Ausgabe von bestimm-
ten Regelbereichen eingesetzt, soll also etwa eine Lautstärkeregelung
im Bereich von 1 bis 10 möglich sein, läßt sich über die Eigenschaften
Min und Max der Intervallbereich der Bildlaufleiste anpassen.
104

4.12.1 Aufgabe
Es soll ein Programm entwickelt werden, das in einer TextBox immer Eine Aufgabe für die
den aktuellen Positionswert ausgibt, an dem sich der Markierungs- ScrollBars
balken der Bildlaufleiste befindet.
4.12.2 Lösung
Private Sub vsc_Zahl_Change() Die Lösung für die Auf-
lab_Zahl.Caption = vsc_Zahl.Value gabe Scrollbars
End Sub
4.13 Das Datei-, Verzeichnis- und

Laufwerklistenfeld
Abbildung 4.14: Das Datei-, Verzeichnis- und Laufwerklistenfeld
Das Dateilistenfeld FileListBox, das Verzeichnislistenfeld DirListBox

und das Laufwerklistenfeld DriveListBox sind ListBoxen, die von Vi-
sual Basic zur Verfügung gestellt werden, um Laufwerkstrukturen dar-
zustellen. Im Dateilistenfeld werden alle Dateien, im Verzeichnisli-
stenfeld die Verzeichnisse und im Laufwerklistenfeld schließlich alle
bekannten Laufwerke angezeigt.

(Name) String Über den Namen wird das Steuerelement im Programm-
code angesprochen.
Caption String In Caption wird die Beschriftung des Fensters eingetragen,
(Max. 255 Zeichen) die während des Programmlaufs sichtbar ist.
Tag String Diese Eigenschaft steht zur freien Verfügung, d. h. sie hat
keinen direkten Einfluß auf das Steuerelement, sondern
kann z.B. als Zwischenspeicher für das Steuerelement die-
nen.
ToolTipText String Der Inhalt dieser Eigenschaft wird in einer Sprechblase als
Erklärung zu einem Steuerelement ausgegeben, wenn die
Maus eine bestimmte Zeit über dem Steuerelement stehen-
bleibt.
Tabelle 4.5: Die wichtigsten Eigenschaften der Datei-, Verzeichnis- und Laufwerklistenfelder
$%& $ " '

105
4.13.1 Aufgabe
Eine Aufgabe zu Es soll ein Programm geschrieben werden, mit dem zwei Verzeich-
den Listenfeldern nisse verglichen werden und das anschließend diejenigen Dateien
auf dem Bildschirm ausgibt, die nur in einem Verzeichnis vorkom-
men.
4.13.2 Lösung
Die Lösung zur Zuerst muß gewährleistet werden, daß die ListBoxen der linken und
Aufgabe Listenfelder der rechten Seite sich gegenseitig aktualisieren. Dafür wird das Ereig-
nis Change der Laufwerks- und Verzeichnislistenfelder benötigt. Wird
in einem Laufwerklistenelement das aktuelle Laufwerk geändert,
muß dieses an das zugehörige Verzeichnislistenelement weitergege-
ben werden. Ebenso muß eine Änderung im Verzeichnislistenfeld so-
fort an das Dateilistenelement weitergegeben werden.
Private Sub drv_links_Change()

'Dem Dateilistenfeld das neue Laufwerk melden
pfd_links.Path = drv_Links.Drive
End Sub
Private Sub pfd_links_Change()

'Dem Dateilistenfeld den neuen Pfad melden
dir_links.Path = pfd_links.Path
'Die Anzahl der gefundenen Dateien ausgeben
If dir_links.ListCount = 1 Then
lab_links.Caption = "Es gibt eine Datei"
Else
lab_links.Caption = _
"Es sind " & dir_links.ListCount & " Dateien"
End If
End Sub
Private Sub btn_Vergleich_Click()

Static Button As String
If btn_vergleich.Caption<>"&Vergleich beenden" Then
'Schaltflächensymbol merken
Button = btn_vergleich.Caption
'Schaltfläche umbenennen
btn_vergleich.Caption = "&Vergleich beenden"
'Verzeichnisbäume verstecken
frm_links.Visible = False
frm_rechts.Visible = False
106

'Vergleichsliste anzeigen
lst_Vergleich.Visible = True
lab_Vergleich.Visible = True
'Vergleich starten
lab_Vergleich.Caption = "Prüfe das Verzeichnis"
Call Vergleichen(dir_links, dir_rechts, _
lst_Vergleich)
Call Anzahl_Dateien(lst_Vergleich.ListCount)
Else
'Schaltflächenbeschriftung umbenennen
btn_vergleich.Caption = Button
'Vergleichsliste verbergen
lst_Vergleich.Visible = False
lab_Vergleich.Visible = False
'Verzeichnisbäume anzeigen
frm_links.Visible = True
frm_rechts.Visible = True
End If
End Sub
Initialisierung des Programms

Für die Initialisierung des Programms – d. h. die Aktualisierung der Initialisieren der Lauf-
Listenfelder – müssen die folgenden Programmzeilen in das Ereignis werke und Pfade
Form_Load eingetragen werden.

Call drv_links_Change
Call drv_rechts_Change
End Sub
Vergleichen der Dateilistenfelder

Um festzustellen, welche Dateien in welchem Listenfeld nicht vor- Vergleichen des Inhal-
kommen, müssen zuerst alle Dateien des ersten Listenfelds mit dem tes der ersten und
Inhalt des zweiten verglichen werden. Alle im zweiten Listenfeld zweiten DateiListBox
nicht gefundenen Dateien werden nun in das Ergebnislistenfeld ein-
getragen. Danach muß geprüft werden, welche Dateien des zweiten
Listenfeldes im ersten Dateilistenfeld enthalten sind. Diese werden
dann ebenfalls in das Ergebnislistenfeld eingetragen.
Private Sub Vergleichen(links As Control, _

rechts As Control, _
Ergebnis As Control)
Dim l As Integer 'Zähler der Dateilistenfelder
Dim r As Integer
$%& $ " '

107
Dim Gefunden As Boolean
Ergebnis.Clear
'Prüfe, welche Dateien nicht im rechten Fenster _
'enthalten sind
For l = 0 To links.ListCount - 1
Gefunden = False
For r = 0 To rechts.ListCount - 1
DoEvents
If Trim(links.List(l)) = _
Trim(rechts.List(r)) Then
Gefunden = True
End If
Next r
If Gefunden = False Then
Ergebnis.AddItem links.List(l)
End If
Next l
...
Hier muß nun nochmals der Vergleich durchgeführt
werden, mit dem Unterschied, daß das rechte
Dateilistenelement in der äußeren Schleife ist.
...
End Sub
In der vorhergehenden Prozedur wurde die neue Anweisung DoEvents

eingeführt. Sie dient dazu, daß die Prozessorzeit an andere Prozesse
abgegeben wird. Dies wird z.B. dann benötigt, wenn Ausgaben auf
der Bildschirmoberfläche gemacht wurden, die aktualisiert werden
müssen.
4.14 Der Zeitgeber Timer
Abbildung 4.15: Der Zeitgeber „Timer”
Der Zeitgeber Timer erzeugt nach einer bestimmten Zeit ein Ereignis.
Mit ihm lassen sich somit Prozesse in bestimmten Zeitintervallen
starten oder für eine bestimmte Zeit sperren. Dieses Zeitintervall
kann zwischen 1 und 65.535 Millisekunden liegen. Der Zeitgeber ist
während der Ausführung des Programms unsichtbar und kann somit
vom Anwender nicht beeinflußt werden. Zur Identifizierung eines
Steuerelements als Zeitgeber werden im folgenden die drei Buchsta-
ben tim verwendet.
108

(Name) String Über den Namen wird das Steuerelement
im Programmcode angesprochen.
Enabled True/False True startet den Zeitgeber, er erzeugt
Impulse.
False stoppt den Timer, er erzeugt keine
Impulse mehr.
Intervall 1-65'536 Diese Eigenschaft beinhaltet die Zeit in
Millisekunden, die zwischen zwei Zählim-
pulsen des Timers liegen soll.
Tag String Diese Eigenschaft steht zur freien Verfü-
gung, d.h. sie hat keinen direkten Einfluß
auf das Steuerelement, sondern kann z.B.
als Zwischenspeicher für das Steuerelement
dienen.
Tabelle 4.6: Die wichtigsten Eigenschaften des Zeitgebers
4.14.1 Aufgabe
Es soll eine einfache Stoppuhr mit den Funktionen Eine Aufgabe für
den Zeitgeber
Start,
Stop,
Restart und
Reset
programmiert werden.
4.14.2 Lösung
Als Grundlage für das zu erstellende Programm kann das Programm Die Lösung zur
Vorlage genommen werden. Die Schaltfläche btn_Ok ist dabei über- Aufgabe Zeitgeber
flüssig und kann somit gelöscht werden. Die zusätzlich benötigten
Steuerelemente werden in Tabelle 4.7 mit ihren einzustellenden Ei-
genschaften aufgeführt.
Steuerelement Eigenschaft Inhalt

Textelement Name lab_Zeit
Label Caption
Schaltfläche Caption &Start
Button Name btn_Start
Tag Startet die Zeitmessung mit der Stoppuhr
Schaltfläche Caption S&top
Button Name btn_Stop
( #) 109

Steuerelement Eigenschaft Inhalt
Tag Beendet die Zeitmessung mit der Stoppuhr
Schaltfläche Caption &Reset
Button Name btn_Null
Tag Setzt die Stopuhr auf null zurück
tim_Stopuhr Name tim_Stopuhr
Timer Interval 10
Tabelle 4.7: Benötigte Steuerelemente für das Stopuhrbeispiel
Für das Messen der vergangenen Zeit werden folgende Variablen be-
nötigt:
Dim Startzeit As Date

Dim Zeit As Date
Die folgenden Funktionen bilden die Funktionalität der Stoppuhr ab:
Private Sub btn_Null_Click()

Startzeit = Time$
Zeit = Startzeit
Lab_Zeit.Caption = Format(0, "Long Time")
End Sub
Private Sub btn_Start_Click()

Zeit = Time$
Startzeit = Zeit - CDate(Lab_Zeit.Caption)
tim_Stoppuhr.Enabled = True
End Sub
Private Sub btn_Stop_Click()

tim_Stoppuhr.Enabled = False
End Sub

Lab_Zeit = Format(0, "Long Time")
Call btn_Stop_Click
Call btn_Null_Click
End Sub
Private Sub tim_Stoppuhr_Timer()

Zeit = Time$
Lab_Zeit.Caption = Format(Zeit - Startzeit, "Long _
Time")
DoEvents
End Sub
110

4.15 Das Liniensteuerelement Linie
Abbildung 4.16: Das Liniensteuerelement „Linie”
Das Steuerelement Linie ist ein grafisches Steuerelement und dient

zum Unterteilen von Fenstern. Der Benutzer kann während der Lauf-
zeit keine Veränderungen vornehmen, da es ausschließlich zur Visua-
lisierung eingesetzt wird.
4.16 Das Figurensteuerelement Shape
Abbildung 4.17: Das Figurensteuerelement „Shape”
Das Figurensteuerelement Shape ist, analog zum Liniensteuerele-

ment, ein grafisches Steuerelement. Es kann als Quadrat, Rechteck,
Kreis, Oval, abgerundetes Rechteck oder als ein abgerundetes Qua-
drat angezeigt werden. Es wird zumeist für das visuelle Gruppieren
von Steuerelementen eingesetzt. Das Figurensteuerelement wird zur
Designzeit verwendet und entspricht den Methoden Circle und Line
während der Laufzeit.
4.16.1 Beispiel zum Figurensteuerelement Shape

Bei dem folgenden Beispielprogramm handelt es sich um eine kleine
Animation. Sie läßt einen Ball in einem Bildfeld-Steuerelement wie
einen Gummiball hüpfen. Sobald der Ball an eine Seite stößt, prallt er
von dieser ab, nach dem physikalischen Gesetz „Einfallswinkel gleich
Ausfallswinkel” ab. Der Ball soll mit dem Steuerelement Shape darge-
stellt werden. In Die Programmoberfläche der „Gummiball-Simula-
tion” ist die Programmoberfläche der „Gummiball-Simulation” dar-
gestellt. Als Grundlage wurde das Vorgabe-Projekt auf der diesem
Buch beiliegenden Diskette verwendet.
"

" 111
Abbildung 4.18: Die Programmoberfläche der „Gummiball-Simulation”
In Tabelle 4.8: Die Steuerelemente der „Gummiball-Simulation” sind

die für das Programm benötigten Steuerelemente und deren Eigen-
schaften beschrieben.
Steuerelement Eigenschaft Inhalt Beschreibung

Zeitgeber (Name) tim_Ball Er steuert den Bewegungsablauf. Je kürzer
das eingestellte Intervall ist, desto schneller
bewegt sich der Ball.
Bildfeld-Steuerelement pic_Ball Dies ist das Grundelement, in dem sich der
Ball bewegt. Beim Erstellen muß sich der Ball
im Bildfeld befinden.
Figuren-Steuerelement shp_Ball Dies stellt den farbigen Gummiball dar, der
sich über den Bildschirm bewegt.
BorderColor &H00FF0000& Dies bezeichnet die Farbe, die der Rand des
Balls hat.
BorderStyle 1 - Ausgefüllt Damit wird definiert, daß der Rahmen des
Steuerelements ausgefüllt ist.
FillColor &H00FF0000& Hiermit wird die Farbe des Balls festgelegt.
FillStyle 0 - Ausgefüllt Diese Eigenschaft definiert, daß der Ball
komplett mit der vorgegebenen Farbe
gefüllt wird.
Tabelle 4.8: Die Steuerelemente der „Gummiball-Simulation”
Beim Starten des Programmes müssen die Position, die Geschwindig-

keit und die Startrichtung des Balls vorgegeben werden. Die Bewe-
gungsrichtung setzt sich aus den horizontalen und vertikalen Antei-
len zusammen.
112

Abbildung 4.19: Bewegungsanteile des Balls einer Zeiteinheit
Da bei jeder Bewegung die zurückgelegte Strecke gleich lang sein

muß, reicht es, einen Bewegungsanteil zu definieren. Der andere Be-
wegungsanteil berechnet sich dann nach dem Satz des Pythagoras:
Bewegungsanteil horizontal =
mit 0 < Bewegungsanteil vertikal < 1

In dem Ereignis Load des Formulars wird die Initialisierung der Start-
parameter durchgeführt.

tim_Ball.Interval = 0 'Zeitgeber deaktivieren
'Ball im Mittelpunkt des Bildfeldes positionieren
shp_Ball.Left = (Pic_ball.Width - shp_Ball.Width) / 2
shp_Ball.Top = (Pic_ball.Height - shp_Ball.Height) / 2
Geschw = 80 'Zurückzulegende Strecke einer
'Zeiteinheit
'Anteile der Bewegungsrichtungen berechnen
Richtung(1) = 0.5
Richtung(0) = (1 - Richtung(1) ^ 2) ^ 0.5
End Sub
Stößt der Ball gegen eine der seitlichen Wände, muß der horizontale
Bewegungsanteil mit –1 multipliziert werden, und schon „prallt” der
Ball von der Wand ab. Das gleiche gilt für den vertikalen Bewegungs-
anteil, wenn der Ball auf die obere oder untere Wand trifft. Ob der
Ball auf eine Wand trifft, läßt sich dadurch feststellen, daß der Rand
des Balls einen Wert annimmt, der außerhalb der Eigenschaftswerte

113
Width Breite des Bildfelds
Height Höhe des Bildfelds
liegt. Ausgeführt wird die Berechnung für die neue Position des Balles
bei jedem Bewegungszyklus.
Private Sub tim_Ball_Timer()

Dim x As Double
Dim y As Double
Dim Position(2) As Integer
Position(0) = shp_Ball.Left
Position(1) = shp_Ball.Top
Position(0) = Position(0) + Richtung(0) * Geschw
Position(1) = Position(1) + Richtung(1) * Geschw
If Position(0) > Pic_ball.Width - shp_Ball.Width Then
Position(0) = (Pic_ball.Width - shp_Ball.Width)
Richtung(0) = -Richtung(0)
Else
If Position(0) < 0 Then
Position(0) = 0
End If
End If
If Position(1) > Pic_ball.Height - shp_Ball.Height Then
Position(1) = (Pic_ball.Height - shp_Ball.Height)
Else
If Position(1) < 0 Then
Position(1) = 0
End If
End If
shp_Ball.Left = Position(0)
shp_Ball.Top = Position(1)
End Sub
Um die Bewegung des Balls zu starten, wird das Ereignis Click der
Schaltfläche OK verwendet. Wird dieser Schalter ausgelöst, soll sich
die Beschriftung in STOP ändern und dem Zeitgeber das Intervall zu-
gewiesen werden, in dem er einen Bewegungsschritt des Balls ausfüh-
ren soll.

Static Beschriftung As String
If btn_Ok.Caption = "&Stop" Then
btn_Ok.Caption = Beschriftung
tim_Ball.Interval = 0
114

Else
Beschriftung = btn_Ok.Caption
btn_Ok.Caption = "&Stop"
tim_Ball.Interval = 5
End If
End Sub
Nach dem ersten Betätigen der Schaltfläche fängt der Ball an, sich
über den Bildschirm zu bewegen. Trifft er auf eine Wand, prallt er
wieder ab und ändert dabei seine Richtung. Wird nach einer gewissen
Zeit die Schaltfläche STOP betätigt, verharrt der Ball auf der letzten Po-
sition. Nach einem erneuten Betätigen des Schalters führt er die Be-
wegung weiter, als sei diese nie unterbrochen worden.
4.17 Hinzufügen weiterer Steuerelemente

Visual Basic enthält mehr Steuerelemente, als im Werkzeugfenster Weitere Steuerele-
eingetragen sind. Um weitere Steuerelemente in das Werkzeugfenster mente zum Werkzeug-
einzublenden, muß mit der rechten Maustaste auf das Werkzeugfen- fenster hinzufügen
ster geklickt werden. Hier erscheint nun ein Kontextmenü, aus dem
der Menüpunkt KOMPONENTEN ausgewählt werden muß. Es öffnet
sich der Dialog zum Hinzufügen weiterer Steuerelemente (Abbildung
4.20).
Abbildung 4.20: Zusätzliche Steuerelemente
* +'

115
Durch Selektieren bzw. Deselektieren der Kontrollkästchen in der Li-
ste können die zusätzlichen Steuerelemente in das Werkzeugfenster
übernommen oder wieder aus dem Werkzeugfenster entfernt wer-
den.
4.18 Der Standarddialog mit dem

CommonDialog
Abbildung 4.21: Das Standarddialog-Steuerelement „CommonDialog”
Einer der großen Vorteile des Betriebssystems Windows besteht

darin, daß viele Standarddialoge in allen Applikationen gleich ausse-
hen; dies ermöglicht es dem Anwender, sich rascher und problemlo-
ser in einem neuen Programm zurechtzufinden. Bei Standarddialo-
gen handelt es sich z.B. um Drucken, Dateien öffnen oder Systemfarben
einstellen.
In Visual Basic gibt es nun die Möglichkeit, diese vom System zur Ver-
fügung gestellten Dialogboxen in ein eigenes Programm einzubin-
den. Dazu wird das Steuerelement CommonDialog benötigt. Hiermit
lassen sich alle Einstellungen wie gewohnt setzen und auch abfragen,
während das Programm läuft. Auf dem Fenster, auf dem das Steuer-
element aufgebracht wurde, ist jedoch nur ein kleines Steuerelement
zu sehen (vgl. Abschnitt „Der Zeitgeber Timer“). Während der Lauf-
zeit des Programms ist gar kein Steuerelement auf der Oberfläche des
Fensters zu sehen.
Um das Steuerelement CommonDialog in die Werkzeugliste einzutra-

gen, muß das Kontrollkästchen des Eintrages
Microsoft Common Dialog Control 6.0
auf dem Registerblatt STEUERELEMENTE der Dialoges KOMPONENTEN ak-

tiviert werden.
Verschiedene Aufrufe sind jeweils den entsprechenden Dialogen zu-

geordnet. Dadurch kann das Programm erkennen, um welchen Stan-
darddialog es sich handelt. Die Position des Dialogs auf der Pro-
grammoberfläche wird vom System selbst festgelegt.
116

Die Befehle zum Auf-
Aufruf zugehöriger Dialog rufen der einzelnen
ShowOpen Öffnet die Dialogbox, um Dateien zu öffnen. Standarddialoge
Abschnitt
ShowSave Öffnet die Dialogbox, um Dateien zu speichern.
Abschnitt
ShowColor Öffnet die Dialogbox, um die Farben einzustellen.
Abschnitt
ShowFont Öffnet die Dialogbox, um die Schriftart festzulegen.
Abschnitt Die Eigenschaften des Dialogs Schriftart
ShowPrinter Öffnet die Dialogbox, um den Drucker festzulegen.
Abschnitt
ShowHelp Öffnet die Dialogbox für die Hilfeeinstellungen.
Abschnitt
Tabelle 4.9: Aufrufe der Standarddialoge
Damit ein Programm, das mit Standarddialogen arbeitet, auch ver-

teilt werden kann, muß die dazugehörige OCX-Datei ebenfalls verteilt
werden. Diese Datei befindet sich zumeist im Windows-Standardver-
zeichnis.
In den folgenden Abschnitten werden die einzelnen Dialoge und ihre

Eigenschaften erklärt. Es wird außerdem zu jedem Dialog ein kurzes
Beispiel gegeben, um die Arbeitsweise des Dialogs zu verdeutlichen.
4.18.1 Die Eigenschaften des Dialogs Datei öffnen/

speichern
Abbildung 4.22: Die Eigenschaften des Dialogs „Datei öffnen/speichern”

117
Ein Standarddialog ist das Öffnen und Speichern von Dateien. Hierzu
können Eigenschaften eingestellt werden, die dann im Dialogfenster
berücksichtigt werden. Sie dienen u.a. dazu, um beispielsweise Da-
teien zu filtern oder um die Anzahl der darzustellenden Dateien in ei-
nem Verzeichnis zu begrenzen. In Tabelle 4.10 sind die Eigenschaften
des Dialogs DATEI ÖFFNEN/SPEICHERN beschrieben.
Eigenschaft Beschreibung
DialogTitle Hier wird die Überschrift des Standarddialogs festgelegt.
FileName Innerhalb dieser Option wird der Dateiname, der gespeichert oder geladen werden
soll, erfaßt.
InitDir Innerhalb dieser Option wird das Verzeichnis, das nach dem Öffnen aktiv sein soll,
festgelegt.
Filter Mit dieser Option läßt sich festlegen, welche Dateitypen angezeigt werden sollen
und welche nicht (z.B. nur Dateien mit der Endung BAK). Des weiteren können auch
mehrere Filter und ihre Beschreibung eingegeben werden.
Text (*.txt; *.csv) | *.txt; *.tsv | Paintbrush (*.pcx) | *.pcx;
Flags Hier werden die Optionen für den Dialog festgelegt: welche Optionen angezeigt und
eingestellt werden können und welche nicht.
DefaultExt Diese Eigenschaft legt die Standard-Dateinamenserweiterung fest oder liefert diese
zurück.
MaxFileSize Diese Option reserviert den Speicher für die Länge der Dateinamen, die in der Dialog-
box angezeigt werden können. Der Wert ist vom Typ Integer. Voreingestellt ist der
Wert 256.
FilterIndex Mit dieser Eigenschaft wird der Standardfilter definiert, wenn in der Eigenschaft Filter
mehr als ein Filter angegeben wurde.
CancelError Mit dieser Eigenschaft wird festgelegt, ob beim Drücken der Taste ABBRECHEN ein Feh-
lerwert generiert wird oder nicht.
True Fehlerwert wird generiert.
False Fehlerwert wird nicht generiert.
Tabelle 4.10: Eigenschaften des Dialogs „Datei öffnen und speichern”
Aufgerufen wird der Dialog mit dem Befehl
Name.ShowOpen
Danach ist das Fenster modal geöffnet, d. h. es kann erst mit dem Pro-
gramm weitergearbeitet werden, wenn das Fenster zum Öffnen oder
Speichern der Dateien wieder geschlossen wurde.
118

4.18.2 Die Eigenschaften des Dialogs Farbpalette
Abbildung 4.23: Die Eigenschaften des Dialogs „Farbpalette”
Für die Definition der Farben, die in Programmen optional eingestellt

werden können, gibt es den Standarddialog Farbpalette. Mit ihm las-
sen sich die Farbeinstellungen mit dem von Windows zur Verfügung
gestellten Dialog definieren. In Tabelle 4.11 sind die Eigenschaften
des Dialogs aufgeführt.
Color Diese Eigenschaft beinhaltet die Nummer der Farbe, die dar-
gestellt werden soll.
Flags Hier werden die Optionen für den Dialog festgelegt: welche
Optionen angezeigt und eingestellt werden können und wel-
che nicht.
CancelError Mit dieser Eigenschaft wird festgelegt, ob beim Drücken der
Taste ABBRECHEN ein Fehlerwert generiert wird oder nicht.
Tabelle 4.11: Eigenschaften des Dialogs „Farbpalette”
Name.ShowColor
gramm weitergearbeitet werden, wenn das Fenster zum Definieren
der Farben wieder geschlossen wurde.

119
4.18.3 Die Eigenschaften des Dialogs Schriftart
Abbildung 4.24: Die Eigenschaften des Dialogs „Schriftart”
Um in einem Steuerelement eine Schriftart zu verändern oder dem

Steuerelement eine neue zuzuweisen, wird der Standarddialog Schrift-
art von Visual Basic unterstützt. Er entspricht dem Standarddialog
von Windows. Um eine Schriftart zu bearbeiten, werden folgende Ei-
genschaften zur Verfügung gestellt (Tabelle 4.12):
FontName Diese Eigenschaft gibt die Schriftart an, die in dem Steuerelement verwendet wird
oder verwendet werden soll.
FontSize Diese Eigenschaft gibt die Größe der Schriftart an.
Min Diese Eigenschaft definiert die kleinste zulässige Schriftgröße oder liefert diese
zurück.
Max Diese Eigenschaft definiert die größte zulässige Schriftgröße oder liefert diese zurück.
Flags Diese Eigenschaft legt die Optionen für den Dialog fest: welche Optionen angezeigt
und eingestellt werden können und welche nicht.
CancelError Mit dieser Eigenschaft wird festgelegt, ob beim Drücken der Taste ABBRECHEN ein
Fehlerwert generiert wird oder nicht.
Bold Hier wird festgelegt, ob die Schrift in Fettbuchstaben dargestellt werden soll
(Beispiel).
Italic Hier wird festgelegt, ob die Buchstaben in Kursivschrift dargestellt werden sollen
(Beispiel).
Underline Hier wird festgelegt, ob die Buchstaben unterstrichen werden sollen (Beispiel).
Strikethru Hier wird festgelegt, ob die Buchstaben durchgestrichen werden sollen (Beispiel).
Tabelle 4.12: Eigenschaften des Dialogs „Schriftart”
120

Name.ShowFont
gramm weitergearbeitet werden, wenn das Fenster zum Definieren
der Schriftart wieder geschlossen wurde.
4.18.4 Die Eigenschaften des Dialogs Drucken
Abbildung 4.25: Die Eigenschaften des Dialogs „Drucken”
Für die Steuerung des Druckers und die Druckerauswahl wird der
Standarddialog Drucken unterstützt. Er entspricht dem von Windows
zur Verfügung gestellten Dialog. Folgende Eigenschaften werden von
diesem Dialog unterstützt und können somit gesetzt werden.
Copies Diese Eigenschaft bestimmt die Anzahl der Kopien, die von dem Dokument gedruckt wer-
den sollen.
Flags Hier werden die Optionen für den Dialog festgelegt: welche Optionen angezeigt und ein-
gestellt werden können und welche nicht.
FromPage Hier muß die erste Seite des Bereichs, der gedruckt werden soll, definiert werden.
ToPage Hier muß die letzte Seite des Bereichs, der gedruckt werden soll, definiert werden.
Min Diese Eigenschaft legt den kleinsten zulässigen Wert für den Druckbereich fest oder liefert
diesen zurück.
Max Diese Eigenschaft legt den größten zulässigen Wert für den Druckbereich fest oder liefert
diesen zurück.

121
PrinterDefault Mit dieser Eigenschaft wird festgelegt, ob die Einstellungen, die der Benutzer in dem
Druckdialog verändert, auch die Einstellungen des Systems verändern, d. h. beim Bestäti-
gen der Einstellungen im Druckdialog werden diese in der zugehörigen Konfigurationsda-
tei gespeichert.
True Einstellungen speichern
False Einstellungen verwerfen
CancelError Mit dieser Eigenschaft wird festgelegt, ob beim Drücken der Taste ABBRECHEN ein Fehler-
wert generiert wird oder nicht.
Tabelle 4.13: Eigenschaften des Eigenschaftsdialogs „Drucken”
Name.ShowPrinter
gramm weitergearbeitet werden, wenn das Fenster zur Druckeraus-
gabe wieder geschlossen wurde.
4.18.5 Die Eigenschaften des Dialogs Hilfe
Abbildung 4.26: Die Eigenschaften des Dialogs „Hilfe”
Mit dem Dialog Hilfe wird der Text aus einer Hilfedatei angezeigt. Da-
bei läßt sich festlegen, ob der Standardhilfedialog z.B. kontextabhän-
gig ist, also zu dem aktuellen Menüpunkt oder Fenster Hilfe anbietet.
Es kann aber auch der Index der Hilfedatei angezeigt werden.
122

HelpContext Diese Eigenschaft legt die Kennung für den Kontext fest, der zu dieser Hilfe gehört,
oder liefert diesen zurück.
HelpCommand Diese Eigenschaft legt fest, um welche Art von Hilfe es sich handelt: eine kontextab-
hängige oder eine Indexhilfe. Die Konstantenwerte, die dieser Eigenschaft zugeord-
net werden können, sind im zugehörigen Objektkatalog enthalten.
HelpKey Diese Eigenschaft legt das Stichwort fest, mit dem die zugehörige Hilfe verbunden ist,
oder liefert dieses zurück.
HelpFile Hiermit werden der Pfad und der Name der Hilfedatei, die dem Dialog zugeordnet
ist, festgelegt oder zurückgeliefert.
Tabelle 4.14: Eigenschaften des Dialogs „Hilfe”
Name.ShowHelp
gramm weitergearbeitet werden, wenn das Fenster wieder geschlos-
sen wurde.
4.18.6 Zusammenfassung
Mit dem Steuerelement CommonDialogBox lassen sich alle Standard- Zusammenfassung zu
dialoge schnell und einfach in ein Visual Basic-Programm integrie- dem Steuerelement
ren. Ein Anwender wird sich somit sehr schnell in diesen Dialogen CommonDialogBox
zurechtfinden, da er sie von anderen Programmen bereits kennt.
Beispiel 1
In diesem Beispiel wird der Standarddialog Schriftart aufgerufen. Beispielprogamm zum
Nach erfolgter Definition des Benutzers werden die Einstellungen in Schriftarten-Standard-
das aufrufende Programm übernommen. dialog
Public btn_Schrift_Click()
dlg_Beispiel.ShowFont
End Sub
Beispiel 2
In diesem Beispiel wird für jeden Dialog eine Schaltfläche definiert, Beispielprogramm
die einen der Dialoge aufruft. Es werden keine Werte eingelesen. Die- zum Aufrufen aller
ses Beispiel dient lediglich dazu, die einzelnen Dialogfenster zu zei- Standarddialoge
gen.

123
Public Sub btn_Dialog_Click(Index as Integer)
select Case Index
Case 0
dlg_Beispiel.ShowOpen
Case 1
dlg_Beispiel.ShowSave
Case 2
dlg_Beispiel.ShowColor
Case 3
dlg_Beispiel.ShowFont
Case 4
dlg_Beispiel.ShowPrinter
Case 5
dlg_Beispiel.ShowHelp
End Case
End Sub
4.19 Das Registerblättersteuerelement SSTab
Abbildung 4.27: Das Steuerelement „Registerblätter”
Die Register in Visual Basic sind wie die Register eines Karteikastens
aufgebaut. Auch dieses Steuerelement muß über den Dialog, der in
Abschnitt 4.17 beschrieben wurde, hinzugefügt werden. In der Liste
des Komponenten-Dialogs handelt es sich um den Eintrag
Microsoft Tabbed Dialog Control 6.0
Auf jedem Register können Steuerelemente untergebracht werden,

die einen bestimmten Programmteil unterstützen. Es lassen sich in
einem Fenster viele Informationen übersichtlich anbringen. In den
modernen Programmen sind diese Registerblätter Standard gewor-
den. In diesem Buch wird das Steuerelement Registerblätter mit den
drei Buchstaben tab identifiziert. Standardmäßig werden die Register-
laschen oben angeordnet. Um im Editiermodus von einem Register-
blatt auf ein anderes zu wechseln, muß mit der linken Maustaste auf
die zu wählende Lasche geklickt werden. In der Eigenschaft Caption
wird das Registerblatt benannt. Es sollte jedoch darauf geachtet wer-
124

den, daß ein Register in einem Fenster nicht zu viele Registerblätter
enthält, da sonst die Übersichtlichkeit wieder verlorengeht. Es bietet
sich in solchen Fällen an, auf eine Seite des Registers ein neues Regi-
ster aufzubringen.

angesprochen.
CurrentTab Integer Hier wird die Nummer des aktiven Registers aufgeführt.
Caption String Hier erfolgt die Aufführung des Laschentitels des aktuellen Regi-
sterblattes.
TabCount Integer Diese Eigenschaft gibt die Anzahl der Registerblätter auf dem
Steuerelement an.
TabsPerRow Integer Diese Eigenschaft gibt die Anzahl der Registerlaschen an, die in
einer Zeile dargestellt werden.
Bei sechs Registerblättern und drei Laschen pro Zeile ergibt sich.
Abbildung 4.28: Anordnung der Registerblätter

Tabelle 4.15: Die wichtigsten Eigenschaften des Steuerelements „Registerblätter”
4.19.1 Aufgabe
Es soll ein Programm entwickelt werden, das sechs Registerblätter hat Eine Aufgabe zum
und in ein Beschreibungsfeld schreibt, welches der Register aktiv ist. Steuerelement
Registerblätter
4.19.2 Lösung
Private Sub tab_Beispiel_Click(PreviousTab As Integer) Die Lösung zu den
Lab_Ausgabe.Caption = tab_Beispiel.Caption Registerblättern
End Sub
4.20 Das MDI-Formular

MDI steht für Multiple Document Interface und bedeutet, daß mehrere
Fenster innerhalb eines Programmfensters enthalten sein können. In
manchen Programmen ist es notwendig, daß mehrere Fenster unter
einem Hauptfenster aktiv sind, z.B. in der Textverarbeitung.
,$
125
Das Programmfenster ist das Hauptfenster. Auch wenn kein Doku-
ment geöffnet ist, ist dieses Hauptfenster aktiv. Werden Dokumente
geöffnet, werden sie in Fenstern dargestellt, die sich innerhalb des
Programmfensters befinden und auch innerhalb dieses Fensterrah-
mens das gleiche Verhalten zeigen wie ein Hauptfenster auf der Desk-
top-Oberfläche. Wird das MDI-Fenster über den Rand des Hauptfen-
sters hinaus verschoben, wird dieser einfach abgeschnitten.

angesprochen.
Caption String In Caption wird die Beschriftung des Fensters eingetragen, die
(Max. 255 Zeichen) während des Programmlaufs sichtbar ist.
MDIChild TRUE/FALSE Diese Eigenschaft gibt an, ob es sich bei dem aktuellen Fen-
ster um ein Fenster im Fenster handelt.
Tag String Diese Eigenschaft steht zur freien Verfügung, d. h. sie hat kei-
nen direkten Einfluß auf das Steuerelement, sondern kann
z.B. als Zwischenspeicher für das Steuerelement dienen.
Tabelle 4.16: Wichtige Eigenschaften des MDI-Fensters
4.20.1 Aufgabe
Eine Aufgabe zum Es soll ein Programm entwickelt werden, in dem über den Button
MDI-Fenster MDI NEU ein Dokumentfenster geöffnet wird. Nach dem Öffnen des
Fensters lautet der Fenstertitel folgendermaßen:
Fenster Nr. N um Uhrzeit Uhrzeit geöffnet.
4.20.2 Lösung
Die Lösung zur Fensterglobal

Aufgabe MDI-Fenster
Für die Realisierung wird eine globale Variable benötigt, die mitzählt,
wie viele Fenster schon geöffnet wurden.
Dim Nr As Integer
MDI-Fenster erzeugen
Mit der folgenden Funktion wird das eigentliche MDI-Fenster er-

zeugt. Das Hauptfenster erhält in der Eigenschaft Name den Wert
frmMDI. Als nächstes wird ein weiteres Formular benötigt dessen Name
frm_Client ist und in der Eigenschaft MDIChild wird der Wert True fest-
gelegt.
126

Private Sub MDIForm_Click()
Dim Fenster As New frm_Client
Nr = Nr + 1
Fenster.Caption = "Fenster Nr " & Nr & " um " & _
Time() & " geöffnet"
Fenster.Show
End Sub
,$
127
5 Wichtige Eigenschaften der
Steuerelemente
Jedes Steuerelement hat bestimmte Eigenschaften, die vom Anwen- Eigenschaften der
der, Entwickler oder vom Programm beeinflußt und geändert werden Steuerelemente nicht
können. Die Eigenschaften der Steuerelemente lassen sich in drei immer ändern
Gruppen einteilen:
1. Eigenschaften, die nur zur Designzeit geändert werden können:

Die horizontale und vertikale Position eines Steuerelements
Der Name des Steuerelements
...
2. Eigenschaften, die vom Programm zur Laufzeit geändert werden
können:
Die Farbe des Steuerelements
Die Eigenschaft Sichtbar oder Unsichtbar des Steuerelements
...
3. Eigenschaften, die vom Anwender während der Programmausfüh-
rung geändert werden können:
Die Eingabetexte von Eingabesteuerelementen
Spaltenbreiten/Zeilenhöhen des Steuerelements Grid
...
In diesem Kapitel werden die wichtigsten Eigenschaften der Steuer-

elemente beschrieben und ihre Wirkungsweise auf die Steuerele-
mente erklärt.
129
5.1 Die Eigenschaft (Name)
Eigenname des Die Eigenschaft (Name) identifiziert das Steuerelement oder das For-
Steuerelements mular im Programmcode. Diese Eigenschaft besitzen alle Elemente
von Visual Basic. Der Name muß immer mit einem Buchstaben oder
einem Unterstrich beginnen. Wird vom Entwickler kein (Name) ver-
geben, so vergibt Visual Basic den Namen selbständig. Der von Visual
Basic vergebene Name ist so aufgebaut, daß er zum einen das Objekt
beschreibt und zum anderen eine laufende Nummer enthält, deren
Wert mit jedem neuen Objekt vom selben Typ um eins erhöht wird.
Dieser Name sollte vom Entwickler dann in einen sogenannten spre-
chenden Namen umgewandelt werden. Wird zum Beispiel ein Text-
element Label auf das Fenster aufgebracht, mit dem ein Ergebnis dar-
gestellt werden soll, bietet sich der Name Lab_Ergebnis für dieses
Steuerelement an.
Der Name für ein Steuerelement sollte vergeben werden, bevor das er-
ste Ereignis programmiert wird, da die verwendeten Ereignisse nicht
umbenannt werden. Bei einer späteren Umbenennung sind dem
Steuerelement somit keine Funktionen mehr zugeordnet. Die ver-
wendeten Funktionen sind jedoch nicht gelöscht, sondern in dem
Abschnitt GENERAL des Formulars gespeichert.
5.2 Die Eigenschaft Appearance

Darstellungsarten des Die Eigenschaft Appearance definiert, wie das Objekt auf der Oberflä-
Steuerelements che dargestellt wird. Es gibt zwei Darstellungsarten:
0 Flat. Zeichnet das Objekt ohne Tiefeneffekte, also flach.
1 3D. Das Objekt wird im neuen Darstellungsmodus von Windows95/

NT gezeichnet, also mit einem 3D-Effekt.
5.3 Die Eigenschaft Caption

Beschriftung des Die Eigenschaft Caption ist die Beschriftung eines Steuerelements.
Steuerelements Diese Eigenschaft kann während der Laufzeit nur vom Programm ge-
ändert werden. Der Inhalt der Eigenschaft Caption ist im Fenster in
der farbigen Titelleiste abgebildet.
Abbildung 5.1: Beispiel zur Eigenschaft „Caption”
130

Die Zeichenkette, die in diese Eigenschaft eingegeben werden kann,
darf nicht länger als 255 Zeichen sein. Dieses Limit wird zumeist
nicht überschritten, da die Beschreibungstexte selten die entspre-
chende Länge erreichen.
5.4 Die Eigenschaft Cancel

Mit Cancel wird die Schaltfläche definiert, die auf die (Esc)-Taste rea- Definiert, ob eine
gieren soll. Zumeist handelt es sich um die Schaltfläche Abbrechen. Schaltfläche auf die
Wenn ein Fenster mit einer Cancel-Taste aktiv ist, löst das Drücken (Esc)-Taste reagiert
der Taste (Esc) die Aktion aus, die normalerweise durch Betätigen der
Schaltfläche mit der Maus gestartet wird. Die Eigenschaft Default de-
finiert die Schaltfläche, die auf die Taste (¢) reagiert
Die Eigenschaft Cancel kann folgende Zustände annehmen:
True = Diese Taste reagiert standardmäßig auf das Betätigen der

Taste (Esc).
False = Diese Taste reagiert nicht standardmäßig auf das Betätigen

der Taste (Esc).
Auf jedem Formular kann es nur ein Steuerelement geben, dessen

Eigenschaft den Wert True besitzt.
5.5 Die Eigenschaft Default

Mit der Eigenschaft Default wird das Steuerelement definiert, das auf Definiert, ob eine
die Eingabetaste ENTER reagieren soll. Zumeist handelt es sich um die Schaltfläche auf die
Schaltflächen BESTÄTIGEN oder OK. Wenn ein Fenster mit einer De- (¢)-Taste reagiert
fault-Taste aktiv ist, löst das Drücken der Taste RETURN die Aktion aus,
die normalerweise durch Betätigen der Schaltfläche mit der Maus ge-
startet wird. Die Eigenschaft Cancel definiert die Schaltfläche, die auf
die Taste (Esc) reagiert.
Die Eigenschaft Default kann folgende Zustände annehmen:
True = Diese Taste reagiert standardmäßig auf das Betätigen der

Taste (¢).
False = Diese Taste reagiert nicht standardmäßig auf das Betätigen

der Taste (¢).
Auf jedem Formular kann es nur ein Steuerelement geben, dessen

Eigenschaft den Wert True besitzt.
131

5.6 Die Eigenschaft Enabled
Verfügbarkeit der Um ein Steuerelement für den Anwender zu sperren, wird die Eigen-
Steuerelemente schaft Enabled zur Verfügung gestellt. Mit Hilfe dieser Eigenschaft
läßt sich definieren, ob ein Anwender ein Steuerelement, z.B. eine
Schaltfläche, nur sieht oder er sie auch auch betätigen darf. Bei Pro-
grammen, die benutzerabhängig, z.B. von einem Paßwort gesteuert
sind, ist es mit Hilfe dieser Eigenschaft sehr einfach, die Funktionali-
tät von Programmen einzuschränken. Zum Teil ist es auch sinnvoll,
Steuerelemente, die einen aufwendigen Prozeß starten, zu deaktivie-
ren, um ein zweites Aufrufen der Funktion solange zu vermeiden, bis
der Prozeß vollkommen abgearbeitet wurde. Wird im folgenden Bei-
spiel die Taste OK während des Abarbeitens der Funktion gedrückt,
hält die Funktion an und startet neu.
Private Sub btn_Eingabe_Click ()

Dim I As Integer
lab_Ausgabe1.Caption = "" 'Löschen des Inhaltes der

'beiden Textausgaben
lab_Ausgabe2.Caption = ""
For I = 1 To 1000 'Erste Schleife, die in
'das erste Label den
'Schleifenindex schreibt
lab_Ausgabe1.Caption = CStr(I)
DoEvents
Next i
For I = 1 To 1000 'Zweite Schleife, die in
'das zweite Label den
'Schleifenindex schreibt
lab_Ausgabe2.Caption = CStr(I)
DoEvents
Next i
End Sub
5.6.1 Hintergrund- und Vordergrundfarbe

Farben des
Steuerelements
Abbildung 5.2: Die Menüs für das Einstellen der Steuerelementfarben
132

Zum Einstellen der Hintergrund- und Vordergrundfarbe stellt Visual
Basic die Menüs aus Abbildung 5.2 zur Verfügung. Auf dem Register
Palette sind alle Farben dargestellt, die für das Steuerelement ausge-
wählt werden können. Mit dem Registerblatt System wird die Farbver-
teilung des Systems dem Steuerelement zugeordnet. Wenn dem Steu-
erelement die Systemfarbeinstellung von Button Face zugewiesen und
diese Farbe im System geändert wird, ändert sich auch die Farbe des
Steuerelements. Wurde die Farbe über das Registerblatt Palette zuge-
wiesen, dann ist die Farbe von den Systemeinstellungen unabhängig.
5.7 Die Eigenschaft MousePointer

Mit dieser Eigenschaft ist es möglich, das Aussehen des Mauszeigers Verändern der Dar-
zu verändern. Standardmäßig ist der Mauszeiger ein Pfeil. Um dem stellungsart des
Anwender zu zeigen, daß das Programm aktiv ist, kann der Mauszei- Mauszeigers
ger z.B. in eine Sanduhr geändert werden. Für die Eingabe wird zu-
meist die Darstellung eines senkrechten Strichs („|”) verwendet. Vi-
sual Basic unterstützt die folgenden verschiedenen Darstellungen:
Wert Aussehen Wert Aussehen

0 Vorgabe 8
1 9
2 10
3 11
4 12
5 13
6 14
7 15
99 Benutzerdefiniert
Tabelle 5.1: Die möglichen Mauspfeile
133

5.8 Die Eigenschaft TabIndex
Mit der Eigenschaft TabIndex wird die Reihenfolge der Steuerele-
mente festgelegt, in der sie durch das Drücken der (ÿ)-Taste abgear-
beitet werden. Visual Basic vergibt diese Werte selbständig durch ein-
faches Numerieren der Steuerelemente in der Reihenfolge, in der sie
auf die aktuelle Form aufgebracht wurden. Muß man die Reihenfolge,
in der die Steuerelemente angesprungen werden, ändern, so gibt der
Entwickler dem Steuerelement die neue Nummer ein. Das Steuerele-
ment, welches zuvor diese Nummer besessen hat, erhält die Nummer
des Steuerelements, dessen Eigenschaftswert sich geändert hat. Der
Wert der Eigenschaft kann zwischen 0 und der Anzahl der Steuerele-
mente – 1 auf dem aktiven Fenster liegen.
5.9 Die Eigenschaft TabStop

Reihenfolge der Steuer- Um bei einem Steuerelement die Möglichkeit abzuschalten, daß es
elementaktivierung den Fokus über die (ÿ)-Taste erhält, kann die Eigenschaft TabStop auf
über Tabulator-Taste False gesetzt werden. Ist TabStop auf True gesetzt, kann das Steuerele-
ment über die (ÿ)-Taste erreicht werden.
5.10 Die Eigenschaft Tag

Zur freien Verfügung Die Eigenschaft Tag ist keine Eigenschaft, die Einfluß auf das Steuer-
element hat. Fast jedes Steuerelement stellt diese Eigenschaft zur Ver-
fügung. Der Programmierer kann sie benutzen, um Zeichenketten
oder Einstellungen des Steuerelements zwischenzuspeichern. Eine
Verwendung dieser Eigenschaft wäre z.B. die Versionskontrolle des
einzelnen Steuerelements.
5.11 Die Eigenschaft Text

Dient zur Daten- Steuerelemente mit der Eigenschaft Text ermöglichen die Eingabe
eingabe während der von Daten während der Programmlaufzeit. In diese Steuerelemente
Programmlaufzeit können vom Benutzer Daten eingegeben werden, die dann vom Pro-
gramm ausgewertet und weiterverarbeitet werden können. Die Ei-
genschaft Text entspricht ansonsten der Eigenschaft Caption (siehe
Abschnitt 5.3).
134

5.12 Die Eigenschaft ToolTipText
Mit dieser Eigenschaft kann der Text eingegeben werden, der in der Hilfetext zum Steuer-
Sprechblase erscheinen soll, wenn der Mauszeiger auf das Steuerele- element in einer
ment zeigt, ohne bewegt zu werden. Wenn z.B. eine Schaltfläche ein- Sprechblase
gesetzt wird, der nur ein Bild zugeordnet ist, kann diese Eigenschaft
die Aktion beschreiben, die von dem Steuerelement ausgelöst wird.
5.13 Die Eigenschaft Visible

Mit dieser Eigenschaft wird dem Steuerelement mitgeteilt, ob es für Sichtbarkeit eines
den Anwender sichtbar ist oder nicht. In einigen Programmen ist es Steuerelements
zum Teil wichtig, daß manche Programmteile ausgeschaltet werden
können, z.B. um Programmteile vor Anwendern zu verbergen (Paß-
wortschutz). Des weiteren kommt es vor, daß sich bestimmte Dialoge
sehr ähneln; über das Aus- und Einblenden von Steuerelementen
kann die Dialogmaske genau an die Bedürfnisse angepaßt werden. Vi-
sible kann zwei Zustände annehmen:
True Das Steuerelement ist sichtbar.
False Das Steuerelement ist unsichtbar.
5.14 Die Eigenschaft WindowState

Ein Fenster kann in Windows drei verschiedene Größendefinitionen Darstellung
besitzen. Es kann minimiert sein, d. h. es ist nur als Icon auf der Win- des Fensters
dows-Oberfläche zu erkennen. Weiterhin kann es als sogenanntes
Vollbild den gesamten Bildschirm ausfüllen. Und schließlich kann es
als Bildschirmausschnitt auf der Oberfläche dargestellt werden. Die
Standardeinstellung von Visual Basic sieht einen Bildschirmaus-
schnitt vor.
Folgende drei Parameter sind für diese Eigenschaft möglich:
0 - Normal Das Programmfenster ist ein Bildschirmausschnitt

auf der Oberfläche.
1 - Minimized Das Programmfenster wird als Icon auf der Oberflä-

che dargestellt.
2 - Maximized Die gesamte Oberfläche wird vom Programmfenster

eingenommen.
135

6 Wichtige Ereignisse der
Steuerelemente
Jedes Steuerelement kann auf bestimmte Ereignisse reagieren. Diese

Ereignisse können dann Ausgaben erzeugen, Eigenschaften der Steu-
erelemente ändern oder Programmodule ausführen. Ereignisse wer-
den meistens durch den Benutzer ausgelöst. Ein Ereignis ist z.B. das
Klicken mit der linken Maustaste auf ein Steuerelement. Jedes Ereig-
nis ist vom Aufbau her eine Prozedur, die beim Eintreffen des Ereig-
nisses ausgeführt wird. Diese Prozeduren können ebenfalls, wie alle
anderen Prozeduren auch, von anderen Funktionen und Prozeduren
aufgerufen werden. Die Ereignisprozeduren sind immer wie folgt auf-
gebaut:
Private Sub ElementName_Ereignis([Parameterliste])
ElementName: Der Name, unter dem das Steuerelement im Pro-

gramm bekannt ist. Der Name entspricht der Ei-
genschaft Name (Abschnitt ).
Ereignis: Das Ereignis, das eintreffen muß, um die Proze-
dur auszuführen. Dieses Ereignis kann entweder
von einem Anwender oder vom System ausgelöst
werden.
Parameterliste: Die Parameterliste enthält alle Variablen, die
beim Eintreffen des Ereignisses abgefragt werden
können. Wird zum Beispiel eine Taste gedrückt,
so ist in der Parameterliste enthalten, welche Ta-
ste gedrückt wurde. Die Parameterliste ist vom Er-
eignis abhängig und somit nicht immer vorhan-
den.
In diesem Kapitel werden die wichtigsten Ereignisse erklärt und ihre

jeweiligen Funktionen anhand von Beispielen aufgezeigt.
137
6.1 Click – der einfache Mausklick
Reagieren auf ein- Das Ereignis Click wird ausgelöst, wenn sich der Mauspfeil auf einem
maliges Klicken mit der Steuerelement befindet und die linke Maustaste einmal gedrückt
linken Maustaste wird. Die Prozedur benötigt keine Parameter, da es immer nur eine
Maus gibt, mit der dieses Ereignis ausgelöst wird. Click selbst reagiert
nur auf die linke Maustaste oder das Bestätigen mit der (¢)-Taste.
Hauptsächlich findet das Ereignis Click bei den Schaltflächen BUTTON
Anwendung.
Private Sub Form_Click()

Private Sub Name_Click([Index As Integer])
Parameter Beschreibung
Index Wenn das Steuerelement ein Teil eines Feldes von
Steuerelementen ist, identifiziert diese Indexnummer
das Steuerelement eindeutig.
6.2 Der doppelte Mausklick: DblClick

Reagieren auf Diese Prozedur wird mit einem Doppelklick der linken Maustaste auf
das Doppelklicken mit ein Steuerelement ausgelöst. Ein Doppelklick ist das zweimalige
der Maus Drücken der linken Maustaste in rascher Abfolge. Einfacher und dop-
pelter Mausklick starten oft bestimmte Programmteile. In ListBoxen
wird mit diesem Ereignis zumeist eine Aktion für das aktive Listenele-
ment gestartet.
Private Sub Form_DblClick()

Private Sub Name_DblClick([Index As Integer])
6.3 Das Laden eines Formulars durch Load

Reagieren auf das Das Ereignis Load tritt ein, wenn ein Fenster in den Hauptspeicher ge-
Laden eines Formulars laden wird. Dieses Ereignis wird z.B. immer vom Hauptfenster ausge-
in den Speicher führt, wenn das Programm gestartet wird. Aus diesem Grund läßt
sich das Ereignis hervorragend für die Initialisierung von Variablen
verwenden. Zumeist werden auch in dieser Prozedur die Initialisie-
rungen für das Programm geladen.
138

Für die Wiederholung dieses Ereignisses reicht es nicht aus, das Fen-
ster zu verstecken und wieder anzuzeigen, sondern es muß aus dem
Hauptspeicher entfernt werden.

Private Sub MDIForm_Load([Index])
Mit den folgenden Befehlen lassen sich Fenster aus dem Hauptspei-
cher entfernen und wieder hineinladen.
'Wenn ein Fenster in den Hauptspeicher geladen werden

'soll
Load Fenstername
'Wenn ein Fenster ein anderes aus dem Hauptspeicher
'entfernen soll
UnLoad Fenstername
'Wenn sich ein Fenster selbst aus dem Speicher
'entfernen soll
UnLoad Me
6.4 GotFocus
Dieses Ereignis wird ausgelöst, wenn das Steuerelement als aktives Wenn ein Steuer-
Element auf die Oberfläche gesetzt wird. Dies geschieht mit einem element oder ein
Mausklick auf das Steuerelement, mit der (ÿ)-Taste oder mit dem Formular selektiert
Programmcode über den Befehl SetFokus. Das Gegenstück zu GotFocus wird
ist LostFocus (den Fokus verlieren).
Private Sub Form_GotFocus ()

Private Sub Name_GotFocus ([Index As Integer])
139
6.5 KeyDown und KeyUp – Drücken und
Loslassen einer Tastaturtaste
Reagieren auf das Wenn eine Taste auf der Tastatur gedrückt wird, tritt das Ereignis Key-
Drücken oder Los- Down ein. Wird die gedrückte Taste wieder losgelassen, tritt das Ereig-
lassen einer beliebigen nis KeyUp ein. Wenn sich auf dem Fenster eine Schaltfläche mit der
Taste auf der Tastatur Eigenschaft Default = True befindet, kann bei keinem anderen Steuer-
element geprüft werden, ob die Taste (¢) gedrückt wurde. Dasselbe
gilt für die Taste (Esc), wenn sich auf dem Fenster eine Schaltfläche
mit der Eigenschaft Cancel = True befindet.
Private Form_KeyDown(KeyCode As Integer, Schift As Integer)

Private Name_KeyDown([Index As Integer,] KeyCode As Integer, Schift As
Integer)
Private Form_KeyUp(KeyCode As Integer, Schift As Integer)
Private Name_KeyUp([Index As Integer,] KeyCode As Integer, Schift As Integer)
KeyCode Dieser Parameter liefert den Tastencode der gedrück-
ten Taste zurück. Die Definitionen der einzelnen Tasten
sind in der Datei Constant.txt von Visual Basic enthal-
ten.
Shift Diese Variable enthält den Status der Tasten (ª),
(Strg) und (Alt):
1 Die (ª)-Taste ist gedrückt.
2 Die (Strg)-Taste ist gedrückt.
4 Die (Alt)-Taste ist gedrückt.
6.6 Drücken und Loslassen einer Maustaste

mit MouseDown und MouseUp
Reagieren auf das Um festzustellen, welche Maustaste vom Anwender gerade gedrückt
Drücken oder Los- oder losgelassen wird, gibt es die Funktionen MouseDown und
lassen einer beliebigen MouseUp. Die Funktion MouseDown wird vor dem Ereignis Click aus-
Maustaste geführt, wenn es sich um die linke Maustaste handelt. Wird eine ge-
drückte Maustaste losgelassen, tritt das Ereignis MouseUp ein. Dieses
Ereignis tritt, im Falle der linken Maustaste, immer nach dem Ereig-
nis Click ein. Im Gegensatz zum Ereignis MouseMove, das die Menge
der gedrückten Tasten prüft, treten diese Ereignisse für jede gedrückte
Maustaste auf.
140

Private Sub Form_MouseDown (Button As Integer, Shift As Integer, X As Sin-
gle, Y As Single)
Private Sub Name_MouseDown ([Index As Integer,] Button As Integer, Shift As
Integer, X As Single, Y As Single)
Private Sub Form_MouseUp (Button As Integer, Shift As Integer, X As Single,
Y As Single)
Private Sub Name_MouseUp ([Index As Integer,] Button As Integer, Shift As
Button Diese Variable gibt an, welche Maustaste dieses Ereig-
nis ausgelöst hat:
1 Die linke Maustaste ist gedrückt.
2 Die rechte Maustaste ist gedrückt.
4 Die mittlere Maustaste ist gedrückt.
(Strg) und (Alt):
Anhand des Wertes in der Variablen Shift läßt sich
genau nachprüfen, welche Tastenkombination dieser
Sondertasten gerade gedrückt wird.
X,Y Diese beiden Variablen enthalten die aktuelle Mauspo-
sition:
X Horizontale Mausposition.
Y Vertikale Mausposition.
6.7 Mit MouseMove die Maus über ein Steu-

erelement bewegen
Wenn sich die Maus über ein Steuerelement bewegt, tritt das Ereignis Reagieren auf die
MouseMove ein. Mit diesem Ereignis können Sie z.B. Hilfemeldungen Bewegung der Maus
in Statuszeilen ausgeben oder Systemvariablen setzen, die dann an- über ein Steuerelement
dere Steuerelemente ein- oder ausblenden. Des weiteren läßt sich
hierbei feststellen, welche Tasten der Maus mit welchen Tastatur-Um-
schalttasten gedrückt sind. Tastatur-Umschalttasten sind in diesem
Falle die Tasten (ª), (Strg) und (Alt).
Private Sub Form_MouseMove (Button As Integer, Shift As Integer, X As Sin-

gle, Y As Single)
Private Sub Name_MouseMove ([Index As Integer,] Button As Integer, Shift As
141
Button Diese Variable gibt an, welche Maustaste dieses Ereig-
nis ausgelöst hat:
1 Die linke Maustaste ist gedrückt.
2 Die rechte Maustaste ist gedrückt.
4 Die mittlere Maustaste ist gedrückt.
Anhand des Wertes in der Variablen Button läßt sich
genau prüfen, welche Maustasten gedrückt sind.
(Strg) und (Alt):
Anhand des Wertes in der Variablen Shift läßt sich
genau nachprüfen, welche Tastenkombination dieser
Sondertasten gerade gedrückt wird.
X,Y Diese beiden Variablen enthalten die aktuelle Mauspo-
sition:
X Horizontale Mausposition.
Y Vertikale Mausposition.
6.7.1 Beispiel zum Ereignis MouseMove

In dem folgenden Beispiel soll die Position der Maus in einem Rah-
mensteuerelement ermittelt werden. Die aktuellen Koordinaten wer-
den in zwei Beschriftungselementen ausgegeben. Wird zusätzlich
eine Maustaste oder eine der Tasten (ª), (Strg) oder (Alt) gedrückt,
während die Maus bewegt wird, so soll ebenfalls in einem Textfeld
ausgegeben werden, welche dieser Tasten gedrückt wurde. In Abbil-
dung 6.1 ist die Programmoberfläche abgebildet.
142

Abbildung 6.1: Die Programmoberfläche für das Beispiel „MouseMove“
In Tabelle 6.1 sind die zugehörigen Steuerelemente mit den Eigen-

schaften beschrieben, die für den Beispiel-Programmcode eingestellt
sein müssen.
Steuerelement Eigenschaft Inhalt Beschreibung

Rahmen- (Name) frm_Maus Es handelt sich hier um das
Steuerelement Rahmensteuerelement, in dem die
Mausdaten abgefragt werden sollen.
Textausgabe- lab_X, lab_Y Hier finden sich Beschriftungselemente zur
Elemente Ausgabe der X- und Y-Mausposition im
Koordinatensystem.
lab_Maus Hier liegen Beschriftungselemente zur
Ausgabe der Maustaste vor, die gedrückt
wird.
lab_Taste Diese Option dient zur Ausgabe der

Sprache

Visual Basic 6 Lernen

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Visual Basic 6 Lernen

Hochgeladen von

Copyright:

Verfügbare Formate

Visual Basic 6 lernen

Visual Basic 6 lernen

An imprint of Addison Wesley Longman, Inc.

© 1999 Addison Wesley Longman GmbH

1 Installation von Visual Basic 6.0 ................................................... 17

2 Einführung in die Entwicklungsumgebung.................................. 23

3 Die Programmentwicklung ............................................................ 47

5 Wichtige Eigenschaften der Steuerelemente............................... 129

6 Wichtige Ereignisse der Steuerelemente ...................................... 137

7 Fehlerbehandlung in Visual Basic ............................................... 147

8 Meldungen anzeigen .................................................................... 157

9 Grafikprogrammierung ................................................................ 161

10 Der Menüdesigner......................................................................... 173

12 Entwicklung einer komplexen Applikation ............................... 181

13 Weitere Programmiergrundlagen ................................................ 199

14 Tools .............................................................................................. 257

15 Der Installationsassistent ............................................................. 287

16 Das Erstellen eines Hilfesystems .................................................. 295

17 Datenbankanbindung .................................................................. 317

S Stichwortverzeichnis .................................................................... 363

Es gibt eine Vielzahl von Programmiersprachen, doch finden sie nur

Das Buch wendet sich an interessierte Einsteiger sowie an Anwender,

Um Ihnen die Übersicht im Text zu erleichtern, werden bestimmte

Schriftart mit Beispiel Bedeutung

Abbildung 1.1: Das Start-Menü von Windows 95

Geben Sie in die Befehlszeile zunächst den Buchstaben des Lauf-

1. ZURÜCK: Wird verwendet, um zu dem vorhergehenden Bildschirm

Durch Betätigen der Schaltfläche WEITER wird nun der Lizenzvertrag

1. ICH STIMME DEM LIZENZVERTRAG ZU

selektiert werden. Beim Ablehnen des Lizenzvertrages wird die Installa-

Wenn auf Ihrem Rechner Komponenten von Visual Studio 97 instal-

Jetzt wird das eigentliche Installationsprogramm von Visual Basic ge-

Jetzt werden zunächst noch einmal die Lizenzvereinbarung (doppelt

Nach Betätigung der WEITER-Taste wird wieder Ihre Interaktion ver-

Bei der benutzerdefinierten Installation müssen Sie selbst die zu instal-

Über diesen Button können Sie ein anderes Verzeichnis auswählen,

Ich empfehle für den Anfang die Option STANDARDINSTALLATION aus-

Wenn sie die Option BENUTZERDEFINIERTE INSTALLATION gewählt ha-

Abbildung 1.3: Die Optionen zur benutzerdefinierten Installation

Die meisten der angezeigten Optionen teilen sich ebenfalls in klei-

Um Visual Basic 6.0 aber möglichst effizient einsetzen zu können,

     21

2.1 Starten von Visual Basic 6.0

Abbildung 2.1: Programme im Menü „Visual Basic 6.0“

Um die Entwicklungsumgebung von Visual Basic 6.0 zu starten, muß

2.2 Die Programmoberfläche von

2.3 Wichtige Grundlagen

2.3.1 Zeichen, die nicht verwendet werden sollten

24          

Abbildung 2.3: Fehlerhafte Dokumentation eines Programmteils

Für eine solide Dokumentation des Programmcodes empfehle ich,

2.3.3 Befehlszeilen über mehrere Zeilen

Das Beispiel in Tabelle 2.1 verdeutlicht dies: Die beiden Programm-

Mit Zeilenumbruch Ohne Zeilenumbruch

Tabelle 2.1: Zeilenumbruch in einer Programmzeile

!  "  25

2.3.5 Direkte Sprünge mit Goto

1. Homecomputer, der in den 80er Jahren sehr verbreitet war.

26          

Eine lange Funktion Aufteilung in einzelne Funktionen

Tabelle 2.2: Umwandlung einer langen Funktion in einzelne Module

Heißt eine Funktion z. B. Selektiere_Anwender, läßt sich schon zumeist

!  "  27

21

24

!" 25

26

!" 27

28

#$ 29

30

#$ 31

32

#$ 33

34

#$ 35

36

#$ 37

38