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 Buches 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 V.1
Vorwort ........................................................................................... 13 Icons und typographische Vereinbarungen des Handbuches ............ 15
1 1.1
Installation von Visual Basic 6.0 ................................................... 17 Systemvoraussetzungen....................................................................... 21 Hardware ............................................................................................. 21 Betriebssystem ..................................................................................... 22
2 2.1 2.2 2.3
Einführung in die Entwicklungsumgebung.................................. 23 Starten von Visual Basic 6.0 ................................................................ 23 Die Programmoberfläche von Visual Basic 6.0 ................................... 23 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 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
2.4
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 3.1 3.2
3.3
4 4.1
4.2
4.3
4.4
4.5 4.6 4.7 4.8
6
Die Programmentwicklung ............................................................ 47 Das einfachste Visual Basic-Programm............................................... 47 Grundlegende Programmstrukturen .................................................. 48 Kurzüberblick ...................................................................................... 48 Variablen............................................................................................. 48 Konstanten.......................................................................................... 53 Mehrdimensionale Felder ................................................................... 55 Selbstdefinierte Datentypen ............................................................... 62 Schleifen.............................................................................................. 63 Verzweigungen ................................................................................... 65 Funktionen und Prozeduren............................................................... 67 Das erste Programm ............................................................................ 71 Eingabe................................................................................................ 72 Ausgabe ............................................................................................... 73 Buttons (Programmsteuerungen) ....................................................... 74 Der Programmcode zum Algorithmus................................................ 75 Größere Benutzerfreundlichkeit ......................................................... 81 Standardsteuerelemente ................................................................. 85 Das Formular Form ............................................................................. 85 Aufgabe ............................................................................................... 87 Lösung................................................................................................. 87 Das Textelement Label........................................................................ 88 Aufgabe ............................................................................................... 88 Lösung................................................................................................. 88 Die Schaltfläche Button ...................................................................... 89 Aufgabe ............................................................................................... 89 Lösung................................................................................................. 90 Das Texteingabeelement TextBox ...................................................... 92 Aufgabe ............................................................................................... 92 Lösung................................................................................................. 93 Das Bildfeldsteuerelement PictureBox................................................ 93 Das Anzeigesteuerelement Image ....................................................... 95 Das Rahmensteuerelement Frame ...................................................... 95 Das Kontrollkästchen CheckBox ........................................................ 96 Aufgabe ............................................................................................... 97 Lösung................................................................................................. 97
4.9
4.10
4.11
4.12
4.13
4.14
4.15 4.16 4.17 4.18
4.19
4.20
5 5.1 5.2 5.3 5.4 5.5 5.6
Das Optionsfeld OptionButton ........................................................... 98 Aufgabe................................................................................................ 99 Lösung ................................................................................................. 99 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 Das Kombinationsfeld Combobox.................................................... 102 Aufgabe.............................................................................................. 103 Lösung ............................................................................................... 103 Die Bildlaufleisten ScrollBar .............................................................. 104 Aufgabe.............................................................................................. 105 Lösung ............................................................................................... 105 Das Datei-, Verzeichnis- und Laufwerklistenfeld .............................. 105 Aufgabe.............................................................................................. 106 Lösung ............................................................................................... 106 Der Zeitgeber Timer........................................................................... 108 Aufgabe.............................................................................................. 109 Lösung ............................................................................................... 109 Das Liniensteuerelement Linie.......................................................... 111 Das Figurensteuerelement Shape ...................................................... 111 Beispiel zum Figurensteuerelement Shape ........................................ 111 Hinzufügen weiterer Steuerelemente ................................................ 115 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 Das Registerblättersteuerelement SSTab............................................ 124 Aufgabe.............................................................................................. 125 Lösung ............................................................................................... 125 Das MDI-Formular............................................................................. 125 Aufgabe.............................................................................................. 126 Lösung ............................................................................................... 126 Wichtige Eigenschaften der Steuerelemente............................... 129 Die Eigenschaft (Name)..................................................................... 130 Die Eigenschaft Appearance .............................................................. 130 Die Eigenschaft Caption.................................................................... 130 Die Eigenschaft Cancel...................................................................... 131 Die Eigenschaft Default..................................................................... 131 Die Eigenschaft Enabled.................................................................... 132 Hintergrund- und Vordergrundfarbe ................................................ 132
7
5.7 5.8 5.9 5.10 5.11 5.12 5.13 5.14
Die Eigenschaft MousePointer.......................................................... 133 Die Eigenschaft TabIndex ................................................................. 134 Die Eigenschaft TabStop ................................................................... 134 Die Eigenschaft Tag .......................................................................... 134 Die Eigenschaft Text ......................................................................... 134 Die Eigenschaft ToolTipText ............................................................ 135 Die Eigenschaft Visible ..................................................................... 135 Die Eigenschaft WindowState .......................................................... 135
6 6.1 6.2 6.3 6.4 6.5
Wichtige Ereignisse der Steuerelemente ...................................... 137 Click – der einfache Mausklick ......................................................... 138 Der doppelte Mausklick: DblClick.................................................... 138 Das Laden eines Formulars durch Load............................................ 138 GotFocus ........................................................................................... 139 KeyDown und KeyUp – Drücken und Loslassen einer Tastaturtaste...................................................................................... 140 Drücken und Loslassen einer Maustaste mit MouseDown und MouseUp ................................................................................... 140 Mit MouseMove die Maus über ein Steuerelement bewegen........... 141 Beispiel zum Ereignis MouseMove ................................................... 142 Den Fokus verlieren: LostFocus ........................................................ 145
6.6 6.7 6.8 7 7.1
7.2 7.3
Fehlerbehandlung in Visual Basic ............................................... 147 Vorgehensweise beim Auftreten eines Laufzeitfehlers ..................... 147 Der Befehl On Error .......................................................................... 148 Der Befehl Error ................................................................................ 151 Ein Programm zum Erstellen der Fehlercodetabelle......................... 151 Die Fehlercodetabelle........................................................................ 153
8
Meldungen anzeigen .................................................................... 157
9 9.1
Grafikprogrammierung ................................................................ 161 Grundlagen zur Grafikausgabe ......................................................... 161 Farben ............................................................................................... 161 Die Line-Methode ............................................................................. 162 Die Methode Circle........................................................................... 164 Grafische Beispiele ............................................................................ 165 RGB-Farbenbeispiel ........................................................................... 165 Chaos auf dem Bildschirm – das „fraktale Apfelmännchen“........... 169
9.2
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 12.1 12.2 12.3 12.4 12.5
Entwicklung einer komplexen Applikation ............................... 181 Beschreibung des Programms „Stack-Taschenrechner“.................... 181 Planung des Projekts ......................................................................... 182 Die verwendeten Steuerelemente und ihre Eigenschaften ............... 183 Programmglobale Definitionen ........................................................ 184 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 Die Programmoberfläche .................................................................. 268 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 Die Programmoberfläche .................................................................. 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 16.1 16.2 16.3 16.4 16.5 16.6
16.7
16.8
Das Erstellen eines Hilfesystems .................................................. 295 Was ist kontextsensitive Hilfe? ......................................................... 296 Grundlegende Begriffe für das Erstellen einer Hilfedatei.................. 296 Der Hilfecompiler HCW .................................................................... 297 Die Installation des HelpCompilers .................................................. 298 Die Formatierungen des Hilfetexts.................................................... 300 Erstellen einer Hilfedatei ................................................................... 301 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 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 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 A.1 A.2
Anhang.......................................................................................... 351 Inhalt der Diskette............................................................................. 351 Standardbefehle................................................................................. 353
11
12
A.3 A.4 A.5
Glossar............................................................................................... 355 Von Visual Basic 5.0 verwendete Dateitypen................................... 357 Zeichentabellen................................................................................. 358
S
Stichwortverzeichnis .................................................................... 363
V
Vorwort
Es gibt eine Vielzahl von Programmiersprachen, doch finden sie nur selten eine so starke Verbreitung wie Visual Basic. Warum gerade Visual 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 erfreut 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 sollen einfache Programmbeispiele den Umgang mit Visual Basic 6.0 erklären und das Grundverständnis für das Programmieren unter Windows vermitteln. Visual Basic 6.0 hat sein Aussehen gegenüber der Version 5.0 nur geringfügig verändert. In den Versionen bis 4.0 waren alle Module in eigenen Fenstern untergebracht. Seit der Version 5.0 sind aber alle Module 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 Design 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 Prozessor 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) erzeugt werden. Der Anwender merkt bei der Bedienung keinen direkten 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 objektorientiert 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 objektorientierte Programmierung in Visual Basic ließe sich leicht ein eigenes Buch schreiben. (Für den fortgeschrittenen Visual Basic-Programmierer 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 anhand 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 Programmierung sowie grundlegende Programmstrukturen ausführlich erläutert. Ebenso wird der Umgang mit der grafischen Oberfläche von Visual 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 wollen. 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 findet. 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 Bedeutung 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 werden 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 aufgelistet 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. Beginnt das System nicht automatisch mit der Installation, kann die Installation manuell gestartet werden. Hierfür wählen sie aus der Startleiste 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 Laufwerks, 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 erscheint der Bildschirm aus Abbildung 1.2.
17
Abbildung 1.2: Der Installationsbildschirm
Hier können Sie sich über die Schaltfläche INFO-DATEI ANZEIGEN weitere Information, über die neue Entwicklungsumgebung im InternetBrowser 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 Festplatte 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 Installation 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 finden Sie auf der Rückseite der CD-Hülle, der Sie die Installationsdiskette entnommen haben. Mit Betätigen der Schaltfläche WEITER wird wieder ein neues Fenster angezeigt. Wenn auf Ihrem Rechner Komponenten von Visual Studio 97 installiert 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 behindern. Mit WEITER wird nun der Installationsschritt für die Art der Installation von Visual Basic aktiviert. Im allgemeinen kann die voreingestellte Option VISUAL BASIC 6.0 ... INSTALLIEREN übernommen werden. Jetzt wird das eigentliche Installationsprogramm von Visual Basic gestartet. Bis zu diesem Zeitpunkt hatten Sie es lediglich mit der Installationssoftware 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 verlangt. Es muß festgelegt werden, auf welche Art die Installation durchgeführt und wohin die Entwicklungsumgebung installiert werden soll. Im folgenden werden die einzelnen Installationsoptionen beschrieben. Standard Visual Basic 6.0 wird mit den Einstellungen installiert, die für die meisten Fälle ausreichend sind. Ich empfehle diese Installationsart, da zum Erlernen einer Programmiersprache die Standardeinstellungen völlig ausreichend sind. Wenn bei der Programmierung weitere Optionen oder Programmteile benötigt werden, läßt sich die Installation jederzeit anpassen und erweitern. Benutzerdefiniert Bei der benutzerdefinierten Installation müssen Sie selbst die zu installierenden Optionen festlegen, d. h. Sie geben an, welche Optionen Sie brauchen und welche nicht. Da beim Erlernen einer Programmiersprache meist nur selten Kenntnisse über die Bedeutung der einzelnen Module 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 allgemeinen ein Verzeichnis auf dem Laufwerk vorgeschlagen, auf dem sich auch das Betriebssystem befindet. Ich empfehle für den Anfang die Option STANDARDINSTALLATION auszuwählen, da mit ihrer Hilfe alle wichtigen Elemente installiert werden. Der Vollständigkeit halber werde ich aber noch auf die BENUTZERDEFINIERTE INSTALLATION eingehen. Wenn sie die Option BENUTZERDEFINIERTE INSTALLATION gewählt haben, erscheint als nächstes Fenster ein Auswahldialog, in dem die verschiedenen 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 kleinere 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ästchen mit dem Haken grau eingefärbt. Wenn aus einer Gruppe kein Modul installiert werden soll, so ist das Kästchen vor der entsprechenden 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 ÄNDERN... das Fenster angezeigt, das die selektierten Module auflistet. Mit der Schaltfläche ALLE AUSWÄHLEN werden alle Optionen mit den jeweiligen Modulen markiert und dann auch installiert. Voreingestellt sind die Module, die bei der Standardinstallation auf die Festplatte kopiert werden. Jetzt beginnt der eigentliche Installationsvorgang. Die Zeit, die für das Kopieren und Konfigurieren der Entwicklungsumgebung gebraucht wird, hängt jetzt nur noch von der Computerhardware 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 Prozessor.
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
CD-ROM-Laufwerk
Monitor
17"-Monitor mit einer Auflösung von 1024x768 Bildpunkten.
Maus
1.1.2
22
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.
serielle oder entsprechend kompatible Maus.
Betriebssystem
Microsoft Windows 95 oder höher.
Microsoft Windows NT Workstation Version 4.0 (mit Service Pack 3).
2
2.1
Einführung in die Entwicklungsumgebung
Starten von Visual Basic 6.0
Nach der Installation von Visual Basic 6.0 befindet sich ein neuer Menüeintrag unter START x PROGRAMME. Wenn der Eintrag, der vom Installationsprogramm 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 Installationsart 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 Auswahlfenster, in dem festgelegt werden muß, welche Art von Applikation entwickelt werden soll. In diesem Buch werden jedoch nur StandardEXE-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 gestellt (Abbildung 2.2). Beim ersten Starten des Programms werden automatisch die Menüleiste, das Projektfenster, die Toolbox und eine leere Form angezeigt, nachdem im Abfragefenster die Option Standard-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 Variablen, doch kann es zu Kommunikationsproblemen kommen, wenn Visual Basic an andere Applikationen angebunden wird. Unter Umstä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 dokumentiert (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 allerdings 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 Programmbeschreibung 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 Zeichen haben keinen Einfluß mehr auf das Programm und werden somit auch nicht mehr berücksichtigt. Nach diesen Kommentarzeichen 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 verteilen. Um Visual Basic mitzuteilen, daß eine Befehlszeile umgebrochen wird, muß ein Unterstrich „_“, dem ein Leerzeichen vorangeht, an die Befehlszeile angehängt werden. Das Beispiel in Tabelle 2.1 verdeutlicht dies: Die beiden Programmzeilen sind zwar identisch, die Programmzeile im linken Fenster ist jedoch 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 Eingabe durch Benutzer zuständig. Sie werden auf Formulare aufgebracht und gestalten somit das Aussehen der Programmfenster. Wichtige Steuerelemente sind z.B. Schaltflächen und Listenelemente.
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 bleiben, 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 aneinandergereihter 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 10 20 30 40 41 42 43 45
Clr For I=3 To 10 If I<5 Then Goto 42 Next I I=20 Goto 45 Print I Goto 30 Print I
Abbildung 2.4: Ein altes BASIC-Programmlisting
Mit dem Befehl Goto kann man direkt zu einer beliebigen Zeile im Programm springen. Auch Visual Basic kennt diesen Befehl; jedoch gilt es allgemein als unschöner Programmierstil, wenn dieser Befehl verwendet 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 zusammengefaß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 Programmzeilen enthalten. Vielmehr ist es besser, eine sehr lange Funktion oder Prozedur in mehrere Bestandteile zu unterteilen. Eine lange Funktion
Aufteilung in einzelne Funktionen
Function Lang Dim I As Integer 'prüfe jedes Zeichen 'ist Leerzeichen dann 'lösche es 'Ende Prüfen 'prüfe jedes Zeichen 'ist es Kleinbuchst. 'Umw. Großbuchst. 'Ende Prüfen 'Vergleiche alle Zeichen 'Ende Vergleich End Function
Function Kurz Dim I As Integer Funktion: 'Entferne Leerzeichen Funktion: 'Wandele alle Klein- in 'Großbuchstaben um Funktion: 'Prüfe, ob alle Zeichen 'gleich sind 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 gesamte Programmcode in kleinere Funktionen ausgelagert wurde, wie ein Programm in Pseudocode lesen. Der Code wirkt eher umgangssprachlich. Heißt eine Funktion z. B. Selektiere_Anwender, läßt sich schon zumeist aus dem Kontext erkennen, was diese Funktion macht. Der Entwickler 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 einzelne Funktionen, die im Rahmen großer Funktionen entstanden sind, wieder von anderen Funktionen und Prozeduren aufrufen. Somit wird auch der redundante Code reduziert.
! "
27
2.3.7
Variablenbenennung
Eine weitere Verdeutlichung des Programmcodes bringt die Verwendung 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 Zwischenspeicher in einem Programmteil gelten, könnte man sie auch Zwischenspeicher 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 konfiguriert werden. Unterhalb der Menüleiste befindet sich die Symbolleiste, mit deren Symbole sich einige Funktionen wie z. B. Programm starten, Programm anhalten und Programm beenden direkt ausführen lassen.
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 Programme benötigt werden. In diesem Fenster werden drei Sorten von Dateien dargestellt. Dateityp
Dateiendung
Beschreibung
Formulare
*.FRM
Enthalten die Steuerelemente und den dazugehörigen Programmcode. 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 Anwendungen 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 bekannt ist (Form1). Diese Angaben können bei jeder Datei geändert werden. Aber Vorsicht: Wenn ein Modul auf ein anderes Modul über den rechten Namen zugreift und dieser geändert wird, schlägt dieser Aufruf bei einem erneuten Programmstart fehl.
# $
29
2.4.3
Das Werkzeugfenster Toolbox
In diesem Werkzeugfenster werden die Steuerelemente von Visual Basic dargestellt, die auf eine Form aufgebracht werden können. Ein Steuerelement läßt sich wie folgt auf ein Formular einfügen und bewegen: 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 positioniert werden. 6. Ein Steuerelement wird auf einem Formular verschoben, in dem
der Mauszeiger über das Steuerelement bewegt wird. Durch drükken und gedrückthalten der linken Maustaste folgt das Steuerelement 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ählten Steuerelements oder des aktiven Formulars. Mit Hilfe des Eigenschaftsfensters lassen sich alle Eigenschaften des zugehörigen Elements einstellen. So können etwa der Name, die Farbe und das Aussehen eines Steuerelements voreingestellt werden. Ein Teil der Eigenschaften kann auch noch während der Ausführung des Programms 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 Programmcode der einzelnen Formulare und Programmdateien (BasFiles) erstellt und bearbeitet. In der ListBox Object (linke obere ListBox 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 Steuerelements, zu dem der Programmcode gehört.
2.4.6
Der Debugger
Um jede Anweisung des Programms während der Ausführung einzeln zu überprüfen – z. B. ob richtig gerechnet oder an der richtigen Stelle verzweigt wird –, gibt es den sogenannten Debugger. Er ermöglicht, den Inhalt einer Variablen oder den Programmablauf zu kontrollieren, 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 vorgestellten 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 bestanden. Diese Relais schalteten über ein Magnetfeld einen mechanischen Kontakt. Wenn sich nun in so einem Kontakt eine Motte verklemmt 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, wobei 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 Cursorposition zu setzen. Das Programm kann nun gestartet werden. Beim Erreichen 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 Debugfenster (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 werden 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 geschrieben. 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 Betä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 Steuerelement 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 Dateien benötigt werden. Neues Projekt erstellen oder ein bestehendes öffnen (Strg)+(N) (Strg)+(O)
Mit diesen Optionen erstellen Sie ein neues Visual Basic-Projekt oder ö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 Entwicklungsumgebung entfernt werden.
34
Projekt speichern/speichern unter Um ein Projekt zu speichern, gibt es den Menüeintrag PROJEKT SPEICHERN. 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.
speichern/Speichern von unter
(Strg)+(S)
Diese Option ist gleichbedeutend mit PROJEKT SPEICHERN/SPEICHERN gilt jedoch nur für die aktuelle Datei des aktiven Projekts der Entwicklungsumgebung.
UNTER,
(Strg)+(P)
Drucken/Druckereinrichtung Mit dem Menübefehl DRUCKEN können die im Projekt enthaltenen Programmteile gedruckt werden. Für die einzelnen Druckereinstellungen steht das Menü DRUCKEREINRICHTUNG zur Verfügung. erstellen Mit diesem Menüpunkt wird eine ausführbare Programmdatei erzeugt, 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.
(Alt)+(Q)
Beenden 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
(Strg)+(Z)
Das Bearbeiten-Menü
Rückgängig/Wiederholen Mit der Option RÜCKGÄNGIG können die Änderungen nach dem letzten Speichern wieder rückgängig gemacht werden. Wurden zu viele Schritte rückgängig gemacht, lassen sie sich mit WIEDERHOLEN wiederherstellen.
(Strg)+(X)
Ausschneiden/Kopieren Diese Option kopiert den markierten Bereich in die Zwischenablage. Bei dem Menübefehl AUSSCHNEIDEN wird der markierte Bereich gelö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 aktuellen 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
(F3) (Strg)+(H)
(ÿ)
Diese Befehle verwenden Sie, um nach einer bestimmten Textstelle im angegebenen Bereich zu suchen. Bei den Menüeinträgen SUCHEN und ERSETZEN müssen die zu suchenden Textstellen definiert werden, bei WEITERSUCHEN werden die zuletzt mit SUCHEN oder ERSETZEN definierten 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 Textanfangs zum linken Rand. Dies wird benötigt, um eine bessere Übersichtlichkeit im Programmcode zu erhalten.
(ª)+(ÿ)
36
Datei einfügen Mit diesem Befehl fügen Sie eine Datei in das aktuelle Projekt ein. (Strg)+(J)
Eigenschaften/Methoden anzeigen 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. (Strg)+(ª)+(J)
Konstanten anzeigen Mit diesem Befehl werden Ihnen alle Konstanten angezeigt, die für die Eigenschaften gültig bzw. erlaubt sind, die links vom Gleichheitszeichen (=) stehen.
Mit den Tasten (½) und (¼) kann die Liste durchsucht werden.
Mit (¢) oder einem Doppelklick wird der Eintrag ausgewählt. (Strg)+(I)
QuickInfo Diese Option zeigt die gesamte Syntax des aktuellen Elements an und markiert den aktuellen Parameter durch Fettschrift.
(Strg)+(ª)+(I)
Parameterinfo Um Informationen zum aktuellen Parameter einer Funktion oder einer Anweisung zu erhalten, wählen Sie diese Option.
(Strg)+
Wort vervollständigen
(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 Objekt an. (ª)+(F7)
Objekt Dieser Befehl ist nur zur Entwurfszeit verfügbar. Wenn sich der Cursor 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 Einfügemarke steht.
(Strg)+(ª)+(F2)
Letzte Position Damit wechseln Sie an die Position im Code, an der die letzte Änderung durchgeführt wurde.
(F2)
Objektkatalog Hiermit erhalten Sie Zugang zum Objektkatalog mit den Objektbibliotheken, Klassenbibliotheken, Klassen, Methoden, Eigenschaften, Ereignissen und Konstanten, die im Code verwendet werden können. 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, Funktionsaufrufe, Variablenwerte und Eigenschaften geändert und kontrolliert werden. Das Direktfenster dient zur Unterstützung bei der Fehlerbeseitigung 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 Änderung des Prozedurkontextes automatisch aktualisiert. Überwachungsfenster Mit dieser Option werden das Überwachungsfenster und die aktuellen Überwachungsausdrücke angezeigt. Das Überwachungsfenster wird automatisch angezeigt, wenn Überwachungsausdrücke im Projekt definiert sind. (Strg)+(L)
Aufrufliste Hiermit wird das Dialogfeld AUFRUFE angezeigt. Beim Programmablauf 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 solange in die Liste aufgenommen, bis das Programm wieder zu der aufrufenden Prozedur zurückkehrt.
(Strg)+(G)
Projekt-Explorer Diese Option präsentiert Ihnen eine hierarchische Liste aller geöffneten Projekte einschließlich ihrer Inhalte. Mit dem Projekt-Explorer bewegen Sie sich innerhalb der Projekte und verwalten diese. Sie können hier jedoch keine Anwendungen erstellen, sondern nur entfernen.
(F4)
Eigenschaftsfenster 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 einnimmt.
# $
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 Steuerelementen oder Formularen verändert werden können. Symbolleisten Damit können Sie alle in Visual Basic zur Verfügung stehenden Symbolleisten 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 aktuellen 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 aktuellen Projekt hinzu.
40
Benutzersteuerelement hinzufügen Damit fügen Sie ein neues oder ein existierendes Steuerelement dem aktuellen Projekt hinzu. 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. (Strg)+(D)
Datei hinzufügen 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. Handelt 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 werden, daß kein verbleibendes Element mehr das zu entfernende Element benötigt. Visual Basic prüft diese Abhängigkeit nicht.
# $
41
Verweise Mit diesem Befehl können Verweise auf Objektbibliotheken, Klassenbibliotheken oder auf ein Projekt aus anderen Projekten eingerichtet werden, die dann ebenfalls dem aktuellen Projekt zur Verfügung stehen. Die Projekte, auf die ein Verweis erzeugt wurde, werden im Objektkatalog 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 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 zwischen 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ü (F8)
Einzelschritt 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. Befindet sich das Programm im Design- und nicht im Haltemodus, wird das Programm gestartet.
(ª)+(F8)
Prozedurschritt Dieser Befehl führt die aktuelle Programmzeile aus, jedoch ohne in die Prozeduren, die in der Programmzeile enthalten sind, zu verzweigen. Ist das Programm im Designmodus und nicht im Haltemodus, wird das Programm gestartet.
(Strg)+(ª)+(F8)
Prozedur abschließen Dieser nur im Haltemodus verfügbare Befehl führt die gesamte Prozedur 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. Sobald 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 ausschließ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 entfernt.
(Strg)(ª)(F9)
Alle Haltepunkte löschen Dieser Befehl löscht alle Haltepunkte, die mit dem Menübefehl HALTEPUNKTE 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 festgelegt werden. Danach wird der Programmcode wieder sequentiell abgearbeitet.
44
Nächste Anweisung anzeigen Markieren Sie hiermit die nächste auszuführende Anweisung. Der Befehl wird verwendet, um den Cursor in der Zeile zu positionieren, die als nächste ausgeführt wird.
2.4.16
Das Ausführen-Menü (F5)
Starten Dieser Befehl dient der Ausführung des aktuellen Projekts in der Entwicklungsumgebung. Starten, vollständige Kompilierung
(Strg)(F5)
Hierdurch wird ebenfalls das aktuelle Projekt in der Entwicklungsumgebung ausgeführt. Zusätzlich wird aber gleichzeitig eine ausführbare Datei erzeugt. (Strg)(Untbr)
Unterbrechen 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 Designmodus gewechselt.
(ª)(F5)
Neu starten 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 eingefü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 Menüs im aktuellen Formular zu öffnen. Optionen Hier können die Einstellungen für die folgenden Visual Basic-Komponenten vorgenommen und an die persönlichen Bedürfnisse angepaß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üpunkte PROGRAMME | VISUAL BASIC 6.0 kann durch Anklicken von VISUAL 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 Entwicklungsumgebung 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 enthält ein leeres Formularfenster, da bis zu diesem Zeitpunkt noch keine Programmierung erfolgt ist.
Ein Programm ohne Programmieraufwand
47
Dennoch ist das Programm in diesem Stadium bereits leistungsfähig. Das Fenster kann vergrößert oder verkleinert, auf der Oberfläche verschoben und sogar beendet werden; es entspricht dem WindowsStandard. Die genannten Befehle können durch Anklicken des Symbols 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 Konstanten. 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 ansprechbare 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 Eigenwert dagegen sehr wohl. Variablen werden benötigt, um z.B. Ergebnisse 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 VARIABLENDEKLARATION ERFORDERLICH zu aktivieren, damit grundsätzlich alle Variablen deklariert werden müssen. Ansonsten können Programmfehler entstehen, deren Ursachen nur sehr schwer zu finden sind (Tabelle 3.1). Das folgende Beispiel soll die Summe aller Zahlen von 1 bis 100 addieren 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 Variablentyp (Zeichenkette, Zahl usw.) es sich handelt.
48
Programm
richtig
falsch
function Summe(Zahl as integer) as integer
function Summe(Zahl as integer) as integer
dim i as integer dim Erg as integer
dim i as integer dim Erg as integer
Erg = Erg + i for i = 0 to Zahl Erg = Erg + i next i Summe = Erg end Function
Erg = Erk + i for i = 0 to Zahl Erg = Erk + i next i Summe = Erg 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 Variablen 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 Fehler relativ einfach zu lokalisieren. In sehr umfangreichen Programmen 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 Variablentypen zur Verfügung: Typ
Wertebereich
Beschreibung
Byte
0 bis 255
Byte sind ganze Zahlen, die hauptsächlich bei Berechnungen und Ausgaben verwendet werden, die aus den ASCII-Werten einzelner Zeichen aus dem ASCIIZeichensatz bestehen (siehe Anhang).
1 Byte
Boolean
True, False 2 Byte
Signalisiert den Zustand Boolscher Ausdrücke oder Variablen. Achtung: In Visual Basic entspricht der Wert -1 dem Zustand True/Wahr und der Wert 0 dem Zustand False/ Falsch.
Integer
–32768 bis +32767 2 Byte
Die Variablentypen Integer und Long sind GanzzahlVariablentypen. Sie werden dort eingesetzt, wo keine Nachkommastellen benötigt werden.
49
Typ
Wertebereich
Beschreibung
Long
–2`147`483`648 bis 2`147`483`647
Die beiden Variablentypen unterscheiden sich darin, daß der Wertebereich von Long deutlich größer als der von Integer ist. Eine Variable vom Typ Long nimmt im Vergleich zu einer vom Typ Integer auch doppelt soviel Speicherplatz ein.
4 Byte
Single
Im negativen Bereich: 3`3,402823*1038 bis – 1.401298*10–45 Im positiven Bereich: 1,401298*10–45 bis
Single und Double sind Fließkommazahlen, die sich darin unterscheiden, daß Double einen weitaus größeren Wertebereich hat als Single, allerdings doppelt soviel Speicher benötigt wie eine Variable vom Typ Single. Diese Variablentypen werden bei Berechnungen eingesetzt, die 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 bis 922`337`203`685`477.5807
Currency ist eine Mischung aus einer Ganz- und einer Fließkommazahl. Damit lassen sich Berechnungen bis zur vierten Stelle nach dem Komma durchführen.
8 Byte Date
Datum 1. Januar 100 bis 31. Dezember 9999
Wird benutzt für Datums- und Uhrzeitangaben, wobei die im Wertebereich angegebenen Begrenzungen gelten.
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 ASCIITabellen 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: 16 Byte
Variant ist ein Default-Variablentyp, der jeden beliebigen Typ aus der obigen Tabelle annehmen kann. Variablen werden automatisch konvertiert. Dieser Variablentyp wird dort eingesetzt, wo sich der Typ einer Variable bei der Programmausführung ändern kann.
Bei Zeichenketten: 22 Byte + 2 Byte pro Zeichen
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 Variablen festzulegen. In Tabelle 3.4 sind Zeichen aufgelistet, die eine Variable 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 vorgestellten 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 Einfachheit dieser Variablentypen veranschaulichen. Es soll eine Funktion geschrieben werden, die das Quadrat einer Variablen 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 explizite 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 Variablentyp 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 Quadrats einer Kommazahl im zweiten Beispiel falsch, denn bei der Übergabe der Variablen an die Funktion Quadrat wird der Nachkommateil einfach abgeschnitten.
3.2.3
Konstanten
Konstanten bestehen wie die Variablen aus zwei Einheiten, dem Konstantennamen 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 Programmierung 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 Const Const Const
Maximum = 181 Maximum As Long = 181 Maximum As Double = 181 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 Versionsnummer. 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 werden
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 einen Datentyp, so ist die Zeichenkette vom Typ String ein Feld von Zeichen. 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 Anwendung in der Vektorrechnung. Statische Felder Wenn die Größe eines Feldes konstant bleibt, spricht man von statischen Feldern. Der Inhalt der einzelnen Feldvariablen kann jederzeit geändert werden, aber die Anzahl der Felder, die zu der Variablen gehören, ist konstant. Im folgenden wird eine Variable Woche deklariert, 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 aneinandergereiht, und jeder Position ist eine eindeutige Nummer zugeordnet. Folgende Programmzeile weist einer Variablen den dritten Wochentag, den Dienstag, zu: Dim Tag As String Tag = Woche(3)
55
Wenn zur Programmierzeit der Inhalt der Variablen noch nicht bekannt 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ändert 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 eindeutig 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 (Abbildung 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 vorzustellen. 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 Indexbereich 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, bekannt 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 Felddeklaration 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 Variablen erfolgt über den Befehl ReDim. Er wird wie der Befehl Dim zur Felddeklaration verwendet, jedoch immer ohne Variablentyp. ReDim ReDim ReDim ReDim
Vektor(10) Matrix(4, 3) Hyper(2, 2, 2, 2, 2, 2, 2, 2) Hyper(2, 2, 2, 2, 2, 2, 2, 2) As Integer 'Ist nicht möglich
Die Feldvariable Vektor ist ein eindimensionales Feld mit zehn Elementen 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 achtdimensionale 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 Dimensionierung 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 beschriebenen Beispiele verwiesen). Dim Feld() ... ReDim Feld(3) ... ReDim Feld(5)
'Deklaration der Variablen 'Erstes Festlegen der Feldgröße '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 Dimensionen. Die folgende Programmzeile erzeugt aus dem dynamischen Feld Dim Feld()
'Deklaration der Variablen
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 Inhalt 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: Dim Feld() 'Deklaration der Variablen ... 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 Basic 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 Variablentyp 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 ermitteln, 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 werden. 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 Feld(1) = 3.1415 Debug.Print Feld(0) Debug.Print "PI = " ... Feld(1) = Feld(1) * Feld(0) = Feld(0) & Debug.Print Feld(0) Debug.Print "2 * PI
eine Zeichenkette"
& Feld(1) 2 " die verlängert wurde" = " & 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 Variablentypen 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 Koordinatensystem mit zwei Achsen die Position eines Punkts genau festzulegen, sind zwei Angaben notwendig: die x-Koordinate und die y-Koordinate (siehe Abbildunb 3.9).
Abbildung 3.9: Ein Punkt in einem Koordinatensystem
62
Im folgenden wird der Datentyp Koordinate für ein zweidimensionales 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 Datentypkomponenten 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 berechnet 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 Schrittweite 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 Ausdruck 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 WhileSchleife immer mindestens einmal durchlaufen, da erst am Ende der
64
Schleife eine Überprüfung auf weitere Durchläufe erfolgt. Die einfachste 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-Entscheidungen 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 Entscheidung, da sie nur zwischen zwei Zuständen unterscheiden kann: Entweder ist der Ausdruck wahr, oder er ist falsch. Die Syntax einer solchen 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-Entscheidungen 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 Entscheidungsspielrä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ühren 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 Case 2: Wochentag Case 3: Wochentag Case 4: Wochentag Case 5: Wochentag Case 6: Wochentag Case 7: Wochentag Case ELSE Wochentag End Select
3.2.8
= "Sonntag" = "Montag" = "Dienstag" = "Mittwoch" = "Donnerstag" = "Freitag" = "Samstag" = "Falsche Eingabe"
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ückgeben, 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 aufzurufende 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 Methode Call-by-Value übergeben werden, muß dies explizit bei der Deklaration 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 deren Speicheradresse. Wird der Inhalt der Variablen in der aufgerufenen Funktion oder Prozedur geändert, so ändert sich auch der Inhalt der Variablen in der aufrufenden Funktion. Durch diese Art der Parameterübergabe ist es nun möglich, daß eine Funktion mehrere verschiedene 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 Callby-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 aufrufenden 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 nochmals anhand der einzelnen Programmschritte verdeutlicht.
69
Call-by-Value
Call-by-Reference
Schritt 1: Initialisierung
Zahl = 4
Zahl = 4
Schritt 2: Aufruf der Fakultätsfunktion
Erg = Fakultaet(Zahl)
Erg = Fakultaet(Zahl)
Variableninhalte nach dem Zurückkehren aus der Fakultätsfunktion
Erg = 24 Zahl = 4
Erg = 24 Zahl = 24
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 Methode 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 aufgerufene 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 ungeraden Ziffern als auch die Anzahl der Stellen ermittelt. Wird dieser Algorithmus oft genug ausgeführt, so lautet das Endergebnis immer 123. Theoretisches Beispiel mit den Zahlen 3 und 12345
Beispiel 1
Beispiel 2
Zahl
gerade Ziffern
ungerade Ziffern
Anzahl Stellen
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
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 werden 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 Eigenschaft Name in Zahlenloch.
Abbildung 3.10: Ein leeres Formularfenster
Wenn man mit der linken Maustaste auf dem Formular einen Doppelklick ausführt, gelangt man in den Programmeditor von Visual Basic. Jede Funktion oder Prozedur kann nun wiederum eine andere Funktion oder Prozedur aufrufen.
Entwickeln einer ersten Applikation mit Visual Basic 6.0
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 Programmeditorfenster 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 End Sub
Version 1.0"
71
Abbildung 3.11: Programmeditor nach dem Doppelklick auf das Formularfenster
Wird das Programm nun nochmals gestartet, erscheint der eingegebene Satz in der Titelleiste des Fensters. Des weiteren hat das Fenster Eigenschaften wie z.B. einen Namen, Aussehen usw. Diese Eigenschaften lassen sich im Eigenschaftenfenster einstellen. In dem Beispiel „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 Programmstart in der Funktion Form_Load initialisiert, sie braucht also nicht geändert zu werden. Um zu zeigen, daß diese Eigenschaft keinen Einfluß auf das Programmfenster hat, kann der voreingestellte Eintrag FORM1 gelöscht werden.
3.3.1 Die Dateneingabe in das Programm Zahlenloch
Eingabe
Für das Beispiel wird eine Eingabemöglichkeit benötigt, um die zu berechnende Zahl frei wählen zu können. Zur Eingabe von Daten über 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 Texteingabeelements auf dem Formular festgelegt. Die Größe des Steuerelements kann durch Ziehen mit gedrückter linker Maustaste definiert 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 ermittelten Daten dem Benutzer dargestellt werden. Es gibt dazu 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 Entscheidung zwischen verschiedenen Steuerelementen zu verdeutlichen. Label
TextBox
ListBox
Ausgabe von Text möglich
Ja
Ja
Ja
Eingabe von Text während des Programmablaufs möglich
Nein
Ja
Nein
Ausgabe von mehreren Zeilen Text möglich (Möglichkeit zum Verschieben des sichtbaren Textes mittels Bildlaufleiste)
Nein
Nein
Ja
Ausgabe des Programmergebnisses
Tabelle 3.11: Vergleich von drei Ausgabe-Steuerelementen
Wie Tabelle 3.11 zeigt, ist es nicht eindeutig, wie viele Schritte notwendig sind, um das Ziel zu erreichen. Es ist aber dennoch sinnvoll, alle Zwischenergebnisse dem Benutzer auszugeben, damit er die Berechnung nachvollziehen kann. Aus der Vergleichstabelle (Tabelle 3.11) ist ersichtlich, daß nur die ListBox mehrere Datenzeilen ausgeben 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 positioniert 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 definiert werden. Die Eigenschaft Name erhält die Definition Wertigkeit.
73
3.3.3 Ausführen von Programmodulen
Buttons (Programmsteuerungen)
Um in einem Programm einen bestimmten Programmteil zu starten, 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 Eigenschaft 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 einmal benutzt wird, da sonst nicht eindeutig definiert werden kann, welche Funktion als erste ausgeführt wird. Um auch dieses Beispielprogramm 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 Zeichenkette &Beenden. Wenn das Programm neu gestartet wird, können beide Buttons betätigt werden. Dennoch geschieht nichts. Weder wird eine Fehlermeldung 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ÜHREN | BEENDEN benutzt werden. Als erstes wird der Button ABBRECHEN programmiert. Durch Doppelklick 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 konkreten 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. Im folgenden Abschnitt soll diese Funktion programmiert werden. Zum besseren Verständnis wird der Programmablauf zuerst in einem Pseudocode entwickelt und danach mit der jeweiligen Erklärung in einen richtigen Visual Basic-Programmcode umgewandelt.
Entwickeln des Programmcodes auf der Basis des Vorgabealgorithmus
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 werden, ob es sich bei den eingegebenen Daten um eine erlaubte Zahl handelt. Wenn das zutrifft, wird diese Zahl einer Variablen zugewiesen und der Algorithmus zum Umwandeln der Zahl gestartet.
Vorbelegen der Variablen mit den Startwerten
75
Der folgende Programmcode führt die Zeile Initialisiere alle Variablen 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 Schleife bis zur Erfüllung des Abbruchkriteriums
Nachdem alle Variablen initialisiert wurden, muß die While-Schleife realisiert werden. Als Kriterium für die einzusetzende Schleife gilt folgendes: 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 Zusammenhang 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 abgearbeitet, bis das Abbruchkriterium der Schleife wahr ist. Der Bereich der While-Schleife des Pseudocodes stellt sich in Visual Basic 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 eine Zeichenkette umzuwandeln und jedes Zeichen (bzw. jede Ziffer) auf das Kriterium „gerade“ bzw. „ungerade“ zu überprüfen. Für die Umwandlung eines Variablentypen in einen anderen existieren folgende Funktionen:
Analysieren aller Ziffern der eingegebenen Zahl
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 Umwandlungsfunktion von String nach Integer benötigt, also die Funktion CInt. Es ist in diesem Fall nicht relevant, welche der drei Umwandlungsfunktionen 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 ForSchleife 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 Zeichen der Zeichenkette s zurückliefert. Der folgende Programmcode ermittelt die Anzahl der geraden und ungeraden Zahlen: Ungerade = 0 Gerade = 0
'Setze die Variablen zum Zählen der 'geraden '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 2
78
8 Modulo 2 = 0
Ermitteln des Ergebnisses und Berechnen der neuen Zahl An dieser Stelle des Programms sind alle drei Werte, die zur Berechnung der neuen Zahl benötigt werden, bekannt: die Anzahl der ungeraden und geraden Zahlen sowie – mit Hilfe der Funktion Len – die Anzahl der Ziffern der Ausgangszahl. Diese Daten bilden nun die neue Zahl. Die einzelnen Zahlen müssen jedoch nicht nach einem bestimmten Algorithmus addiert, sondern wie einzelne Zeichenketten aneinandergereiht werden.
Berechnen der neuen Zahl anhand der analysierten Ziffern der Ausgangszahl
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 Berechnungen über die Zwischenschritte nachvollziehbar. Die folgende Programmzeile 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-Programmcode 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 Abbildung 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 denen 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 Beispieltabelle auftreten.
3.3.5
Größere Benutzerfreundlichkeit
Bei vielen Programmen erhält man in Form einer sog. Statusleiste für die meisten Steuerelemente auf der Programmoberfläche eine schnelle Hilfe. In Visual Basic ist diese schnelle Hilfe recht einfach zu realisieren.
Erhöhen der Benutzerfreundlichkeit durch Einsatz einer Statuszeile
Als Statusleiste wird ein Steuerelement benötigt, das der Ausgabe dient, in dem aber keine Eingabe gemacht werden darf. Darüber hinaus ist es nicht möglich, mehrere Datensätze darzustellen. In der Tabelle 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 Aktivieren des Symbols im Werkzeugfenster und durch Festlegen der Position und Größe infolge von Anklicken und Ziehen des Steuerelements mit Hilfe der Maus erzeugt. Die Statusleiste läßt sich optisch hervorheben, indem bei der Eigenschaft BorderStyle die Option 1FestEinfach (Abbildung 3.15) eingestellt wird. Mit der Statusleiste wird erreicht, daß zu jedem Steuerelement eine Hilfetext ausgegeben werden kann, wenn der Mauszeiger über das jeweilige Steuerelement bewegt wird.
81
Fast jedes Steuerelement besitzt die Eigenschaft Tag, die keinen Einfluß auf das Steuerelement selbst hat. In dieser Eigenschaft kann zu jedem Steuerelement ein kurzer Beschreibungstext eingegeben werden. 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 Zeichenkette zugewiesen worden, da in der Statuszeile auch kein Hilfetext 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 ausgefü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 werden: Form Private Sub Form_MouseMove(Button As Integer, Shift As Integer, X As Single, 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 Single, Y As Single) Status.Caption = Zahl.Tag End Sub
83
4
Standardsteuerelemente
In diesem Kapitel wird ein kurzer Überblick über einen Teil der Steuerelemente gegeben, die von Visual Basic standardmäßig mitgeliefert werden. Mit kleinen Beispielprogrammen zu jedem Steuerelement werden dessen jeweiligen Aufgaben erklärt. Dabei wird auch auf die wichtigsten Funktionen und Eigenschaften der Steuerelemente eingegangen.
Elemente für die Programmsteuerung, Dateieingabe und -ausgabe sowie die Gestaltung der Formulare
Das entstandene Programm aus den Beispielen der Objekte Form, Button 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 gebraucht werden, aufgebracht. Sie sind die Fenster des Programms. Jedes Visual Basic-Programm benötigt mindestens ein Formular: das
85
Startformular. Ein Programm kann aber auch aus mehreren Formularen bestehen. Um für ein Formular den Programmcode zu entwikkeln, muß der Editor (siehe Abbildung 4.1) geöffnet werden. Mit einem 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 Formular Form. Unter General werden alle Funktionen, Prozeduren, Konstanten und Variablen abgelegt, auf die alle Steuerelemente des Formulars zugreifen sollen. Hier wird auch definiert, ob alle Variablen, die in dem Formular 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 verwendet werden, auch deklariert werden. Eigenschaft
mögliche Wert
Beschreibung
(Name)
String
Der Name identifiziert das Fenster im Programmcode.
Appearance
0 - Flat 1 - 3D
Mit dieser Eigenschaft wird angegeben, ob das Fenster im neuen 3D-Design von Windows 95 oder in der alten Darstellung gezeigt wird.
AutoRedraw
True/False
Diese Eigenschaft gibt an, ob das Fenster nach jedem Aktivieren neu gezeichnet werden soll.
BackColor
0 - 16777,215 (&HFFFFFF)
Mit dieser Eigenschaft wird die Hintergrundfarbe des Fensters eingestellt (Abschnitt ).
Caption
String (Max 255. Zeichen)
In Caption wird die Beschriftung des Fensters eingetragen, die während des Programmlaufs sichtbar ist.
MDIChild
True/False
Diese Eigenschaft gibt an, ob es sich bei dem aktuellen Fenster um ein Fenster im Fenster handelt.
Tag
String
Steht zur freien Verfügung, d. h. es 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 sich die Maus über dem Steuerelement befindet.
Tabelle 4.1: Die wichtigsten Eigenschaften des Fensters
Eine der wichtigsten Ereignisprozeduren des Formulars ist die Funktion 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 indem die ersten drei Buchstaben das Objekt beschreiben. Bei einem Formular bietet sich die Abkürzung frm an. Der festgelegte Name findet sich auch rechts im Projektfenster wieder. Der Name, der vom System 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 Eigenschaft Caption ist Form1.
4.1.1
Aufgabe
Das folgende Programmbeispiel soll beim Starten des Programms den Titel „Beispiel” in die Kopfzeile des Fensters schreiben.
4.1.2
Eine Aufgabe zum Formular
Lösung
Als erstes wird der Name des Formulars festgelegt; wir wählen hierzu frm_Beispiel. Der Eigenschaft Caption braucht kein Parameter zugewiesen zu werden, da in diesem Fall mit einer Konstanten gearbeitet werden soll. Weitere formularglobale Konstanten und Variablen werden nicht gebraucht. Also ergeben sich für den Abschnitt
Die Lösung zur Formularaufgabe
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 jedem Programmstart ausgeführt, daher muß hier der Programmcode geschrieben werden, um den Titel des Fensters zu beschriften. Private Sub Form_Load() 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 Tastenkombination (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 Steuerelemente 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 Standard, daß zu jedem Steuerelement ein Hilfetext in der Statuszeile ausgegeben wird. Um ein Steuerelement als Label zu markieren, bieten sich hier die drei Anfangsbuchstaben lab als Kennzeichnung des Namens an.
4.2.1 Eine Aufgabe zum Textelement
Zur Ausgabe eines Hilfetextes soll eine Statuszeile auf das aktuelle Formular aufgebracht werden. Der Text, der in der Statuszeile dargestellt wird, soll zentriert sein, und das Label soll optisch den Eindruck erwecken, als sei es in das Formular eingelassen.
4.2.2 Die Lösung zur Textelementaufgabe
Aufgabe
Lösung
Zunächst muß ein Label auf das geöffnete Formular als Fußzeile auf 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 Eigenschaft 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 werden. Dieser kann entweder über die Eingabe einer 2 oder das Auswählen dieser Option über die angebotene ListBox erfolgen. Als letzte Eigenschaft wird nun der 3D-Effekt eingeschaltet, damit die Statuszeile optisch versenkt auf dem Bildschirm erscheint. Dazu muß die Eigenschaft 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. Private Sub Form_Load() frm_Beispiel.Caption = Titel 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 wichtigste Funktion der Schaltfläche ist die Ereignisprozedur Click. Diese Ereignis reagiert auf das Aktivieren der Schaltfläche. Bei den Eigenschaften 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 Beschreibung des Steuerelements ablegen. Für die Kennzeichnung des Buttons als Steuerelement im Namen wird im weiteren Verlauf btn verwendet.
4.3.1
Aufgabe
Es sollen zwei Schaltflächen auf das Formular aufgebracht werden. Die eine Schaltfläche ABBRUCH dient zum Beenden des Programms, die andere Schaltfläche OK dient zum Starten einer Aufgabe. In diesem Fall soll die Aufgabe darin bestehen, zu zählen, wie oft die Schaltfläche OK betätigt wurde, und den ermittelten Wert in der Titelleiste des Fensters auszugeben. Außerdem soll in der Statuszeile eine Beschreibung zu der Aufgabe der jeweiligen Schaltfläche ausgegeben werden.
Eine Aufgabe zur Schaltfläche
89
4.3.2 Die Lösung zur Aufgabe Schaltfläche
Lösung
Zuerst werden die beiden Schaltflächen auf die Form gebracht. Die erste 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 vergessen 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-Ereignis 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 gebraucht wird, ist eine globale Variable. Ihr Wert muß auch nach Verlassen 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 Formulars eingetragen werden. Dim Anzahl As Integer
'Zählt die Anzahl der 'Tastendrücke OK
Initialisiert wird die Variable beim Programmstart mit dem Standardwert 0. Visual Basic initialisiert zwar selbständig alle numerischen Variablen mit 0; jedoch ist es für die Übersichtlichkeit des Programmcodes besser, diese Zuweisung nochmals in der Ereignisprozedur Load des Formulars auszuführen.
90
Private Sub Form_Load() frm_Beispiel.Caption = Titel lab_Status.Caption = "" Anzahl = 0 End Sub
Wenn das Programm nun gestartet und mit der Maus auf die Schaltfläche Ok gedrückt wird, so erscheint die geforderte Ausgabe in der Titelleiste 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 meisten 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, Shift As Integer, X As Single, Y As Single) 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 Steuerelement 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 einer Funktion gelöscht werden. Dazu eignet sich die Funktion MouseMove des Formulars, da sich die Maus entweder auf einem Steuerelement befindet, d. h. Statustext anzeigt, oder auf dem Formular, d. h. keinen Statustext anzeigt.
91
Private Sub Form_MouseMove(Button As Integer, _ Shift As Integer, X As Single, Y As Single) 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 Abbildung 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 Tastatur. Für die Identifizierung des Steuerelements im Programmcode wird im folgenden die Kennung txt verwendet.
4.4.1 Eine Aufgabe zum Textelement
92
Aufgabe
Es soll ein Programm entwickelt werden, mit dem Längenmaße umgerechnet werden können. Dafür werden zwei Texteingabeelemente benötigt. Das erste Element txt_Wert dient zum Erfassen des Ursprungsmaßes, beispielsweise Kilometer. In das zweite Element txt_Faktor wird der Umrechnungsfaktor eingegeben. Bei der Umrech-
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 Label 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 Aufgabe Textelement
Private Sub btn_Ok_Click() 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() lab_Ergebnis.Caption = "" End Sub
4.5
Das Bildfeldsteuerelement PictureBox
Abbildung 4.6: Das Bildfeldsteuerelement „PictureBox”
Um auf einem Formular Grafiken anzuzeigen, stellt Ihnen Visual Basic das Steuerelement PictureBox zur Verfügung. In diesem Grafikfenster 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 Identifizierung des Steuerelements wird die Kennung pic für Picture ver-
93
wendet. Daraus ergibt sich der Name pic_Bild für das folgende Beispiel. 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 abgeschnitten. 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 Bildfeldsteuerelement – der Anzeige von Grafiken folgender Formate:
Bitmap (*.bmp; *.dib)
Windows-Metafile (*.wmf)
Icon (*.ico; *.cur)
In Abbildung 4.7 ist dem Anzeigesteuerelement schon eine Grafikdatei 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 Systemressourcen benötigt und schneller dargestellt werden kann als das Bildfeldsteuerelement. Es unterstützt jedoch nicht den gleichen Umfang an Ereignissen, Eigenschaften und Methoden wie das Bildfeldsteuerelement. 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 Grafik 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 verwendet, 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 Kassettenrecorder ist entweder eingeschaltet oder nicht eingeschaltet. Die Kontrollkästchen einer Gruppe haben keinen direkten Einfluß aufeinander. 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 1 aktiviert
Mit dieser Eigenschaft wird festgelegt oder geprüft, ob das Kontrollkä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 Sichtbarkeit eines Textfensters eingestellt wird. Der zweite Button gibt seinen aktuellen Zustand in diesem Textfenster aus, d.h. das Kontrollkästchen-Steuerelement schreibt den Wert „Wahr” in das Textfeld, wenn es aktiviert ist; ist es nicht aktiviert, erscheint der Wert „Falsch”.
4.8.2
Eine Aufgabe zum Kontrollkästchensteuerelement
Lösung
Um ein Steuerelement unsichtbar zu machen, muß man auf die Eigenschaft Visible (sichtbar) zurückgreifen. Enthält die Eigenschaft Visible den Wert „Falsch”, ist das Steuerelement während der Programmausführung nicht sichtbar.
Lösung zur Aufgabe Kontrollkästchensteuerelement
Private Sub Form_Load() 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 Eigenschaften Wahr oder Falsch annehmen kann. Jedoch sind alle Optionsfeldsteuerelemente 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 ausgewählt ist. In Visual Basic können damit auch verschiedene Berechtigungsstufen 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.
98
Eigenschaft
mögliche Werte
Beschreibung
(Name)
String
Über den Namen wird das Steuerelement im Programmcode angesprochen.
Caption
String
Diese Eigenschaft beinhaltet die Beschreibung rechts neben dem Schalter (Ausgabe 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 Steuerelement dienen.
Eigenschaft
mögliche Werte
Beschreibung
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.3: Die wichtigsten Eigenschaften des Optionenschalters
4.9.1
Aufgabe
Es soll ein Programm erstellt werden, in dem über drei Optionenschalter festgelegt wird, ob der Schalter OK unsichtbar, sichtbar oder verfügbar sein soll. Dazu werden drei Steuerelemente benötigt. Wegen der besseren Übersichtlichkeit sollen sie in einem Frame zusammengefaßt werden.
4.9.2
Eine Aufgabe zum Optionenschalter
Lösung
Um ein Steuerelement für die Eingabe des Benutzers zu sperren, gibt es die Eigenschaft Enabled (verfügbar). Ist der Wert der Eigenschaft 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.
Die Lösung zur Aufgabe Optionenschalter
Private Sub Form_Load() 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 Listenelemente dabei ausgewählt werden; direkte Eingabe von Daten in das Listenfeld-Steuerelement ist jedoch nicht möglich. Diese Steuerelemente 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 stehen einige Befehle zur Verfügung. Im folgenden werden die wichtigsten Befehle aufgeführt. Eigenschaft
mögliche Werte
Beschreibung
(Name)
String
Über den Namen wird das Steuerelement im Programmcode 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 eingetragenen Zeilen; sie kann nur gelesen werden.
Listindex
Integer
Diese Eigenschaft enthält die Nummer der momentan selektierten Zeile des Listenelements; sie kann gelesen und geändert werden.
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.
Text
String
Diese Eigenschaft enthält die Zeichenkette des markierten Datensatzes 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 ListenfeldSteuerelement hinzugefügt werden.
Eintragen eines neuen 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 ListenfeldSteuerelement entfernt. Durch Angabe einer Datensatznummer kann gezielt ein Datensatz aus der gesamten Liste zum Löschen ausgewählt werden.
4.10.3
Löschen eines Datensatzes im Listenfeldsteuerelement
Den gesamten Inhalt des ListenfeldSteuerelements löschen
Mit dem Befehl Clear werden alle Datensätze, die im ListenfeldSteuerelement eingetragen sind, gelöscht.
Alle Datensätze eines Listenfeldsteuerelements löschen
4.10.4
Aufgabe
Eine ListBox soll beim Programmstart mit Namen gefüllt werden. Bei einem Doppelklick auf einen bestimmten Namen wird dieser in eine zweite ListBox verschoben. Mit dem Button OK werden alle Namen aus der zweiten ListBox entfernt und wieder zurück in die erste verschoben. Bei jedem Namen, der mit Ok zurückverschoben wird, erscheint 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 versehentlich in die zweite ListBox kopiert wurde, wieder zu entfernen, muß ebenfalls ein Doppelklick auf den zu löschenden Namen erfolgen.
4.10.5
Eine Aufgabe zum Steuerelement Listenfeld
Lösung
Private Sub Form_Load() lst_Namen.AddItem ("Flink Fritze") lst_Namen.AddItem ("Hastig Hugo") lst_Namen.AddItem ("Simson Simone")
Die Lösung für die Aufgabe Listenfeldsteuerelement
" "
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 Private Sub btn_Ok_Click() 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 neben 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 eintragen“, „Einen Datensatz löschen“ und „Den gesamten Inhalt des Listenfeld-Steuerelements löschen“) identisch.
102
4.11.1
Aufgabe
Es soll nochmals ein Programm zum Umrechnen eines Wertes in einen anderen erstellt werden. Im Gegensatz zu dem ersten Beispiel soll das Steuerelement für den Umrechnungsfaktor jedoch eine Combobox sein, die schon folgende Umrechnungsfaktoren enthält:
Kilometer in Seemeilen,
Seemeilen in Kilometer,
Stunden in Minuten.
Eine Aufgabe für die ComboBox
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 'Die Call Call Call End Sub
Sub Form_Load() Combobox mit Vorgabewerten füllen cmb_Faktor.AddItem("1,852", 0) cmb_Faktor.AddItem("0,53996") cmb_Faktor.AddItem("60", 2)
Die Lösung zur Aufgabe ComboBox
Private Sub txt_Wert_Change() 'Löschen des alten Wertes im Ergebnislabel lab_Ergebnis.Caption = "" End Sub Private Sub cmb_Faktor_Change() 'Löschen des alten Wertes im Ergebnislabel lab_Ergebnis.Caption = "" End Sub Private Sub btn_Ok_Click() '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 lab_Ergebnis.Caption = "" '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 unterstü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 aktuelle 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 bestimmten 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 den aktuellen Positionswert ausgibt, an dem sich der Markierungsbalken der Bildlaufleiste befindet.
4.12.2
ScrollBars
Lösung
Private Sub vsc_Zahl_Change() lab_Zahl.Caption = vsc_Zahl.Value End Sub
4.13
Eine Aufgabe für die
Die Lösung für die Aufgabe Scrollbars
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 Visual Basic zur Verfügung gestellt werden, um Laufwerkstrukturen darzustellen. Im Dateilistenfeld werden alle Dateien, im Verzeichnislistenfeld die Verzeichnisse und im Laufwerklistenfeld schließlich alle bekannten Laufwerke angezeigt. Eigenschaft
mögliche Werte
Beschreibung
(Name)
String
Über den Namen wird das Steuerelement im Programmcode angesprochen.
Caption
String (Max. 255 Zeichen)
In Caption wird die Beschriftung des Fensters eingetragen, 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 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.
Tabelle 4.5: Die wichtigsten Eigenschaften der Datei-, Verzeichnis- und Laufwerklistenfelder
$%& $ " '
105
4.13.1 Eine Aufgabe zu den Listenfeldern
Es soll ein Programm geschrieben werden, mit dem zwei Verzeichnisse verglichen werden und das anschließend diejenigen Dateien auf dem Bildschirm ausgibt, die nur in einem Verzeichnis vorkommen.
4.13.2 Die Lösung zur Aufgabe Listenfelder
Aufgabe
Lösung
Zuerst muß gewährleistet werden, daß die ListBoxen der linken und der rechten Seite sich gegenseitig aktualisieren. Dafür wird das Ereignis Change der Laufwerks- und Verzeichnislistenfelder benötigt. Wird in einem Laufwerklistenelement das aktuelle Laufwerk geändert, muß dieses an das zugehörige Verzeichnislistenelement weitergegeben werden. Ebenso muß eine Änderung im Verzeichnislistenfeld sofort 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 Listenfelder – müssen die folgenden Programmzeilen in das Ereignis Form_Load eingetragen werden.
Initialisieren der Laufwerke und Pfade
Private Sub Form_Load() Call drv_links_Change Call drv_rechts_Change End Sub
Vergleichen der Dateilistenfelder Um festzustellen, welche Dateien in welchem Listenfeld nicht vorkommen, müssen zuerst alle Dateien des ersten Listenfelds mit dem Inhalt des zweiten verglichen werden. Alle im zweiten Listenfeld nicht gefundenen Dateien werden nun in das Ergebnislistenfeld eingetragen. Danach muß geprüft werden, welche Dateien des zweiten Listenfeldes im ersten Dateilistenfeld enthalten sind. Diese werden dann ebenfalls in das Ergebnislistenfeld eingetragen.
Vergleichen des Inhaltes der ersten und zweiten DateiListBox
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 Buchstaben tim verwendet.
108
Eigenschaft
mögliche Werte
Beschreibung
(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ählimpulsen 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
Start,
Stop,
Restart und
Reset
Eine Aufgabe für den Zeitgeber
programmiert werden.
4.14.2
Lösung
Als Grundlage für das zu erstellende Programm kann das Programm Vorlage genommen werden. Die Schaltfläche btn_Ok ist dabei überflüssig und kann somit gelöscht werden. Die zusätzlich benötigten Steuerelemente werden in Tabelle 4.7 mit ihren einzustellenden Eigenschaften 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
( #)
Die Lösung zur Aufgabe Zeitgeber
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 benö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 Private Sub Form_Load() 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 Laufzeit keine Veränderungen vornehmen, da es ausschließlich zur Visualisierung eingesetzt wird.
4.16
Das Figurensteuerelement Shape
Abbildung 4.17: Das Figurensteuerelement „Shape”
Das Figurensteuerelement Shape ist, analog zum Liniensteuerelement, ein grafisches Steuerelement. Es kann als Quadrat, Rechteck, Kreis, Oval, abgerundetes Rechteck oder als ein abgerundetes Quadrat 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 dargestellt werden. In Die Programmoberfläche der „Gummiball-Simulation” ist die Programmoberfläche der „Gummiball-Simulation” dargestellt. 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 Eigenschaften 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 Geschwindigkeit und die Startrichtung des Balls vorgegeben werden. Die Bewegungsrichtung setzt sich aus den horizontalen und vertikalen Anteilen 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 Bewegungsanteil 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 Startparameter durchgeführt. Private Sub Form_Load() 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 Bewegungsanteil, 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 Richtung(0) = -Richtung(0) End If End If If Position(1) > Pic_ball.Height - shp_Ball.Height Then Position(1) = (Pic_ball.Height - shp_Ball.Height) Richtung(1) = -Richtung(1) Else If Position(1) < 0 Then Position(1) = 0 Richtung(1) = -Richtung(1) 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 zugewiesen werden, in dem er einen Bewegungsschritt des Balls ausführen soll. Private Sub btn_Ok_Click() 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 Position. Nach einem erneuten Betätigen des Schalters führt er die Bewegung weiter, als sei diese nie unterbrochen worden.
4.17
Hinzufügen weiterer Steuerelemente
Visual Basic enthält mehr Steuerelemente, als im Werkzeugfenster eingetragen sind. Um weitere Steuerelemente in das Werkzeugfenster einzublenden, muß mit der rechten Maustaste auf das Werkzeugfenster 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).
Weitere Steuerelemente zum Werkzeugfenster hinzufügen
Abbildung 4.20: Zusätzliche Steuerelemente
* + '
115
Durch Selektieren bzw. Deselektieren der Kontrollkästchen in der Liste können die zusätzlichen Steuerelemente in das Werkzeugfenster übernommen oder wieder aus dem Werkzeugfenster entfernt werden.
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 aussehen; dies ermöglicht es dem Anwender, sich rascher und problemloser in einem neuen Programm zurechtzufinden. Bei Standarddialogen 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 Verfügung gestellten Dialogboxen in ein eigenes Programm einzubinden. 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 Steuerelement aufgebracht wurde, ist jedoch nur ein kleines Steuerelement zu sehen (vgl. Abschnitt „Der Zeitgeber Timer“). Während der Laufzeit des Programms ist gar kein Steuerelement auf der Oberfläche des Fensters zu sehen. Um das Steuerelement CommonDialog in die Werkzeugliste einzutragen, muß das Kontrollkästchen des Eintrages Microsoft Common Dialog Control 6.0
auf dem Registerblatt STEUERELEMENTE der Dialoges KOMPONENTEN aktiviert werden. Verschiedene Aufrufe sind jeweils den entsprechenden Dialogen zugeordnet. Dadurch kann das Programm erkennen, um welchen Standarddialog es sich handelt. Die Position des Dialogs auf der Programmoberfläche wird vom System selbst festgelegt.
116
Die Befehle zum AufAufruf
zugehöriger Dialog
rufen der einzelnen
ShowOpen
Öffnet die Dialogbox, um Dateien zu öffnen. Abschnitt
Standarddialoge
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 verteilt werden kann, muß die dazugehörige OCX-Datei ebenfalls verteilt werden. Diese Datei befindet sich zumeist im Windows-Standardverzeichnis. 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 Dateien zu filtern oder um die Anzahl der darzustellenden Dateien in einem 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 Dialogbox 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 Fehlerwert 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 Programm 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 lassen sich die Farbeinstellungen mit dem von Windows zur Verfügung gestellten Dialog definieren. In Tabelle 4.11 sind die Eigenschaften des Dialogs aufgeführt. Eigenschaft
Beschreibung
Color
Diese Eigenschaft beinhaltet die Nummer der Farbe, die dargestellt werden soll.
Flags
Hier werden die Optionen für den Dialog festgelegt: 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. True Fehlerwert wird generiert. False Fehlerwert wird nicht generiert.
Tabelle 4.11: Eigenschaften des Dialogs „Farbpalette”
Aufgerufen wird der Dialog mit dem Befehl Name.ShowColor
Danach ist das Fenster modal geöffnet, d. h. es kann erst mit dem Programm 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 Schriftart von Visual Basic unterstützt. Er entspricht dem Standarddialog von Windows. Um eine Schriftart zu bearbeiten, werden folgende Eigenschaften zur Verfügung gestellt (Tabelle 4.12): Eigenschaft
Beschreibung
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. True Fehlerwert wird generiert. False Fehlerwert wird nicht generiert.
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
Aufgerufen wird der Dialog mit dem Befehl Name.ShowFont
Danach ist das Fenster modal geöffnet, d. h. es kann erst mit dem Programm 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. Eigenschaft
Beschreibung
Copies
Diese Eigenschaft bestimmt die Anzahl der Kopien, die von dem Dokument gedruckt werden sollen.
Flags
Hier werden die Optionen für den Dialog festgelegt: welche Optionen angezeigt und eingestellt 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
Eigenschaft
Beschreibung
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ätigen der Einstellungen im Druckdialog werden diese in der zugehörigen Konfigurationsdatei gespeichert. True Einstellungen speichern False Einstellungen verwerfen
CancelError
Mit dieser Eigenschaft wird festgelegt, ob beim Drücken der Taste ABBRECHEN ein Fehlerwert generiert wird oder nicht. True Fehlerwert wird generiert. False Fehlerwert wird nicht generiert. Tabelle 4.13: Eigenschaften des Eigenschaftsdialogs „Drucken”
Aufgerufen wird der Dialog mit dem Befehl Name.ShowPrinter
Danach ist das Fenster modal geöffnet, d. h. es kann erst mit dem Programm weitergearbeitet werden, wenn das Fenster zur Druckerausgabe 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. Dabei läßt sich festlegen, ob der Standardhilfedialog z.B. kontextabhängig ist, also zu dem aktuellen Menüpunkt oder Fenster Hilfe anbietet. Es kann aber auch der Index der Hilfedatei angezeigt werden.
122
Eigenschaft
Beschreibung
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 kontextabhängige oder eine Indexhilfe. Die Konstantenwerte, die dieser Eigenschaft zugeordnet 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”
Aufgerufen wird der Dialog mit dem Befehl Name.ShowHelp
Danach ist das Fenster modal geöffnet, d. h. es kann erst mit dem Programm weitergearbeitet werden, wenn das Fenster wieder geschlossen wurde.
4.18.6
Zusammenfassung
Mit dem Steuerelement CommonDialogBox lassen sich alle Standarddialoge schnell und einfach in ein Visual Basic-Programm integrieren. Ein Anwender wird sich somit sehr schnell in diesen Dialogen zurechtfinden, da er sie von anderen Programmen bereits kennt.
Zusammenfassung zu dem Steuerelement CommonDialogBox
Beispiel 1 In diesem Beispiel wird der Standarddialog Schriftart aufgerufen. Nach erfolgter Definition des Benutzers werden die Einstellungen in das aufrufende Programm übernommen.
Beispielprogamm zum Schriftarten-Standarddialog
Public btn_Schrift_Click() dlg_Beispiel.ShowFont End Sub
Beispiel 2 In diesem Beispiel wird für jeden Dialog eine Schaltfläche definiert, die einen der Dialoge aufruft. Es werden keine Werte eingelesen. Dieses Beispiel dient lediglich dazu, die einzelnen Dialogfenster zu zeigen.
Beispielprogramm zum Aufrufen aller Standarddialoge
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 geworden. In diesem Buch wird das Steuerelement Registerblätter mit den drei Buchstaben tab identifiziert. Standardmäßig werden die Registerlaschen oben angeordnet. Um im Editiermodus von einem Registerblatt 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 Register aufzubringen. Eigenschaft
mögliche Werte
Beschreibung
(Name)
String
Über den Namen wird das Steuerelement im Programmcode angesprochen.
CurrentTab
Integer
Hier wird die Nummer des aktiven Registers aufgeführt.
Caption
String
Hier erfolgt die Aufführung des Laschentitels des aktuellen Registerblattes.
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
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.15: Die wichtigsten Eigenschaften des Steuerelements „Registerblätter”
4.19.1
Aufgabe
Es soll ein Programm entwickelt werden, das sechs Registerblätter hat und in ein Beschreibungsfeld schreibt, welches der Register aktiv ist.
Eine Aufgabe zum Steuerelement Registerblätter
4.19.2
Lösung
Private Sub tab_Beispiel_Click(PreviousTab As Integer) Lab_Ausgabe.Caption = tab_Beispiel.Caption End Sub
4.20
Die Lösung zu den Registerblättern
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 Dokument 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 Fensterrahmens das gleiche Verhalten zeigen wie ein Hauptfenster auf der Desktop-Oberfläche. Wird das MDI-Fenster über den Rand des Hauptfensters hinaus verschoben, wird dieser einfach abgeschnitten. Eigenschaft
mögliche Werte
Beschreibung
(Name)
String
Über den Namen wird das Steuerelement im Programmcode angesprochen.
Caption
String (Max. 255 Zeichen)
In Caption wird die Beschriftung des Fensters eingetragen, die während des Programmlaufs sichtbar ist.
MDIChild
TRUE/FALSE
Diese Eigenschaft gibt an, ob es sich bei dem aktuellen Fenster um ein Fenster im Fenster handelt.
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.16: Wichtige Eigenschaften des MDI-Fensters
4.20.1 Eine Aufgabe zum MDI-Fenster
Aufgabe
Es soll ein Programm entwickelt werden, in dem über den Button 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
Die Lösung zur Aufgabe MDI-Fenster
Lösung
Fensterglobal 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 erzeugt. 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 festgelegt.
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 Anwender, Entwickler oder vom Programm beeinflußt und geändert werden können. Die Eigenschaften der Steuerelemente lassen sich in drei Gruppen einteilen:
Eigenschaften der Steuerelemente nicht immer ändern
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 Steuerelemente beschrieben und ihre Wirkungsweise auf die Steuerelemente erklärt.
129
5.1 Eigenname des Steuerelements
Die Eigenschaft (Name)
Die Eigenschaft (Name) identifiziert das Steuerelement oder das Formular 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) vergeben, 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 sprechenden Namen umgewandelt werden. Wird zum Beispiel ein Textelement Label auf das Fenster aufgebracht, mit dem ein Ergebnis dargestellt werden soll, bietet sich der Name Lab_Ergebnis für dieses Steuerelement an. Der Name für ein Steuerelement sollte vergeben werden, bevor das erste Ereignis programmiert wird, da die verwendeten Ereignisse nicht umbenannt werden. Bei einer späteren Umbenennung sind dem Steuerelement somit keine Funktionen mehr zugeordnet. Die verwendeten Funktionen sind jedoch nicht gelöscht, sondern in dem Abschnitt GENERAL des Formulars gespeichert.
5.2 Darstellungsarten des Steuerelements
Die Eigenschaft Appearance
Die Eigenschaft Appearance definiert, wie das Objekt auf der Oberflä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 Beschriftung des Steuerelements
Die Eigenschaft Caption
Die Eigenschaft Caption ist die Beschriftung eines 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 entsprechende Länge erreichen.
5.4
Die Eigenschaft Cancel
Mit Cancel wird die Schaltfläche definiert, die auf die (Esc)-Taste reagieren soll. Zumeist handelt es sich um die Schaltfläche Abbrechen. Wenn ein Fenster mit einer Cancel-Taste aktiv ist, löst das Drücken der Taste (Esc) die Aktion aus, die normalerweise durch Betätigen der Schaltfläche mit der Maus gestartet wird. Die Eigenschaft Default definiert die Schaltfläche, die auf die Taste (¢) reagiert
Definiert, ob eine Schaltfläche auf die (Esc)-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 die Eingabetaste ENTER reagieren soll. Zumeist handelt es sich um die Schaltflächen BESTÄTIGEN oder OK. Wenn ein Fenster mit einer Default-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 gestartet wird. Die Eigenschaft Cancel definiert die Schaltfläche, die auf die Taste (Esc) reagiert.
Definiert, ob eine Schaltfläche auf die (¢)-Taste 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 Verfügbarkeit der Steuerelemente
Die Eigenschaft Enabled
Um ein Steuerelement für den Anwender zu sperren, wird die Eigenschaft 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 Programmen, die benutzerabhängig, z.B. von einem Paßwort gesteuert sind, ist es mit Hilfe dieser Eigenschaft sehr einfach, die Funktionalität von Programmen einzuschränken. Zum Teil ist es auch sinnvoll, Steuerelemente, die einen aufwendigen Prozeß starten, zu deaktivieren, um ein zweites Aufrufen der Funktion solange zu vermeiden, bis der Prozeß vollkommen abgearbeitet wurde. Wird im folgenden Beispiel 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 ausgewählt werden können. Mit dem Registerblatt System wird die Farbverteilung des Systems dem Steuerelement zugeordnet. Wenn dem Steuerelement 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 zugewiesen, 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 zu verändern. Standardmäßig ist der Mauszeiger ein Pfeil. Um dem Anwender zu zeigen, daß das Programm aktiv ist, kann der Mauszeiger z.B. in eine Sanduhr geändert werden. Für die Eingabe wird zumeist die Darstellung eines senkrechten Strichs („|”) verwendet. Visual Basic unterstützt die folgenden verschiedenen Darstellungen: Wert
Aussehen
Wert
0
Vorgabe
8
1
9
2
10
3
11
4
12
5
13
6
14
7
15 99
Verändern der Darstellungsart des Mauszeigers
Aussehen
Benutzerdefiniert
Tabelle 5.1: Die möglichen Mauspfeile
133
5.8
Die Eigenschaft TabIndex
Mit der Eigenschaft TabIndex wird die Reihenfolge der Steuerelemente festgelegt, in der sie durch das Drücken der (ÿ)-Taste abgearbeitet werden. Visual Basic vergibt diese Werte selbständig durch einfaches 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 Steuerelement, 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 Steuerelemente – 1 auf dem aktiven Fenster liegen.
5.9 Reihenfolge der Steuerelementaktivierung über Tabulator-Taste
Um bei einem Steuerelement die Möglichkeit abzuschalten, daß es den Fokus über die (ÿ)-Taste erhält, kann die Eigenschaft TabStop auf False gesetzt werden. Ist TabStop auf True gesetzt, kann das Steuerelement über die (ÿ)-Taste erreicht werden.
5.10 Zur freien Verfügung
Programmlaufzeit
134
Die Eigenschaft Tag
Die Eigenschaft Tag ist keine Eigenschaft, die Einfluß auf das Steuerelement hat. Fast jedes Steuerelement stellt diese Eigenschaft zur Verfü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 Dient zur Dateneingabe während der
Die Eigenschaft TabStop
Die Eigenschaft Text
Steuerelemente mit der Eigenschaft Text ermöglichen die Eingabe von Daten während der Programmlaufzeit. In diese Steuerelemente können vom Benutzer Daten eingegeben werden, die dann vom Programm ausgewertet und weiterverarbeitet werden können. Die Eigenschaft Text entspricht ansonsten der Eigenschaft Caption (siehe Abschnitt 5.3).
5.12
Die Eigenschaft ToolTipText
Mit dieser Eigenschaft kann der Text eingegeben werden, der in der Sprechblase erscheinen soll, wenn der Mauszeiger auf das Steuerelement zeigt, ohne bewegt zu werden. Wenn z.B. eine Schaltfläche eingesetzt wird, der nur ein Bild zugeordnet ist, kann diese Eigenschaft die Aktion beschreiben, die von dem Steuerelement ausgelöst wird.
5.13
Hilfetext zum Steuerelement in einer Sprechblase
Die Eigenschaft Visible
Mit dieser Eigenschaft wird dem Steuerelement mitgeteilt, ob es für den Anwender sichtbar ist oder nicht. In einigen Programmen ist es 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. Visible 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 besitzen. Es kann minimiert sein, d. h. es ist nur als Icon auf der Windows-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 Bildschirmausschnitt vor.
Sichtbarkeit eines Steuerelements
Darstellung des Fensters
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 Steuerelemente ändern oder Programmodule ausführen. Ereignisse werden meistens durch den Benutzer ausgelöst. Ein Ereignis ist z.B. das Klicken mit der linken Maustaste auf ein Steuerelement. Jedes Ereignis ist vom Aufbau her eine Prozedur, die beim Eintreffen des Ereignisses 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 aufgebaut: Private Sub ElementName_Ereignis([Parameterliste]) ElementName:
Der Name, unter dem das Steuerelement im Programm bekannt ist. Der Name entspricht der Eigenschaft Name (Abschnitt ).
Ereignis:
Das Ereignis, das eintreffen muß, um die Prozedur 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 Taste gedrückt wurde. Die Parameterliste ist vom Ereignis abhängig und somit nicht immer vorhanden.
In diesem Kapitel werden die wichtigsten Ereignisse erklärt und ihre jeweiligen Funktionen anhand von Beispielen aufgezeigt.
137
6.1 Reagieren auf einmaliges Klicken mit der linken Maustaste
Click – der einfache Mausklick
Das Ereignis Click wird ausgelöst, wenn sich der Mauspfeil auf einem Steuerelement befindet und die linke Maustaste einmal gedrückt 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 Reagieren auf das Doppelklicken mit der Maus
Der doppelte Mausklick: DblClick
Diese Prozedur wird mit einem Doppelklick der linken Maustaste auf ein Steuerelement ausgelöst. Ein Doppelklick ist das zweimalige Drücken der linken Maustaste in rascher Abfolge. Einfacher und doppelter Mausklick starten oft bestimmte Programmteile. In ListBoxen wird mit diesem Ereignis zumeist eine Aktion für das aktive Listenelement gestartet. Private Sub Form_DblClick() Private Sub Name_DblClick([Index As Integer]) Parameter
Beschreibung
Index
Wenn das Steuerelement ein Teil eines Feldes von Steuerelementen ist, identifiziert diese Indexnummer das Steuerelement eindeutig.
6.3 Reagieren auf das Laden eines Formulars in den Speicher
138
Das Laden eines Formulars durch Load
Das Ereignis Load tritt ein, wenn ein Fenster in den Hauptspeicher geladen wird. Dieses Ereignis wird z.B. immer vom Hauptfenster ausgefü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 Initialisierungen für das Programm geladen.
Für die Wiederholung dieses Ereignisses reicht es nicht aus, das Fenster zu verstecken und wieder anzuzeigen, sondern es muß aus dem Hauptspeicher entfernt werden. Private Sub Form_Load() Private Sub MDIForm_Load([Index]) Parameter
Beschreibung
Index
Wenn das Steuerelement ein Teil eines Feldes von Steuerelementen ist, identifiziert diese Indexnummer das Steuerelement eindeutig.
Mit den folgenden Befehlen lassen sich Fenster aus dem Hauptspeicher 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 Element auf die Oberfläche gesetzt wird. Dies geschieht mit einem Mausklick auf das Steuerelement, mit der (ÿ)-Taste oder mit dem Programmcode über den Befehl SetFokus. Das Gegenstück zu GotFocus ist LostFocus (den Fokus verlieren).
Wenn ein Steuerelement oder ein Formular selektiert wird
Private Sub Form_GotFocus () Private Sub Name_GotFocus ([Index As Integer]) Parameter
Beschreibung
Index
Wenn das Steuerelement ein Teil eines Feldes von Steuerelementen ist, identifiziert diese Indexnummer das Steuerelement eindeutig.
139
6.5
Reagieren auf das Drücken oder Loslassen einer beliebigen Taste auf der Tastatur
KeyDown und KeyUp – Drücken und Loslassen einer Tastaturtaste
Wenn eine Taste auf der Tastatur gedrückt wird, tritt das Ereignis KeyDown ein. Wird die gedrückte Taste wieder losgelassen, tritt das Ereignis KeyUp ein. Wenn sich auf dem Fenster eine Schaltfläche mit der Eigenschaft Default = True befindet, kann bei keinem anderen Steuerelement 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) Parameter
Beschreibung
Index
Wenn das Steuerelement ein Teil eines Feldes von Steuerelementen ist, identifiziert diese Indexnummer das Steuerelement eindeutig.
KeyCode
Dieser Parameter liefert den Tastencode der gedrückten Taste zurück. Die Definitionen der einzelnen Tasten sind in der Datei Constant.txt von Visual Basic enthalten.
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
Reagieren auf das Drücken oder Loslassen einer beliebigen Maustaste
140
Drücken und Loslassen einer Maustaste mit MouseDown und MouseUp
Um festzustellen, welche Maustaste vom Anwender gerade gedrückt oder losgelassen wird, gibt es die Funktionen MouseDown und MouseUp. Die Funktion MouseDown wird vor dem Ereignis Click ausgeführt, wenn es sich um die linke Maustaste handelt. Wird eine gedrückte Maustaste losgelassen, tritt das Ereignis MouseUp ein. Dieses Ereignis tritt, im Falle der linken Maustaste, immer nach dem Ereignis 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.
Private Sub Form_MouseDown (Button As Integer, Shift As Integer, X As Single, 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 Integer, X As Single, Y As Single) Parameter
Beschreibung
Index
Wenn das Steuerelement ein Teil eines Feldes von Steuerelementen ist, identifiziert diese Indexnummer das Steuerelement eindeutig.
Button
Diese Variable gibt an, welche Maustaste dieses Ereignis ausgelöst hat: 1 Die linke Maustaste ist gedrückt. 2 Die rechte Maustaste ist gedrückt. 4 Die mittlere Maustaste ist gedrückt.
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. 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 Mausposition: X Horizontale Mausposition. Y Vertikale Mausposition.
6.7
Mit MouseMove die Maus über ein Steuerelement bewegen
Wenn sich die Maus über ein Steuerelement bewegt, tritt das Ereignis MouseMove ein. Mit diesem Ereignis können Sie z.B. Hilfemeldungen in Statuszeilen ausgeben oder Systemvariablen setzen, die dann andere Steuerelemente ein- oder ausblenden. Des weiteren läßt sich hierbei feststellen, welche Tasten der Maus mit welchen Tastatur-Umschalttasten gedrückt sind. Tastatur-Umschalttasten sind in diesem Falle die Tasten (ª), (Strg) und (Alt).
Reagieren auf die Bewegung der Maus über ein Steuerelement
Private Sub Form_MouseMove (Button As Integer, Shift As Integer, X As Single, Y As Single) Private Sub Name_MouseMove ([Index As Integer,] Button As Integer, Shift As Integer, X As Single, Y As Single)
141
Parameter
Beschreibung
Index
Wenn das Steuerelement ein Teil eines Feldes von Steuerelementen ist, identifiziert diese Indexnummer das Steuerelement eindeutig.
Button
Diese Variable gibt an, welche Maustaste dieses Ereignis 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.
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. 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 Mausposition: X Horizontale Mausposition. Y Vertikale Mausposition.
6.7.1
Beispiel zum Ereignis MouseMove
In dem folgenden Beispiel soll die Position der Maus in einem Rahmensteuerelement ermittelt werden. Die aktuellen Koordinaten werden 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 Abbildung 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 Eigenschaften beschrieben, die für den Beispiel-Programmcode eingestellt sein müssen. Steuerelement
Eigenschaft
Inhalt
Beschreibung
RahmenSteuerelement
(Name)
frm_Maus
Es handelt sich hier um das Rahmensteuerelement, in dem die Mausdaten abgefragt werden sollen.
lab_X, lab_Y
Hier finden sich Beschriftungselemente zur 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 Information, welche der drei Tasten (ª), (Strg) oder (Alt) gedrückt wurde.
TextausgabeElemente
Tabelle 6.1: Die Steuerelemente des Beispiels „MouseMove“
Wenn die Maus in dem Rahmensteuerelement bewegt wird, sollen die Ausgabewerte in den Beschriftungsfeldern aktualisiert werden. Da der Programmcode in dem Ereignis MouseMove jedesmal aufgerufen wird, wenn der Anwender die Maus bewegt, muß somit auch hier die Ausgabe der geforderten Daten in die Steuerelemente stattfinden. Private Sub frm_Maus_MouseMove(Button As Integer, Shift As Integer, X As Single, Y As Single) 'Ausgabe der Mauskoordinaten lab_X.Caption = X lab_Y.Caption = Y
143
'Prüfen, welche der Maustasten gedrückt wird Select Case Button Case 0: lab_Maus.Caption = "" Case 1: lab_Maus.Caption = "Linke Maustaste" Case 2: lab_Maus.Caption = "Rechte Maustaste" Case 4: lab_Taste.Caption = "Mittlere Maustaste" End Select 'Prüfen, ob eine der Tasten Umschalt, Strg oder 'ALT gedrückt wird Select Case Shift Case 0: lab_Taste.Caption = "" Case 1: lab_Taste.Caption = "Umschalt-Taste" Case 2: lab_Taste.Caption = "Ctrl-Taste" Case 4: lab_Taste.Caption = "Alt-Taste" End Select End Sub
Befindet sich die Maus nicht mehr in dem Rahmensteuerelement, so müssen auch alle Ausgabewerte gelöscht werden. Eine Möglichkeit wäre, über die Berechnung der Koordinaten festzustellen, ob sich die Maus noch im zu prüfenden Bereich befindet. Die zweite, jedoch sehr viel einfachere Methode bedient sich des Ereignisses MouseMove vom Formular. Dieses Ereignis trifft dann ein, wenn das Rahmensteuerelement verlassen wird. Somit ist es am einfachsten, dort den Programmcode zu implementieren, der alle Ausgabewerte löscht. Private Sub Form_MouseMove(Button As Integer, Shift As Integer, X As Single, Y As Single) lab_X.Caption = "" lab_Y.Caption = "" lab_Maus.Caption = "" lab_Taste.Caption = "" lab_Status.Caption = frm_Maus.Tag End Sub
144
6.8
Den Fokus verlieren: LostFocus
Dieses Ereignis wird ausgelöst, wenn das Steuerelement seinen Status von „aktiv“ auf „passiv“ wechselt. Dies geschieht, sobald mit der Maus ein anderes Steuerelement angeklickt oder mit der TAB-Taste das nächste Steuerelement aktiviert wird. Das Gegenstück zu LostFocus ist GotFocus (den Fokus erhalten).
Reagieren auf das Deaktivieren eines Steuerelements
Private Sub Form_LostFocus () Private Sub Form_LostFocus ([Index As Integer]) Parameter
Beschreibung
Index
Wenn das Steuerelement ein Teil eines Feldes von Steuerelementen ist, identifiziert diese Indexnummer das Steuerelement eindeutig.
!
145
7
Fehlerbehandlung in Visual Basic
In einem Programm können immer wieder Fehler auftreten, die nicht vorhersehbar sind. Wird z. B. eine Datei auf die Festplatte gespeichert, kann es passieren, daß der benötigte Platz größer ist als der zur Verfügung stehende. Auch bei Zugriffen auf eine Datenbank ist es möglich, daß das Programm auf Anfragen der Visual Basic-Applikation nicht mehr antwortet, da die Datenbank sich in einem Fehlerzustand befindet. Um zu verhindern, daß solche Systemfehler einen Programmabsturz verursachen, stellt Visual Basic eine Routine für die Fehlerbehandlung zur Verfügung. In diesem Kapitel werden die Befehlssyntax und ihre Arbeitsweise vorgestellt und durch zwei kurze Beispielprogramme verdeutlicht.
7.1
Vorgehensweise beim Auftreten eines Laufzeitfehlers
Fehlertolerante Programme
informieren den Anwender, daß ein Fehler aufgetreten ist,
beenden eventuell das Programmmodul, ohne daß Daten verlorengehen oder das gesamte System blockiert wird,
beeinträchtigen jedoch nicht den Programmablauf, sondern arbeiten dort weiter, wo der Fehler keinen Einfluß mehr hat – zumeist in dem Modul, welches das fehlerhafte Modul aufgerufen hat.
Für die Entwicklung eines solchen Programmes bietet Visual Basic 6.0 die im folgenden aufgeführten Befehle an.
147
7.1.1 Einleitung der Fehlerbehandlungsroutine
Der Befehl On Error
Wenn in einem Visual Basic-Programm während des Betriebs ein Fehler auftritt, so erscheint eine Fehlermeldung, und das Programm wird abgebrochen. Mit dem Befehl On Error kann dem Programm jedoch gesagt werden, wie es beim Auftreten eines Fehlers reagieren soll. Für die genaue Spezifikation, was explizit bei einem Fehler zu geschehen hat, werden die beiden Befehle Resume und Goto im Zusammenhang mit dem Befehl On Error verwendet. Der Befehl Goto
Sprungbefehl in einen beliebigen Programmteil
Der Befehl Goto (gehe zu) ist ein sog. direkter Sprungbefehl. Bei seiner Verwendung muß man als Parameter immer eine Zieladresse angeben, zu der hin der Sprung erfolgen soll. Im allgemeinen sollte dieser Befehl nicht verwendet werden, da er die Übersichtlichkeit der prozedualen Programmierung zerstört. In Verbindung mit dem Befehl On Error wird er jedoch sinnvoll verwendet (man sieht, keine Regel ohne Ausnahme). On Error Goto Sprungmarke ... Sprungmarke: ...
Tritt in dem Programmteil nach dem Befehl On Error Goto Sprungmarke ein Fehler auf, so wird die normale bzw. vorgesehene Abarbeitung unterbrochen und an der Sprungmarke fortgesetzt. Hier kann nun eine Ausgabe an den Benutzer erfolgen, um ihm mitzuteilen, daß ein Fehler aufgetreten ist, oder aber es wird eine besondere Funktion aufgerufen, die die Ursache des Fehlers bereinigt. Die Standardvorgabe hierfür lautet: On Error Goto 0
Mit dem Befehl Goto 0 wird das Visual Basic-Programm im Fehlerfall mit der Ausgabe einer Fehlermeldung beendet. Ist im Programm keine Fehlerbehandlung programmiert, so hat diese Zeile standardmäßig Gültigkeit. Das folgende Beispiel überprüft, ob eine Datei mit dem Namen DATEIexistiert. Wenn die Datei zum Lesen geöffnet werden kann, ist sie auch vorhanden. Die Funktion liefert den Wahrheitswert True zurück. Tritt beim Öffnen der Datei ein Fehler auf, wird der Wahrheitswert False zurückgeliefert. NAME
148
Function Datei_vorhanden(Dateiname As String) As Boolean Dim Datei As Integer On Error Goto Fehler_Division Datei = FreeFile Open Dateiname For Input As Datei close Datei Datei_vorhanden = True Exit Function Fehler_Division: Datei_vorhanden = False Exit Function End Function
Der Befehl Resume Der Befehl Resume kann mit „Wiederaufnahme“ übersetzt werden, d. h. bei Resume wird der Befehl an der Fehlerstelle solange wiederholt, bis kein Fehler mehr auftritt. Es kann also leicht eine Endlosschleife entstehen. Die Verwendung dieses Befehls in der Fehlerbehandlung geschieht wie folgt:
Wiederholen des letzten Befehles
On Error Resume
Diese Fehlerbehandlung hat zur Folge, daß eine Programmzeile solange ausgeführt wird, bis kein Fehler mehr auftritt. Sollte es sich bei diesem Fehler um eine nicht zu behebende Ursache handeln, entsteht eine Endlosschleife. Das folgende Beispiel ist eine solche Endlosschleife, wenn der Teiler 0 ist. Dieses Programm kann dann nur noch mit der Tastenkombination (Strg)+(Pause) beendet werden. Dim Zahl As Double Dim Teiler As Double 'Der Wert Teiler wird vom Benutzer eingegeben Zahl = 100 On Error Resume Ergebnis = Zahl / Teiler ...
Der Teiler wird vom Benutzer eingegeben. Sollte der Benutzer für den Teiler den Wert 0 wählen, kann die Division nicht durchgeführt werden, und es tritt ein Fehler auf. Der Programmcode bestimmt aber, daß die Zeile solange ausgeführt werden soll, bis der Fehler nicht mehr auftritt. Da sich aber der Wert der Variablen Teiler nicht ändert, sondern immer 0 bleibt, wird sich dieser Fehler nie beseitigen lassen – das Programm läuft endlos weiter. Aus diesem Grund gibt es eine Erweiterung des Befehls Resume.
149
Wiederaufsetzen des Programmablaufes beim nächsten Befehl
On Error Resume Next
Resume Next ignoriert die Befehlszeile, in der ein Fehler auftritt, und
verhindert, daß das Programm in der Endlosschleife bleibt. Das Programm sieht dann folgendermaßen aus: Dim Zahl As Double Dim Teiler As Double 'Der Wert Teiler wird vom Benutzer eingegeben. Zahl = 100 On Error Resume Next Ergebnis = Zahl / Teiler ...
Jetzt ist zwar das Problem mit der Endlosschleife gelöst, aber ein neues Problem ist entstanden: ein Fehlverhalten des Programms. Es rechnet nicht richtig, wenn der Wert der Variablen Teiler 0 ist, weil die Programmzeile, die die Berechnung durchführt, ignoriert wird. Folglich ist der Wert der Variablen Ergebnis nicht berechnet, sondern wurde auf den beim Funktionsaufruf initialisierten Wert 0 gesetzt. Das Objekt Err Das Objekt zur Fehlercodebehandlung
Um einen Fehler im Programm weiterverarbeiten zu können, werden für bestimmte Fehler, die auftreten können, Fehlernummern vergeben. Diese Fehlernummern werden im Objekt Err gespeichert. Solange kein Fehler auftritt, ist der Wert des Objekts Err gleich 0. Tritt ein Fehler auf, so kann der Fehlercode, also die Fehlerursache, über den Inhalt der Variablen Err ermittelt werden. Für das Beeinflussen des in Err gespeicherten Fehlers stehen folgende Funktionen zur Verfügung:
Funktion
Beschreibung
Err.Clear
Löscht den Fehlercode im Object Err. Diese Funktion entspricht der Zuweisung Err = 0
Err.Raise n...
Löst den Fehler mit dem Code n aus, wobei die Nummer n ein selbst definierter Fehlerwert sein kann.
Err.Description
Enthält den Fehlertext zur Fehlernummer.
Err. HelpContext
Ist ein Verweis auf den Hilfetext zum aktuellen Fenster.
Err.HelpFile
Ist ein Verweis auf die Hilfedatei.
Err.LastDLLError
Liefert den Fehlercode zur letzten aufgerufenen DLL-Datei.
Err.Number
Liefert die Fehlernummer; entspricht dem Wert in Err.
Err.Source
Ist die Zeichenkette, die das Modul oder den Befehl identifiziert, in dem der Fehler erzeugt wurde. Tabelle 7.1: Funktionen des Objekts „Err“
150
7.1.2
Der Befehl Error
Den Befehl Error gibt es in zwei Varianten: Die erste liefert als Ergebnis die Beschreibung zu einer Fehlernummer als String zurück, die zweite erzeugt einen Fehler mit dem Fehlercode n, d. h. dem Object Err wird ein Fehlercode zugewiesen. Error(n) Error n
7.2
Die Funktion für die Fehlercodebehandlung
'Liefert den Fehlertext zum Fehlercode n 'Erzeugt den Fehler mit dem Code n
Ein Programm zum Erstellen der Fehlercodetabelle
Das folgende Programm soll alle Fehlercodes, die in Visual Basic bekannt sind, in eine Tabelle schreiben. In der Tabelle sind dann die folgenden Angaben enthalten:
die Fehlernummer
die Fehlerbeschreibung
die zugehörige Hilfedatei
die ID des Hilfetextes in der Hilfedatei
Als Ausgangsprogramm dient das Projekt VORLAGE.VBP, das schon in einem Vorangegangenem Kapitel entwickelt wurde. Es befindet sich auf der beigefügten Diskette im Verzeichnis Vorlage. Um die Originalversion nicht zu verändern, sollte das Projekt mit dem Formular VORLAGE.FRM in ein neues Verzeichnis, zum Beispiel ERR_TAB, kopiert werden. Nachdem dies geschehen ist und die Projektdatei in Visual Basic geöffnet wurde, muß das Steuerelement DBGrid auf die Oberfläche gezogen werden. Die Eigenschaften des Grids müssen an diejenigen in Tabelle 7.1 angepaßt werden. Eigenschaft
Parameter
Name
grd_Fehler
Tag
Hier werden alle von Visual Basic definierten Fehler eingetragen.
Tabelle 7.2: Eigenschaften des Grids zur Ausgabe der Fehlercodes
Der Button OK kann von der Oberfläche gelöscht werden, da beim Aufrufen des Programms das Grid automatisch gefüllt wird. Folgende Funktionen werden gebraucht:
151
Sub Ueberschriften_eintragen() grd_Fehler.Col = 0 grd_Fehler.Row = 0 grd_Fehler.Text = "Nummer" grd_Fehler.ColWidth(0) = 750 grd_Fehler.Col = 1 grd_Fehler.Text = "Fehlermeldung" grd_Fehler.ColWidth(1) = 4000 grd_Fehler.Col = 2 grd_Fehler.Text = "Hilfedatei" grd_Fehler.ColWidth(2) = 2000 grd_Fehler.Col = 3 grd_Fehler.Text = "ID" grd_Fehler.ColWidth(3) = 1000 End Sub Sub Fehlertabelle_erzeugen() Dim I As Integer Dim MaxInt As Integer MaxInt = 1000 grd_Fehler.Cols = 4 grd_Fehler.Rows = 1 Call Ueberschriften_eintragen On Error GoTo Fehler For I = 1 To MaxInt Error I lab_Status.Caption = "Es ist " & CInt((I / MaxInt) * 100) & "% fertig" DoEvents Next I Exit Sub Fehler: If Len(Err.Description) > 0 Then grd_Fehler.Rows = grd_Fehler.Rows + 1 grd_Fehler.Row = grd_Fehler.Rows - 1 grd_Fehler.Col = 0 grd_Fehler.Text = Err.Number grd_Fehler.Col = 1 grd_Fehler.Text = Err.Description grd_Fehler.Col = 2 grd_Fehler.Text = Err.HelpFile grd_Fehler.Col = 3 grd_Fehler.Text = Err.HelpContext End If
152
Resume Next End Sub Private Sub Form_Activate() Call Fehlertabelle_erzeugen End Sub
Die Fehlercodetabelle
7.3
Fehlercode
Fehlermeldung
ID in der Hilfedatei
3
Return ohne GoSub.
1000003
5
Unzulässiger Prozeduraufruf oder ungültiges Argument.
1000005
6
Überlauf.
1000006
7
Nicht genügend Speicher.
1000007
9
Index außerhalb des gültigen Bereichs.
1000009
10
Datenfeld ist unveränderlich oder momentan gesperrt.
1000010
11
Division durch 0.
1000011
13
Typen unverträglich.
1000013
14
Nicht genügend Zeichenfolgenspeicher.
1000014
16
Ausdruck zu komplex.
1000016
17
Angeforderte Operation nicht durchführbar.
1000017
18
Unterbrechung durch Benutzer.
1000018
20
Resume ohne Fehler.
1000020
28
Nicht genügend Stapelspeicher.
1000028
35
Sub oder Function nicht definiert
1000035
47
Zu viele Clients für DLL-Anwendung.
1000047
48
Fehler beim Laden einer DLL.
1000048
49
Falsche DLL-Aufrufkonvention.
1000049
51
Interner Fehler.
1000051
52
Dateiname oder -nummer falsch.
1000052
53
Datei nicht gefunden.
1000053
54
Dateimodus falsch.
1000054
55
Datei bereits geöffnet.
1000055
57
Fehler beim Lesen von/Schreiben auf Gerät.
1000057
58
Datei existiert bereits.
1000058
59
Falsche Datensatzlänge.
1000059
61
Datenträger voll.
1000061
62
Einlesen hinter Dateiende.
1000062
153
Fehlercode
Fehlermeldung
ID in der Hilfedatei
63
Falsche Datensatznummer.
1000063
67
Zu viele Dateien.
1000067
68
Gerät nicht verfügbar.
1000068
70
Zugriff verweigert.
1000070
71
Datenträger nicht bereit.
1000071
74
Umbenennen bei Angabe unterschiedlicher Laufwerke nicht möglich.
1000074
75
Fehler beim Zugriff auf Pfad/Datei.
1000075
76
Pfad nicht gefunden.
1000076
91
Objektvariable oder With-Blockvariable nicht festgelegt.
1000091
92
For-Schleife nicht initialisiert.
1000092
93
Ungültige Musterzeichenfolge.
1000093
94
Unzulässige Verwendung von Null.
1000094
96
Ereignisse des Objekts können nicht aufgefangen werden, da von dem Objekt bereits Ereignisse für die maximale Anzahl an Ereignisempfängern ausgelöst werden.
1000096
97
Friend-Funktion eines Objekts, das keine Instanz der definierenden Klasse ist, kann nicht aufgerufen werden.
1000097
98
Eine Eigenschaft oder ein Methodenaufruf kann keinen Verweis auf ein privates Objekt enthalten, weder als Argument noch als Rückgabewert.
1000098
321
Ungültiges Dateiformat.
1000321
322
Erforderliche temporäre Datei kann nicht angelegt werden.
1000322
325
Ungültiges Format in Ressourcendatei.
1000325
380
Unzulässiger Eigenschaftswert.
1000380
381
Ungültiger Index für Eigenschaftenfeld.
1000381
382
Set wird zur Laufzeit nicht unterstützt.
1000382
383
Set wird nicht unterstützt (schreibgeschützte Eigenschaft).
1000383
385
Index für Eigenschaftenfeld benötigt.
1000385
387
Set nicht erlaubt.
1000387
393
Get wird zur Laufzeit nicht unterstützt.
1000393
394
Get wird nicht unterstützt (Eigenschaft kann nur gesetzt werden).
1000394
422
Eigenschaft nicht gefunden.
1000422
423
Eigenschaft oder Methode nicht gefunden.
1000423
424
Objekt erforderlich.
1000424
429
Objekterstellung durch ActiveX-Komponente nicht möglich.
1000429
430
Klasse unterstützt keine Automatisierung.
1000430
432
Datei- oder Klassenname während Automatisierungsoperation nicht gefunden.
1000432
438
Objekt unterstützt diese Eigenschaft oder Methode nicht.
1000438
154
Fehlercode
Fehlermeldung
ID in der Hilfedatei
440
Automatisierungsfehler.
1000440
442
Verbindung zur Klassen- oder Objektbibliothek für den Remote-Prozeß nicht mehr verfügbar. Klicken Sie auf 'OK', um einen Dialog anzuzeigen, mit dem Sie den Verweis entfernen können.
1000442
443
Automatisierungsobjekt hat keinen Standardwert.
1000443
445
Objekt unterstützt diese Aktion nicht.
1000445
446
Objekt unterstützt keine benannten Argumente.
1000446
447
Objekt unterstützt die aktuelle Ländereinstellung nicht.
1000447
448
Benanntes Argument nicht gefunden.
1000448
449
Argument ist nicht optional.
1000449
450
Falsche Anzahl an Argumenten oder ungültige Eigenschaftszuweisung.
1000450
451
Objekt ist keine Auflistung.
1000451
452
Ungültiger Ordinalwert.
1000452
453
Angegebene DLL-Funktion nicht gefunden.
1000453
454
Code-Ressource nicht gefunden.
1000454
455
Fehler durch gesperrte Code-Ressource.
1000455
457
Dieser Schlüssel ist bereits einem Element dieser Auflistung zugeordnet.
1000457
458
Variable verwendet einen in Visual Basic nicht unterstützten Typ der Automatisierung.
1000458
459
Objekt oder Klasse unterstützt diese Ereignismenge nicht.
1000459
460
Zwischenablagenformat ungültig.
1000460
481
Ungültiges Bild.
1000481
482
Druckerfehler.
1000482
735
Datei kann nicht in TEMP-Verzeichnis gespeichert werden.
1000735
744
Suchtext nicht gefunden.
1000744
746
Ersetzungen zu lang.
1000746
Tabelle 7.3: Fehlercodetabelle
155
8
Meldungen anzeigen
Um Meldungen an den Benutzer auszugeben, die bestätigt werden müssen, kann entweder ein Formular generiert, oder das Meldungsfenster MsgBox (Messagebox) verwendet werden, das Visual Basic zur Verfügung stellt. MsgBox(Meldungstext [, Schaltflächen][, Fenstertitel] [, Hilfedatei, HilfeID]
Beim Aufruf des Meldungsfensters können
der Meldungstext, der im Meldungsfenster ausgegeben werden soll,
der Fenstertitel des Meldungsfensters,
die Schaltflächen, die auf dem Meldungsfenster erscheinen sollen, und
die zugehörige Hilfe (Hilfedatei und HilfeID), die beim Drücken der Taste (F1) erscheinen soll,
festgelegt werden. Der Meldungstext und der Fenstertitel sind Zeichenketten. Im Meldungstext können – für eine übersichtlichere Darstellung – die Sonderzeichen
chr(9) für einen Tabulatorsprung,
chr(10) für den Zeilenvorschub (LineFeed),
chr(13) für den Wagenrücklauf sowie
chr(10) & chr(13) für den Zeilenvorschub mit Wagenrücklauf
verwendet werden. Die Länge der Zeichenkette im Meldungstext ist auf 1024 Zeichen begrenzt. Der Fenstertitel ist optional und braucht somit nicht angegeben zu werden. In diesem Fall tragen wir einfach den Namen des Projekts ein.
157
Der Parameter für die Schaltflächen ist ein numerischer Wert. Mit ihm wird angegeben, welche Schaltflächen in dem Meldungsfenster verfügbar sind. Wenn kein Wert für den Parameter Schaltflächen angegeben ist, werden folgende Standardeinstellungen gesetzt:
Das Meldungsfenster hat die Schaltfläche OK.
Die erste Schaltfläche wird beim Betätigen der (¢)-Taste aktiviert.
Das Fenster ist modal, d. h. die Applikation wird solange blockiert, bis eine Schaltfläche betätigt wurde.
In Tabelle 8.1 sind alle möglichen Werte, die die Eigenschaft Schaltflächen annehmen darf, definiert und erklärt.
vbOKOnly
vbOKCancel
vbAbortRetryIgnore
!
"#$% & $' $
vbYesNoCancel
(
)" $
vbYesNo
*
) $
vbRetryCancel
+
#$% &
vbCritical
,
" - .
vbQuestion
(!
" " / 0 1 . -
vbExclamation
*2
" " / 0 1 . #
vbInformation
,*
" " / 0 1 . $ 3 .3
vbDefaultButton1
% 34# 5 (¢) 6 7" 8 . 7 . 7 1
vbDefaultButton2
!+,
% %%6 7 5 (¢) 8 . 7 . 7 1 3
158
vbDefaultButton3
+!
% % 5 (¢) 8 . 7 . 7 1
vbApplicationModal
%- 8873 .3 %67 7 - 3 8873 0 0
vbSystemModal
*9,
%- : ..33. /- %6 7 3 "0 ;3 8873 ; 60
Tabelle 8.1: Die Schaltflächenkonstanten mit Werten und ihrer Beschreibung
Durch die Kombination der einzelnen Werte können unterschiedliche Meldungsfenster erzeugt und den Bedürfnissen des Programms angepaßt werden. Die Eigenschaft Hilfedatei ist optional und enthält bei Bedarf den Dateinamen der Datei, in der sich die gewünschte Hilfe befindet. Wenn der Parameter Hilfedatei angegeben wurde, muß auch der Parameter HilfeID angegeben werden, damit festgelegt wird, welche Hilfe in der Datei geladen werden soll. Das folgende Beispiel verarbeitet alle von Visual Basic definierten Fehlermeldungen. Tritt ein Fehler auf, kann durch Drücken der Taste (F1) eine kontextbezogene Hilfe zum aktuellen Fehler angefordert werden. Sub Fehlermeldung(Fehler As Integer) Dim Meldung As String 'Die auszugebende Meldung Err.Number = Fehler
'Den aufgetretenen Fehler 'der Fehleranalyse 'zuweisen 'Erzeugen des Meldungstextes mit den Err-Objektdaten Meldung = "Fehler Nr: " & Err.Number & " im " & _ Programm: " & Err.Source & Chr(13) & _ "Fehlermeldung: " & Error(Err.Number) 'Ausgabe des Fehlers in einem Meldungsfenster. Call MsgBox(Meldung, 16, "Fehlermeldung", _ Err.HelpFile, Err.HelpContext) End Sub
159
Diese Funktion wird aus einer Fehlerbehandlungsroutine aufgerufen. Für Testzwecke reicht es aus, diese Funktion in das Standardprojekt Vorgabe einzubinden und in der Funktion btn_Ok_Click() folgende Programmzeilen zu implementieren: Private Sub btn_Ok_Click() On Error GoTo weiter
'Wenn ein Fehler auftritt, gehe 'zur Sprungmarke weiter Error 3 'Erzeuge Fehler mit Nummer 3 Exit Sub 'Wenn noch kein Fehler 'aufgetreten ist, verlasse die 'Funktion weiter: 'Wenn ein Fehler aufgetreten 'ist, mache hier weiter Call Fehlermeldung(Err.Number) 'Fehlermeldung 'ausgeben End Sub
Wird das Programm gestartet, erscheint das Meldungsfenster in Abbildung 8.1. Mit dem Befehl Error 3 wird der Fehler „Nr. 3“ von Visual Basic erzeugt. Dieser Wert kann für Testzwecke geändert werden. In einem regulären Programm würde diese Programmzeile natürlich nicht enthalten sein. Würde dann ein Fehler im Programm auftreten, gäbe Visual Basic eine Meldung aus, und mit der Taste (F1) erhielte man Hilfe zu dem aufgetretenen Fehler.
Abbildung 8.1: Meldungsfenster mit Ausgabe einer erzeugten Fehlermeldung
160
9
Grafikprogrammierung
Ein großer Vorteil der grafischen Benutzeroberfläche ist – wie der Name schon sagt – die Möglichkeit, Grafiken darzustellen. In diesem Abschnitt wird die Programmierung von verschiedenen Grafiken beschrieben. Zuerst werden jedoch die Grundlagen erörtert und einige Befehle erklärt.
9.1
Grundlagen zur Grafikausgabe
9.1.1
Farben
Es gibt in Visual Basic 6.0 zwei Funktionen, mit denen die Farbe definiert werden kann: zum einen die Funktion QBColor für die Darstellung von 16 Farben, zum anderen die Funktion RGB für die TrueColorFarbdarstellung. Die Farbfunktion „QBColor“ Farbe = QBColor(Farbnummer As Integer)
Parameter
Beschreibung
Farbe
Dieser Parameter enthält den Farbwert für den RGB-Farbenmodus von Visual Basic, der für die Farbgebung von Steuerelementen und Objekten benötigt wird.
Farbnummer
Dieser Parameter listet die Farbnummern aus dem 16-Farben-Modus auf. 0 Schwarz
8
Dunkelgrau
1 Blau
9
Hellblau
2 Grün
10 Hellgrün
3 Türkis
11 helles Türkis
4 Rot
12 Hellrot
5 Fuchsinrot
13 helles Fuchsinrot
6 Braun
14 Gelb
7 Hellgrau
15 Weiß
161
Die Funktion QBColor rechnet die Farben aus dem 16-Farben-Modus in die Farben des RGB-Modus um. Dieser Befehl ist noch aus Gründen der Kompatibilität zu älteren Visual Basic-Versionen vorhanden. Er findet in der Programmierung unter den Visual Basic-Versionen ab Version 4.0 wenig Einsatz. Die „RGB“-Farbfunktion Farbe = RGB(Rot As Integer, Grün As Integer, Blau As Integer)
Parameter
Beschreibung
Farbe
Enthält den Farbwert für den RGB-Farben-Modus von Visual Basic, der für die Farbgebung der Steuerelemente und Objekte benötigt wird.
Rot
Gibt den Rotanteil an, den der Ergebnisfarbwert besitzt.
Grün
Gibt den Grünanteil an, den der Ergebnisfarbwert besitzt.
Blau
Gibt den Blauanteil an, den der Ergebnisfarbwert besitzt.
Mit der RGB-Methode können Farben mit 256 verschiedenen Rot-, Grün- und Blauanteilen ausgegeben werden. Rein rechnerisch können somit 256 x 256 x 256 = 16.777.216 verschiedene Farben dargestellt werden.
9.1.2
Die Line-Methode
Mit dieser Methode können einzelne oder miteinander verbundene Linien sowie Rechtecke gezeichnet werden. Um die Eigenschaften einer Linie festzulegen, stehen die folgenden Befehle zur Verfügung:
162
DrawWidth Definiert die Linienbreite.
DrawMode
Definiert die Art der Linie vor dem Hintergrund.
DrawStyle
Definiert die Art der Linie bezüglich ihres Aussehens (durchgezogen, gestrichelt ...).
Die Line-Methode setzt sich wie folgt zusammen: Object.Line [Step][(X1, Y1)] [Step](X2, Y2), [Farbe], [B][F] Parameter
Beschreibung
Objekt
Wenn das Steuerelement ein Teil eines Feldes von Steuerelementen ist, identifiziert diese Indexnummer das Steuerelement eindeutig.
Step
Mit dem Schlüsselwort Step wird angegeben, ob die in den Parametern (X1, Y1) angegebene Anfangsposition der Linie relativ zur aktuellen Grafikposition ist oder ob es sich um absolute Koordinaten in dem aktuellen Object handelt. Wird das Schlüsselwort Step angegeben, ist die Anfangsposition relativ zur aktuellen Grafikposition.
(X1, Y1)
Diese beiden Parameter sind optional, d. h., wenn diese Parameter fehlen, wird der Anfang der Linie auf die aktuelle Grafikposition festgelegt.
Step
Das zweite Schlüsselwort Step bezieht sich auf die Endkoordinaten der Linie und ist ebenfalls optional. Für dieses Schlüsselwort gilt dasselbe wie für das Schlüsselwort Step, das sich auf die Anfangskoordinaten bezieht.
(X2, Y2)
Mit diesen Koordinaten wird der Endpunkt der Linie festgelegt und somit auch die neue Grafikposition. Dieses Parameterpaar ist unbedingt anzugeben.
Farbe
Dieser Parameter definiert die Farbe, in der die Linie oder das Rechteck gezeichnet wird. Es handelt sich hierbei um eine Variable vom Typ Long, die die RGB-Farbe festlegt. Legt man keine Farbe fest, wird automatisch die Einstellung der ForeColor-Eigenschaft verwendet.
B
Ist der Parameter B angegeben, wird ein Rechteck gezeichnet, wobei die Koordinaten dann die diagonale Linie in dem Rechteck definieren. Also sind die Koordinaten gleichbedeutend mit den gegenüberliegenden Ecken des Rechtecks.
F
Dieser Parameter wird immer nur in Verbindung mit dem Parameter B verwendet. F gibt an, ob das Rechteck mit der Farbe gefüllt werden soll, die auch zum Zeichnen des Rechteckrahmens verwendet wurde, oder ob die Einstellungen aus den Eigenschaften
FillColor
FillStyle
verwendet werden sollen. Ist F angegeben, wird das Rechteck mit der Rahmenzeichenfarbe gefüllt.
163
9.1.3
Die Methode Circle
Mit Circle können Sie Kreise, Ellipsen oder Kreisbögen zeichnen. Zur Definition der Linienstärke und der Fläche stehen folgende Befehle zur Verfügung:
DrawWidth Definiert die Linienbreite.
DrawMode
Definiert die Art der Linie vor dem Hintergrund.
DrawStyle
Definiert die Art der Linie bezüglich ihres Aussehens (durchgezogen, gestrichelt ...).
Die Methode Circle setzt sich wie folgt zusammen: Object.Circle [Step] (X,Y), Radius, [Farbe, Start, Ende, Verhältnis] Parameter
Beschreibung
Step
Mit dem Schlüsselwort Step wird angegeben, ob der Mittelpunkt des Zeichnungselements die aktuelle Grafikposition ist oder ob es sich um absolute Koordinaten in dem aktuellen Objekt handelt. Wird das Schlüsselwort Step angegeben, ist die Anfangsposition relativ zur aktuellen Grafikposition.
(X, Y)
Diese beiden Parameter sind unbedingt erforderlich: Diese Koordinaten geben den Mittelpunkt des Zeichnungselements an.
Radius
Dieser Parameter ist ebenfalls erforderlich und gibt den Radius des Zeichnungselements an.
Farbe
Mit diesem Parameter wird die Farbe des Zeichnungselements festgelegt; er ist optional. Wenn kein Farbwert definiert wird, erfolgt die Färbung des Zeichnungselements in der Farbe, die in der Eigenschaft ForeColor des Objekts definiert wurde. Der Wert, der die Farbe definiert, kann entweder ein RGB-Farbwert oder ein Farbwert der QBColor-Funktion sein.
164
Start
Dieser Parameter gibt den Startpunkt an, wenn es sich bei dem Zeichnungselement um kein geschlossenes Element handeln soll (wie z.B. einen Kreis).
Ende
Dieser Parameter gibt den Endpunkt an, wenn es sich bei dem Zeichnungselement um kein geschlossenes Element handeln soll (wie z.B. einen Kreis).
Verhältnis
Mit diesem Parameter wird das Seitenverhältnis der Ellipse angegeben. Ist das Verhältnis 1, erhält man einen Sonderfall, den Kreis. Wird dieser Parameter nicht angegeben, ist der Wert 1 voreingestellt und somit ein Kreis vorgegeben.
9.2
Grafische Beispiele
In dem folgenden Abschnitt werden zwei grafische Beispielprogramme gezeigt, mit denen die Möglichkeiten der grafischen Programmierung unter Visual Basic dargestellt werden sollen. Als Grundlage dient ebenfalls das mitgelieferte Vorgabeprojekt auf der Diskette, so daß man sich ganz auf die Grafikprogrammierung konzentrieren kann.
9.2.1
RGB-Farbenbeispiel
In diesem Beispiel wird ein Programm entwickelt, mit dem alle RGBFarben in einem Bildfeld-Steuerelement dargestellt werden können. Die Farbwerte der drei Grundfarben Rot, Grün und Blau werden über Bildlaufleisten eingestellt. In drei Bildfeld-Steuerelementen wird die jeweilige Grundfarbe angezeigt, in einer weiteren, vierten die Farbe, die sich als Mischung aus den drei Farben ergibt. Zu jedem BildfeldSteuerelement gibt es ein Texteingabeelement, in dem der jeweilige Farbwert ausgegeben wird. Der Farbwert kann aber auch über das Texteingabeelement geändert werden. Die Programmoberfläche Um die gestellten Anforderungen zu erfüllen, ist eine Programmoberfläche wie in Abbildung 9.1 nötig.
Abbildung 9.1: Die Programmoberfläche für das RGB-Farbenbeispiel
165
Für jede der drei Grundfarben gibt es eine Bildlaufleiste mit einem zugehörigen Texteingabeelement und einer Bildschaltfläche. In einer zusätzlichen Bildschaltfläche und einem Texteingabeelement wird der gesamte RGB-Farbwert aller drei Farben ausgegeben. Mit der Taste AUTOMATISCH werden die drei Farbregler vom Programm verschoben und erzeugen automatisch einige mögliche Farben. In Tabelle 9.1 sind die Eigenschaften der benötigten Steuerelemente beschrieben. Als Projektgrundlage kann das Programm VORLAGE, das Sie auf der beigefügten Diskette finden, verwendet werden. Steuerelement
Eigenschaft
Inhalt
Beschreibung
Bildlaufleisten
(Name)
hsc_Farbe(0-2)
Dient zum Regeln des Anteils der jeweiligen Grundfarbe an die RGB-Farbe.
pic_Farbe(0-2)
Stellt den jeweiligen Farbwert dar, der mit den Bildlaufleisten definiert wurde.
pic_RGB
Stellt die Farbe dar, die aus dem Mischen der eingestellten Grundfarben entsteht.
txt_Farbe(0-2)
Dient zur Ein- und Ausgabe des aktuellen Farbwerts einer Grundfarbe.
txt_RGB
Dient zur Ein- und Ausgabe des aktuellen RGB-Farbwerts.
Bildfeld-Steuerelemente
TexteingabeElement
Tabelle 9.1: Die Steuerelemente zum RGB-Farbenbeispiel
Die Programmentwicklung Wird das Programm gestartet, müssen zuerst alle Farbwerte initialisiert werden. Für diesen Vorgang wird das Ereignis Load des Formulars benutzt. Als erstes wird der Wertebereich festgelegt, in dem sich die Bildlaufleisten bewegen. Da die RGB-Funktion in allen drei Eingabeparametern einen Wertebereich von 0 bis 255 hat, wird auch der Wertebereich der Bildlaufleisten von 0 bis 255 definiert. Dann werden die Bildlaufleisten auf 0 zurückgesetzt und alle anderen Steuerelemente an die eingestellten Farbwerte in den Bildlaufleisten angepaßt. Nach der Initialisierung sind somit alle drei Farbwerte ausgeschaltet. Private Sub Form_Load() Dim i As Integer 'Initialisieren der Farbbereiche For i = 0 To 2 hsc_Farbe(i).Min = 0 hsc_Farbe(i).Max = 255 hsc_Farbe(i).Value = 0 pic_Farbe(i).BackColor = 0
166
txt_Farbe(i).Text = 0 Next i 'Initialisieren des Misch-Farbfeldes pic_RGB.BackColor = 0 txt_RGB.Text = 0 End Sub
Als nächstes muß der Programmcode entwickelt werden, der jede Änderung der Bildlaufleisten in den Bildfeld- und Texteingabe-Elementen aktualisiert. Hierfür wird das Ereignis Change der Bildlaufleisten verwendet. Private Sub hsc_Farbe_Change(Index As Integer) Dim Farbe(3) As Integer 'In Index ist die Bildlaufleiste enthalten, deren Wert sich 'geändert hat die beiden anderen Farben sind unverändert. Farbe(Index) = 1 'Aktualisiere den RGB_Farbwert pic_RGB.BackColor = RGB(hsc_Farbe(0).Value, _ hsc_Farbe(1).Value, hsc_Farbe(2).Value) 'Aktualisiere die Farbe in dem der Bildlaufleiste zugehörigen 'Bildfeld-Steuerelement. pic_Farbe(Index).BackColor = RGB( _ Farbe(0) * hsc_Farbe(0).Value, _ Farbe(1) * hsc_Farbe(1).Value, _ Farbe(2) * hsc_Farbe(2).Value) 'Aktualisiere auch die jeweiligen Textschaltflächen txt_RGB.Text = pic_RGB.BackColor txt_Farbe(Index).Text = hsc_Farbe(Index).Value End Sub
Werden nun die Bildlaufleisten verschoben, werden ebenfalls alle Farben, die sich ändern, aktualisiert. Um auch die Farben anzupassen, wenn sich der Inhalt der Textelemente ändert, muß in dem Ereignis KeyUp die Einstellung der jeweiligen Bildlaufleiste geändert werden. Durch das Ändern der Bildlaufleistenvariablen wird das Ereignis Change ausgelöst, und alle Felder werden nach dem zuvor beschriebenen Ablauf aktualisiert. Der Programmcode muß im KeyUpEreignis enthalten sein, damit es keine Rückkopplung geben kann und das Programm keinen Fehler verursacht. Des weiteren muß die Eingabe in die Textelemente auf ihre Gültigkeit hin geprüft werden. Wird z.B. eine Zahl in die Grundfarbenelemente eingegeben, die größer als 255 oder kleiner als 0 ist, so muß dieser falsche Wert erkannt und ersetzt werden. Der zulässige Höchstwert bei dem RGB-Farb-Textelement ist (256 x 256 x 256) – 1 = 16777215.
167
Private Sub txt_Farbe_KeyUp(Index As Integer, KeyCode As Integer, Shift As Integer) Dim Speicher As Long On Error GoTo Fehler_txt_Farbe_KeyUp Speicher = CLng("0" & txt_Farbe(Index).Text) If Speicher > 255 Or Speicher < 0 Then Speicher = 255 End If hsc_Farbe(Index).Value = Speicher Exit Sub Fehler_txt_Farbe_KeyUp: txt_Farbe(Index).Text = Speicher Exit Sub End Sub Private Sub txt_RGB_KeyUp(KeyCode As Integer, Shift As Integer) Dim Speicher As Long On Error GoTo Fehler_txt_RGB_KeyUp Speicher = CLng("0" & txt_RGB.Text) If Speicher > 16777215 Or Speicher < 0 Then Speicher = 16777215 End If hsc_Farbe(0).Value = Speicher Mod 256 Speicher = (Speicher – (Speicher Mod 256)) / 256 hsc_Farbe(1).Value = Speicher Mod 256 Speicher = (Speicher – (Speicher Mod 256)) / 256 hsc_Farbe(2).Value = Speicher Mod 256 Exit Sub Fehler_txt_RGB_KeyUp: txt_RGB.Text = Speicher Exit Sub End Sub
Zum Schluß wird noch der automatische Ablauf für den Farbenwechsel programmiert. Hierbei werden die Bildlaufleisten über For-Schleifen bewegt. Diese Funktion läßt sich beliebig erweitern. Die hier aufgeführte Funktion ist nur ein kleiner Auszug aus den möglichen Bewegungsabläufen. Private Sub btn_Ok_Click() Dim i As Integer Dim Farbe As Long 'Alle Eingabemöglichkeiten sperren frm_RGB_Farben.Enabled = False 'Die Farben neu initialisieren hsc_Farbe(0).Value = 0 hsc_Farbe(1).Value = 0
168
hsc_Farbe(2).Value = 0 For i = 0 To 2 'Alle Farbregler nacheinander For Farbe = 0 To 255 'nach oben aussteuern hsc_Farbe(i).Value = Farbe DoEvents Next Farbe For Farbe = 0 To 255 'und wieder zurückregeln hsc_Farbe(i).Value = 255 – Farbe DoEvents Next Farbe Next i 'Alle drei Farben gleichzeitig aufs Maximum hochregeln For Farbe = 0 To 255 hsc_Farbe(0).Value = Farbe hsc_Farbe(1).Value = Farbe hsc_Farbe(2).Value = Farbe DoEvents Next Farbe 'Alle Eingabemöglichkeiten wieder frei schalten frm_RGB_Farben.Enabled = True End Sub
9.2.2
Chaos auf dem Bildschirm – das „fraktale Apfelmännchen“
Wer kennt es nicht, das „fraktale Apfelmännchen“! Es ist ein sehr schönes Beispiel, um einzelne Bildpunkte in einem Fenster zu definieren. Das Beispielprogramm soll das „fraktale Apfelmännchen“ in einem Anzeige-Steuerelement ausgeben (ohne daß hierbei näher auf die Definition des Apfelmännchens eingegangen wird). Dies soll die Möglichkeit bieten, einige Grafikbefehle kennenzulernen. Der Algorithmus, der dieser Berechnung zugrundeliegt, kann im Buch „Visual Basic 5.0. Effiziente Programmentwicklung unter Windows 95“ von Michael Kofler bzw. in anderen Fachbüchern nachgelesen werden. Die Vorgaben des „fraktalen Apfelmännchens“ Die folgenden Konstanten definieren den Wertebereich, in dem die Berechnung der Fraktale durchgeführt wird. Const Aufloesung = 250 Const X_Oben = 1.7 Const X_Unten = –0.8 Const Y_Oben = 1.2 Const Y_Unten = –1.2 Dim Farben As Long
169
Berechnung des Farbwerts Die folgende Funktion berechnet den Farbwert, den ein Bildpunkt in dem Ausgabefenster erhalten soll. Private Function Fraktale(X As Integer, y As Integer) As Integer Dim u As Double Dim a As Double Dim Merker As Double Dim Real As Double 'Realteil der komplexen Zahl Dim Imaginaer As Double 'Imaginärteil der komplexen 'Zahl Dim Iteration As Integer 'Anzahl der Berechnungen u = 0 'Initialisierung der Startwerte a = 0 'für die Iteration Iteration = 0 On Error GoTo Err_Fraktale 'Berechnung des Realanteiles und des Imaginäranteiles 'der komplexen Zahl Real = X_Unten + X * ((X_Oben – X_Unten) _ / Aufloesung) Imaginaer = Y_Oben – y * ((Y_Oben – Y_Unten) _ / Aufloesung) 'Berechnen des Farbwertes anhand der benötigten 'Iterationsdurchläufe While a < 4 And Iteration < 15 DoEvents Merker = (u ^ 2 – a ^ 2) – Real a = 2 * u * a – Imaginaer u = Merker Iteration = Iteration + 1 Wend Fraktale = Iteration Exit Function Err_Fraktale: Fraktale = Iteration End Function
Aufruf des Berechnungsalgorithmus Mit der folgenden Funktion wird die Größe des Ausgabefensters ermittelt, an die sich die geforderte Auflösung des „fraktalen Apfelmännchens“ anpaßt. Durch Betätigen der Schaltfläche OK wird die Berechnung für jeden Bildpunkt gestartet.
170
Private Sub btn_Ok_Click() Dim i As Integer 'Zähler der X–Achse des Koordinatensystems Dim j As Integer 'Zähler der Y–Achse des Koordinatensystems Dim X As Double Dim y As Double Dim Iteration As Integer 'Anzahl der benötigten Berechnungen 'Berechnung der Länge und Höhe eines Bildpunkts X = pic_Bild.ScaleWidth / Aufloesung y = pic_Bild.ScaleHeight / Aufloesung 'Berechnung des Farbwertes von jedem Bildpunkt im Koordinatensystem For i = 0 To Aufloesung - 1 For j = 0 To Aufloesung - 1 DoEvents Iteration = Fraktale(i, j) pic_Bild.Line (i * X, j * y)-((i + 1) * X, _ (j + 1) * y), QBColor(Iteration), BF Next j Next i End Sub
Das Ergebnis In Abbildung 9.2 ist das fertig berechnete „fraktale Apfelmännchen“ dargestellt. Je nach Leistungsfähigkeit des eingesetzten Computers und gewählter Auflösung kann die Berechnung dieses Bildes mehrere Minuten in Anspruch nehmen.
Abbildung 9.2: Das „fraktale Apfelmännchen“
171
10
Der Menüdesigner
Alle bisher entwickelten Applikationen bestanden nur aus den Steuerelementen. Unter Windows besitzen aber die meisten Programme auch eine Menüzeile. Auch in Visual Basic hat man die Möglichkeit, eine Menüzeile für die Programme zu generieren. Hierfür wird der Menüdesigner bereitgestellt (Abbildung 10.1). Man startet ihn über das Menü EXTRAS | MENÜ-EDITOR...
Abbildung 10.1: Der Menüdesigner
Im Menüdesigner müssen zwei grundsätzliche Einträge gemacht werden: zum einen die Menüoption, zum anderen die Funktion bzw. Prozedur, die mit diesem Menüpunkt aufgerufen werden soll. Bevor mit dem Entwurf des Menüs begonnen werden kann, sollten die Menüeinträge und ihre Struktur definiert sein. Für dieses Design bietet sich die Baumstruktur an, wie sie z.B. zur Darstellung des Dateisystems im Datei-Manager verwendet wird. Des weiteren sollten Standardfunktionen, die durch Windows-Standards unterstützt werden,
173
in Menüs implementiert sein. Im allgemeinen sind dies Funktionen aus den Menüs
DATEI SPEICHERN, SPEICHERN UNTER, DRUCKEN, BEENDEN;
BEARBEITEN RÜCKGÄNGIG, WIEDERHOLEN, AUSSCHNEIDEN, KOPIEREN, EINFÜGEN, INHALTE EINFÜGEN, LÖSCHEN, MARKIEREN, SUCHEN, ERSETZEN;
Fenster NEUES FENSTER, ANORDNEN, TEILEN;
? (für HILFE) INHALT, SUCHEN, INDEX.
In dem Feld Caption werden die Menütexte eingetragen. Um die einzelnen Menübefehle über die (Alt)-Taste aktivieren zu können, muß vor den Buchstaben, der mit der (Alt)-Taste das Menü aktivieren soll, das kaufmännische „Und“ (&) gesetzt werden. Dieser Buchstabe erscheint dann unterstrichen im Menü. Im Textfeld Name muß die interne Bezeichnung des Menüpunkts eingetragen werden. Dieser Name identifiziert dann den Menüpunkt, so wie der Name in einem Steuerelement das Steuerelement identifiziert. Aus diesem Grund sollte auch für diesen Namen eine Kennung zur Identifizierung vergeben werden. In den angeführten Beispielen wird dies die Kennung mnu sein. Sollten in einem Programm dann etwa eine Schaltfläche und ein Menüeintrag zum Beenden des Programmes vorhanden sein, können beide die gleiche Bezeichnung haben, z.B. ABBRECHEN, und durch die Kennung, die vorangestellt wird, unterschieden werden: btn_Abbrechen mnu_Abbrechen.
Diese Art der Namensvergabe ist sehr übersichtlich, da anhand des Namens erkennbar ist, daß beide Funktionen das Programm gleichermaßen beeinflußen sollen, aber unterschiedliche Steuerelemente sind. In Visual Basic ist es zwar erlaubt, daß zwei Pull-Down-Einträge in einem Menü den gleichen Namen haben, sie müssen sich dann jedoch in ihren Indexwerten unterscheiden. Über die Schaltflächen (Abbildung 10.2) kann man die Position eines Menüeintrags im Menü definieren. Die beiden linken Buttons geben die Ebenen im Menü an, die beiden rechten Buttons die vertikale Position im Menü. Für die Menüleiste gilt: der oberste Eintrag im Menüdesigner ist im Menü ganz links, der unterste ganz rechts positioniert.
174
Abbildung 10.2: Die Pfeilschaltflächen des Menüdesigners
Die CheckBox Enabled gibt an, ob der Menüpunkt verfügbar ist. Mit dieser Eigenschaft kann während der Laufzeit eine Menüoption abgeschaltet werden. Wenn z. B. ein bestimmter Prozeß in einem Programm ausgeführt wird, der nicht abgebrochen werden darf, läßt sich über diese Eigenschaft der Menüpunkt BEENDEN deaktivieren. Der Benutzer sieht diesen Menüeintrag, kann ihn jedoch nicht aktivieren. Die CheckBox Visible gibt an, ob dieser Menüeintrag sichtbar ist. Also: Wenn im Pull-Down-Menü unter DATEI im Menüdesigner fünf Punkte eingetragen werden und dabei zwei als unsichtbare gesetzt werden, erscheinen während der Programmausführung nur die anderen drei Einträge. Mit dieser Option läßt sich somit das sog. kontextabhängige Menü realisieren: Es sind dadurch immer nur diejenigen Menübefehle sichtbar, die auch ausgeführt werden können. Um bei einem Menüeintrag das Checked-Zeichen („“) anzuzeigen, z.B. um zu verdeutlichen, daß diese Option aktiviert wurde, gibt es die ebenso genannte Eigenschaft Checked. Das Zeichen befindet sich im Menü FENSTER, wo es ausgibt, welches aktiviert ist. Mit der Option Shortcut kann man einstellen, mit welcher Tastenkombination dieser Menüpunkt ausgeführt werden kann. In Windows gibt es z.B. folgende standardmäßige Shortcuts: (Strg)+(X) für Ausschneiden, (Strg)+(K) für Kopieren, (Strg)+(V) für Einfügen,
10.1
Aufgabe
Sie sollen nun ein Programmenü entwickeln, das alle Windows-Standardmenüs enthält.
10.2
Lösung
Das Lösungsprogramm befindet sich auf der Diskette im Verzeichnis \MENU. In Abbildung 10.3 ist das Menü dargestellt, wie es im Menüdesigner aussieht. Abbildung 10.4 zeigt das Dateimenü während der Programmausführung.
175
Abbildung 10.3: Das Beispielmenü im Menüdesigner während der Designphase
Abbildung 10.4: Das fertige Beispielmenü
176
11
Aufbau eines Visual BasicProjekts
Es gibt in der Programmierung zwei große Klassen, denen die meisten Programmiersprachen zugeordnet werden können: die ablaufgesteuerten und die ereignisgesteuerten Programmiersprachen.
11.1
Ablaufgesteuerte Programmierung
Ablaufgesteuerte Programmierung bedeutet, daß der Programmfluß eindeutig definiert ist. In diesem Fall kann man ein sogenanntes Flußdiagramm mit einem Anfang und einem Ende zeichnen (siehe Abbildung 11.1).
Abbildung 11.1: Beispiel eines schematischen Ablaufplans
177
Der Programmfluß mit Programmanfang und Programmende ist eindeutig erkennbar. Programme, die immer eine sog. Start- oder Hauptfunktion benötigen, fallen in die Kategorie der ablaufgesteuerten Programmiersprachen. 11.2
Ereignisgesteuerte Programmierung
Visual Basic ist eine ereignisgesteuerte Sprache und reagiert deshalb auf unterschiedliche Ereignisse, die auf das Programm einwirken, in unterschiedlicher Weise. Das Programmbeispiel zeigt, daß ein Ereignis, das während der Ausführung eines Programmteils eintrift, diesen unterbricht und einen neuen startet. Die Programmteile sind zwar voneinander unabhängig; dennoch kann das Programm nur einen Ablauf steuern. Als Grundlage für das Beispielprogramm dient ebenfalls das Vorgabeprojekt auf der Diskette. Die Schaltfläche OK wird in EREIGNIS1 umbenannt. Zusätzlich wird eine dritte Schaltfläche mit Namen EREIGNIS2 benötigt. Um den Status der einzelnen Ereignisse anzuzeigen, werden zwei Textelemente benötigt. Die beiden Ereignisse sind einfach nur zwei For-Schleifen, die den Inhalt der Zählvariablen in das jeweilige Textelement schreiben. Im folgenden ist der zugehörige Programmcode abgebildet. Private Sub btn_Ereignis1_Click() Dim i As Integer For i = 0 To 32000 DoEvents lab_Ereignis1.Caption = i Next i End Sub Private Sub btn_Ereignis2_Click() Dim i As Integer For i = 0 To 32000 DoEvents lab_Ereignis2.Caption = i Next i End Sub
Wird die Schaltfläche EREIGNIS1 betätigt, beginnt die For-Schleife mit der Ausgabe des aktuellen Zählschleifenwerts im Textelement. Wird nun die Schaltfläche EREIGNIS2 betätigt, bleibt der aktuelle Schleifenwert des ersten Ereignisses im Textelement bestehen. Im Textelement für das zweite Ereignis wird mit der Ausgabe des aktuellen Schleifenwertes begonnen.
178
Im ersten Moment mag dies sehr vorteilhaft aussehen. Dennoch passieren durch diesen Effekt viele Programmabstürze. Folgendes theoretisches Programmbeispiel soll das Problem erläutern: Durch Betätigen der Schaltfläche EREIGNIS1 wird eine Tabelle Adressen aus einer Datenbank erzeugt. Das Ereignis, das durch die Schaltfläche EREIGNIS2 ausgelöst wird, greift auf die Tabelle Adressen zu und generiert nun eine Tabelle Städte. Wird nun die Schaltfläche EREIGNIS2 betätigt, während noch die Tabelle Adressen generiert wird, ist dieser Prozeß noch nicht abgeschlossen, und die Ergebnistabelle Städte ist falsch. Um solche Fehler zu vermeiden, sollten die Steuerelemente nur verfügbar sein, wenn kein Prozeß aktiv ist. Wird ein Prozeß gestartet, werden alle Steuerelemente, die einen Fehler erzeugen können, solange auf gesperrt gesetzt, bis der Prozeß erfolgreich abgeschlossen ist.
179
12
12.1
Entwicklung einer komplexen Applikation
Beschreibung des Programms „StackTaschenrechner“
In diesem Kapitel soll nun endlich eine komplexere Anwendung entwickelt werden, als dies bisher der Fall war – ein Stack-Taschenrechner. Diese Art Taschenrechner arbeitet mit der Postfix-Notation, d. h. es sind zunächst der oder die Operanden einzugeben und dann erst der Operator, da die Zahlen in einem Stack gespeichert werden. Dieser Stack arbeitet wie eine LiFo-Liste1. Es ist zwar für einen Taschenrechner ungewöhnlich, nach dieser Art zu rechnen, doch hat dies den Vorteil, daß kein expliziter Speicher mehr benötigt wird. In Tabelle 12.1 sind die drei Rechenarten Präfix, Infix und Postfix für die Berechnung der Gleichung 12.1 dargestellt.
R ges =
R1 * R2 R1 + R2
Gleichung 12.1: Berechnung des Gesamtwiderstands aus einer Parallelschaltung von zwei Widerständen
Präfix
Infix
Postfix
/ *R1R2 +R1R2
(R1*R2)/(R1+R2)
R1R2* R1R2+ /
Die Operatoren stehen vor den Operanden
Die Operatoren stehen zwischen den Operanden
Die Operatoren stehen hinter den Operanden
Tabelle 12.1: Vergleich der drei Notationsarten „Präfix“, „Infix“ und „Postfix“
1. „Last in, first out“: Die Zahl, die als letzte in die Liste geschrieben wurde, wird als erste entnommen.
181
In Tabelle 12.2 werden die einzelnen Eingaben in den Stackrechner und in einen normalen Infixrechner einander gegenübergestellt. Für R1 soll der Widerstandswert 200 Ω, für R2 der Widerstandswert 100 Ω angenommen werden. Postfix
Infix
Stackrechner
normaler Taschenrechner
Eingabe von R1
200
Eingabe von R1
200
Eingabe von R2
100
Drücken der Taste ADDITION
+
Drücken der Taste MULTIPLIKATION
*
Eingabe von R2
100
Eingabe von R1
200
Zwischenergebnis in den Speicher
MR
Eingabe von R2
100
Eingabe von R1
200
Drücken der Taste ADDITION
+
Drücken der Taste MULTIPLIKATION
*
Drücken der Taste DIVISION
/
Eingabe von R2
100
Drücken der Taste DIVISION
/
Inhalt des Speichers abfragen
MR
Tabelle 12.2: Berechnung der Gleichung 12.1 mit Postfix- und Infix-Taschenrechner
Wie in Tabelle 12.1 zu sehen ist, wird die Gleichung in der richtigen Reihenfolge eingegeben, nämlich 1. Multiplikation, 2. Addition und 3. Division.
Es wird kein Speicher benötigt, um das Zwischenergebnis zu behalten. Ein weiterer Vorteil dieses Taschenrechnerprogramms ist, daß es ohne Probleme erweitert und den persönlichen Bedürfnissen angepaßt werden kann.
12.2
Planung des Projekts
Zuerst muß geklärt werden, welche Funktionen der Taschenrechner biten soll. Zunächst wird natürlich ein numerischer Tastaturblock für die Eingabe der Zahlen benötigt. 0...9
Darüber hinaus wird jeweils eine Taste benötigt, um Eingaben zu bestätigen und zu löschen. Enter, Del
Des weiteren müssen die vier Grundrechenarten vorhanden sein:
182
!
+ – * /
Als zusätzliche Funktionen werden schließlich noch die Winkelfunktionen eingebaut. Ebenso ist eine Funktion zu realisieren, die ermittelt, ob es sich bei der eingegebenen Zahl um eine Primzahl handelt. Sin, Cos, Tan IstPrim Invers
Es sollen immer die letzten vier Werte, die auf dem Stack gespeichert sind, sichtbar sein. Um die Farben einstellen zu können, soll ein Menü auf einem Tabulator verwendet werden.
12.3
Die verwendeten Steuerelemente und ihre Eigenschaften
In Tabelle 12.3 sind alle Steuerelemente und ihre Namen eingetragen. Auf diese Tabelle wird dann im weiteren Verlauf der Programmentwicklung verwiesen, um identische Programme zu erhalten. Steuerelemente
Wert
Labelfelder
lab_Ausgabe(1-3) lab_FarbeAusgabe
Schaltflächen
btn_Ziffer(0-9) btn_Komma btn_Enter btn_Del btn_Clear btn_Plus btn_Minus btn_Mal btn_Geteilt btn_Undo btn_Cosinus btn_Tangens btn_Sinus btn_Invers btn_Pi
" #
$
183
Steuerelemente
Wert btn_Istprim btn_SchriftAusgabe btn_Farbe_Ausgabe
CommonDialog
cmd_Einstellungen
Tabelle 12.3: Eigenschaften der Taschenrechner-Steuerelemente
12.4
Programmglobale Definitionen
Die folgenden Einstellungen sollen in dem Visual Basic-Modul Global gemacht werden. Sie dienen zur Definition von Zahlen wie z.B. der Zahl Pi (p) oder anderen Definitionen, die im gesamten Programm bekannt sein sollen. In diesem Modul werden auch die neuen Variablentypen definiert, die dem gesamten Programm zur Verfügung stehen müssen. Option Explicit Type Stack Inhalt() As String Anzahl As Integer End Type Global Global Global Global Global Global Global Global
Const Const Const Const Const Const Const Const
PLUS = 0 MINUS = 1 MAL = 2 GETEILT = 3 SINUS = 4 COSINUS = 5 TANGENS = 6 INVERS = 7
Global Const Komma = "," Global Const PI = 3.141592654 Global Const MAXLONG = 2147483647
184
!
12.5
Funktionen im Formular
12.5.1
Formularglobale Definitionen
Option Explicit Dim Liste As Stack Dim Merker As Stack
12.5.2
'Enthält alle eingegebenen Zahlen 'Enthält die Zahlen der letzten Berechnung
Initialisieren der Variablen
Die Initialisierung der Variablen erfolgt beim Programmstart in der Eigenschaft Form_Load. Startet man das Programm, wird diese Funktion abgearbeitet. Da beim Programmstart noch keine Werte auf den Stack geschrieben wurden, ist die Anzahl der eingetragenen Werte 0. Zur Verdeutlichung der Initialisierung der Stackvariablen sollten die Felder, in welchen die Stackwerte gespeichert werden, ebenfalls initialisiert werden. Für die Initialisierung der Farbenauswahl wird die momentane Farbeinstellung des Ausgabefensters dem Label zugewiesen, das die Einstellungen auf dem Registerblatt Optionen darstellt. Private Sub Form_Load() Liste.Anzahl = 0 Erase Liste.Inhalt btn_Undo.Enabled = False lab_FarbeAusgabe.BackColor = lab_Ausgabe(0).BackColor lab_FarbeAusgabe.ForeColor = lab_Ausgabe(0).ForeColor End Sub
12.5.3
Speichern des letzten Zustandes
Um Eingaben oder Berechnungen rückgängig zu machen, muß die Veränderung, die mit einem Rechenschritt oder einer Eingabe gemacht wird, zwischengespeichert werden. Hierzu wird die Funktion Merke_den_Wert benötigt. Sie speichert in einem Feld, das wie die Stackvariable aufgebaut ist, die letzten Werte. Als Parameter benötigt diese Funktion deshalb zum einen den Wert, der gespeichert werden soll, und zum anderen die Nummer des Werts, um den es sich dabei handelt. Die Funktion arbeitet wie folgt:
% %
185
Wird ihr ein Wert übergeben, verändert sie die Feldgröße so, daß der neue Wert genau an der letzten Stelle eingetragen wird. Durch diese Methode braucht das Feld nicht initialisiert zu werden, da die Feldgröße auf 1 gesetzt wird, wenn der erste Wert eingetragen ist. Wird dann ein Rechenschritt zwischengespeichert, kann die Schaltfläche UNDO auf verfügbar geschaltet werden. Function Merke_den_Wert(Inhalt As String, Wert As Integer) 'Erweitere das Feld der zu merkenden Einträge und 'speichere den neuen Inhalt ReDim Preserve Merker.Inhalt(Wert) Merker.Inhalt(Wert – 1) = Inhalt Merker.Anzahl = Wert btn_Undo.Enabled = True End Function
12.5.4
Vorbereitung der Berechnung
Um die Berechnung durchzuführen, müssen einige Vorgänge zuvor geprüft werden. Wird eine Berechnung mit einem Wert durchgeführt, z. B. das Invertieren einer Zahl, muß zuerst überprüft werden, ob das Eingabefeld eine Zahl enthält; diese wird dann in die Stackvariable übernommen. Ist im Eingabefeld keine Zahl enthalten, wird die Stackvariable überprüft. Bei Berechnungen mit zwei Zahlen muß dies für beide Zahlen erfolgen usw. Ist diese Überprüfung abgeschlossen, kann die eigentliche Berechnung erfolgen. Dies geschieht dann aber im Programm-Modul Rechnen. Function Rechnen(Operation As Integer) Dim i As Integer Dim Operanden As Integer 'Anzahl der benötigten 'Operanden für die 'Funktion Dim Ergebnis As String 'Das Ergebnis der 'Berechnung 'Wenn sich eine Zahl noch in der Eingabe befindet, 'schiebe sie auf den Stack Call Stack_aktualisieren Select Case Operation Case PLUS, MINUS, MAL, GETEILT Operanden = 2 If Liste.Anzahl >= Operanden Then Ergebnis = Zweier_Tupel((CDbl( _ Liste.Inhalt(Liste.Anzahl – _ 2))), (CDbl(Liste.Inhalt( _ Liste.Anzahl – 1))), Operation)
186
!
Else Operanden = 0 End If Case SINUS, COSINUS, TANGENS, INVERS Operanden = 1 If Liste.Anzahl >= Operanden Then Ergebnis = Einer_Tupel((CDbl(Liste.Inhalt _ (Liste.Anzahl – 1))), Operation) Else Operanden = 0 End If End Select 'Lösche alle Operanden aus dem Stack und speichere 'sie zwischen For i = 1 To Operanden Call Merke_den_Wert(Liste.Inhalt( _ Liste.Anzahl – 1), i) Call Stack_Wert_loeschen Call Stack_anzeigen Next i lab_Eingabe.Caption = Ergebnis 'Schreibe das Ergebnis auf den Stack und 'aktualisiere die Anzeige Call Stack_aktualisieren End Function
12.5.5
Eingabe von der Tastatur
Um Eingaben von der Tastatur durchführen zu können, muß eine Funktion entwickelt werden, die in den richtigen Rechenschritt verzweigt. Diese Funktion ruft dann nur noch die Ereignisse der einzelnen Schaltflächen auf, die mit der Maus betätigt werden können. Function Rechner_betätigen(KeyAscii As Integer) Select Case KeyAscii Case Asc(0) To Asc(9) 'Eine Ziffer wird 'eingegeben Call btn_Ziffer_Click(Chr(KeyAscii)) Case Asc("."), Asc(",") If btn_Komma.Enabled = True Then Call btn_Komma_Click End If Case 13 'Die Taste Return Call btn_Enter_Click Case 43 'Das Plus-Zeichen "+" Call btn_Plus_Click
% %
187
Case 45 'Das Call btn_Minus_Click Case 42 'Das Call btn_Mal_Click Case 47 'Das Call btn_Geteilt_Click Case Asc("d"), Asc("D") 'Die Call btn_Del_Click Case Asc("l"), Asc("L") 'Die Call btn_Clear_Click Case Asc("u"), Asc("U") 'Die Call btn_Undo_Click Case Asc("c"), Asc("C") 'Den Call btn_Cosinus_Click Case Asc("s"), Asc("S") 'Den Call btn_Sinus_Click Case Asc("t"), Asc("T") 'Den Call btn_Tangens_Click Case Asc("i"), Asc("I") Call btn_Invers_Click End Select End Function
12.5.6
Minus-Zeichen "–" Mal-Zeichen "*" Geteilt-Zeichen "/" Del-Taste Clear-Taste Undo-Taste Cosinus berechnen Sinus berechnen Tangens berechnen
Den Stack aktualisieren
Um die Liste aller Zahlen zu verwalten, die in den Taschenrechner eingegeben wurden, werden noch folgende Funktionen benötigt:
Die Liste nach Berechnung aktualisieren Stack_aktualisieren
Die Liste neu anzeigen Stack_anzeigen
Einen neuen Wert in die Liste eintragen Stack_eintragen
Einen alten Wert aus der Liste entfernen Stack_Wert_loeschen
Function Stack_aktualisieren() 'Wenn keine Eingabe erfolgt, verlasse die Funktion If Len(lab_Eingabe.Caption) < 1 Then tab_Rechner.SetFocus 'Aber vorher das Tab wieder 'aktivieren Exit Function End If 'Wenn das letzte Zeichen ein Komma ist, entferne 'dieses
188
!
If Right(lab_Eingabe.Caption, 1) = Komma Then lab_Eingabe.Caption = Left(lab_Eingabe.Caption, _ Len(lab_Eingabe.Caption)–1) End If Call Stack_eintragen(lab_Eingabe.Caption) Call Stack_anzeigen lab_Eingabe.Caption = "" btn_Komma.Enabled = True tab_Rechner.SetFocus End Function Function Dim i For i If
Stack_anzeigen() As Integer = 0 To 3 i < Liste.Anzahl Then lab_Ausgabe(i).Caption = Liste.Inhalt( _ Liste.Anzahl – (i + 1)) Else lab_Ausgabe(i).Caption = "" End If Next i End Function Function Stack_eintragen(Wert As String) 'Das dynamische Feld um 1 vergrößern, ReDim Preserve Liste.Inhalt(Liste.Anzahl + 1) Liste.Inhalt(Liste.Anzahl) = Wert 'Neuer Wert kommt 'hinzu. Liste.Anzahl = Liste.Anzahl + 1 'Erhöhen der 'eingetragenen Werte End Function Function Stack_Wert_loeschen() 'Wenn es mindestens einen Eintrag in die Liste gibt If Liste.Anzahl > 0 Then 'Entferne den letzten Wert aus dem Listenfeld ReDim Preserve Liste.Inhalt(Liste.Anzahl – 1) 'Erniedrige die registrierten Einträge um 1 Liste.Anzahl = Liste.Anzahl – 1 End If End Function
% %
189
12.5.7
Programm beenden
Mit der folgenden Funktion wird das Programm beendet, wenn die Schaltfläche ABBRECHEN betätigt wird: Private Sub btn_Abbrechen_Click() End End Sub
12.5.8
Gesamten Stack löschen
Um alle Einträge auf dem Stack zu löschen, muß der Inhalt des Listenfelds gelöscht werden, und alle Werte, die in der Liste eingetragen waren, müssen für die Funktion Widerrufen zwischengespeichert werden. Private Sub btn_Clear_Click() Dim i As Integer For i = 0 To Liste.Anzahl – 1 Call Merke_den_Wert(Liste.Inhalt(Liste.Anzahl – _ (i + 1)), i + 1) Next i Erase Liste.Inhalt Liste.Anzahl = 0 Call Stack_anzeigen lab_Eingabe.Caption = "" tab_Rechner.SetFocus End Sub
12.5.9
Den letzten Wert auf dem Stack löschen
Damit auch der letzte Eintrag auf dem Stack getilgt wird, muß der letzte Wert des Listenfelds gelöscht und in der Zwischenspeicherliste für die Funktion Widerrufen abgelegt werden. Private Sub btn_Del_Click() If Len(lab_Eingabe.Caption) > 0 Then lab_Eingabe.Caption = "" Else If Liste.Anzahl > 0 Then Call Merke_den_Wert(Liste.Inhalt( _ Liste.Anzahl–1), 1) If Liste.Anzahl > 1 Then Call Merke_den_Wert(Liste.Inhalt( _ Liste.Anzahl – 2), 2) End If
190
!
End If Call Stack_Wert_loeschen End If Call Stack_anzeigen tab_Rechner.SetFocus End Sub
12.5.10
Bestätigung einer Eingabe
Wird eine erfolgte Eingabe bestätigt, muß geprüft werden, ob diese im eingegebenen Format gültig ist. Wurde etwa als letztes Zeichen ein Komma eingegeben, so soll dieses entfernt werden. Private Sub btn_Enter_Click() If Len(lab_Eingabe.Caption) < 1 And Liste.Anzahl > 0 Then lab_Eingabe.Caption = Liste.Inhalt( _ Liste.Anzahl – 1) End If btn_Undo.Enabled = True If Merker.Anzahl > 0 Then Erase Merker.Inhalt Merker.Anzahl = 0 End If Call Stack_aktualisieren End Sub Private Sub btn_Komma_Click() If Len(lab_Eingabe.Caption) = 0 Then 'Wenn keine 'Ziffer vor dem lab_Eingabe.Caption = 0 'Komma eingegeben 'wurde End If lab_Eingabe.Caption = lab_Eingabe.Caption & Komma btn_Komma.Enabled = False End Sub
12.5.11
Farben definieren
Um einige Farbeinstellungen durchzuführen, werden folgende Funktionen benötigt: Private Sub Btn_Farbe_Ausgabe_Click() Dim i As Integer cmd_Einstellungen.DialogTitle = "Farbe auswählen" cmd_Einstellungen.ShowColor
% %
191
lab_FarbeAusgabe.BackColor = cmd_Einstellungen.Color For i = 0 To 3 lab_Ausgabe(i).BackColor = _ lab_FarbeAusgabe.BackColor Next i End Sub Private Sub btn_SchriftAusgabe_Click() Dim i As Integer cmd_Einstellungen.DialogTitle = "Farbe auswählen" cmd_Einstellungen.ShowColor lab_FarbeAusgabe.ForeColor = cmd_Einstellungen.Color For i = 0 To 3 lab_Ausgabe(i).ForeColor = lab_FarbeAusgabe.ForeColor Next i End Sub
12.5.12
Berechnungsfunktionen
Die folgenden Funktionen rufen die in der Aufgabe geforderten Berechnungen auf; sie sind den zugehörigen Schaltflächen hinterlegt. Private Sub btn_Cosinus_Click() Call Rechnen(COSINUS) End Sub Private Sub btn_Mal_Click() Call Rechnen(MAL) End Sub Private Sub btn_Minus_Click() Call Rechnen(MINUS) End Sub Private Sub btn_Sinus_Click() Call Rechnen(SINUS) End Sub Private Sub btn_Tangens_Click() Call Rechnen(TANGENS) End Sub Private Sub btn_Geteilt_Click() Call Rechnen(GETEILT) End Sub
192
!
Private Sub btn_Invers_Click() Call Rechnen(INVERS) End Sub Private Sub btn_Istprim_Click() If lab_Eingabe.Caption <> "" Then 'Wenn eine Zahl 'im Eingabefeld 'steht Call btn_Enter_Click End If If lab_Ausgabe(0).Caption <> "" Then Call Teste_auf_Prim(lab_Ausgabe(0).Caption) End If End Sub Private Sub btn_Pi_Click() Call btn_Enter_Click lab_Eingabe.Caption = PI Call btn_Enter_Click End Sub Private Sub btn_Plus_Click() Call Rechnen(PLUS) End Sub
12.5.13
Die letzte Aktion widerrufen
Um die letzte Aktion widerrufen zu können, muß die nachfolgende Funktion Undo implementiert werden. Sie schreibt die Werte, die sich in der Zwischenspeicherliste befinden, wieder zurück auf den Stack. Wenn diese Aktion ausgeführt wurde, muß die Schaltfläche, die diese Aktion auslöst, auf nicht verfügbar gesetzt werden, da nur der letzte Schritt widerrufen werden kann. Private Sub btn_Undo_Click() Dim i As Integer Call Stack_Wert_loeschen For i = 1 To Merker.Anzahl Call Stack_eintragen(Merker.Inhalt(Merker.Anzahl – i)) Next i btn_Undo.Enabled = False Call Stack_aktualisieren Call Stack_anzeigen End Sub
% %
193
12.5.14
Die Eingabe der Ziffern
Die beiden nachfolgenden Funktionen lesen die Ziffern in das Eingabefenster ein. Die erste liest die Ziffer von dem Tastenfeld, welches mit der Maus gesteuert wird, die zweite Funktion reagiert auf einen Tastendruck der Tastatur. Private Sub btn_Ziffer_Click(Index As Integer) lab_Eingabe.Caption = lab_Eingabe.Caption & Index tab_Rechner.SetFocus End Sub Private Sub tab_Rechner_KeyPress(KeyAscii As Integer) If tab_Rechner.Tab = 0 Then Call Rechner_betätigen(KeyAscii) End If End Sub
12.6
Das Modul für die Berechnungen
In diesem Modul finden die gesamten Berechnungen statt, die mit dem Taschenrechner durchgeführt werden können. Um eine Berechnung durchzuführen, muß jedoch zuerst ermittelt werden, wie viele Operanden benötigt werden.
12.6.1
Funktion zum Überprüfen eines Operanden
Die Funktion für die Überprüfung, ob es sich bei der eingegebenen Zahl um eine Primzahl handelt, liefert keinen Ergebniswert zurück, der eine sinnvolle Weiterverarbeitung erlaubt. Für den Anwender ist in diesem Fall nur wichtig:
Handelt es sich um eine Primzahl?
Wenn es sich um keine Primzahl handelt, welche Zahl ist dann der Teiler?
Die folgende Funktion ermittelt den kleinsten Teiler der eingegebenen Zahl und gibt diesen in einem Meldungsfenster aus, wenn es sich um keine Primzahl handelt. Der eingesetzte Algorithmus, mit dem eine Zahl auf Prim geprüft wird, arbeitet wie folgt: Die Zahl wird durch 2 geteilt. Ist die Division ohne Rest durchführbar, ist 2 ein Teiler dieser Zahl. Ist ein Rest vorhanden, wird die nächste ganze Zahl als Teiler genommen. Dies wird so lange durchgeführt, bis eine Division ohne Rest möglich oder der Teiler größer ist als das Ergebnis der Berechnung „Zahl/Teiler“.
194
!
Sub Teste_auf_Prim(Zahl As String) Dim Testzahl As Long Dim Teiler As Integer Dim Rest As Boolean Rest = False 'Wenn die Zahl zu groß ist If Abs(CDbl(Zahl)) > MAXLONG Or CDbl(Zahl) < 0 Then Call MsgBox("Zahl nicht im Definitionsbereich", _ , "Primzahl") Exit Sub End If Testzahl = CLng(Zahl) 'Die zu ermittelnde Zahl muß 'eine Ganzzahl sein If Testzahl = CDbl(Zahl) Then 'Wenn es eine ganze 'Zahl ist, Teiler = 2 'initialisiere den kleinsten 'Teiler While Testzahl / Teiler > Teiler And Rest = False If Testzahl Mod Teiler = 0 Then 'Wenn bei der 'Division kein Rest = True 'Rest bleibt, beende 'die Berechnung Else Teiler = Teiler + 1 'Nehme die nächste 'ganze Zahl als Teiler End If Wend If Rest = False Then Call MsgBox(Zahl & " ist eine Primzahl", , _ "Primzahl") Else Call MsgBox(Zahl & " ist durch " & _ Teiler & " teilbar", , "Primzahl") End If End If End Sub
12.6.2
Berechnungen mit einem Operanden
Um Berechnungen mit nur einem Operanden durchzuführen, wird nachfolgende Funktion benötigt. Sie prüft, um welche Berechnung es sich handelt, führt dann die Berechnung aus und liefert schließlich das Ergebnis an die aufrufende Funktion zurück.
" & $'
195
Function Einer_Tupel(Operand As Double, OPERATOR As Integer) As String On Error GoTo Fehler_Einer_Tupel Select Case OPERATOR Case SINUS Einer_Tupel = Sin(Operand) Case COSINUS Einer_Tupel = Cos(Operand) Case TANGENS Einer_Tupel = Tan(Operand) Case INVERS Einer_Tupel = Operand * (–1) End Select Exit Function Fehler_Einer_Tupel: Call Fehlermeldung((Err.Number)) Einer_Tupel = "" Exit Function End Function
12.6.3
Arithmetische Funktionen
Die folgenden mathematischen Funktionen führen die eigentlichen Berechnungen mit zwei Operanden aus. Function Addition(Operand1 As Double, Operand2 As Double) As String Addition = Operand1 + Operand2 End Function Function Multiplikation(Operand1 As Double, Operand2 As Double) As String Multiplikation = Operand1 * Operand2 End Function Function Subtraktion(Operand1 As Double, Operand2 As Double) As String Subtraktion = Operand1 – Operand2 End Function Function Division(Operand1 As Double, Operand2 As Double) As String Division = Operand1 / Operand2 End Function
196
!
12.6.4
Berechnungen mit zwei Operanden
Genauso wie im Fall mit einem Operanden wird auch im Falle von zwei Operanden eine Funktion benötigt, um die Berechnungen mit ihnen durchzuführen. Auch sie prüft, um welche Berechnung es sich handelt, führt danach die Berechnung aus und liefert am Ende das Ergebnis an die aufrufende Funktion zurück. Function Zweier_Tupel(Operand1 As Double, Operand2 As Double, OPERATOR As Integer) As String On Error GoTo Fehler_Zweier_Tupel Select Case OPERATOR Case PLUS Zweier_Tupel = Addition(Operand1, Operand2) Case MINUS Zweier_Tupel = Subtraktion(Operand1, Operand2) Case MAL Zweier_Tupel = Multiplikation(Operand1, Operand2) Case GETEILT Zweier_Tupel = Division(Operand1, Operand2) End Select Exit Function Fehler_Zweier_Tupel: Call Fehlermeldung((Err.Number)) Zweier_Tupel = "" Exit Function End Function
12.7
Das Modul zur Fehlerbehandlung
Um Fehler wie z.B. die Division durch 0 im Programm abzufangen, wird eine Funktion benötigt, die die auftretende Fehlermeldung in einem Meldungsfenster ausgibt. Wie das Behandeln von Fehlern und deren Abarbeitung funktioniert, wurde schon in Kapitel 7, „Fehlerbehandlung in Visual Basic“, vorgestellt. Auch auf den Aufruf eines Meldungsfensters und dessen Parameter wird nicht nochmals eingegangen. Sub Fehlermeldung(Nummer As Integer) Dim Meldung As String 'Die auszugebende Meldung Err.Number = Nummer 'Weise den aufgetretenen 'Fehler der Fehleranalyse 'zu 'Erzeugen des Meldungstextes mit den Err–Objektdaten
" & ( %
197
Meldung = "Fehler Nr: " & Err.Number & " im _ Programm: " & Err.Source & Chr(13) & _ "Fehlermeldung: " & Error(Err.Number) 'Ausgabe des Fehlers in einem Meldungsfenster Call MsgBox(Meldung, 16, "Fehlermeldung", _ Err.HelpFile, Err.HelpContext) End Sub
198
!
13
Weitere Programmiergrundlagen
In diesem Kapitel werden weitere Aktionen behandelt, die mit Visual Basic programmiert werden können. Es wird erklärt, wie Dateien bearbeitet werden oder wie auf der Oberfläche das Ziehen und Fallenlassen („Drag and Drop“) von Objekten programmiert wird. Ebenfalls wird erklärt, wie die Rekursion arbeitet.
13.1
Arbeiten mit Dateien
Für das Arbeiten mit Dateien werden von Visual Basic zahlreiche Funktionen zur Verfügung gestellt, mit denen sich Dateien u.a. erzeugen, öffnen, lesen, schreiben und löschen lassen.
13.1.1
Dateien öffnen
Der Befehl Open Zum Öffnen von Dateien gibt es in Visual Basic den Befehl Open. Mit ihm werden vorhandene Dateien für den Datenzugriff geöffnet. Existiert eine Datei nicht, so kann sie mit diesem Befehl erzeugt werden. Die Funktion ist folgendermaßen definiert: Open Name For Modus [Access access][lock] As [#]Nr [Len=Länge]
199
Parameter
Beschreibung
Name
Dieser Parameter stellt den Namen der Datei, die zum Bearbeiten geöffnet werden soll, dar. Der Name kann auch das Laufwerk und den Dateipfad enthalten, in dem sich die Datei befindet. Existiert die Datei nicht, so wird sie erzeugt, wenn sie in einem anderen Modus als Input geöffnet wird. Der Name einer Datei darf unter Windows95 max. 250 Zeichen lang sein (inkl. Laufwerks- und Pfadangaben).
Modus
Der Modus gibt an, für welche Dateizugriffe die Datei geöffnet wird. Append Binary Input Output Random
An die Datei werden Daten angehängt Binärer Dateizugriff Datei nur zum Lesen öffnen Datei nur zum Schreiben öffnen Datei zum Lesen und Schreiben öffnen
access
Ein optionales Paßwort zur Angabe, welche Zugriffe auf die geöffnete Datei erlaubt sind: Read, Write und ReadWrite.
lock
Ein optionaler Parameter zur Angabe, welche Zugriffe von anderen Prozessen erlaubt sind, wenn die Datei geöffnet ist.
Nr
Dieser Parameter ist unbedingt erforderlich: Er gibt den Datenkanal an, über den der Zugriff auf die Datei stattfinden soll. Der Wert dieser Zahl muß im Bereich zwischen 1 und 511 (inkl.) liegen.
Länge
Dieser optionale Parameter muß kleiner als 32768 sein. Mit ihm wird die Länge eines Satzes in Bytes festgelegt, wenn die Datei im Modus Random geöffnet wurde.
Im folgenden sind einige Befehlszeilen als Beispiel zum Öffnen einer Datei aufgeführt: Open "AUTOEXEC.BAT" For Input As #1 Dateiname$ = "AUTOEXEC.BAT" Open Dateiname$ For Random Access Read Shared As #511 Len = 20
Dateiname$ = "AUTOEXEC.BAT" Dateinummer& = 2 Open Dateiname$ For Output Access Write As Dateinummer&
Die Funktion FreeFile Mit der Funktion FreeFile kann der nächste freie Datenkanal zum Öffnen einer Datei ermittelt werden. Durch die Verwendung dieses Befehls ist immer gewährleistet, daß kein Programmfehler durch das Überschreiben eines Datenkanals auftritt, der gerade in Benutzung ist.
200
Datenkanal = FreeFile[(Bereich)]
Parameter
Beschreibung
Bereich
Dies ist ein optionaler Parameter, der angibt, in welchem Wertebereich die Nummer des freien Datenkanals liegen soll. Bei 0 wird eine freie Datenkanalnummer im Bereich 1 bis 255 zurückgemeldet, bei 1 im Bereich 256 bis 511. Wird kein Parameter angegeben, so wird er mit 0 voreingestellt.
Datenkanal
Dies ist die Nummer des nächsten freien Datenkanals, über den Dateizugriffe stattfinden können.
Dateinummer& = FreeFile Open "AUTOEXEC.BAT" For Input As Dateinummer&
13.1.2
Lesen und Schreiben in Dateien
Um in geöffneten Dateien Daten lesen oder schreiben zu können, werden von Visual Basic die in Tabelle 13.1 aufgeführten Befehle bereitgestellt. Befehl
Beschreibung
Print #
Schreibt Daten in eine sequentielle Datei. Die Daten sind dabei genauso formatiert wie bei der Ausgabe auf den Bildschirm – es sind keine Steuerzeichen sichtbar.
Write #
Schreibt Daten in eine sequentielle Datei. Die auzugebenden Daten werden aber automatisch wie folgt formatiert: Zeichenketten: "Dies ist ein Text" Boolsche Ausdrücke: #TRUE#, #FALSE#. Datum: #tt-dd-jjjj hh:mm:ss# Fehler: #ERROR Nummer# Null: #NULL#
Put
Schreibt Daten in eine binäre oder in eine Datei, die im Modus Random geöffnet wurde.
Input
Liest Daten aus einer Datei, die mit den Befehlen Print # oder Put geschrieben wurden.
Input #
Liest Daten aus einer sequentiellen Datei, die mit Write # geschrieben wurden.
Line Input #
Liest einen ganzen Datensatz, eine ganze Zeile aus einer Datei, in die Daten mit dem Befehl Print # oder Put geschrieben wurden.
Get
Liest Daten aus einer binären Datei oder einer Datei, die im Modus Random geöffnet wurde.
Tabelle 13.1: Befehle zum Lesen und Schreiben in Dateien
201
13.1.3
Dateien schließen
Um das Arbeiten an einer Datei abzuschließen, muß diese wieder geschlossen werden. Dadurch wird auch der Datenkanal, der für die Kommunikation zwischen Datei und Programm geöffnet wurde, wieder frei. Der Befehl für das Schließen einer Datei heißt close. close [[#]Datenkanal_1][, [#]Datenkanal_2]...
Parameter
Beschreibung
Datenkanal_n
Die Datenkanalnummer enthält die Nummer des Datenkanals, der geschlossen werden soll. Wird keine Datenkanalnummer angegeben, werden alle geöffneten Dateien geschlossen.
Wenn Dateien geschlossen werden, die im Modus Append oder Output geöffnet wurden, werden alle Daten, die sich noch im Speicher befinden, zum Speichern an das Betriebssystem weitergegeben.
13.1.4
Umbenennen von Dateien
Dateien oder Verzeichnisse können mit dem Befehl Name umbenannt werden. Es wird keine neue Kopie der Datei oder des Verzeichnisses angelegt, sondern nur der Eigenname der Datei geändert. Name alterName As neuerName
alterName
Hierbei handelt es sich um den Namen der Datei oder des Verzeichnisses, die bzw. das umbenannt werden soll. Diese Zeichenkette darf ein Verzeichnis mit Laufwerksangabe enthalten.
neuerName
Dieser Parameter stellt den neuen Namen der Datei oder des Verzeichnisses dar. Diese Zeichenkette darf ein Verzeichnis mit Laufwerksangabe enthalten, es darf jedoch noch keine Datei mit dem neuen Dateinamen existieren.
Wird eine Datei mit dem Befehl Name umbenannt, muß das Quelllaufwerk mit dem Ziellaufwerk in der Pfadangabe der Datei übereinstimmen. Die Verzeichnisse in der Pfadangabe können jedoch unterschiedlich sein. In diesem Fall wird die Datei umbenannt und in das neue Verzeichnis verschoben. Dateien lassen sich auch nur verschieben, wenn der Name der Quelldatei identisch mit dem der Zieldatei ist, sie sich jedoch in der Pfadangabe unterscheiden. Der Pfad des Ver-
202
zeichnisses in das die Datei verschoben werden soll, muß vorhanden sein, sonst tritt ein Fehler auf. 'Umbenennen einer Datei Name "TESTDATEI\TEST.TXT" AS "TESTDATEI\TESTNEU.TXT" 'Verschieben einer Datei in ein anderes Verzeichnis Name "TESTDATEI\TEST.TXT" AS "TEST.TXT" 'Umbenennen und Verschieben einer Datei Name "TESTDATEI\TEST.TXT" AS "TESTNEU.TXT"
13.1.5
Löschen von Dateien
Zum Löschen von Dateien kann unter Visual Basic der Befehl Kill verwendet werden. Kill Dateiname
Parameter
Beschreibung
Dateiname
Die Zeichenkette Dateiname definiert eine oder mehrere Dateien, die gelöscht werden sollen. Es darf auch ein Verzeichnis mit Laufwerksangabe enthalten.
Um mehrere Dateien in einem Verzeichnis löschen zu können, sind auch die Sonderzeichen „?“ für ein beliebiges Zeichen und „*“ für mehrere beliebige Zeichen erlaubt. Wird der Befehl Kill verwendet, um eine geöffnete Datei zu löschen, tritt ein Fehler auf. Es ist auch nicht möglich, Verzeichnisse damit zu löschen. Kill "TESTDATEI\TEST"
13.1.6
Formatieren von Dateien
Um die Ausgabedaten in einer Datei zu positionieren, werden von Visual Basic zwei Befehle zur Verfügung gestellt. Mit dem einen werden Tabulatoren, mit dem anderen Leerzeichen gesetzt. Die Tab-Methode Mit der Methode Tab werden Tabulatoren in einer Datei gesetzt, um z.B. Daten mit unterschiedlicher Länge spaltenweise untereinander schreiben zu können (Abbildung 13.1).
203
Abbildung 13.1: Durch Tabulatoren getrennte Daten in einer Datei
In Abbildung 13.2 wurden die Daten nur mit einem Leerzeichen getrennt. Wenn die Datei mit einem Texteditor angeschaut oder ausgedruckt wird, lassen sich die Daten aus Abbildung 13.1 leichter verstehen.
Abbildung 13.2: Durch Leerzeichen getrennte Daten einer Datei
Verwendet wird die Funktion wie folgt: Tab[(Anzahl])
Parameter
Beschreibung
Anzahl
Mit diesem Parameter wird definiert, wieviele Zeichen mit dem Tabulator übersprungen werden sollen. Ist die Anzahl der zu überspringenden Zeichen größer als die Länge einer Zeile, erfolgt die Ausgabe des nächsten Zeichens in einer neuen Zeile.
Der Anfang eines neuen Tabulators ist immer abhängig vom Ende des alten Tabulators, nicht vom Ende des Wortes, welches vor dem Tabulator steht. 'Ausgabe zweier Wörter mit der Standard-Tabulatoreinstellung Print #1, "Hallo"; Tab; "Visual Basic" 'Ausgabe zweier Wörter mit einem Tabulatorsprung von 30 Print #1, "Hallo"; Tab(30); "Visual Basic"
Die SPC-Funktion Mit der Funktion SPC werden Leerzeichen zwischen zwei Ausdrücken geschrieben. Mit dieser Funktion werden die Ausdrücke abhängig von der Position des zuletzt ausgegebenen Zeichens, gesetzt. Spc(Anzahl]
204
Parameter
Beschreibung
Anzahl
Mit diesem Parameter wird definiert, wieviele Leerzeichen eingefügt werden sollen, bevor die Ausgabe des nächsten Zeichens erfolgt. Ist die Anzahl der auszugebenden Leerzeichen größer als die Länge einer Zeile, werden die noch nicht geschriebenen Leerzeichen in den folgenden Zeilen ausgegeben.
Der Anfang des neu auszugebenden Zeichens ist immer abhängig vom Ende des zuletzt ausgegebenen Zeichens. 13.1.7
Beispiel zu „Arbeiten mit Dateien“
,
Es soll ein einfaches Programm erstellt werden, mit dem eine Datei erzeugt, umbenannt und wieder gelöscht werden kann. Als Grundlage dient das Programm VORGABE, welches sich auf der beigelegten Diskette befindet. Die Programmoberfläche Für das Beispielprogramm müssen noch folgende Steuerelemente auf das Formular aufgebracht werden: 1. Drei Schaltflächen:
ERZEUGEN
UMBENENNEN
LÖSCHEN
2. Drei Texteingabeelemente:
Name der zu erzeugenden Datei
Neuer Name der umzubenennenden Datei
Name der zu löschenden Datei.
3. Ein Beschriftungsfeld:
AKTUELLES VERZEICHNIS
4. Die Schaltfläche BTN_OK kann entfernt werden.
205
Abbildung 13.3: Programmoberfläche für das Beispiel „Arbeiten mit Dateien“
Der Programmcode Beim Starten des Programms müssen alle Schaltflächen, die das Arbeiten mit Dateien steuern, deaktiviert werden, da das zugehörige Texteingabeelement noch keinen Dateinamen enthält, auf den die auszulösende Aktion wirken soll. Ebenfalls soll in dem Beschriftungsfeld ausgegeben werden, in welchem Verzeichnis sich die Datei befindet. Private Sub Form_Load() Lab_Verzeichnis.Caption = CurDir Call txt_Dateiname_Change Call txt_NeuerName_Change Call txt_loeschen_Change End Sub
Nach dem Start können die Dateinamen in die Texteingabeelemente eingegeben werden. Es bleibt dabei jedoch zu berücksichtigen, daß der Quellname von Dateien, die umbenannt werden sollen, im Texteingabeelement für den zu erzeugenden Dateinamen steht. Aus diesem Grund darf die Schaltfläche DATEI UMBENENNEN für den Fall, daß ein Zielname eingegeben wurde, jedoch der Quellname fehlt, nicht verfügbar sein. Private Sub txt_Dateiname_Change() If Len(txt_Dateiname.Text) < 1 Then btn_Erzeugen.Enabled = False Call txt_NeuerName_Change Else btn_Erzeugen.Enabled = True Call txt_NeuerName_Change End If End Sub
206
Private Sub txt_NeuerName_Change() If Len(txt_NeuerName.Text) > 0 And _btn_Erzeugen.Enabled = True Then btn_Umbenennen.Enabled = True Else btn_Umbenennen.Enabled = False End If End Sub Private Sub txt_loeschen_Change() If Len(txt_loeschen.Text) < 1 Then btn_Loeschen.Enabled = False Else btn_Loeschen.Enabled = True End If End Sub
Sind die Dateinamen in die Textelemente eingegeben, sind auch die zugehörigen Schaltflächen verfügbar und können die jeweilige Aktion auslösen. Mit der Schaltfläche DATEI ERZEUGEN wird eine Datei mit dem Namen erzeugt, der in dem Texteingabeelement txt_Dateiname eingetragen wurde. Private Sub btn_Erzeugen_Click() Dim Kanal As Integer On Error GoTo Fehler_btn_Erzeugen_Click Kanal = FreeFile Open txt_Dateiname.Text For Output As Kanal Print #Kanal, "Neue Testdatei" Print #Kanal, "Der geöffnete Kanal ist " & Kanal Print #Kanal, Print #Kanal, "Zwei Wörter, getrennt mit Standardtabulator" Print #Kanal, "Hallo"; Tab; "Welt" Print #Kanal, Print #Kanal, "Zwei Wörter, getrennt mit Tabulator 30" Print #Kanal, "Hallo"; Tab(30); "Welt" Print #Kanal, Print #Kanal, "Zwei Wörter, getrennt mit 30 Leerzeichen" Print #Kanal, "Hallo"; Spc(30); "Welt" Close Exit Sub Fehler_btn_Erzeugen_Click: Call MsgBox("Fehler Nr.: " & Err.Number & Chr(13) & _ & & Err.Description, 16, "Fehler") End Sub
207
Mit der Schaltfläche DATEI UMBENENNEN wird der Name der Datei, der im Texteingabeelement txt_Dateiname eingetragen ist, geändert in den Namen, der im Texteingabeelement txt_NeuerName eingetragen wurde. Private Sub btn_Umbenennen_Click() On Error GoTo Fehler_btn_Umbenennen_Click Name txt_Dateiname.Text As txt_NeuerName.Text Exit Sub Fehler_btn_Umbenennen_Click: Call MsgBox("Fehler Nr.: " & Err.Number & Chr(13) _ & & Err.Description, 16, "Fehler") End Sub
Mit der Schaltfläche DATEI LÖSCHEN wird die Datei gelöscht, deren Name im Texteingabeelement TXT_LOESCHEN eingetragen wurde. Private Sub btn_Loeschen_Click() On Error GoTo Fehler_btn_Loeschen_Click Kill (txt_loeschen) Exit Sub Fehler_btn_Loeschen_Click: Call MsgBox("Fehler Nr.: " & Err.Number & Chr(13) _ & Err.Description, 16, "Fehler") End Sub
13.1.8
Testen des Programms
Nach dem Programmstart müssen alle Schaltflächen auf „nicht verfügbar“ geschaltet sein. Wird nun zum Erstellen einer Datei der Name „Test“ in das Textelement eingegeben und die Schaltfläche DATEI ERZEUGEN betätigt, wird diese Datei in dem Verzeichnis erzeugt. Diese Datei läßt sich ansehen, indem mit dem Windows Explorer in das Verzeichnis in welchem diese Datei abgelegt ist, gewechselt und auf das Dateisymbol geklickt wird. In dem Fenster, welches nun erscheint, kann zur Darstellung der Datei das Programm „Notepad“ ausgewählt werden.
208
Abbildung 13.4: Mit dem Beispielprogramm erzeugte Datei
Als nächstes kann zum Umbenennen der Datei der Dateiname in das Texteingabeelement txt_NeuerName eingegeben werden, der der Datei neu zugewiesen werden soll. Mit dem Betätigen der Schaltfläche DATEI UMBENENNEN wird dieser Vorgang ausgeführt. Wird diese Schaltfläche ein zweites Mal gedrückt, erscheint eine Fehlermeldung, da die Datei, die umbenannt werden soll, nicht mehr existiert. Zum Löschen der Datei kann der Name aus dem Texteingabeelement txt_NeuerName kopiert und in das Textfeld, in welchem die zu löschende Datei enthalten ist, eingetragen werden. Nach dem Auslösen der Schaltfläche DATEI LÖSCHEN wird die Datei vom Datenträger entfernt. Auch hier löst ein zweites Aktivieren der Schaltfläche eine Fehlermeldung aus, da die Datei nicht mehr existiert.
13.1.9
Weitere Funktionen für das Arbeiten mit Dateien
Das Ende einer Datei Um zu prüfen, ob das Ende einer Datei erreicht wurde, gibt es die Funktion EOF („End of File“). Wurde eine Datei im Modus Random oder Input geöffnet, so meldet die EOF-Funktion den Wahrheitswert True zurück, wenn das Ende der Datei erreicht wurde. Ansonsten lautet der zurückgelieferte Wert False. Wahrheitswert = EOF(Dateinummer)
209
Parameter
Beschreibung
Dateinummer
Die Dateinummer ist die Datenkanalnummer der Datei, bei der überprüft werden soll, ob das Ende schon erreicht ist.
Das folgende Programmbeispiel gibt die Datei AUTOEXEC.BAT Zeile für Zeile im Beschriftungsfeld aus. Dim Datei As Integer Dim Datensatz As String ... Datei = FreeFile Open "C:\AUTOEXEC.BAT" For Input As Datei While Not EOF(Datei) ... Line Input #Datei, Datensatz lab_Ausgabe.Caption = Datensatz DoEvents Wend ... Close
Eine komplette Datei laden Um eine komplette Datei vom Typ RTF („Rich Text Format“) oder TXT („Text“) in ein Steuerelement zu laden, gibt es die Methode LoadFile. Die Methode ist nur bei Rtf-Steuerelementen verfügbar. Name.LoadFile(Dateiname as String, Dateityp)
Parameter
Beschreibung
Dateiname
Der Dateiname kann einen Laufwerksbuchstaben und ein Verzeichnis zusätzlich zu der zu ladenden Datei enthalten. Der Name der Datei muß eindeutig sein.
Dateityp
Der Dateityp gibt an, um welche Art von Datei es sich handelt, die in das -Steuerelement geladen werden soll. rtfRTF 0 Eine Datei vom Typ RTF rtfText 1 Eine Datei vom Typ Text
Wird eine Datei mit der Methode LoadFile in ein Rtf-Steuerelement geladen, wird der gesamte Inhalt des Steuerelementes überschrieben. Dabei werden auch die Werte der Eigenschaften Text und RTF geändert.
210
Um ein Rtf-Steuerelement in der Werkzeugleiste zu erhalten, muß aus dem Visual Basic-Menü PROJEKT die Option KOMPONENTEN ausgewählt werden. Hier werden alle weiteren Steuerelemente, die mit Visual Basic 5.0 mitgeliefert wurden, angezeigt. Diese können durch Selektieren in die Benutzeroberfläche aufgenommen werden. Das Steuerelement, das die Methode LoadFile unterstützt, ist Microsoft Rich TextBox Control 5.0. Die folgende Funktion lädt die Datei AUTOEXEC.BAT beim Starten des Programmes in das Rtf-Steuerelement: Private Sub Form_Load() Call RTF_Datei.LoadFile("C:\AUTOEXEC.BAT", rtfText) End Sub
13.1.10
Funktionen für das Arbeiten mit Verzeichnissen
Für das Arbeiten mit Verzeichnissen stellt Visual Basic folgende Befehle zur Verfügung:
ChDir Pfad
Diese Funktion verhält sich ebenso wie die Funktion CD unter MS-DOS. Mit dieser Funktion wird das neue aktive Verzeichnis festgelegt.
ChDrive Laufwerk
Mit dieser Funktion kann das aktive Laufwerk gewechselt werden. Das neue Laufwerk, auf das gewechselt werden soll, wird im Parameter Laufwerk angegeben. Wird kein Laufwerk angegeben, wird das Laufwerk nicht gewechselt.
CurDir Laufwerk Laufwerk
Diese Funktion liefert als Ergebnis das momentan aktive Verzeichnis auf dem in dem Parameter Laufwerk angegebenen Laufwerk. Wird kein Laufwerk angegeben, so wird das aktuelle Laufwerk gewählt.
MkDir Pfad
Diese Funktion ist vergleichbar mit dem Befehl MD unter MS-DOS. Damit wird das Verzeichnis, das im Parameter Pfad angegeben wurde, erzeugt.
RmDir Pfad
Diese Funktion entfernt das Verzeichnis, das in dem Parameter Path angegeben wurde. Dabei ist zu beachten, daß das zu entfernende Verzeichnis keine weiteren Dateien oder Unterverzeichnisse enthält.
211
13.2
Ziehen und Fallenlassen – „Drag and Drop“
Mit Ziehen und Fallenlassen bzw. Drag and Drop können Objekte auf der grafischen Oberfläche kopiert und verschoben werden. Ein alltägliches Beispiel hierfür findet sich im Kopieren von Dateien im DateiManager bzw. Explorer. Dort werden selektierte Dateien durch das Gedrückthalten der linken Maustaste in andere Verzeichnisse verschoben oder kopiert. Die Programmierung von Drag and Drop ist am einfachsten durch „learning by doing“ zu verstehen. 13.2.1
Verschieben von Objekten
Es soll ein Programm entwickelt werden, auf dessen Oberfläche ein Gesicht abgebildet ist. Dieses Gesicht kann mittels Drag and Drop auf die Schaltflächen ABBRECHEN oder ZURÜCKSETZEN verschoben werden. Wird das Gesicht auf die Schaltfläche ZURÜCKSETZEN verschoben, verwandelt es sich in ein lachendes Gesicht. Wird es auf die Schaltfläche ABBRECHEN verschoben, so wird daraus ein ernstes Gesicht. Wurde das Gesicht auf einer der beiden Schaltflächen fallengelassen, wird das aktuelle Gesicht in die Schaltfläche übernommen und das Bild, aus dem das Gesicht entnommen wurde, wird unsichtbar. Durch Betätigen der Schaltfläche ZURÜCKSETZEN wird der Ausgangszustand wiederhergestellt. Die Programmoberfläche
Abbildung 13.5: Oberfläche des Beispiels „Verschieben mit Drag and Drop“
In Abbildung 13.5 ist die Programmoberfläche im Ausgangszustand abgebildet. Wird das Gesicht mit Hilfe von Drag and Drop auf eine der beiden Schaltflächen verschoben, so erscheint das neue Bild auf dieser Schaltfläche, und das Ursprungsbild wird unsichtbar (Abbildung 13.6).
212
Abbildung 13.6: Nach dem Verschieben des Gesichts auf eine Schaltfläche
Die Steuerelement-Eigenschaften Damit ein Objekt auf der Oberfläche verschoben werden kann, müssen einige Eigenschaften dieses Objekts daraufhin eingestellt werden. In Tabelle 13.2 sind die Eigenschaften zum Verschieben des Gesichtes auf der Programmoberfläche aufgeführt und beschrieben. Steuerelement
Eigenschaft
Inhalt
Beschreibung
Schaltflächen
(Name)
btn_Ok
Dieses Steuerelement dient der Wiederherstellung des Ausgangzustands, den das Programm nach dem Start hatte.
Style
1 – Grafisch
Wenn der Eigenschaft Picture ein Bild zugeordnet wird, ist dieses auf der Schaltfläche zu sehen.
DragIcon
(Symbol)
(Name)
btn_Abbruch
Damit wird das Programm beendet.
Style
1 – Grafisch
Wenn der Eigenschaft Picture ein Bild zugeordnet wird, ist dieses auf der Schaltfläche zu sehen.
DragIcon
(Symbol)
(Name)
pic_Gesicht
Enthält das Gesicht, das auf der Programmoberfläche verschoben werden soll.
DragMode
1 – Automatisch
Wird das Steuerelement mit der linken Maustaste selektiert, verändert sich der Mauskursor automatisch und stellt das Symbol dar, welches der Eigenschaft DragIcon zugewiesen ist.
DragIcon
(Symbol)
Picture
(Symbol)
Bild-Schaltfläche
Tabelle 13.2: Steuerelement-Eigenschaften zum Thema „Verschieben mit Drag and Drop“
213
Das Ereignis DragOver Mit dem Ereignis DragOver wird bestimmt, was innerhalb einer Ziehoperation passieren kann. Es kann z.B. signalisiert werden, ob das aktuell gezogene Steuerelement auf dem Ziel abgelegt werden darf oder nicht, indem sich das Symbol, in das sich der Mauszeiger verwandelt hat, in ein anderes verändert. Private Sub Form_DragOver(Source As Control, X As Single, Y As Single, State As Integer) Private Sub MDIForm_DragOver(Source As Control, X As Single, Y As Single, State As Integer) Private Sub Name_DragOver([Index As Integer,] Source As Control, X As Single, Y As Single, State As Integer)
Parameter
Beschreibung
Index
Wenn das Steuerelement ein Teil eines Feldes von Steuerelementen ist, identifiziert diese Indexnummer das Steuerelement eindeutig
Source
Dieser Parameter enthält das Steuerelement, das gezogen wird, mit all seinen Eigenschaften und Methoden. So kann z.B. der Eindruck erzeugt werden, daß das zu ziehende Steuerelement sein Aussehen verändert.
Source.DragIcon = Name.DragIcon X
Dieser Parameter gibt die aktuelle horizontale Position des Mauszeigers innerhalb des Zielelements an. Die Maßeinheit ist immer die gleiche, wie die des Zielsystems in den Eigenschaften
ScaleWidth, ScaleLeft. Y
Dieser Parameter gibt die aktuelle vertikale Position des Mauszeigers innerhalb des Zielelementes an. Die Maßeinheit ist immer die gleiche, wie die des Zielsystems in den Eigenschaften
ScaleHight, ScaleTop. State
Gibt den Bewegungszustand des gezogenen Steuerelements an, das sich in den folgenden Übergangsphasen befinden kann: 0 = Betreten (Das Quell-Steuerelement wird in den Bereich eines Zieles hineingezogen). 1 = Verlassen (Das Quell-Steuerelement wird aus dem Bereich eines Zieles herausgezogen). 2 = Darüber (Das Quell-Steuerelement wurde von einer Position im Zielbereich zu einer anderen Position verschoben).
Mit dem Parameter State kann die Aktion bestimmt werden, die an den Übergangspunkten stattfinden soll. Hat State den Wert 0 für Betreten, wird das Symbol verändert; hat State den Wert 1, wird es wieder in den Ausgangszustand zurückversetzt.
214
Das Ereignis DragDrop Das Ereignis DragDrop tritt beim Fallenlassen eines Objekts nach dem Ziehen auf der Oberfläche ein. Drag and Drop kann z.B. für das Verschieben von Steuerelementen oder das Kopieren von Dateien benutzt werden. Private Sub Form_DragDrop(Source As Control, X As Single, Y As Single) Private Sub MDIForm_DragDrop(Source As Control, X As Single, Y As Single) Private Sub Object_Form_DragDrop(Source As Control, X As Single, Y As Single)
Parameter
Beschreibung
Index
Wenn das Steuerelement ein Teil eines Feldes von Steuerelementen ist, identifiziert diese Indexnummer das Steuerelement eindeutig
Source
Dieser Parameter enthält das Steuerelement, das gezogen wird, mit all seinen Eigenschaften und Methoden. So kann z.B. der Eindruck erzeugt werden, daß das zu ziehende Steuerelement sein Aussehen verändert.
Source.DragIcon = Name.DragIcon X
Dieser Parameter gibt die aktuelle horizontale Position des Mauszeigers innerhalb des Zielelementes an. Die Maßeinheit ist immer die gleiche, wie die des Zielsystems in den Eigenschaften
ScaleWidth, ScaleLeft. Y
Dieser Parameter gibt die aktuelle vertikale Position des Mauszeigers innerhalb des Zielelementes an. Die Maßeinheit ist immer die gleiche, wie die des Zielsystems in den Eigenschaften
ScaleHight, ScaleTop.
Der Programmcode Wenn das Programm zu diesem Zeitpunkt gestartet wird, verändert sich der Mauszeiger bereits in dem Moment, in dem das Gesicht angeklickt und die Maus mit gedrückter Taste über den Bildschirm bewegt wird. Bewegt man den Mauszeiger über ein Steuerelement, so tritt das Ereignis DragOver ein. Damit der Mauszeiger auf den Hintergrund reagiert, über den er bewegt wird, muß in diesem Ereignis des zugehörigen Steuerelements die Zuweisung des neuen Symbols erfolgen. Private Sub btn_Abbruch_DragOver(Source As Control, X As Single, Y As Single, State As Integer) If State = 1 Then Source.DragIcon = Source.Picture
215
Else Source.DragIcon = btn_Abbruch.DragIcon End If End Sub Private Sub btn_Ok_DragOver(Source As Control, X As Single, Y As Single, State As Integer) If State = 1 Then Source.DragIcon = Source.Picture Else Source.DragIcon = btn_Ok.DragIcon End If End Sub
In dem Status, in dem sich das Programm jetzt befindet, kann das Gesicht über die Oberfläche bewegt werden und sich auch schon den Schaltflächen anpassen. Bewegt man den Mauszeiger über die Schaltfläche ZURÜCKSETZEN, verändert sich das freundliche Gesicht zu einem lachenden, bewegt man den Mauszeiger über die Schaltfläche ABBRECHEN, wird das Gesicht traurig. Damit die zugehörigen Gesichter auch auf die Steuerelemente fallengelassen werden können, muß das Ereignis DragDrop eintreffen. Mit den folgenden Funktionen wird das Fallenlassen des Gesichts auf das zugehörige Steuerelement programmiert: Private Sub btn_Abbruch_DragDrop(Source As Control, X As Single, Y As Single) btn_Abbruch.Picture = Source.DragIcon pic_Gesicht.Visible = False End Sub Private Sub btn_Ok_DragDrop(Source As Control, X As Single, Y As Single) btn_Ok.Picture = Source.DragIcon pic_Gesicht.Visible = False End Sub
Zum Abschluß das Programms fehlt noch das Zurücksetzen auf die Ausgangsposition, denn wenn ein Gesicht auf der Oberfläche einer Schaltfläche verschoben wurde, ist das Ursprungsbild unsichtbar, und von der Schaltfläche kann das Bild nicht wieder entfernt werden. Private Sub btn_Ok_Click() btn_Ok.Picture = Nothing btn_Abbruch.Picture = Nothing pic_Gesicht.Visible = True End Sub
216
13.2.2
Verschieben von Objekten mit anschließender Reaktion
Es soll ein Programm erstellt werden, mit dem Objekte visuell vernichtet werden können. So wird z.B. durch Ziehen des Objekts auf ein Faß dieses verbrannt. Es gibt in diesem Zusammenhang zwei Objektarten: ein Bildfeld- und ein Anzeigenfeld-Steuerelement. Die Bildfelder können in den Mülleimer und in der Fabrik, die Anzeigefelder können nur in der Fabrik entsorgt werden. Wird ein Symbol „entsorgt“, läuft eine kurze Animation ab. In Tabelle 13.3 werden die Symbole, die zur Verfügung stehen, aufgeführt und beschrieben. Bilder
Beschreibung Hier darf kein Objekt abgelegt werden.
TRFFC14.ICO
POINT03.ICO
MAC02.ICO
MAIL01A.ICO MAIL01B.ICO
TRASH02A.ICO TRASCH02B.ICO
MISC01.ICO MISC02.ICO
Das aktuelle Objekt darf hier nicht abgelegt werden, es muß im anderen Objekt zur Entsorgung abgegeben werden. Der Computer ist ein Objekt, das zur Entsorgung zur Verfügung steht. Da Computer nicht verbrannt werden dürfen, wird dieses Symbol in ein Anzeigefeld eingefügt. Der Brief ist das Symbol für brennbare Materialien und darf somit verbrannt werden. Wird das Symbol durch Anklicken selektiert, so wandelt sich der offene Brief in einen geschlossenen um. Da das Verbrennen von Papier bedingt erlaubt ist, wird dieses Symbol in ein Bildfeld-Steuerelement eingefügt. Die Entsorgung durch Verbrennen wird durch den Mülleimer symbolisiert, der beim Fallenlassen eines erlaubten Objekts für kurze Zeit vom linken Symbol in das rechte wechselt. Das Entsorgen von Objekten wird mit dem Rotieren des Symbols dargestellt. Beide Symbole werden abwechselnd eine Zeitlang dargestellt, um eine Rotation zu simmulieren.
Tabelle 13.3: Grafische Elemente für das Beispiel von Drag and Drop mit kleiner Animation
Die Programmoberfläche Als Grundlage für das Beispielprogramm dient das Projekt Vorgabe von der Diskette, das mit den folgenden Steuerelementen erweitert werden muß.
217
1. Drei Bildfeld-Steuerelemente:
der Briefumschlag (Datei MAIL01A. ICO)
der Mülleimer (Datei TRASH02A.ICO)
die Entsorgungsanlage (Datei MISCO01.ICO)
2. Ein Anzeigefeld-Steuerelement:
der Computer (Datei MAC02.ICO)
3. Die Schaltfläche BTN_OK wird entfernt.
Die Programmoberfläche für das „Entsorgungsprogramm“ ist in Abbildung 13.7 dargestellt.
Abbildung 13.7: Programmoberfläche für das Entsorgungsprogramm
Der Briefumschlag kann auf beide Entsorgungssymbole, der Computer kann nur auf das untere Entsorgungssymbol gezogen werden. Wird während des Modus Drag das Symbol über die Schaltfläche ABBRECHEN bewegt, verwandelt es sich in ein Stoppzeichen. In Tabelle 13.4 werden die Eigenschaften zum Verschieben des Gesichts auf der Programmoberfläche aufgeführt und beschrieben. Steuerelement
Eigenschaft
Inhalt
Beschreibung
Schaltfläche
(Name)
btn_Abbrechen
Mit dieser Schaltfläche wird das Programm beendet.
DragIcon
BildfeldSteuerelemente
(Name) Picture
218
Wird während der Phase Drag ein Symbol über die Schaltfläche bewegt, ändert es sich in das Stop-Symbol, da es hier nicht abgelegt werden kann. pic_Muelleimer
Dies ist das Entsorgungselement, mit dem die Materialien verbrannt werden.
Steuerelement
Eigenschaft
Inhalt
Beschreibung
(Name)
pic_Fabrik
Dies ist das Entsorgungselement, mit dem alle Materialien entsorgt werden können.
pic_Brief
Dies ist das Symbol für Materialien, die verbrannt werden dürfen.
Picture
(Name) Picture
DragIcon
AbbildungsfeldSteuerelemente
Wenn das Symbol in die Entsorgung verschoben wird, verschließt sich der Briefumschlag.
DragMode
1 – Automatisch
Wird das Steuerelement mit der linken Maustaste selektiert, verändert sich der Mauskursor automatisch und stellt das Symbol dar, welches der Eigenschaft DragIcon zugewiesen ist.
(Name)
img_Computer
Das Symbol für die Materialien, die nur in der Fabrik entsorgt werden dürfen.
Picture
Tabelle 13.4: Die Steuerelement-Eigenschaften zum Entsorgungsprogramm
Der Programmcode Als erstes soll die Schaltfläche ABBRECHEN als Verbotszone gekennzeichnet werden, wenn während der Phase Ziehen der Mauszeiger darüberbewegt wird. Für diese Phase werden die beiden Übergangszustände Eintritt (STATUS = 0) und Austritt (STATUS = 1) unterschieden. Private Sub btn_Abbruch_DragOver(Source As Control, X As Single, Y As Single, State As Integer) If State = 0 Then btn_Abbruch.Picture = Source.DragIcon Source.DragIcon = btn_Abbruch.DragIcon Else If State = 1 Then Source.DragIcon = btn_Abbruch.Picture End If End If End Sub
Wird zum jetzigen Programmierzeitpunkt das Programm gestartet und der Mauscursor über die Schaltfläche bewegt, verändert sich dieser in ein Stopp-Signal, da hier „keine Ablage“ signalisiert werden soll. Wird das Symbol dennoch auf der Schaltfläche fallengelassen, ist diesem Objekt beim nächsten Ziehen nicht mehr das Symbol zugeordnet, welches in der Eigenschaft des Steuerelementes als DragIcon definiert wurde, sondern das Symbol Stop.
219
Dieses Phänomen ist sehr einfach zu erklären: In dem Ereignis DragOver der Schaltfläche ABBRECHEN wird dem zu ziehenden Steuerelement ein neues Symbol zugeordnet und nicht mehr auf den Ausgangszustand zurückgesetzt. Um nun zu vermeiden, daß nach einem falschen Ablegen eines Steuerelements die Symbole zum Verschieben nicht mehr stimmen, lassen sie sich mit der Funktion LoadPicture zu Beginn der Ziehen-Phase neu initialisieren. Bild = LoadPicture(Dateiname As String)
Parameter
Beschreibung
Dateiname
Der Dateiname kann einen Laufwerksbuchstaben und ein Verzeichnis zusätzlich zu der zu ladenden Grafikdatei enthalten. Der Name der Grafikdatei muß aber eindeutig sein.
Von Visual Basic werden die folgenden Grafikformate erkannt und unterstützt:
Bitmap-Dateien (*.BMP)
Symboldateien (*.ICO)
Dateien im RLE-Format (*.RLE1)
Dateien im Metafile-Format (*.WMF)
Dateien im erweiterten Metafile-Format (*.EMF)
Dateien im GIF-Format (*.GIF)
JPEG-Dateien (*.JPG)
Damit jedesmal, bevor das Drag-Symbol angezeigt wird, das richtige Symbol in der Eigenschaft DragIcon eingetragen ist, wird zuerst in dem Ereignis DragOver des zu verschiebenden Objekts das Symbol geladen. Private Sub img_Computer_DragOver(Source As Control, X As Single, Y As Single, State As Integer) img_Computer.DragIcon = img_Computer.Picture End Sub Private Sub pic_Brief_DragOver(Source As Control, X As Single, Y As Single, State As Integer) pic_Brief.DragIcon = LoadPicture(CurDir("d") & "\BILDER\MAIL01A.ICO") End Sub
1. RLE = Run-length-encoded
220
Da auf dem Symbol für die Fabrik alle Materialien entsorgt werden dürfen, wird als nächstes das Ereignis DragDrop der Bildschaltfläche PIC_FABRIK entwickelt. Um ein animiertes Bild zu erzeugen, ist es ausreichend, die beiden Symbole MISC01.ICO und MISC02.ICO abwechselnd für bestimmte Zeit in dem Steuerelement darzustellen. Geladen werden die Symbole ebenfalls mit der Funktion LoadPicture. Private Sub pic_Fabrik_DragDrop(Source As Control, X As Single, Y As Single) Dim i As Integer Dim j As Integer For i = 0 To 10 pic_Fabrik.Picture = LoadPicture(CurDir("d") & "\BILDER\MISC02.ICO") For j = 0 To 300 DoEvents Next j pic_Fabrik.Picture = LoadPicture(CurDir("d") & "\BILDER\MISC01.ICO") For j = 0 To 300 DoEvents Next j Next i End Sub
Da eine einfache Schleife fast keine Zeit benötigt, wenn sie durchlaufen wird, wurde den beiden Schleifen, die nach dem Wechseln des Symbols programmiert wurden, der Befehl DoEvents hinzugefügt. DoEvents ermöglicht die Aktualisierung der Anzeige und verbraucht somit einiges an Systemzeit. Bei dem Mülleimer ist die Animation etwas einfacher. Jedoch muß hier geprüft werden, um welches Objekt es sich bei dem abzulegenden Element handelt. Ist es ein erlaubtes Steuerelement, so wird die Animation gestartet; ist es kein erlaubtes Steuerelement, muß das Ziehen-Symbol in die nach unten zeigende Hand geändert werden. Private Sub pic_Muelleimer_DragDrop(Source As Control, X As Single, Y As Single) Dim i As Integer Dim Pfad As String If TypeOf Source Is PictureBox Then pic_Muelleimer.Picture = LoadPicture(CurDir("d") & "\BILDER\TRASH02B.ICO") For i = 0 To 3000 DoEvents
221
Next i pic_Muelleimer.Picture = LoadPicture(CurDir("d") & "\BILDER\TRASH02A.ICO") End If End Sub Private Sub pic_Muelleimer_DragOver(Source As Control, X As Single, Y As Single, State As Integer) If Not (TypeOf Source Is PictureBox) Then If State <> 1 Then Source.DragIcon = LoadPicture(CurDir("d") & "\BILDER\POINT03.ICO") Else Source.DragIcon = Source.Picture End If End If End Sub
Wird nun der verschlossene Briefumschlag auf den Mülleimer gelegt, sieht es aus, als lodere für kurze Zeit eine Flamme auf und der Brief wurde verbrannt.
13.3
Einführung in die Objektorientierung
Mit der Version 5.0 von Visual Basic wurden die Grundlagen für die Objektorientierung geschaffen. Hierfür stellt Visual Basic das sogenannte Klassenmodul bereit. Bevor ich aber im Detail auf dieses Klassenmodul eingehe, möchte ich auf die Objektorientierung im allgemeinen zu sprechen kommen. Das Hauptmerkmal der objektorientierten gegenüber der herkömmlichen Programmierung ist, daß ihre sogenannten Objekte gekapselt sind. D.h. auf die Daten und Funktionen, die beim Objektorientierten Programmieren als Methoden bezeichnet werden, kann von außen nicht zugegriffen werden, es sei denn, es wurde eine Schnittstelle definiert. Die gesamten Daten und Methoden liegen lokal zu einem Objekt. Soll eine Funktion mit diesem Objekt ausgeführt werden, so muß dazu eine Nachricht an das Objekt gesendet werden. Diese wird dann wiederum von dem Objekt, welches die Nachrichten empfängt, interpretiert. Im Grunde entspricht das Senden einer Nachricht einem Funktionsaufruf. Jedoch besteht noch ein wesentlicher Unterschied zur herkömmlichen Programmierung: Jedes Objekt entscheidet für sich, welche Methode beim Eintreffen einer Nachricht ausgewählt wird. Dies nennt man auch „Überladen von Funktion“. Während also in einer konventionellen Programmiersprache die
222
richtige Funktion auf eine Variable angesetzt werden muß, ist es bei der Objektorientierung wichtig, welche Nachricht das Objekt versteht. Der große Vorteil der objektorientierten Technik liegt des weiteren darin, daß jedes Objekt seine definierte Schnittstelle hat und über diese mit dem Objekt kommuniziert werden kann. Wie das Objekt im Kern arbeitet und welche Funktionen dieses Objekt dafür verwendet, ist für den Anwender des Objekts nicht wichtig. Somit kann eine interne Veränderung in diesem Objekt ohne Probleme durchgeführt werden, solange die Schnittstellen nicht verändert werden. Die Klassen sind die Prototypen der Objekte und legen deren Eigenschaften fest. Jedes Objekt muß genau einer Klasse angehören. Diese Objekte bezeichnet man auch als Instanzen. Als nächstes kann noch die Vererbung eingeführt werden, d.h. ähnliche Klassen können miteinander in Beziehung gesetzt werden. Die eine Klasse vererbt ihre Eigenschaften an eine andere. Durch die Klassenbildung ist die Entwicklung großer Softwareprojekte sehr stark vereinfacht worden. Denn zum einen wird es durch die hierarchische Anordnung ähnlicher Klassen möglich, die Gemeinsamkeiten in zentralen Oberklassen zusammenzufassen. Zum anderen ist durch die Vererbung sichergestellt, daß alle von einer gemeinsamen Basisklasse abgeleiteten Klassen automatisch über dieselben Eigenschaften verfügen. Außerdem kann eine Klassenhierarchie ohne Probleme um weitere Klassen ergänzt werden. Wie jedoch auch bei der herkömmlichen Programmierung, ist es wichtig, Struktur in die Datentypen zu bringen, um die Redundanz des Codes zu vermindern. Des weiteren ist eine gute Klassendefinition für den Verbundmechanismus wichtig. Bei einer schlechten Klassendefinition können auch die Vorteile der objektorientierten Programmierung nicht zum Tragen kommen. In diesem Abschnitt werden zunächst einmal einige Begriffe erklärt, die für die objektorientierte Programmierung wichtig sind. Da das Thema „Objektorientierung“ umfassend genug ist, um ein eigenes Buch zu füllen, soll es hier bei einer Darstellung der Grundlagen bleiben.
13.3.1
Was ist ein Objekt?
Unter Objekten versteht man im allgemeinen alle Größen, die durch einen Bezeichner benannt werden. Prinzipiell handelt es sich somit auch bei allen Variablen um Objekte, da sie durch einen Bezeichner benannt werden. Jedoch wird der Begriff eines Objektes in der objektorientierten Programmierung weiter eingeschränkt. Ein Objekt ist
!"#
223
hier ein Informationsträger, der einen zeitlich veränderbaren Zustand besitzt. Die Kommunikation mit einem Objekt erfolgt ausschließlich über Nachrichten. Es ist genau definiert, wie das Objekt auf bestimmte Nachrichten eingeht. Eine andere Kommunikationsart gibt es nicht. Mit den Nachrichten wird dann der Zustand des Objekts verändert.
13.3.2
Was sind Eigenschaften?
Mit den Eigenschaften wird dem Anwender eines Objekts suggeriert, daß die Klasse einen eigenen Wert hat, der über eine bestimmte Eigenschaft ausgelesen werden kann. In der Komponente selbst kann dieser Wert eine sehr komplexe Datenstruktur darstellen. Er kann nur über sehr aufwendige Prozesse berechnet oder verändert werden. Bei den Windows-Komponenten sind die Eigenschaften schon zur Entwurfszeit verfügbar. Mit ihnen können z.B. das Aussehen und das Verhalten eines Steuerelementes schon definiert werden, wenn das Programm noch entwickelt wird. Ein weiterer großer Vorteil von Eigenschaften ist, daß mit ihnen die Werte und Formate geprüft werden können, die dem Objekt zugewiesen werden sollen. Sie werden dem Objekt also schon bei seiner Erzeugung zugewiesen. Fehlern, die durch ungültige Eingaben verursacht werden können, wird schon beim Zuweisen eines Wertes vorgebeugt. Auch das Auslesen der Eigenschaften birgt einen Vorteil gegenüber einer öffentlichen Variablen. Der Wert, der aus einer Eigenschaft gelesen wird, besitzt immer Gültigkeit, da er schon beim Zuweisen auf Gültigkeit geprüft wurde. Eigenschaften werden in den Klassen folgendermaßen deklariert: property Get|Let|Set Prozedurname ([Param1 As Vartyp, ..., Paramn As Vartyp]) ... End Property
13.3.3
Was sind Ereignisse?
Ereignisse stellen die Verbindung zwischen einem Steuerelement und dem Programmcode des Entwicklers dar. In den Ereignissen wird definiert, welcher Programmcode ausgeführt werden soll, wenn eine bestimmte Benutzeraktion durchgeführt wird. Bei solchen Aktionen kann es sich z.B. um eine Bewegung mit der Maus, um das Betätigen eine Taste usw. handeln.
224
Ereignisse stellen somit die Verbindung zwischen den Komponentenentwicklern und den Komponentenanwendern dar.
13.3.4
Was sind Methoden?
Methoden sind Funktionen, mit denen Aktionen in bezug auf das Objekt ausgeführt werden oder die einen Wert zurückliefern, der nicht als eine Eigenschaft des Objekts angesehen werden kann. Außerdem werden Methoden verwendet, um verschiedene Eigenschaften durch einen einzigen Aufruf zu initialisieren oder abzufragen. Methoden sind wie Ereignisse nur zur Laufzeit verfügbar, da sie keinen eigenen Wert besitzen, sondern einen bestimmten Programmcode ausführen.
13.3.5
Was ist eine Klasse?
In der objektorientierten Programmierung werden mit Hilfe von Klassen eigene Datentypen definiert. Was ist nun eigentlich eine Klasse? Schlägt man im mathematischen Duden nach, findet man die folgende Definition:
Eine Klasse ist eine Kollektion von Objekten mit mindestens einem gemeinsamen Merkmal.
In der Programmierung dient der Begriff „Klasse“ zur schematischen Zusammenfassung von Strukturen und Objekten. Eine Klasse in Visual Basic 6.0 läßt sich durch die folgenden vier Grundregeln relativ gut beschreiben: 1. Eine Klasse ist eine Menge von Datenelementen, mit denen die
Daten der Klasse dargestellt werden. Dabei kann der Typ des Datenelements beliebig sein und die Anzahl null oder mehr betragen. 2. Mit einer Klasse werden Elementfunktionen zusammengefaßt. Sie
stellen die möglichen Operationen dar, die in bezug auf die Klasse ausgeführt werden können. Die Elementfunktionen sind die Schnittstelle der Klasse, und ihre Anzahl beträgt null oder mehr. 3. Die Elemente einer Klasse werden in verschiedene Zugriffsebenen
eingeteilt. Sie können privat, protected oder public sein. Im Normalfall werden die Objekte, die die Klasse darstellen, privat sein, und die Operationen, die in bezug auf die Klasse ausgeführt werden, werden public sein.
!"#
225
4. Jede Klasse kann als Typangabe verwendet werden und hat somit
eine Definitionsbezeichnung. Die Definition eines Objekts als eine bestimmte Klasse kann wie überall dort durchgeführt werden, wo auch standardmäßig definierte Typangaben vorkommen dürfen. Hat man z.B. eine Klasse clsKomplex erzeugt, so kann ihre Definition mit folgender Deklaration durchgeführt werden: dim objKomplex As new clsKomplex
Klassen, die einen privaten und einen frei zugänglichen Bereich haben, bezeichnet man als abstrakte Datentypen.
13.3.6
Erzeugen einer Klasse
Eine neue Klasse wird einem Projekt über das Menü PROJEKT|KLASSENMODUL hinzufügen hinzugefügt. In dem Dialog (Abbildung 13.8), der sich darauf hin öffnet, wird das Modul Klassenmodul gewählt.
Abbildung 13.8: Das Fenster Klassenmodul hinzufügen
Im Projektfenster wird nun eine neue Gruppe eingetragen, die Gruppe Klassenmodule. Hierrunter befindet sich die neue Klasse mit Namen Class1. Im Eigenschaftsfenster kann bei der Eigenschaft Name der Klassenname festgelegt werden. Bei der Namensvergabe sollte immer die Buchstabenkennung cls vor den Namen gestellt werden. Der Name der Beispielklasse, der für die weiteren Schritte verwendet wird, ist clsComplex.
226
13.3.7
Datenelemente
Die Datenelemente einer Klasse werden wie Variablen deklariert. Im folgenden wird das Beispiel einer Deklaration von Elementen in einer Klasse dargestellt. Option Explicit Public myReal As Integer Public myImaginaer As Integer
Die Datenelemente einer Klasse können von einem beliebigen Typ sein. Auch die Reihenfolge, in der die verschiedenen Datentypen deklariert werden, ist prinzipiell nicht von Bedeutung. Als Datentyp einer Klasse ist natürlich auch eine andere Klasse erlaubt. Im folgenden Beispiel verwendet die Klasse Complex die Klasse Koordinaten, wobei die Klasse erst durch eine Vorausdeklaration definiert werden muß. dim objXY as New clsKoordinaten class Complex
Methoden oder Elementfunktionen Damit mit den Datenelementen der Klasse bestimmte Operationen durchgeführt werden können, müssen bestimmte Nachrichten an das Objekt gesendet werden können. Die Übermittlung solcher Nachrichten an das Objekt übernehmen die Elementfunktionen. Diese Elementfunktionen entsprechen den Funktionen und den Prozeduren in den Basic-Modulen. Public Sub Init(newReal As Integer, newImaginaer As Integer) myReal = newReal myImaginaer = newImaginaer End Sub Public Sub Clear() Real = 0 Imaginaer = 0 End Sub Public Function Real() As Integer Real = myReal End Function Public Function Imaginaer() As Integer Imaginaer = myImaginaer End Function
!"#
227
Der Aufbau der Elementfunktions-Deklaration ist identisch mit den Standardfunktionen aus den Basic-Modulen. Eigenschaften Im Abschnitt „Methoden oder Elementfunktionen“ wurden Variablen als public deklariert, um den Zugriff auf die Daten der Klasse zu ermöglichen. Der Nachteil dieser Art von Parameterzugriff ist, daß keine Plausibilitätsprüfung der Daten durchgeführt wird. Deklariert man die beiden Klassenvariablen myReal und myImaginaer als PRIVATE, so hat man jetzt die Möglichkeit, den Zugriff auf diese Daten über zwei Funktionen zu realisieren, mit denen eine Prüfung der Daten möglich wäre. Die Daten sind aber Eigenschaften der Klasse und sollten somit auch nach außen als Eigenschaften dargestellt werden. Aus diesem Grund werden die beiden Eigenschaften myReal und myImaginaer der Klasse Complex eingeführt. Der Programmcode zum Lesen der Eigenschaften myReal und myImaginaer sieht wie folgt aus: Public Property Get Real() As Integer Real = myReal End Property Public Property Get Imaginaer() As Integer Imaginaer = myImaginaer End Property
Die Methoden zum Schreiben der Eigenschaften myReal und myImaginaer verwenden den Befehl Let. Der Programmcode sieht dann wie folgt aus: Public Property Let Real(newReal As Integer) myReal = newReal End Property Public Property Let Imaginaer(newImaginaer As Integer) myImaginaer = newImaginaer End Property
Natürlich sind die Methoden, die von der jeweiligen Eigenschaft aufgerufen werden, nicht sehr komplex. Aus diesem Grund wird noch die Eigenschaft Vektor eingeführt. Diese Eigenschaft berechnet den Wert des Vektors, der sich aus dem Imaginärteil und dem Realteil der komplexen Zahl bildet. Diese Funktion benötigt nur die Leseberechtigung.
228
Die Formel zur Berechnung der Vektorlänge (hierbei handelt es sich immer um eine positive Zahl) der komplexen Zahl ist: Vektor =
real 2 + imaginä r 2
Public Property Get Vektor() As Double Vektor = Sqr(myReal ^ 2 + myImaginaer ^ 2) End Property
Testen der Klasse Complex Um die Klasse clsComplex zu testen, wird eine neue Anwendung erzeugt. Dieser Anwendung wird dann die Datei, die den Programmcode der Klasse clsComplex enthält, hinzugefügt. Die Ausgabe des Testwerts wird in ein Beschriftungselement LABVEKTOR geschrieben, und die Eingabewerte werden in den Textelementen txtReal und txtImaginaer eingetragen. Der gesamte Programmcode zum Testen der Klasse clsComplex ist in dem folgenden Listing dargestellt. Option Explicit Private objZahl As New clsComplex Private Sub btnAbbrechen_Click() End End Sub Private Sub Form_Load() labVektor.Caption = objZahl.Vektor End Sub Private Sub txtImaginaer_Change() If Len(txtImaginaer.Text) > 0 Then objZahl.Imaginaer = CInt(txtImaginaer.Text) Else objZahl.Imaginaer = 0 End If labVektor.Caption = objZahl.Vektor End Sub Private Sub txtReal_Change() If Len(txtReal.Text) > 0 Then objZahl.Real = CInt(txtReal.Text) Else
!"#
229
objZahl.Real = 0 End If labVektor.Caption = objZahl.Vektor End Sub
Wir haben nun eine Klasse mit Eigenschaften und Methoden. Dennoch hat unsere Klasse ein Problem: Wenn die Eigenschaften der Klasse abgefragt werden, bevor die Klasse initialisiert wird, kann kein sinnvoller Wert zurückgeliefert werden. Um diesen Fehler zu vermeiden, muß eine Initialisierung vorgenommen werden, sobald die Klasse erzeugt wird. Der Konstruktor Bei dem Konstruktor handelt es sich prinzipiell um eine Methode mit einigen Einschränkungen. Der Konstruktor wird immer dann vom Compiler aufgerufen, wenn ein Klassenobjekt definiert oder Speicher für die Klasse reserviert wird. Diese Deklaration des Konstruktors unterliegt denselben Richtlinien wie die allgemeinen Methoden einer Klasse, mit dem Unterschied, daß kein Typ für einen Rückgabewert definiert werden darf: Der Name des Konstruktors ist schon festgelegt. Der Konstruktor ist ein Teil der erzeugten Klasse und wird erzeugt, indem im Kopf des Fensters für den Programmcode der Wert Class aus der linken DropDown-Liste und Initialize aus der rechten DropDown-Liste gewählt werden.
Abbildung 13.9: Erzeugen des Konstruktors
Im folgenden Programmteil ist der Konstruktor in die Klasse clsComplex eingeführt worden. Private Sub Class_Initialize() Real = 0 Imaginaer = 0 End Sub
In dem Programmcode, der dem Konstruktor zugeordnet wird, werden die lokalen Variablen myReal und myImaginär mit dem Wert 0 initialisiert. Bei dem Programmcode der Methode wird, wie schon bei der Deklaration, auf eine Definition des Rückgabewertes verzichtet.
230
Wird jetzt der Inhalt der Klasse clsComplex abgefragt, bevor ein Wert initialisiert wird, so liefern alle Eigenschaften dieses Objektes den Wert 0 zurück. Manchmal kommt es jedoch vor, daß die Klasse mit anderen Werten initialisiert werden soll; hierfür muß dann eine andere Methode bereitgestellt werden. Vorsicht Das Gegenstück zum Konstruktor ist der Destruktor. Beim Destruktor handelt es sich ebenfalls um eine Methode. Sie wird immer dann automatisch ausgeführt, wenn die Klasse aus dem Speicher entfernt wird. Dies passiert z.B., wenn die Referenz eines Objekts aus dem Bezugsrahmen fällt.
Der Destruktor
Der Name des Destruktors ist wie der Name des Konstruktors schon festgelegt. Er wird ebenfalls im Kopf des Fensters für den Programmcode ausgewählt.
Abbildung 13.10: Erzeugen des Destruktors
Für den Destruktor werden im allgemeinen keine Berechnungen mehr durchgeführt, da beim Auflösen des Objekts keine Aktionen mehr durchgeführt werden müssen, die den Datenbestand im Objekt selbst aktualisieren. Dies sollte alles vorher geschehen. Ein Destruktor dient einzig und allein dem Aufräumen des Objekts im Programmspeicher.
13.4
Das Arbeiten mit zwei Formularen
In Visual Basic ist es möglich, ein Programm zu entwickeln, welches mit mehreren Formularen arbeiten kann. Das einfachste Beispiel hierfür ist das Verwenden von Meldungsfenstern. Diese Formulare sind jedoch in ihrer Layoutgestaltung sehr begrenzt. Soll nun eine Anwendung mit mehreren Fenstern entwickelt werden, muß zuerst ein neues Fenster in das Projekt aufgenommen werden. Zum einen kann ein neues Formular über den Auswahlpunkt FORMULAR HINZUFÜGEN aus dem Visual Basic-Menü PROJEKT hinzugefügt werden, zum anderen kann mit der rechten Maustaste auf das Projektfenster geklickt werden. Aus dem dort bereitgestellten Kontextmenü werden HINZUFÜGEN und FORMULAR gewählt. In der hierarchischen Projektliste des Projektfensters erscheint nun ein neues Formular. Dieses For-
$%
231
mular kann wie alle anderen bearbeitet werden. Es lassen sich Steuerelemente aufbringen und die Eigenschaften verändern.
13.4.1
Laden und Anzeigen eines Formulars
Um aus dem Hauptformular – dem Formular, das beim Programmstart ausgeführt wird – ein weiteres Formular zu laden oder anzuzeigen, gibt es die Methoden Show und Load. Die Anweisung Load Mit der Methode Load werden Formulare in den Speicher geladen, jedoch noch nicht angezeigt. Wurde ein Formular in den Speicher geladen, können Daten an die Steuerelemente gesendet werden, ohne daß diese angezeigt werden. Load Name Parameter
Beschreibung
Name
Bei dem zu ladenden Objekt kann es sich um ein Formular, MDIFormular oder ein Element aus einem Steuerelementenfeld handeln.
Load braucht im allgemeinen nicht verwendet zu werden, denn jeder Verweis auf ein Formular lädt dieses automatisch, es sei denn, das Formular wird in einer der Anweisungen Set oder If...TypeOf verwendet. In manchen Applikationen ist es jedoch für das Programm sinnvoll, daß zuerst alle Formulare des Visual Basic-Projekts geladen und initialisiert und erst bei Bedarf sichtbar gemacht werden. Wird ein Objekt mit der Anweisung Load geladen, so werden zuerst alle Elemente und Eigenschaften neu initialisiert. Anschließend wird die Ereignisprozedur des Formulars Load ausgeführt. Die Methode Show Mit dieser Methode wird ein Formular angezeigt. Wurde das Formular noch nicht mit der Methode Load geladen, wird dies jetzt automatisch von Visual Basic vorgenommen.
232
Name.Show Stil, Umgebungsform
Parameter
Beschreibung
Name
Der Parameter Name gibt das MDI-Formular oder das Formular an, das angezeigt werden soll.
Stil
Dies ist ein optionaler Parameter vom Typ Ganzzahl, mit dem das Verhalten des Fensters bestimmt wird. Ist der Wert 0, so ist das Fenster gebunden (modal), d.h., es muß zuerst eine Operation abgeschlossen werden, bevor der Fokus wieder auf ein anderes Fenster gesetzt werden kann. Ist der Wert 1, so ist das Fenster ungebunden, d.h., der Fokus kann zwischen mehreren Fenstern wechseln.
Umgebungsform
Dies ist ein optionaler Parameter, mit dem definiert wird, welche Komponente dieses Unterformular besitzt. In Visual Basic-Standardformularen wird das Schlüsselwort Me verwendet.
Wird in einer Funktion mit dem Befehl Show ein gebundenes Formular angezeigt, so wird der Programmcode, der nach der Anweisung Show folgt, erst ausgeführt, wenn das gebundene Formular nicht mehr angezeigt wird. Beim Anzeigen eines ungebundenen Formulares wird die Funktion weiter abgearbeitet.
Abbildung 13.11: Abarbeitung einer Funktion bei ungebundener Fensteraktivierung
$%
233
Abbildung 13.12: Abarbeitung einer Funktion bei gebundener Fensteraktivierung
In Abbildung 13.11 wird dargestellt, wie eine Funktion beim Aufrufen eines nicht abhängigen Fensters als unabhängig abgearbeitet wird. Abbildung 13.12 dagegen zeigt, wie dies bei einem abhängigen Fenster abläuft. Ausblenden eines Fensters Um ein Fenster auszublenden, ohne es zu entladen, gibt es die Funktion Hide. Name.Hide
Parameter
Beschreibung
Name
Bei dem auszublendenden Objekt kann es sich um ein Formular oder um ein MDI-Formular handeln.
Wurde ein Fenster ausgeblendet, können vom Benutzer keine Aktionen mehr in bezug auf das Fenster ausgeführt werden. Das Visual Basic-Programm jedoch kann weiterhin Daten an die Steuerelemente senden bzw. von ihnen abfragen. Auch andere Applikationen, die mit der Anwendung über DDE kommunizieren, können auf das ausgeblendete Formular zugreifen. Wurde Hide aufgerufen, ohne das Fomular zuvor geladen zu haben, lädt die Funktion zwar das Formular, zeigt es aber nicht an. Die Methode Hide ist das Gegenstück zu der Methode Show.
234
Entladen eines Fensters Um ein Formular aus dem Speicher zu entfernen, gibt es unter Visual Basic die Anweisung Unload. Mit dieser Anweisung wird das Formular aus dem Speicher entfernt, und alle auf dem Formular gemachten Einstellungen gehen verloren. Unload Name
Parameter
Beschreibung
Name
Bei dem zu entladenden Objekt kann es sich um ein Formular, MDI-Formular oder ein Element aus einem Steuerelementenfeld handeln.
Wenn ein Formular aus dem Hauptspeicher entfernt wird, kann nicht mehr auf die Steuerelemente des Formulars zugegriffen werden. Diese Aktion ist zumeist dann nötig, wenn das Formular komplett neu initialisiert oder wenn der von dem Formular benötigte Hauptspeicher für andere Applikationen oder Module zur Verfügung gestellt werden muß. Wird die Funktion Unload ausgeführt, bevor das Formular mit Load oder Show geladen wird, hat dieser Befehl keinen Einfluß auf das Programm.
13.4.2
Beispiel zum Arbeiten mit zwei Formularen
Das folgende Beispielprogramm soll zum Bearbeiten von INI-Dateien dienen. In ein Fenster – das Editorfenster (Abbildung 13.13) – soll der Inhalt der Datei geladen werden, damit sie bearbeitet werden kann. Zu den Aufgaben eines solchen Editors gehören mindestens die folgenden Punkte:
DATEI
DATEI ÖFFNEN
DATEI SPEICHERN bzw. SPEICHERN UNTER
DATEI DRUCKEN
DATEI SCHLIESSEN
BEENDEN
$%
235
Abbildung 13.13: Das Editorfenster
In einem zweiten Fenster – dem Informationsfenster (Abbildung 13.14) –, das von dem Editorfenster abhängig ist, werden wichtige Informationen zur geladenen INI-Datei, wie z.B. die Abschnitt-Überschriften, ausgegeben.
Abbildung 13.14: Das Informationsfenster
Wenn das Informationsfenster von dem Editorfenster aufgerufen wird, kann im Editorfenster weitergearbeitet werden. Um die Steuerung des Zusatzfensters (Informationsfenster) aus dem Hauptfenster (Editorfenster) durchzuführen, muß das Menü des Hauptfensters um folgende Einträge erweitert werden:
236
OPTIONEN
Inhaltsverzeichnis
Aktualisieren
Der Menüpunkt AKTUALISIEREN wird benötigt, um die in dem Informationsfenster ausgegebenen Daten nach einer größeren Änderung, z.B. nach Entfernen eines Abschnitts aus der INI-Datei, wieder zu aktualisieren. Wird in dem Informationsfenster ein Abschnitt ausgewählt, so wird auch im Editor dieser Abschnitt gesucht und dargestellt. Das RTF-Steuerelement RichTextBox
Abbildung 13.15: Das RTF-Steuerelement „RichTextBox“
Im Abschnitt „Eine komplette Datei laden“ wurde schon einmal kurz auf das Textsteuerelement Microsoft Rich TextBox Control 5.0 eingegangen. In diesem Abschnitt wird es noch einmal verwendet, jedoch soll hier tiefer auf die Möglichkeiten, die dieses Steuerelement bietet, eingegangen werden. Mit Microsoft Rich TextBox Control 5.0 läßt sich der Text einer Datei nicht nur darstellen, sondern er kann in diesem Steuerelement sogar mit den folgenden Eigenschaften formatiert werden: SelBold
Schrift im markierten Bereich fett formatieren.
SelItalic
Schrift im markierten Bereich kursiv formatieren.
SelStrikethru
Schrift im markierten Bereich durchstreichen.
SelUnderline
Schrift im markierten Bereich unterstreichen.
SelFontName
Schriftart im markierten Bereich festlegen.
SelFontSize
Schriftgröße im markierten Bereich festlegen.
SelHangingIndent
Linken Einzug des Textes festlegen.
SelIndent
Rechten Textabstand festlegen.
SelRightIndent
Abstand für den hängenden Einzug festlegen.
SelCharOffset
Einen markierten Text hoch oder tief stellen.
Das RTF-Steuerelement unterstützt die Zwischenablage und auch die OLE-Einbettung. Es können somit auch über OLE eingebettete WinWord-Dateien in ein Dokument eingebunden werden, welches mit dem RTF-Steuerelement erstellt wurde.
$%
237
Um den Inhalt eines RTF-Text-Steuerelements zu drucken, sollte die Methode SelPrint verwendet werden. Das Fortschrittsleisten-Steuerelement ProgressBar
Abbildung 13.16: „ProgressBar“
Mit ProgressBar läßt sich der Fortschritt einer länger andauernden Operation anzeigen. Zuerst wird der Bereich definiert, der die gesamte Operation abdeckt, danach kann der Fortschritt aktualisiert werden, indem der Eigenschaft Value der jeweilige Fortschrittswert zugewiesen wird. Die Anzahl der rechteckigen Flächen, die den Fortschritt durch Ausfüllen des Steuerelements simulieren, läßt sich indirekt über die Größe des Steuerelements beeinflussen. Je breiter und höher das Steuerelement ist, um so mehr und um so höhere rechteckige Flächen gibt es. Es sollte bei der Verwendung des Steuerelements darauf geachtet werden, daß die Anzahl der dargestellten rechteckigen Flächen in einem guten Verhältnis zur zu überwachenden Operation steht. So ist es z.B. nicht sinnvoll, einen Prozeß mit 200 Schritten in einem Fortschrittsbalken mit zwei Flächen abzubilden. Der eigentliche Fortschritt ist dann nicht zu erkennen. Die Steuerelemente des Editorfensters Für die Menüleiste des Editorfensters muß folgendes Menü mit dem Menüeditor abgebildet werden: 1. DATEI
DATEI ÖFFNEN
men_dat_oeffnen
DATEI SPEICHERN
men_dat_speichern
DATEI SPEICHERN UNTER
men_dat_unter
DATEI DRUCKEN
men_dat_drucken
DATEI SCHLIESSEN
men_dat_schliessen
BEENDEN
men_dat_ende
2. OPTIONEN
238
men_Datei
men_optionen
INHALTSVERZEICHNIS
men_opt_Inhalt
AKTUALISIEREN
men_opt_Aktual
Steuerelement
Eigenschaft
Inhalt
Beschreibung
RTF-Steuerelement (RichTextBox)
(Name)
RTF_Editor
Dies ist das Steuerelement, in dem der Inhalt der INI-Datei angezeigt und bearbeitet wird.
ScrollBars
3 – rtfBoth
Wenn der Inhalt der Datei über die Grenzen des Steuerelements hinausgeht, werden die Bildlaufleisten eingeschaltet.
(Name)
cmd_Editor
Dieses Steuerelement wird für die Dialoge zum öffnen, Speichern und Drucken der INI-Datei benötigt.
Standarddialog-Steuerelement
Tabelle 13.5: Die Steuerelemente des Editorfensters
Die Steuerelemente des Informationsfensters Steuerelement
Eigenschaft
Inhalt
Beschreibung
Listenfeld Steuerelement
(Name)
lst_Editor
Dieses Steuerelement zeigt alle in der INI-Datei enthaltenen Abschnittüberschriften.
ScrollBars
3 – rtfBoth
Wenn der Inhalt der Datei über die Grenzen des Steuerelements hinausgeht, werden die Bildlaufleisten eingeschaltet.
(Name)
lab_Kapitel
Dieses Steuerelement enthält die Abschnittsüberschrift, die im Listenfeld selektiert ist. Hier werden auch die Abschnittsüberschriften dargestellt, die für das Listenfeld zu lang sind.
BorderStyle
1 – Fest Einfach
Dadurch wirkt das Steuerelement wie in die Oberfläche eingelassen.
(Name)
lab_AktZeilen
Hier wird ausgegeben, wieviele Zeilen zum aktuellen Abschnitt gehören.
BorderStyle
1 – Fest Einfach
Dadurch wirkt das Steuerelement wie in die Oberfläche eingelassen.
(Name)
Lab_Zeilen
Hier wird angegeben, wieviele Zeilen die INIDatei enthält.
BorderStyle
1 – Fest Einfach
Dadurch wirkt das Steuerelement wie in die Oberfläche eingelassen.
(Name)
lab_Ueberschr
Hiermit wird angegeben, wieviele Überschriften die INI-Datei enthält.
BorderStyle
1 – Fest Einfach
Dadurch wirkt das Steuerelement wie in die Oberfläche eingelassen.
(Name)
lab_besch_Zeilen
Dies ist das Beschriftungselement für den Text Zeilen gesamt:
lab_besch_ueber
Dies ist das Beschriftungselement für den Text Überschriften:
! " #
Beschriftungselemente
Tabelle 13.6: Die Steuerelemente des Informationsfensters
$%
239
13.4.3
Die Programmentwicklung
In diesem Abschnitt wird nun der Programmcode für die gewünschte Applikation entwickelt, wobei zu beachten ist, daß die Funktion Kapitel_suchen erst gegen Ende entwickelt wird. Dabei bleibt immer nur zu berücksichtigen, daß bei einem Programmtest die jeweilige Programmzeile auskommentiert werden muß.Alternativ kann die folgende Dummy-Funktion eingebaut werden, die dann nachträglich erweitert wird: Sub Kapitel_suchen() End Sub
Beenden des Programms Eine der Funktionen, die dem Anwender als erstes zur Verfügung stehen sollten, ist die zur Beendigung des Programms über das Menü. Hierzu dient die folgende Funktion: Private Sub men_dat_ende_Click() End End Sub
Geöffnete Datei schließen Mit dieser Funktion werden die Variablen, die alle Daten der geöffneten Datei enthalten, zurück gesetzt. Sub Datei_Schliessen() frm_Editor.Caption = frm_Editor.Tag Geoeffnete_Datei = "" RTF_Editor.Text = "" Call Kapitel_suchen End Sub
Das Öffnen der zu bearbeitenden Datei Als erstes soll die Funktion zum Laden der INI-Datei entwickelt werden, um als Grundlage für weitere Programmierarbeiten zu dienen. Geladen wird die Datei über den Menüpunkt DATEI | DATEI ÖFFNEN. Danach soll ein Dialog erscheinen, in dem die zu öffnende Datei ausgewählt werden kann. Damit deren Name auch anderen Funktionen zur Laufzeit zur Verfügung steht, wird eine globale Variable Geoeffnete_Datei eingeführt.
240
Private Sub men_Dat_oeffnen_Click() cmd_Editor.DialogTitle = "Datei öffnen" cmd_Editor.filename = "*.ini" cmd_Editor.ShowOpen On Error GoTo Fehler_men_dat_oeffnen_Click Geoeffnete_Datei = cmd_Editor.filename RTF_Editor.LoadFile (cmd_Editor.filename) Call FensterTitel(cmd_Editor.filename) Call Kapitel_suchen Exit Sub Fehler_men_dat_oeffnen_Click: Call Datei_Schliessen Exit Sub End Sub
Schließen einer Datei Nachdem eine Datei geöffnet wurde, muß es natürlich auch die Möglichkeit geben, diese wieder zu schließen, ohne das Programm zu verlassen. Private Sub men_dat_schliessen_Click() Call Datei_Schliessen End Sub
Speichern einer Datei Wurden an einer Datei Änderungen durchgeführt, die auch erhalten bleiben sollen, muß die Datei unter demselben Namen, unter dem sie geöffnet wurde, wieder gespeichert werden können. Für diese Aktion gibt es den Menüpunkt DATEI SPEICHERN. Private Sub men_dat_speichern_Click() If Len(Geoeffnete_Datei) > 0 Then 'Wenn ein Dateiname 'existiert RTF_Editor.SaveFile Geoeffnete_Datei, 1 End If End Sub
Um die vorgenommenen Änderungen in einer anderen Datei zu speichern – damit z.B. eine Sicherheitskopie von der zu ändernden Datei angelegt wird –, stellt das Programm die Option SPEICHERN UNTER zur Verfügung. Wird dieser Menüpunkt gewählt, so erscheint ebenfalls ein Dialog, mit dem das Verzeichnis gewechselt und ein neuer Dateiname vergeben werden kann.
$%
241
Private Sub men_Dat_unter_Click() Dim Datei As String cmd_Editor.DialogTitle = "Datei öffnen" cmd_Editor.filename = "*.ini" cmd_Editor.ShowSave Datei = cmd_Editor.filename If Len(trunc(Datei)) > 0 Then RTF_Editor.SaveFile Datei, 1 Call FensterTitel(cmd_Editor.filename) End If End Sub
Die aktive Datei drucken Um die aktive Datei an den Drucker zu senden, wird die Methode SelPrint des Rtf-Textelementes verwendet. Zuerst wird jedoch der Drukker über das Druckmenü des Standardsteuerelements cmd_Editor ausgewählt. Dabei wird beim Aufrufen des Druckmenüs berücksichtigt, ob nur ein Teil der Datei markiert wurde, also nicht die ganze Datei gedruckt werden soll, oder ob nichts markiert wurde, also die gesamte Datei gedruckt werden soll. Private Sub menDat_drucken_Click() If Len(RTF_Editor) > 0 Then cmd_Editor.Flags = cdlPDReturnDC + cdlPDNoPageNums If RTF_Editor.SelLength = 0 Then cmd_Editor.Flags = cmd_Editor.Flags + cdlPDAllPages Else cmd_Editor.Flags = cmd_Editor.Flags + cdlPDSelection End If cmd_Editor.ShowPrinter DoEvents Printer.Print "" RTF_Editor.SelPrint cmd_Editor.hDC End If End Sub
Das Fenster für die Inhaltsangaben aktivieren Um das Fenster für die Inhaltsangaben zu aktivieren, muß der folgende Programmcode in das Click-Ereignis des Menübefehls OPTIONEN | INHALTSVERZEICHNIS aufgenommen werden. Wurde das Formular zur Ausgabe der Dateiinformationen noch nicht geöffnet, so lädt die Methode Show das Fenster in den Hauptspeicher und zeigt dieses an. Zudem wird ein Haken zur Bestätigung vor das Menü INHALTSVERZEICHNIS gesetzt. Ist das Fenster geöffnet, wird duch Auswählen des
242
Menüs das Formular ausgeblendet und das Bestätigungszeichen vor dem Menü entfernt. Private Sub men_opt_Inhalt_Click() If men_opt_Inhalt.Checked = True Then men_opt_Inhalt.Checked = False men_opt_Aktual.Enabled = False frm_Inhalt.Hide Else men_opt_Inhalt.Checked = True men_opt_Aktual.Enabled = True frm_Inhalt.Show 0, Me Call Kapitel_suchen End If End Sub
Ermitteln der Informationen zu der geöffneten Datei Mit der zu Anfang dieses Abschnitts erwähnten Funktion Kapitel_suchen werden nun die benötigten Informationen, die in dem Formular frm_Inhalt angezeigt werden, ermittelt. Zuerst wird geprüft, ob die geladene Datei Informationen enthält. Danach wird zu jedem Abschnitt die Anzahl der zugehörigen Zeilen ermittelt. Ein Abschnitt in einer ini-Datei wird immer durch ein Wort eingeleitet, das in den eckigen Klammern „[„ und „]“ steht. Dieses gefundene Wort wird dann in das Listenelement auf dem Formular eingetragen. Da die Anzahl der Zeichen in der Datei bekannt ist – die Länge des Textes, der in der Eigenschaft Text vom Steuerelement RTF-Editor eingetragen wird –, kann der aktuelle Fortschritt der Operation in dem Fortschrittssteuerelement angezeigt werden. Sub Kapitel_suchen() Dim i As Integer Dim Kapitel As Boolean Dim Maximum As Integer Dim Titel As String Dim Zeilen As Integer Dim Zeichen As String Titel = "" Zeilen = 0 frm_Inhalt.Enabled = False frm_Editor.Enabled = False 'Alle Ausgabefelder neu initialisieren frm_Inhalt.lab_Zeilen.Caption = 0
$%
243
frm_Inhalt.lab_ueberschr.Caption = 0 frm_Inhalt.lab_Kapitel.Caption = "" frm_Inhalt.lab_AktZeilen.Caption = 0 frm_Inhalt.lst_Editor.Clear frm_Inhalt.pgb_Editor.Min = 0 Maximum = Len(RTF_Editor.Text) 'Wenn die INI-Datei keine Zeichen enthält oder die Angaben 'dazu nicht ermittelt werden sollen If Maximum < 1 Or men_opt_Inhalt.Checked = False Then frm_Inhalt.Enabled = True frm_Editor.Enabled = True Exit Sub End If 'Durchsuche den kompletten Inhalt frm_Inhalt.pgb_Editor.Max = Maximum For i = 1 To Maximum Zeichen = Mid(RTF_Editor.Text, i, 1) If Zeichen = "[" Then If Len(Titel) > 0 Then frm_Inhalt.lst_Editor.AddItem Titel & Chr(9) & _ Zeilen – 1 frm_Inhalt.lab_ueberschr.Caption = _ frm_Inhalt.lab_ueberschr.Caption + 1 End If Kapitel = True Titel = "" Zeilen = 0 Else If Zeichen = "]" Then Kapitel = False Else If Kapitel = True Then Titel = Titel & Zeichen Else If Zeichen = Chr(13) Then Zeilen = Zeilen + 1 frm_Inhalt.Lab_Zeilen.Caption = _ frm_Inhalt.Lab_Zeilen.Caption + 1 End If End If End If End If If i Mod 10 = 0 Then DoEvents frm_Inhalt.pgb_Editor.Value = i Next i frm_Inhalt.lst_Editor.AddItem Titel & Chr(9) & Zeilen
244
frm_Inhalt.Enabled = True frm_Editor.Enabled = True End Sub
Aktualisieren des Datei-Informationsfensters Um das Datei-Informationsfenster zu aktualisieren, muß nun lediglich die Funktion Kapitel_suchen aus dem Ereignis Click des Menüs aufgerufen werden. Private Sub men_opt_Aktual_Click() Call Kapitel_suchen End Sub
Diese Option ist jedoch nur verfügbar, wenn das Informationsfenster aktiv ist. Suchen des im Listenelement selektierten Abschnitts Um den aktuellen Abschnitt, der im Listenfeld lst_Editor selektiert wurde, zu finden, wird die Methode Find des Rtf-Textelements verwendet. Mit ihr springt das Programm direkt an die Kapitelüberschrift und markiert diese als aktiv. Des weiteren wird in den Beschriftungselementen nochmals die gesamte Abschnitt-Überschrift mit der Anzahl von Zeilen ausgegeben, die zu diesem Steuerelement gehören. Private Sub lst_Editor_Click() Dim i As Integer Dim Ergebnis As Long i = 1 lab_Kapitel.Caption = "" While Mid(lst_Editor.Text, i, 1) <> Chr(9) lab_Kapitel.Caption = lab_Kapitel.Caption & Mid(lst_Editor.Text, i, 1) i = i + 1 Wend Ergebnis = frm_Editor.RTF_Editor.Find("[" & lab_Kapitel.Caption & "]", 0, Len(frm_Editor.RTF_Editor.Text)) frm_Editor.SetFocus lab_AktZeilen.Caption = Right(lst_Editor.Text, Len(lst_Editor.Text) – i) End Sub
$%
245
Schließen des Informationsfensters Wenn das Informationsfenster nicht über das Editorfenstermenü OPTIONEN | INHALTSVERZEICHNIS geschlossen wird, muß der Bestätigungshaken vor diesem Menüeintrag trotzdem entfernt werden. Diese Aktion wird in dem Ereignis Form_Unload des Inhaltsverzeichnisfensters ausgeführt. Private Sub Form_Unload(Cancel As Integer) frm_Editor.men_opt_Inhalt.Checked = False End Sub
Rekursive Programmierung
13.5
Bei der Rekursion handelt es sich um eine Programmiertechnik, bei der sich eine Funktion immer wieder selbst aufruft, bis ein bestimmtes Abbruchkriterium erfüllt ist. Trifft das Abbruchkriterium nicht ein, wird die Funktion so oft aufgerufen, bis der Hauptspeicher gefüllt ist und die Fehlermeldung „Nicht genügend Stapelspeicher“ erscheint. Im folgenden Abschnitt wird die Arbeitsweise von rekursiven Funktionen anhand von Beispielen erklärt.
Einfache Rekursion
13.5.1
Eine einfache rekursive Funktion enthält nur einen einzigen Aufruf ihrer selbst.
X1
X2 0
X3 1
... 2
Xn n-1
Abbildung 13.17: Eine Liste mit n Zahlen
Um die Zahlen aus Abbildung 13.17 zu addieren, gibt es zwei Möglichkeiten. Die erste Möglichkeit besteht darin, eine Schleife zu programmieren, die über einen Index jedes Feld der Liste ausliest und alle Werte miteinander addiert. Der folgende Beispiel-Programmcode berechnet nach dieser Methode die Summe von n Zahlen. Function Addiere(Liste As Variant) As Integer Dim i As Integer Dim Ergebnis As Variant Ergebnis = 0 For i = 0 To UBound(Liste) Ergebnis = Ergebnis + Liste(i)
246
Next i Addiere = Ergebnis End Function
Die zweite Möglichkeit ist die Summenbildung über eine rekursive Funktion, die eine Liste – beginnend mit dem ersten Element – bis zum Ende durchläuft und alle Werte miteinander addiert, bis das letzte Listenelement gefunden wurde. Folgender Programmcode berechnet die Summe aller Zellen des Feldes rekursiv: Function Addiere(Liste As Variant, Index As Integer) As Integer Addiere = 0 If Index <= UBound(Liste) Then 'Wenn nicht das letzte Feld Addiere = Addiere(Liste, Index + 1) + Liste(Index) End If End Function
Wie der Vergleich der beiden Funktionen sehr gut erkennen läßt, ist die rekursive Funktion zur Berechnung der Summe kürzer als die Funktion, die die For-Schleife enthält. Zur weiteren Verdeutlichung der einfachen rekursiven Funktion soll ein Programm zur Berechnung der Fakultät geschrieben werden. Dazu soll in einem Texteingabeelement eine Zahl eingegeben, und nach Betätigen der (¢)-Taste die Fakultät dieser Zahl in einem Beschriftungselement ausgegeben werden können. Die Fakultät „!“ einer Zahl wird wie folgt berechnet: n
n! = ∏ X ; n! = 1*2*3*...*n x =1
Gleichung 13.1: Berechnung der Fakultät
Daraus folgt: 3! = 1 x 2 x 3 = 6 4! = 1 x 2 x 3 x 4 = 24 5! =1 x 2 x 3 x 4 x 5 = 120 Als Grundlage für das Programm kann wieder das Vorlageprogramm auf der Buchdiskette im Verzeichnis \VORLAGE\ dienen.
&#'
247
Lösung: der folgenden Funktion zur Berechnung der Fakultät wird als Parameter die Zahl übergeben, deren Fakultät berechnet werden soll. Bei der Deklaration des Parameters reicht der Typ Byte aus, da die größte Zahl, von der die Fakultät berechnet werden kann, die Zahl 171 ist. Bei 172 findet ein Überlauf statt, und das Programm bricht mit einer Fehlermeldung ab. Function Fakultaet(Eingabe As Byte) As Variant If Eingabe > 1 Then Fakultaet = Fakultaet(Eingabe – 1) * Eingabe Else Fakultaet = 1 End If End Function
Wird im Texteingabefeld eine Zeichenkette eingegeben, die nicht von der Funktion Fakultät verarbeitet werden kann, so sollte eine Fehlermeldung auf dem Bildschirm ausgegeben werden. Private Sub btn_Ok_Click() Dim Meldung As String On Error GoTo Fehler_btn_Ok_Click lab_Ausgabe.Caption = Fakultaet(txt_Eingabe.Text) Exit Sub Fehler_btn_Ok_Click: Meldung = "Fehler Nr.:" & Err.Number & " im Program " & _ Err.Source & " aufgetreten" & Chr(10) & Chr(13) & _ "Fehlermeldung: " & Error(Err.Number) Call MsgBox(Meldung, 16, "Fehlermeldung", Err.HelpFile, _ Err.HelpContext) End Sub
Tritt in der Funktion BTN_OK_CLICK() ein Fehler auf, verzweigt das Programm in die Fehlerbehandlungsroutine. Dies ist bei der Eingabe einer nicht erlaubten Zeichenkette der Fall oder dann, wenn die Fakultät größer ist als die größte darstellbare Zahl von Visual Basic.
13.5.2
Mehrfache Rekursion
Die mehrfache Rekursion ist schwieriger zu verstehen als die einfache. Jedoch lassen sich einige Aufgaben sehr viel einfacher mit dieser Programmiertechnik beschreiben. Zur Verdeutlichung soll eine Funktion geschrieben werden, die die Fibonacci-Zahl zu einem Eingabewert berechnet. Die Zahl berechnet sich wie folgt:
248
Fibonacci(n) = Fibonacci(n–1) + Fibonacci(n–2) wobei gilt: Fibonacci(1) = 1 Fibonacci(2) = 1 Betrachtet man Fibonacci als Reihe, so erhält man folgende Zahlenfolge (bis 15): Index
1
2
3
4
5
6
7
8
9
1 0
1 1
1 2
1 3
1 4
1 5
Fibonacci
1
1
2
3
5
8
1 3
2 1
3 4
5 5
8 9
1 4 4
2 3 3
3 7 7
6 1 0
Tabelle 13.7: Fibonacci-Reihe bis 15
Um nun die Rekursion darzustellen, die nötig ist, um eine FibonacciZahl zu berechnen, bietet sich ein Baum für die Darstellung des rekursiven Abstiegs an (Abbildung 13.18). 13 7 8
5
3 2 1
1
3
1
3
5
2
4
1
2
5
6
1
1
2
3
1
2
1
1
3
1
3
4
1
2
2
2
1
1
1
2
4
1
3
5
2
1
1
3
1
2
2
2
Abbildung 13.18: Darstellung des rekursiven Abstiegs in einem Baum
In Abbildung 13.18 ist zu erkennen, daß sich jede Fibonacci-Zahl aus den beiden vorhergehenden Fibonacci-Zahlen errechnet. In dem folgenden Listing wird die Fibonacci-Zahl mit einer Schleife berechnet. Function Fibonacci(Eingabe Dim Ergebnis As Double Dim Merker As Double Dim Merker2 As Double Dim i As Integer
As Integer) As Double 'Aktuelle Fibonacci-Zahl 'Speichert letzte Fibonacci-Zahl 'Speichert vorletzte Fibonacci-Zahl
&#'
249
Ergebnis = 1 Merker = 1 For i = 2 To Eingabe Merker2 = Merker Merker = Ergebnis
'Initialisieren der Fibonacci-Zahlen 'von 1 und 2 – 1 'Zwischenspeichern der letzten Fibonacci-Zahl 'Zwischenspeichern der aktuellen Fibonacci-Zahl
Ergebnis = Merker2 + Ergebnis 'Berechnen der neuen 'Fibonacci-Zahl Next i Fibonacci = Ergebnis End Function
Diese Funktion läßt sich nun sehr stark durch Verwendung der mehrfachen Rekursion vereinfachen. Die Funktion zur Berechnung der Fibonacci-Zahl wird solange aufgerufen, bis der Initialwert 1 gefunden wurde, die Zahl also definiert ist und nicht berechnet werden muß. Dieser beschriebene Ablauf ist in der folgenden Funktion programmiert: Function Fibonacci(Eingabe As Integer) As Double If Eingabe < 3 Then Fibonacci = 1 Else Fibonacci = Fibonacci(Eingabe – 1) + Fibonacci(Eingabe – 2) End If End Function
Der Programmcode dieser Funktion ist um einiges kürzer und besser zu verstehen als der zuerst entwickelte. Jedoch gibt es auch einen Nachteil: Die Programmlaufzeit erhöht sich sehr stark. Zum Vergleich kann beiden Funktionen die Aufgabe gegeben werden, Fibonacci von 50 zu berechnen. Während die Methode mit der ForSchleife innerhalb kürzester Zeit zum Ergebnis führt, wartet man bei der rekursiven Berechnung recht lange darauf.
13.6
Die Registrierdatenbank
In den Versionen Windows 3.x und Windows NT 3.x wurden die Konfigurationseinstellungen von Programmen in INI-Dateien gespeichert. Dabei war die Datei WIN.INI die Hauptkonfigurationsdatei von Windows. In ihr wurden systembezogene Daten abgelegt. Für die anwendungsspezifischen Informationen besaßen die meisten Programme wiederum eigene INI-Dateien. Seit Windows 95 und Windows NT 4.0 werden die Konfigurationen in der Registrierdatenbank (engl. Registry) abgespeichert. Ob dies weit-
250
reichende Vor- oder Nachteile hat, ist dabei von keinerlei praktischem Interesse mehr. Inzwischen gehört es zum guten Ton, keine INI-Dateien mehr zu verwenden. In der Registrierdatenbank befinden sich nun alle Informationen über die Windows-Konfiguration, sowie die Daten der installierten Anwendungsprogramme. Welche Daten von einer Anwendung in die Registrierdatenbank geschrieben werden, hängt von der jeweiligen Applikation ab.
Abbildung 13.19: Der Registrierungseditor mit dem Eintrag von Visual Basic 6.0
Um Einträge der Registrierdatenbank anzuzeigen, stellen Windows 95 und Windows NT 4.0 einen Registrierungseditor zur Verfügung. Mit seiner Hilfe können Einträge in der Registrierdatenbank gesucht und modifiziert werden. Die Verwaltung der Registrierdatenbank wird wiederum intern auf mehrere Dateien verteilt. Zur Zeit handelt es sich dabei um die Dateien SYSTEM.DAT und USER.DAT, die jedoch für den Zugriff auf die Registrierdatenbank keine Rolle spielen. Der Aufbau der Registrierdatenbank ist hierarchisch und ähnelt darin dem Aufbau der Verzeichnisstruktur auf einem Datenträger.
13.6.1
Die Schlüssel der Registrierdatenbank
Die Registrierdatenbank besitzt sechs Hauptschlüssel, wobei drei von ihnen besondere Bedeutung zukommt. Die drei wichtigsten Schlüssel sind:
& #
251
HKey_Classes_Root: Hier werden alle wichtigen Informationen zu allen Windows-Klassen abgelegt. Darunter fallen die Verknüpfungen von Dateiendungen mit den Anwendungen, die OLE-Klassen und die Registrierung aller anderen Schnittstellen nach dem Component Object Model.
HKey_Current_User: Dieser Schlüssel beinhaltet spezielle Informationen für den aktuellen Benutzer. Im Prinzip gibt dieser Schlüssel nur einen Ast des Baumes HKey_Users wieder, in dem auch eventuell noch weitere Benutzerdaten gespeichert werden.
HKey_Lokal_Machine: Hier werden die Informationen gespeichert, die für die Arbeitsstation relevant sind und für alle Benutzer Gültigkeit besitzen.
Im folgenden werden die drei Hauptschlüssel, denen bei der Softwareentwicklung keine so hohe Bedeutung zukommt, abgehandelt.
HKey_Current_Config: Dieser Schlüssel stammt von dem Hauptschlüssel HKey_Lokal_Machine unter Windows 95 ab, wobei im Unterschlüssel die Nummer der zur Zeit verwendeten Hardwarekonfiguration enthalten ist. Dieser Schlüssel wird für Rechner verwendet, die zwischen zwei Hardwarekonfigurationen unterscheiden. Laptops unterscheiden z.B. zwischen eingedocktem und ausgedocktem Zustand.
HKey_User: In diesem Hauptschlüssel sind alle Profile der Anwender enthalten. Meldet sich ein Anwender am System an, wird das Profil des aktuellen Anwenders an den Schlüssel HKey_Current_User vererbt.
HKey_Dyn_Data: Dieser Schlüssel wird bei jedem Start des Betriebssystems neu erstellt. Alle im HKey_Dyn_Data enthaltenen Daten werden in den Arbeitsspeicher geladen.
Jeder dieser Schlüssel kann beliebig viele Unterschlüssel besitzen. In den INI-Dateien wurde eine Selektion nach Abschnitten durchgeführt. In der Registrierdatenbank erfolgt die Selektion immer durch die Angabe eines gesamten Eintragungspfades.
13.6.2
Der Zugriff auf die Registrierdatenbank
Zum einen stellt die Windows-API selbst verschiedene Funktionen bereit, um mit der Registrierdatenbank zu arbeiten. Die Handhabung dieser Funktionen ist jedoch sehr ermüdend und auch relativ kompliziert. Um den Zugriff auf die Registrierdatenbank zu vereinfachen, stellt Visual Basic eigene Funktionen zur Verfügung. Mit ihnen läßt sich der Zugriff auf die Registrierdatenbank sehr viel einfacher realisieren.
252
Eintrag speichern mit SaveSetting Um Schlüssel in der Registrierdatenbank zu erzeugen oder zu speichern, wird die Funktion SaveSetting zur Verfügung gestellt. SaveSetting AppName, Section, Key, Setting Parameter
Beschreibung
APPNAME
Dieser Parameter ist erforderlich und beschreibt den Namen des Projekts oder der Applikation, auf das bzw. die sich der Registrierungseintrag bezieht.
SECTION
Dieser Parameter ist erforderlich und beschreibt den Namen des Abschnitts in dem der Schlüssel gespeichert werden soll.
KEY
Dieser Parameter ist erforderlich. Er repräsentiert den Namen des Schlüssels, dessen Wert gespeichert werden soll.
SETTING
Dieser Parameter ist erforderlich und ist der Wert des Schlüssels, dessen Name mit dem Parameter Key gespeichert wurde.
Abbildung 13.20: Parameterliste zu SaveSetting
Eintrag lesen mit GetSetting Um einen mit SaveSetting gespeicherten Schlüssel wieder aus der Registrierdatenbank zu lesen, wird die Funktion GetSetting von Visual Basic zur Verfügung gestellt. Ihre Parameter sind ähnlich denen von SaveSetting. Result = GetSetting(AppName, Section, Key[ Default]) Parameter
Beschreibung
RESULT
RESULT ist der Ergebniswert, den die Funktion GetSetting zurückliefert.
APPNAME
Dieser Parameter ist erforderlich und beschreibt den Namen des Projekts oder der Applikation auf das bzw. die sich der Registrierungseintrag bezieht.
SECTION
Dieser Parameter ist erforderlich und beschreibt den Namen des Abschnitts in dem der Schlüssel gespeichert ist.
KEY
Dieser Parameter ist erforderlich. Er repräsentiert den Namen des Schlüssels, dessen Wert ermittelt werden soll.
[DEFAULT]
Dieser Parameter ist nicht erforderlich. Er wird verwendet, um der Funktion zu definieren welchen Wert sie an RESULT zurückliefern soll, wenn der Wert des Schlüssels oder der Schlüssel selbst nicht gefunden wurde.
Abbildung 13.21: Parameterliste zu GetSetting
& #
253
Eintrag löschen mit DeleteSetting Um einen bestimmten Abschnitt oder nur einen Schlüssel in der Registrierdatenbank zu löschen, wird die Funktion DeleteSetting verwendet. DeleteSetting(AppName, Section[, Key]) Parameter
Beschreibung
APPNAME
Dieser Parameter ist erforderlich und beschreibt den Namen des Projekts oder der Applikation, auf das bzw. die sich der Registrierungseintrag bezieht.
SECTION
Dieser Parameter ist erforderlich und beschreibt den Namen des Abschnitts der gelöscht werden soll oder in dem sich der zu löschende Schlüssel befindet.
[KEY]
Dieser Parameter ist nicht erforderlich. Wird er angegeben, so wird nur der eine Schlüssel aus der Registrierdatenbank entfernt. Wird er nicht angegeben, so werden alle Schlüssel entfernt, die sich unter dem Abschnitt befinden, der im Parameter Section definiert wurde.
Abbildung 13.22: Parameterliste zu GetSetting
Alle Einträge eines Abschnitts lesen Um alle Schlüssel eines bestimmten Abschnitts, die mit der Funktion SaveSetting erzeugt wurden, aus der Registrierdatenbank zu lesen, wird die Funktion GetAllSettings verwendet. Result = GetSetting(AppName, Section, Key[ Default]) Parameter
Beschreibung
RESULT
RESULT ist der Ergebniswert vom Typ Variant, der eine zweidimensionale Liste zurückliefert.
APPNAME
Dieser Parameter ist erforderlich und beschreibt den Namen des Projekts oder der Applikation auf das bzw. die sich der Registrierungseintrag bezieht.
SECTION
Dieser Parameter ist erforderlich und beschreibt den Namen des Abschnitts in dem die Schlüssel gespeichert sind, deren Werte zurückgeliefert werden sollen.
Abbildung 13.23: Parameterliste zu GetSetting
13.6.3
Das Arbeiten mit der Registrierdatenbank
Das Arbeiten mit der Registrierdatenbank wird in den folgenden vier Punkten relativ einfach zusammengefaßt:
254
Erzeugen einer neuen Instanz
Öffnen eines neuen Schlüssels
Lesen und Schreiben der Daten in dem Schlüssel
Schließen des bearbeiteten Schlüssels
Mit dem folgenden Programmcode soll das Auslesen eines bestimmten Werts aus der Registrierdatenbank demonstriert werden. Hierfür wird die Schaltfläche btnSchreiben benötigt, die einen Wert aus dem Eingabeelement TXTEINGABE in die Registrierdatenbank schreibt, und eine Schaltfläche BTNLESEN, die diesen Wert dann wieder aus der Registrierdatenbank liest und in dem Beschriftungselement labParam ausgibt. Im folgenden ist der Programmcode für das besprochene Beispiel abgebildet. Option Explicit Private Sub btnAbbrechen_Click() End End Sub Private Sub btnSchreiben_Click() Call SaveSetting("RegistrySchreiben", "Test", "Wert", _ txtEingabe.Text) End Sub Private Sub Command1_Click() labParam.Caption = GetSetting("RegistrySchreiben", "Test", _ "Wert", "Kein Wert gefunden") End Sub
& #
255
14
Tools
In diesem Kapitel werden einige nützliche Tools und Spiele entwikkelt, mit denen das Arbeiten unter Windows 95 vereinfacht wird oder die eine kurze Ablenkung bedeuten.
14.1
Verzeichnisgröße
Es kommt immer wieder vor, daß man wissen möchte, wieviel Festplattenkapazität ein Verzeichnis mit all seinen Unterverzeichnissen benötigt oder wie viele Unterverzeichnisse und Dateien dort enthalten sind. Das folgende Programmbeispiel soll diese Informationen ermitteln. Als Grundlage für dieses Programm wird ebenfalls das Programm Vorgabe benutzt. Im folgenden werden alle Informationen, die das Programm liefern soll, nochmals definiert:
Anzahl der Verzeichnisse
Anzahl der Dateien
benötigte Speicherkapazität
Diese Informationen sollen für die zwei Optionen gelten:
mit Unterverzeichnissen
ohne Unterverzeichnisse
14.1.1
Die Programmoberfläche
In diesem Abschnitt soll die Programmoberfläche entwickelt werden. Dazu werden alle benötigten Steuerelemente auf das Fenster aufgebracht und ihre Eigenschaften definiert. Um ein Verzeichnis auszuwählen, zu dem die Informationen ausgegeben werden sollen, werden die Steuerelemente Laufwerklistenfeld, Verzeichnislistenfeld und Dateilistenfeld benötigt.
257
Für die Ausgabe der Informationen werden sechs Beschriftungselemente in einem Rahmen-Steuerelement benötigt. Dieses RahmenSteuerelement wird dann auf einem Register mit den zwei Laschen mit Unterverzeichnis und ohne Unterverzeichnis aufgebracht. In Abbildung 14.1 wird das mögliche Aussehen des Programms dargestellt.
Abbildung 14.1: Die Oberfläche des Verzeichnisinformations-Programms
In Tabelle 14.1 werden die Steuerelemente und ihre Eigenschaften aufgeführt, die für die Realisierung benötigt werden. Steuerelement
Eigenschaft
Inhalt
Beschreibung
Laufwerklistenfeld
(Name)
drv_DirInhalt
Dies ist der Name des Laufwerklistenfeldes, mit dem es im Programmcode angesprochen wird.
Verzeichnislistenfeld
(Name)
dir_DirInhalt
Dies ist der Name des Verzeichnislistenfeldes, mit dem es im Programmcode angesprochen wird.
Dateilistenfeld
(Name)
fil_DirInhalt
Dies ist der Name des Dateilistenfeldes, mit dem es im Programmcode angesprochen wird.
Hidden
True
Im Dateilistenfeld sollen auch versteckte Dateien angezeigt werden.
Pattern
*.*
Es sollen alle Dateien, unabhängig von ihrem Namen, angezeigt werden.
258
Steuerelement
Eigenschaft
Inhalt
Beschreibung
ReadOnly
True
Im Dateilistenfeld sollen auch Dateien angezeigt werden, die schreibgeschützt sind.
System
True
Im Dateilistenfeld sollen auch Systemdateien angezeigt werden.
Rahmen-Steuerelement
(Name)
frm_Dir_Grösse
Der Name des Rahmen-Steuerelements, mit dem es im Programmcode angesprochen wird.
RegisterSteuerelement
(Name)
tab_Verzeichnis
Der Name des Register-Steuerelements, mit dem es im Programmcode angesprochen wird.
TabCount
2
Das Register-Steuerelement hat 2 Registerblätter.
TabCaption
mit Unterverzeichnissen
Der Beschriftungstext des ersten Registerblatts.
ohne Unterverzeichnisse
Beschriftungstext des zweiten Registerblatts.
TabsPerRow
2
Anzahl der Registerblätterlaschen, die in einer Zeile dargestellt werden.
(Name)
lab_Beschriftung(0-2)
Der Name des Beschriftungselements, mit dem es im Programmcode angesprochen wird.
Caption(0)
Benötigter Speicher
Beschriftungstext
Caption(1)
Anzahl Dateien
der Steuerelemente.
Caption(2)
Anzahl Verzeichnisse
(Name)
lab_Speicher
Beschriftungs-elemente
Name der Beschriftungselemente, mit denen sie im Programmcode angesprochen werden.
lab_Dateien lab_Verzeichnis Caption
Bei allen drei Steuerelementen wird keine Beschriftung eingegeben.
Tabelle 14.1: Die Steuerelemente des Verzeichnis-Informations-Programms
14.1.2
Der Programmcode zum VerzeichnisInformationsprogramm
Hier wird der eigentliche Programmcode für das Verzeichnis-Informations-Programm entwickelt. Dabei wird jede Funktion zuerst erklärt und dann Schritt für Schritt entwickelt.
259
Verzeichnis auswählen Um ein Verzeichnis auszuwählen, zu dem die Information angefordert wird, stehen die Steuerelemente Laufwerks- und Verzeichnislistenfeld zur Verfügung. Das Dateilistenfeld wird für das Auswählen des Verzeichnisses nicht benötigt, es dient in diesem Programm nur zum Anzeigen aller Dateien im aktuellen Verzeichnis. Als erstes wird der Programmcode, der dem Laufwerkslistenfeld zugeordnet ist, entwickelt. Wenn ein neues Laufwerk ausgewählt wird, muß dieses ebenfalls an das Verzeichnislistenfeld weitergegeben werden, da sich damit auch das Verzeichnis ändert. Achtung: In dem Laufwerkslistenfeld kann auch ein Disketten- oder CD-ROM-Laufwerk ausgewählt werden. Ist aber kein Datenträger eingelegt, kann diese Auswahl zum Absturz führen, also muß dieser Fehler mit einer Fehlerbehandlungsroutine abgefangen werden. Es gibt jedoch auch noch andere Möglichkeiten, warum auf ein Laufwerk nicht zugegriffen werden kann: Z.B. wenn es sich um ein Laufwerk in einem Netzwerk handelt, das zur Zeit nicht verfügbar ist. Tritt ein Fehler bei der Auswahl eines Laufwerks auf, muß das Programm automatisch wieder das Laufwerk einstellen, welches davor ausgewählt war. Private Sub drv_DirInhalt_Change() Dim Laufwerk As Variant 'Zwischenspeicher für das aktuelle Laufwerk On Error GoTo Fehler_drv_DirInhalt_Change ...'Ermittle das aktuelle Laufwerk Laufwerk = Left((dir_DirInhalt.Path), 3) 'Dem Verzeichnislistenfeld das neue Laufwerk mitteilen dir_DirInhalt.Path = drv_DirInhalt.Drive Exit Sub 'Es trat kein Fehler auf Fehler_drv_DirInhalt_Change: 'Es trat ein Fehler auf, also gib eine Fehlermeldung aus Call MsgBox("Fehler beim Laufwerkszugriff", 16, "Laufwerk", _ Err.HelpFile, Err.HelpContext) 'Wechsle wieder auf das zuvor aktive Laufwerk drv_DirInhalt.Drive = Laufwerk Exit Sub 'Funktion ohne Änderung beendet End Sub
Aktualisierung der Verzeichnisinformationen Nachdem das Laufwerk gewechselt wurde, wird auch das Verzeichnis im Verzeichnislistenfeld aktualisiert. Jetzt fehlt noch die Aktualisierung des Dateilistenfeldes. Diese Aktualisierung muß immer dann ausgeführt werden, wenn sich der Inhalt des Verzeichnisses ändert.
260
Nachdem ein Verzeichnis geändert wurde, muß auch der Inhalt der Beschriftungsfelder, die zur Darstellung der Verzeichnisinformation dienen, aktualisiert werden. Private Sub dir_DirInhalt_Change() On Error GoTo Fehler_dir_DirInhalt_Change 'Dem Dateilistenfeld das neue Laufwerk mitteilen Fil_DirInhalt.Path = dir_DirInhalt.Path 'Beschriftungsfelder neu initialisieren lab_Speicher.Tag = 0 Lab_Dateien.Caption = 0 lab_Verzeichnis.Caption = 0 'Abhängig vom selektierten Registerblatt die Verzeichnis'informationen ermitteln If tab_Verzeichnis.Tab = 0 Then Call Verzeichnissuchen(dir_DirInhalt.Path, True) Else Call Verzeichnissuchen(dir_DirInhalt.Path, False) End If Exit Sub 'Informationen erfolgreich ermittelt Fehler_dir_DirInhalt_Change: 'Wenn ein Fehler aufgetreten ist, lösche alle Beschriftungs'felder, da keine genauen Informationen mehr vorliegen lab_Speicher.Caption = "" Lab_Dateien.Caption = "" lab_Verzeichnis.Caption = "" 'Ausgeben einer Fehlermeldung an den Benutzer Call MsgBox("Fehler beim Verzeichnislesen", 16, _ "Verzeichnis", Err.HelpFile, Err.HelpContext) Exit Sub 'Funktion kann abgebrochen werden End Sub
Verzeichnis und Unterverzeichnisse durchsuchen Die Funktion Verzeichnissuchen(), die aus der Ereignisfunktion dir_DirInhalt_Change() aufgerufen wird, ermittelt die gewünschten Informationen und schreibt diese direkt in die Beschriftungsfelder. Durch das Aktualisieren der Beschriftungsfelder während der Ausführung erkennt der Benutzer, daß das Programm nicht blockiert ist, denn die Zeit, die benötigt wird, um ein Verzeichnis mit allen seinen Unterverzeichnissen zu durchsuchen, kann – bei komplexen Verzeichnissen – recht lang sein.
261
Beim Aufruf der Funktion soll definiert werden, ob nur das aktuelle Verzeichnis oder auch alle Unterverzeichnisse durchsucht werden sollen. Daraus ergibt sich folgende Funktionsdeklaration: Sub Verzeichnissuchen(Verzeichnis As String, Subdir As Boolean)
Parameter
Beschreibung
Verzeichnis
Dies ist das Verzeichnis, das nach Dateien und Unterverzeichnissen durchsucht werden soll.
Subdir
Ist der Parameter True, dann sollen auch die Unterverzeichnisse durchsucht werden. Ist er False, soll die Funktion nur das aktuelle Verzeichnis untersuchen.
Ermitteln des Verzeichnisinhaltes Für das Durchsuchen eines Verzeichnisses gibt es unter Visual Basic den Befehl DIR. Er liefert, abhängig von den Parametereinstellungen, alle Unterverzeichnisse und Dateien in einem Verzeichnis. Die Befehlssyntax ist wie folgt definiert: Ergebnis = Dir([Dateiname [, Attribute]])
Ergebnis
Dieser Parameter liefert einen Verzeichnis- oder Dateinamen zurück, der die definierten Kriterien Dateiname und Attribute erfüllt.
Dateiname
Der Dateiname ist optional und gibt an, nach welchen Dateien gesucht werden soll. Der Dateiname kann auch ein Laufwerk und ein Verzeichnis enthalten. Ebenfalls sind die Sonderzeichen * für mehrere Zeichen und ? für ein Zeichen erlaubt.
Attribute
Dieser Parameter definiert die Attribute der Dateien, die angezeigt werden sollen. Folgende Attribute sind definiert:
262
Konstante
Wert
Beschreibung
vbNormal
0
Normal.
vbHidden
2
versteckte Datei.
vbSystem
4
Systemdatei.
vbVolume
8
Laufwerksbuchstaben; alle anderen Attribute werden ignoriert.
vbDirectory
16
Verzeichnis oder Mappe.
Die gefundenen Verzeichniseinträge sind nicht sortiert. Um sie zu sortieren, können sie in eine Feldvariable eingelesen und dann sortiert werden. Wird mit der Funktion DIR kein Eintrag gefunden, so wird ein leerer String ("") zurückgeliefert.
Abbildung 14.2: Der Aufbau eines Verzeichnisbaums
Betrachtet man den Aufbau eines Verzeichnisbaums (Abbildung 14.2), so hat man zwei Möglichkeiten, alle Verzeichnisse zu durchlaufen: Entweder zuerst in die Tiefe – Tiefensuche (depth-first-search) – oder zuerst in die Breite – Breitensuche (breadth-first-search). Tiefensuche Die Tiefensuche arbeitet einen Suchbaum ab, indem zuerst alle Unterknoten des Baums durchsucht werden, bevor ein Nachbarknoten durchsucht wird. In Abbildung 14.3 wird ein Baum dargestellt, der nach dem Verfahren der Tiefensuche abgearbeitet wird. Die Nummern an jeder Kante geben die Reihenfolge an, in der die einzelnen Zweige des Baumes abgearbeitet werden.
Abbildung 14.3: Das Durchlaufen eines Suchbaums mit Tiefensuche
263
Breitensuche Die Breitensuche arbeitet einen Suchbaum ab, indem zuerst alle Knoten einer Ebene des Baums und danach die Unterknoten durchsucht werden. In Abbildung 14.4 wird ein Baum dargestellt, der nach dem Verfahren der Breitensuche abgearbeitet wird. Die Nummern an jedem Knoten geben an, in welcher Reihenfolge die einzelnen Blätter des Baums durchlaufen werden.
Abbildung 14.4: Das Durchlaufen eines Suchbaums mit Breitensuche
Das Programmbeispiel für das Durchsuchen des Verzeichnisbaums verwendet die Tiefensuche. Die Tiefensuche ist hervorragend geeignet, um rekursiv programmiert zu werden. Zuerst wird mit dem Befehl DIR geprüft, welche Unterverzeichnisse und Dateien sich in dem aktuellen Verzeichnis befinden. Gefundene Unterverzeichnisse werden in einer Feldvariablen gespeichert und gezählt. Die gefundenen Dateien werden ebenfalls gezählt und die Dateigrößen summiert. Ermitteln der Dateigröße Um in Visual Basic festzustellen, welche Größe eine Datei in Bytes hat, gibt es den Befehl FileLen. Die Befehlssyntax ist wie folgt definiert: Dateigroesse = FileLen(Dateiname)
264
Dateigroesse
Dieser Parameter gibt die Grösse einer Datei in Bytes an, bevor sie geöffnet wird. Um die Größe einer Datei zu ermitteln, die geöffnet wurde, muß der Befehl LOF verwendet werden.
Dateiname
Der Dateiname muß unbedingt angegeben werden, da er definiert, von welcher Datei die Größe ermittelt werden soll.
Die ermittelten Werte werden zu den schon gewonnenen Werten in den Beschriftungsfeldern addiert. Danach ruft sich die Funktion erneut für jedes gefundene Unterverzeichnis auf. In Abbildung 14.5 wird dargestellt, wie der Verzeichnisbaum aus Abbildung 14.2 abgearbeitet wird. Die Pfeile an den Ästen zeigen die Reihenfolge der Abarbeitung der einzelnen Blätter an.
Abbildung 14.5: Abarbeitung der Verzeichnisstruktur
Nachdem alle Werte in die Beschriftungsfelder eingetragen wurden, ruft sich die Funktion für jedes gefundene Unterverzeichnis auf, wenn der Aufrufparameter SubDir den Wert True hat. Sub Verzeichnissuchen(Verzeichnis As String, Subdir As Boolean) Dim Eintraege() As String 'Liste aller Unterverzeichnisse Dim i As Integer 'Indexvariable ChDrive Left(Verzeichnis, 1) 'Wechsle in das zu prüfende DRV ChDir Verzeichnis 'Wechsle in das zu prüfende DIR ReDim Preserve Eintraege(i + 1) 'Erweitere das Verzeichnisfeld 'für ein neu gefundenes DIR Eintraege(i) = Dir("*.*", 22) 'Prüfe auf alle Einträge im DIR Do While Eintraege(i) <> "" 'Solange ein Eintrag vorhanden 'Handelt es sich bei dem Eintrag um ein Verzeichnis? If GetAttr(Eintraege(i)) = vbDirectory Then 'Ist es ein für die Auswertung relevantes Verzeichnis? If Eintraege(i) <> "." And Eintraege(i) <> ".." Then 'Erhöhe die Anzahl der gefundenen Verzeichnisse lab_Verzeichnis = lab_Verzeichnis + 1 'Erweitere die Verzeichnisliste für weitere Einträge i = i + 1 ReDim Preserve Eintraege(i + 1) End If Else 'Wenn es kein Verzeichnis ist
265
'Erhöhe den Zähler für die Dateien um 1 Lab_Dateien.Caption = Lab_Dateien.Caption + 1 'und aktualisiere den benötigten Speicherzähler lab_Speicher.Tag = CStr(CDbl(lab_Speicher.Tag) + _ FileLen(Eintraege(i))) 'Für eine bessere Anzeige der benötigten 'Speicherkapazität wird die aktuelle Summe bei 'Überschreitung von 5000 Bytes umgerechnet in KB und 'bei der Überschreitung von 2000000 Bytes umgerechnet 'in MB If lab_Speicher.Tag > 2000000 Then lab_Speicher.Caption = _ CLng(lab_Speicher.Tag / 1048576) & " MB" Else If lab_Speicher.Tag > 5000 Then lab_Speicher.Caption = CLng(lab_Speicher.Tag / 1024) & " KB" Else lab_Speicher.Caption = lab_Speicher.Tag & " Byte" End If End If End If DoEvents Eintraege(i) = Dir 'Weiteren Verzeichniseintrag ermitteln Loop If Subdir = False Then 'Wenn nur das aktuelle Verzeichnis Exit Sub 'durchsucht werden soll, verlasse End If 'die Funktion 'Analysiere die Unterverzeichnisse For i = 0 To UBound(Eintraege) – 2 If Right(Verzeichnis, 1) = "\" Then 'Wenn ein "\" den 'Verzeichnisnamen abschließt Call Verzeichnissuchen(Verzeichnis & Eintraege(i), True) Else 'sonst schließe das 'Verzeichnis mit "\" ab. Call Verzeichnissuchen(Verzeichnis & "\" & _ Eintraege(i), True) End If Next i End Sub
Es ist z.B. möglich, daß über ein Netzwerk ein anderer Anwender Daten in ein Verzeichnis kopiert oder darin löscht. Daher muß das Ereignis Click der Schaltfläche die Funktion zur Aktualisierung der gesamten Informationen (Anzahl Unterverzeichnisse, Anzahl Dateien und Speicherbedarf) des Verzeichnisses aufrufen.
266
Private Sub btn_Ok_Click() Call dir_DirInhalt_Change End Sub
Wie auch beim Betätigen der Schaltfläche OK müssen alle Daten durch Wechseln des aktiven Registerblattes aktualisiert werden. Bei dem einen Registerblatt ist für den Anwender nur das aktuelle Verzeichnis wichtig, beim anderen Registerblatt der gesamte Verzeichnisbaum. Private Sub tab_Verzeichnis_Click(PreviousTab As Integer) Call dir_DirInhalt_Change End Sub
Beim ersten Programmstart wird jedoch auffallen, daß in den Steuerelementen
Laufwerklistenfeld
Verzeichnislistenfeld
ein Laufwerk mit Verzeichnis ausgewählt ist, aber in den Beschriftungs-Steuerelementen keine Daten über das Verzeichnis ausgegeben werden. Der Grund dafür ist, daß beim Programmstart nicht das Ereignis Change des Verzeichnislistenfelds eintrifft. Aus diesem Grund muß die Funktion dir_DirInhalt_Change noch im Ereignis Load vom Formular aufgerufen werden. Private Sub Form_Load() Call dir_DirInhalt_Change End Sub
14.2
Berechnungen mit dem Zufallsgenerator
Das folgende Programm soll ein Beispiel dafür sein, daß mit dem Computer Probleme gelöst werden können, deren Lösungsweg nicht einmal dem Programmierer bekannt ist. Die Aufgabe ist, zwei Gleichungen mit zwei Unbekannten zu lösen. I.
a = bx * cy
II.
d = ex * f y
Gleichung 14.1: Gleichungssystem mit zwei Gleichungen und zwei Unbekannten
Die Auflösung dieses Gleichungssystems wird einigen Lesern bestimmt nicht leicht fallen. Dennoch soll ein Programm zur Lösung dieser Gleichungen geschrieben werden. Da der Lösungsweg nicht bekannt ist, bedient man sich des Zufallsgenerators.
267
14.2.1
Die Programmoberfläche
Für eine übersichtliche Darstellung sollten die beiden Formeln so auf der Oberfläche angeordnet sein, daß zum einen die Eingabe der Konstanten sinngemäß geschieht und zum anderen die Formeln als solche vom Anwender verstanden werden können. Als Grundgerüst dient, wie schon in den vorherigen Beispielen, das Visual Basic-Projekt Vorgabe. Darauf werden sechs Texteingabeelemente für die Konstanteneingabe a, b, c, d, e, f und weitere zehn Beschriftungsfelder aufgebracht. In Abbildung 14.6 wird das mögliche Aussehen der Programmoberfläche dargestellt.
Abbildung 14.6: Die Programmoberfläche für das Gleichungssystem
In Tabelle 14.2 wird jedes Steuerelement, welches zusätzlich auf das Vorgabe-Formular aufgebracht werden muß, beschrieben. Steuerelement
Eigenschaft
Inhalt
Beschreibung
TexteingabeElemente
(Name)
txt_Konstante(0-5)
Der Name der Texteingabeelemente, mit denen sie im Programmcode angesprochen werden.
In der Eigenschaft Font ist die Schriftgröße auf 14 geändert worden, um einen optischen Größeneffekt gegenüber den hochgestellten Zahlen zu erhalten. BeschriftungsElemente
(Name)
lab_Beschriftung(0-4)
Der Name der Beschriftungselemente, die nur zur Visualisierung auf dem Formular aufgebracht werden. Es handelt sich dabei um die Steuerelemente: Fehler und je zweimal =, +
lab_x(0-1) lab_y(0-1)
268
In diesen Beschriftungselementen wird der zuletzt berechnete Wert für die Variablen X und Y angezeigt.
Steuerelement
Eigenschaft
Inhalt
Beschreibung
lab_Fehler
In diesem Beschriftungselement wird der momentane Fehler ausgegeben, den das Gleichungssystem zur Zeit noch enthält. Wird eine Lösung gefunden, so sollte dieser Wert sehr klein sein.
Tabelle 14.2: Die Steuerelemente zum Lösen des Gleichungssystems
14.2.2
Der Zufallsgenerator
Wie bereits erwähnt, wird für die Lösungsfindung der Zufallsgenerator verwendet. In Visual Basic heißt der Befehl, der eine zufällige Zahl erzeugt, Rnd. Um den Zufallsgenerator zu initialisieren, steht der Befehl Randomize zur Verfügung. Die Syntax dieser Befehle ist wie folgt definiert: Randomize [Initialwert]
Parameter
Beschreibung
Initialwert
Mit diesem Parameter wird die Ursprungszahl des Zufallsgenerators bestimmt. Wird dieser Parameter nicht angegeben, dann wird automatisch ein Wert aus der Systemzeit generiert.
Zufallszahl = Rnd[(Nummer)]
Parameter
Beschreibung
Zufallszahl
Dies ist die Zahl, die vom Zufallsgenerator erzeugt wurde.
Nummer
Die Nummer ist ein optionaler Parameter und muß nicht angegeben werden. Wird er verwendet, so hat er folgende Funktion:
Nummer
kleiner als 0
Liefert immer die gleiche Zahl als Ergebnis zurück. Der Zufallsgenerator ist „unterbrochen“.
gleich 0
Liefert die Zahl als Ergebnis zurück, die am häufigsten generiert wurde.
größer als 0
Liefert die nächste Zufallszahl zurück.
nicht angegeben
Genauso wie größer als 0.
Die Zufallszahl, die erzeugt wird, ist immer kleiner als eins oder größer/gleich null. Um also eine Zufallszahl in einem bestimmten Be-
269
reich zu erzeugen, muß die ermittelte Zahl an den neuen Bereich und den neuen Zahlentyp angepaßt werden. Das folgende Beispiel erzeugt ganzzahlige Zufallszahlen im Bereich von –10 bis + 20: U_Grenze = –10 O_Grenze = 20 Ergebnis = cint(rnd * (O_Grenze – U_Grenze)) + U_Grenze
14.2.3
Der Algorithmus zum Gleichungssystem
Das Programm sucht die Lösung durch Annäherung, d.h. die Variablen werden mit einem Zufallswert initialisiert. Mit diesen Zufallswerten berechnet nun das Programm beide Gleichungen des Gleichungssystems. Der dabei ermittelte Fehler wird in einer Variablen zwischengespeichert. Nun wird zuerst eine Gleichungsvariable mit dem Zufallsgenerator verändert und der neue Fehler des Gleichungssystems ermittelt. Ist dieser Fehler kleiner als der im Zwischenspeicher, so wird der neue Wert in der Gleichungsvariablen behalten. Ist der Fehler größer, behält die Gleichungsvariable ihren alten Wert. Das gleiche wird nun mit der zweiten Gleichungsvariablen gemacht. Wie stark sich eine Gleichungsvariable durch den Zufallsgenerator verändert, wird nun auch noch abhängig vom aktuellen Fehler gemacht. Ist der Fehler sehr groß, werden die Gleichungsvariablen stärker verändert. Geht der Fehler gegen null, wird die Veränderung ebenfalls geringer, um gezielter die besten Werte für die Gleichungsvariablen zu ermitteln. Dieser Algorithmus soll im folgenden entwickelt werden. Eingabewerte prüfen Als erstes muß geprüft werden, ob die vom Benutzer einzugebenden Gleichungskonstanten auch alle korrekt eingegeben wurden. Hierzu müssen alle Texteingabefelder auf ihre Gültigkeit überprüft werden. Ist ein nicht erlaubter Wert eingegeben worden, gibt die Funktion eine Meldung an den Benutzer aus und liefert den Wahrheitswert False an die aufrufende Funktion zurück. Function Alle_Werte_OK() Dim i As Integer Dim Test As Double On Error GoTo Fehler_Alle_Werte_OK For i = 0 To 5 Test = txt_Konstante(i) * 1
270
Next i Alle_Werte_OK = True Exit Function Fehler_Alle_Werte_OK: Call MsgBox("Falsche Konstante eingegeben", 16, _ "Fehlereingabe", Err.HelpFile, Err.HelpContext) Alle_Werte_OK = False Exit Function End Function
Initialisierung Nachdem alle Gleichungskonstanten als gültig erkannt wurden, müssen die beiden Unbekannten des Gleichungssystems initialisiert werden. Da die beiden Variablen in jeweils zwei Beschriftungsfeldern ausgegeben werden, müssen dort die Werte, die mit dem Zufallsgenerator erzeugt werden, zugewiesen werden. Es darf jedoch nicht vergessen werden, daß vor dem ersten Benutzen des Zufallsgenerators dieser ebenfalls initialisiert werden muß. Sub Init_Var() lab_x(0).Caption lab_x(1).Caption lab_y(0).Caption lab_y(1).Caption End Sub
= = = =
Rnd lab_x(0) Rnd lab_y(0)
Ermitteln des Gleichungsfehlers Um den Gesamtfehler des Gleichungssystems zu ermitteln, ist zu berücksichtigen, daß der Gesamtfehler immer einen positiven Wert haben sollte. Dies läßt sich realisieren, indem mit dem Betrag1 des Fehlers gerechnet wird. Hierfür gibt es unter Visual Basic den Befehl ABS. Effektiver ist es jedoch, wenn das Quadrat des Fehlers berechnet wird. Das Quadrat einer Zahl ergibt, wie der Betrag, immer eine positive Zahl. Zudem handelt es sich bei dem Fehler um eine quadratische Abweichung, und er fällt somit bei Berücksichtigung sehr viel stärker ins Gewicht. Zum besseren Verständnis wird die Funktion zur Fehlerberechnung (Gleichung 14.2) nochmals mit den verwendeten Bezeichnungen aus Gleichung 14.1 beschrieben.
1. Der Betrag einer Zahl ist der positive Eigenwert dieser Zahl.
271
Fehler = (a - (bx * cy)2 + (d - (ex * f y)2 Gleichung 14.2: Berechnung der quadratischen Abweichung
Function Fehlerberechnung() Dim Ergebnis As Double On Error Resume Next Ergebnis = (txt_Konstante(0).Text – (txt_Konstante(1).Text ^ _ lab_x(0).Caption) * (txt_Konstante(2).Text ^ _ lab_y(0).Caption)) ^ 2 Ergebnis = Ergebnis + (txt_Konstante(3).Text – _ (txt_Konstante(4).Text ^ lab_x(0).Caption) * _ (txt_Konstante(5).Text ^ lab_y(0).Caption)) ^ 2 lab_Fehler.Caption = Ergebnis Fehlerberechnung = Ergebnis End Function
Ändern einer Gleichungsvariablen Diese Funktion verändert den Wert einer Gleichungsvariablen mit dem Zufallsgenerator. Dabei wird der aktuelle Fehler des Gleichungssystems berücksichtigt. Ist der Fehler groß, kann die Variable auch stärker verändert werden, um schneller ein besseres Ergebnis zu erzeugen. Ist der Fehler nur noch gering, kann eine größere Veränderung der Gleichungsvariablen dazu führen, daß der Fehler nicht mehr verbessert wird. Das System könnte dann keine Lösung mehr finden. Damit die Zahlen, die erzeugt werden, nicht zu groß werden können und somit einen Programmfehler erzeugen, sollten sie auf ein Maximum begrenzt werden. Wird dieses Maximum dennoch überschritten, da die Zahlen per Zufallsgenerator ermittelt werden, ist zu empfehlen, daß diese Variable komplett neu initialisiert wird, da diese Berechnung das Ergebnis mit großer Wahrscheinlichkeit nicht mehr finden kann. Sub Aendere_Var(Variable As Integer) Dim Ergebnis As Double Ergebnis = Rnd * lab_Fehler.Caption / 10 If Rnd > 0.5 Then Ergebnis = Ergebnis * –1 Select Case Variable Case 1: If Abs(lab_x(0).Caption + Ergebnis) < 100 Then lab_x(0).Caption = lab_x(0).Caption + Ergebnis Else lab_x(0).Caption = Rnd End If
272
Case 2: If Abs(lab_y(0).Caption + Ergebnis) < 100 Then lab_y(0).Caption = lab_y(0).Caption + Ergebnis Else lab_y(0).Caption = Rnd End If End Select End Sub
Durchführen der Berechnung Die nun folgende Funktion steuert den Ablauf der bisher erstellten Funktionen nach dem im Abschnitt „Der Algorithmus zum Gleichungssystem“ beschriebenen Algorithmus. Zuerst wird geprüft, ob alle Werte, die vom Benutzer eingegeben werden müssen, auch gültig sind. Danach werden die zu berechnenden Variablen x und y mit Zufallszahlen initialisiert. Nachdem geprüft wurde, wie groß die Abweichung der beiden rechten Seiten gegenüber den geforderten Ergebnissen der linken Seiten ist, wird entweder nach besseren Werten für x und y gesucht oder die Berechnung beendet. In dieser Schleife (der Fehler der Berechnung ist zu groß) wird zuerst die Variable x verändert. Verbessert sich das Ergebnis des Gleichungssystems, wird der neue Wert übernommen, ansonsten wird der alte Wert beibehalten. Danach wird die Variable y verändert; hierfür wird ebenfalls der neue Fehler ermittelt. Die Forderung, daß der Fehler mit den neuen Variablenwerten geringer sein muß als mit den alten Werten, verhindert eine Verschlechterung des Gesamtergebnisses. Sub Berechnen() Dim Fehler As Double Dim neuer_Fehler As Double On Error GoTo Fehler_Berechnen 'Prüfen, ob alle Eingabewerte erlaubt sind If Not Alle_Werte_OK Then Exit Sub 'Initialisiere die Variablen mit dem Zufallsgenerator Call Init_Var 'Berechne die aktuelle Abweichung vom Ergebnis Fehler = Fehlerberechnung Do While Fehler > 0.001 'Solange der Fehler nicht im 'gewünschten Toleranzbereich liegt Call Aendere_Var(1) 'ändere den Wert von x neuer_Fehler = Fehlerberechnung If Fehler > neuer_Fehler Then 'Wenn Rechenfehler kleiner wurde
273
lab_x(1).Caption = lab_x(0).Caption 'übernehme den neuen 'Wert für x, Fehler = neuer_Fehler Else 'sonst behalte das alte x lab_x(0).Caption = lab_x(1).Caption End If Call Aendere_Var(2) 'Ändere den Wert von y neuer_Fehler = Fehlerberechnung If Fehler > neuer_Fehler Then 'Wenn Rechenfehler kleiner wurde, lab_y(1).Caption = lab_y(0).Caption 'übernehme den neuen 'Wert für y, Fehler = neuer_Fehler Else 'sonst behalte das alte y lab_y(0).Caption = lab_y(1).Caption End If DoEvents Loop 'Ende der Schleife Toleranzbereich Exit Sub Fehler_Berechnen: 'Wenn ein Fehler aufgetreten ist, Exit Sub 'breche die Berechnung ab End Sub
Starten der Berechnung Nach der Eingabe aller Vorgabewerte kann die Berechnung vom Anwender durch Betätigen der Schaltfäche OK gestartet werden. Private Sub btn_Ok_Click() Call Berechnen End Sub
Änderung eines Wertes Da der Benutzer während des Programmablaufes die Gleichungskonstanten ändern kann, sollte die Berechnung bei einer Änderung abgebrochen und die Ausgabe auf der Programmoberfläche aktualisiert werden. Private Sub txt_Konstante_Change(Index As Integer) Dim i As Integer For i = 0 To 1 lab_x(i) = "X" lab_y(i) = "Y" Next i End Sub
274
14.2.4
Auflösung des Gleichungssystems
Für die mathematisch interessierten Leser, die nicht genug Zeit oder Geduld haben, um das Gleichungssystem aufzulösen, soll hier der Lösungsweg aufgezeigt werden. Gleichungssystem: I. II.
a = bx *cy d = ex * f y
Logarithmieren: I. II.
log b a = log b (b x * c y ) log f d = log f ( e x * f y )
II.
log b a = x + log b (c y ) log f d = log f ( e x ) + y
I.
x = log b a − log b (c y )
I.
x=
ln a − ln(c y ) ln b
I.
x=
1 (ln a − y ln c) ln b
II.
y = log f d − log f ( e x )
II.
ln d − ln(e x ) y= ln f
II.
y=
I.
1 (ln d − x ln e) ln f
Substitution:
k= I. II.
ln a ln c = ln d = ln e m n l= ln f ln f ln b ln b
x = k − ly y = m − nx
275
I in II eingesetzt
y = m − n( k − ly ) y = m + nly − nk y (1 − nl ) = m − nk
y=
m − nk 1 − nl
Resubstitution und Lösung:
ln d ln a ln e − ln f ln b ln f y= ln c ln e 1− ln b ln f
ln d ln a ln e − ln f ln b ln f 1 ln a − ln c x= ln c ln e ln b 1− ln b ln f
14.2.5
y=
ln b ln d − ln a * ln e ln b ln f − ln c * ln e
x=
1 ln b ln d − ln a * ln e ln c ln a − ln b ln b ln f − ln c * ln e
Zusammenfassung
Diese Art der Problemlösung wird in der Informatik auch für sehr komplexe Aufgaben eingesetzt. Natürlich sind die dafür verwendeten Algorithmen und Datenstrukturen etwas komplexer als in diesem Beispiel, jedoch ist die Arbeitsweise sehr ähnlich. Der Fachbegriff für diese Algorithmen lautet Genetische Algorithmen und Evolutionsstrategien. Der Vorteil dieser Algorithmen besteht darin, daß immer ein Ergebnis gefunden wird. Der Nachteil: Es ist meistens nicht das optimalste Ergebnis.
276
14.3
Das Spiel MasterMind
Mit dem folgenden Spiel soll die Programmierung von Drag and Drop, dem Ziehen und Fallenlassen, geübt werden. Drag and Drop bedeutet im einzelnen, daß ein Element auf der Benutzeroberfläche mit der linken Maustaste angewählt werden kann; während die Maustaste gedrückt bleibt, ändert sich der Mauszeiger in ein anderes Symbol. Dieses Symbol kann auf der Benutzeroberfläche verschoben werden. Duch Loslassen der Maustaste wird dieses Symbol „fallengelassen“. Ein Beispiel für Drag and Drop findet man z.B. im WindowsExplorer: Hier werden Dateien in andere Verzeichnisse verschoben und kopiert, indem sie zuerst angeklickt und dann mit gedrückter Maustaste über einem anderen Ordner fallengelassen werden.
14.3.1
Die Spielregeln von MasterMind
Ziel des Spieles ist es, vier Farben, die vom Computer per Zufall ermittelt werden, zu erraten. Nach acht Schritten muß die Lösung gefunden sein; ist sie es nicht, hat man verloren. Ist ein Schritt abgeschlossen, so wertet der Computer diesen aus. Hat der Spieler eine richtige Farbe auf dem falschen Platz gesetzt, wird dies mit einem weißen Feld bewertet. Ist die Farbe am richtigen Platz, wird dies mit einem schwarzen Feld angezeigt. Jede Farbe kann mehrmals vorkommen, wobei die „leere Farbe“ auch eine gültige Farbe ist.
14.3.2
Die Programmoberfläche
Als Grundlage für die Programmoberfäche wird wieder das altbewährte Visual Basic-Projekt Vorgabe von der Diskette eingesetzt. Danach wird die Oberfläche in vier Bereiche eingeteilt: Der Auswahlbereich: Der Bereich, der vorgibt, aus welchen Farben der Computer sein Zufallsmuster zusammenstellen kann. Es ist auch der Bereich, aus dem der Spieler seine Farben auswählt. Der Lösungsbereich: In diesem Bereich wird das vom Computer vorgegebene Muster angezeigt, wenn das Spiel beendet ist, wenn also das Muster gefunden wurde oder keine Eingabemöglichkeiten mehr bestehen. Der Eingabebereich: Im Eingabebereich gibt der Spieler sein Muster vor. Dieser Bereich besteht aus acht Feldern, wobei jedes Feld exakt so aussieht wie das Lösungsfeld.
277
Der Auswertungsbereich: Im Auswertungsbereich wird nach Abschluß eines Spielzuges ausgegeben, wie viele Farben gefunden wurden und wie viele davon die richtige Position haben. In Abbildung 14.7 ist eine mögliche Anordnung der Steuerelemente auf der Programmoberfläche abgebildet.
Abbildung 14.7: Die Programmoberfläche des Spiels MasterMind
Die Programmoberfläche besteht in diesem konkreten Fall aus folgenden Steuerelementen Steuerelement
Eigenschaft
Inhalt
Beschreibung
RahmenSteuerelement
(Name)
frm_Eingabe(0-7)
Hier finden sich alle Rahmensteuerelemente, die die Eingabeflächen für das Farbmuster des Spielers enthalten. Jedes Rahmensteuerelement enthält ebenfalls 4 Eingabefelder.
frm_Ergebnis(0-7)
Hier finden sich alle Rahmensteuerelemente, die die Ausgabeflächen enthalten, mit denen der Computer die Anzahl der gefundenen Farben anzeigt. Jedes Rahmensteuerelement enthält 4 Ausgabefelder.
frm_Loesung
In diesem Steuerelement wird das Zufallsmuster des Computers dargestellt.
278
Steuerelement
Bilderschaltflächen
Eigenschaft
Inhalt
Beschreibung
frm_Vorgabe
In diesem Steuerelement sind alle Farben dargestellt, aus denen das Zufallsmuster generiert werden kann.
(Name)
pic_Farben(0-7)
Diese Steuerelemente sind im RahmenSteuerelement frm_Vorgabe untergebracht und enthalten die zur Auswahl stehenden Farben.
DragMode
1-Automatisch
Wird ein Steuerelement mit der linken Maustaste selektiert, verändert sich der Mauskursor automatisch und stellt das Symbol dar, welches der Eigenschaft DragIcon zugewiesen ist.
DragIcon
(Symbole)
Symbol, das der Mauskursor im Drag Drop-Modus darstellen soll (Die DRAG*.ICO-Dateien von der Diskette).
Picture
(Bild)
Bild, das das Steuerelement darstellen soll, also jeweils eine der acht darzustellenden Farben (Die FARBE.ICO-Dateien von der Diskette).
(Name)
pic_Loesung(0-3)
Dies enthält die vom System mittels Zufallsgenerator ausgewählten Farben.
pic_Eingabe(0-29)
Hier definiert der Spieler seine Farbeingaben. Auf jedem frm_Eingabe sind vier pic_Eingabe-Steuerelemente aufgebracht, mit dem Index von links nach rechts steigend.
pic_Ergebnis(0-29)
Hier gibt der Computer die Information an den Spieler aus, wieviele Farben gefunden wurden. Auf jedem frm_Ergebnis sind vier pic_Ergebnis-Steuerelemente aufgebracht.
Tabelle 14.3: Die Steuerelemente des Spieles MasterMind
14.3.3
Der Programmcode zu MasterMind
In diesem Abschnitt wird der Programmcode für das Spiel entwickelt und bei jeder Funktion – bevor sie entwickelt wird – auf ihre Aufgabe und Arbeitsweise eingegangen. Der Programmstart Wird das Programm gestartet, müssen zunächst einige Initialisierungen vorgenommen werden. Zum einen sollen die Felder, die das Ergebnis des Spielzuges ausgeben, nicht sichtbar sein. Zum anderen dürfen die Felder zur Eingabe nicht verfügbar sein, da der Computer noch kein Lösungsmuster ermittelt hat. Die Felder, in denen der
279
Computer sein Zufallsmuster ausgibt, müssen ebenfalls auf „nicht sichtbar“ gesetzt werden. Beim Starten des Programmes sollte auch der Zufallsgenerator mit Randomize neu initialisiert werden, damit eine Wiederholung des alten Spieles verhindert wird. Private Sub Form_Load() Dim i As Integer Randomize 'Zufallsgenerator initialisieren 'Die Verfügbarkeit der Steuerelemente definieren lab_Loesung.Visible = False frm_Loesung.Enabled = False For i = 0 To 7 frm_Ergebnis(i).Visible = False frm_Ergebnis(i).Enabled = False frm_Eingabe(i).Enabled = False Next i End Sub
Das Spiel beginnen Wird das Spiel begonnen, so müssen alle Ergebnisse und LösungsfeldSteuerelemente auf „leer“ zurückgesetzt werden. Denn wenn schon ein Spiel stattgefunden hat, sind den Steuerelementen noch die alten Farben zugewiesen. Um ein Bildfeld-Steuerelement zu löschen, ist es am einfachsten, wenn der Eigenschaft Picture „nichts“ zugewiesen wird. Dies geschieht mit dem Befehl Nothing. Sub Felder_loeschen() Dim i As Integer For i = 0 To 3 + 4 * 7 pic_Eingabe(i).Picture = Nothing pic_Ergebnis(i).Picture = Nothing Next i End Sub
Das Zufallsmuster Nach dem Zurücksetzen aller Bildfeld-Steuerelemente wird vom Computer das Zufallsmuster aus den möglichen Farben bestimmt. Für diesen Zweck wird die folgende Funktion benötigt. Sie bestimmt vier Zufallszahlen und rechnet sie in den möglichen Wertebereich um. In diesem Spiel gibt es neun Farben, also sind die Zahlen 0 bis 8 gültig.
280
Sub Ermittle_Zufallsmuster() Dim i As Integer For i = 0 To 3 pic_Loesung(i).Picture = pic_Farben(CInt(Rnd * 8)).Picture Next i End Sub
Farbauswahl des Spielers durch Drag and Drop Wurden den Steuerelementen die Eigenschaften aus Tabelle 14.3 zugewiesen, verändert sich beim Anklicken eines Farbensteuerelements der Mauscursor in das Symbol, welches der Eigenschaft DragIcon zugewiesen wurde. Dies kann nun zwar über die Oberfläche bewegt, jedoch nirgendwo abgelegt werden. Um nun ein Bild aus den Farbensteuerelementen per Drag and Drop in die Eingabebilder zu übernehmen, muß in der Ereignisfunktion DragDrop der Eingabebilder das Bild des Quellsteuerelements zugewiesen werden. Private Sub pic_Eingabe_DragDrop(Index As Integer, Source As Control, X As Single, Y As Single) pic_Eingabe(Index).Picture = Source.Picture End Sub
Spielzug auswerten Nachdem ein Spielzug abgeschlossen wurde, muß vom Computer ausgewertet werden, wie viele Farben richtig geraten wurden, aber an der falschen Position (weißes Bildfeld) und wie viele an der richtigen Position (schwarzes Bildfeld) sind. Um zu vermeiden, daß ein Farbfeld zweimal bewertet wird, erhält die Eigenschaft Tag des Bildfeldsteuerelementes den Zustand True, wenn sie einmal identifiziert wurden. Die Eigenschaft Tag signalisiert somit, ob ein Lösungsbildelement schon mit einem Eingabebildelement verknüpft wurde. Um zu vermeiden, daß eine Farbe, die sich an der richtigen Position befindet, nicht als solche angezeigt wird, weil zuvor ein anderes Farbfeld mit der gleichen Farbe dieses Element schon als benutzt gekennzeichnet hat, werden zuerst die Farben geprüft, die an der richtigen Position stehen. Danach wird überprüft, ob die Farben, deren Benutzersignal noch False ist, in dem Vorgabemuster überhaupt vorhanden sind. Die Funktion liefert True zurück, wenn alle Farben gefunden wurden und an der richtigen Position sind. Sonst ist der Rückgabewert False. Function Auswertung(Nummer As Integer) Dim i As Integer Dim j As Integer Dim Ergebnis(4) As Integer
281
Dim gefunden As Integer 'Prüfe, ob eine richtige Farbe am richtigen Ort ist For i = 0 To 3 If pic_Loesung(i).Picture = _ pic_Eingabe(i + 4 * Nummer).Picture Then pic_Eingabe(i + 4 * Nummer).Tag = True pic_Loesung(i).Tag = True Ergebnis(gefunden) = 2 gefunden = gefunden + 1 Else pic_Eingabe(i + 4 * Nummer).Tag = False pic_Loesung(i).Tag = False End If Next i 'Prüfe, ob eine richtige Farbe vorhanden ist, 'jedoch auf einer falschen Position ist For i = 0 To 3 For j = 0 To 3 If pic_Eingabe(i + 4 * Nummer).Tag = False And _ pic_Loesung(j).Tag = False Then If pic_Loesung(j) = pic_Eingabe(i + 4 * Nummer) Then pic_Eingabe(i + 4 * Nummer).Tag = True Ergebnis(gefunden) = 1 gefunden = gefunden + 1 End If End If Next j Next i 'Eintragen der gefundenen Übereinstimmungen in die 'Auswertungsbilder For i = 0 To 3 If Ergebnis(i) = 2 Then pic_Ergebnis(i + 4 * Nummer).Picture = _ pic_Farben(0).Picture Else If Ergebnis(i) = 1 Then pic_Ergebnis(i + 4 * Nummer).Picture = _ pic_Farben(8).Picture End If End If Next i Auswertung = Ist_Gewonnen(Nummer) End Function
282
Mit der Funktion Ist_Gewonnen wird geprüft, ob alle Ergebnisbildfelder des aktuellen Spielzuges identisch mit dem Farbmuster sind, das als Volltreffer definiert wurde. Function Ist_Gewonnen(Nummer As Integer) As Boolean Dim i As Integer Ist_Gewonnen = True For i = 0 To 3 If pic_Ergebnis(i + 4 * Nummer).Picture <> _ pic_Farben(0).Picture Then Ist_Gewonnen = False End If Next i End Function
Ausgabe des Spielendes Wird das Spiel beendet – zum einen durch Finden des Vorgabemusters, zum anderen, weil die Anzahl der möglichen Spielzüge nicht ausgereicht hat –, muß ein Meldungstext auf dem Bildschirm ausgegeben werden. Sub Meldungstext_Ausgeben(Gewonnen As Boolean) If Gewonnen = True Then Call MsgBox("Herzlichen Glückwunsch", vbInformation, _ "Gewonnen") Else Call MsgBox("Sie haben leider verloren", vbExclamation, _ "Verloren") End If End Sub
Die Spielsteuerung Alle bisher entwickelten Funktionen müssen nun sinnvoll gesteuert werden. Es muß definiert werden, auf welchen Eingabesteuerelementen der Spieler seine Farben definieren (fallenlassen) darf und wann der Computer den Spielzug auswerten soll. Private Sub btn_Ok_Click() Static Aktiv As Integer Static Beschriftung As String Dim Gewonnen As Boolean If btn_Ok.Caption <> "Aus&werten" Then Beschriftung = btn_Ok.Caption btn_Ok.Caption = "Aus&werten" Aktiv = 0
283
frm_Eingabe(Aktiv).Enabled = True frm_Eingabe(Aktiv).BorderStyle = 0 pic_Loesung(0).Visible = False pic_Loesung(1).Visible = False pic_Loesung(2).Visible = False pic_Loesung(3).Visible = False Call Ermittle_Zufallsmuster Call Felder_loeschen Else frm_Eingabe(Aktiv).Enabled = False frm_Eingabe(Aktiv).BorderStyle = 1 frm_Ergebnis(Aktiv).Visible = True Gewonnen = Auswertung(Aktiv) If Aktiv > 6 Or Gewonnen = True Then btn_Ok.Caption = Beschriftung pic_Loesung(0).Visible = True pic_Loesung(1).Visible = True pic_Loesung(2).Visible = True pic_Loesung(3).Visible = True Call Meldungstext_Ausgeben(Gewonnen) Else frm_Ergebnis(Aktiv).Visible = True Aktiv = Aktiv + 1 frm_Eingabe(Aktiv).Enabled = True frm_Eingabe(Aktiv).BorderStyle = 0 End If End If End Sub
Die Variable Aktiv bestimmt den aktuellen Spielzug. Zuerst wird geprüft, ob die Beschriftung der Schaltfläche mit dem Text identisch ist, der bestimmt, ob es sich um einen weiteren Spielzug oder einen Neuanfang des Spieles handelt. Handelt es sich bei der Beschriftung nicht um den Text Aus&werten, sondern um einen anderen, wird das Spiel begonnen. Die Variable Aktiv wird initialisiert und der Beschriftungstext der Schaltfläche auf Aus&werten geändert. Bei jedem Spielzug, bei dem die Beschriftungsschaltfläche Aus&werten heißt, wird der Spielzugzähler Aktiv um eins erhöht und die Eingabe vom Spieler ausgewertet. Damit der Spieler seine gewählte Farbe nicht auf allen Eingabebildfeldern mittels Drag and Drop ablegen kann, wurden zu Beginn des Spiels alle Eingaberahmen auf „nicht verfügbar“ gesetzt. Aus diesem Grund muß jetzt vor jedem Spielzug dasjenige EingaberahmenElement auf „verfügbar“ geschaltet werden, auf dem die nächsten Eingaben gemacht werden. Beim Abschließen eines Spielzugs muß
284
das Eingaberahmen-Steuerelement dann wieder gesperrt und das zugehörige Ergebnisrahmen-Steuerelement angezeigt werden. Zum Schluß wünsche ich noch viel Spaß beim Spielen!
285
15
Der Installationsassistent
Um ein mit Visual Basic 6.0 geschriebenes Programm an andere Anwender weiterzugeben, wird der Entwicklungsumgebung ein Installationsassistent zur Verfügung gestellt. In der neuen Version von Visual Basic heißt dieser Assistent nun Verpackungs- und WeitergabeAssistent; da dieser Name aber zu lang ist, werde ich bei Installationsassistent bleiben. Mit Hilfe dieses Assistenten lassen sich Installations- oder Setup-Programme für selbstgeschriebene Anwendungen herstellen.
Eine Applikation zum Erstellen von Installationsdisketten
Abbildung 15.1: Der Installationsassistent
287
Starten des Installationsassistenten
15.1 Aufrufen der Applikation aus der Windowsoberfläche
Der Installationsassistent (siehe Abbildung 15.1) wird über das folgende Menü aufgerufen: Start | | | |
Programme Microsoft Visual Basic 6.0 Microsoft Visual Basic 6.0 Tools Verpackungs- und Weitergabe-Assistent
Das nun erscheinende Fenster erklärt die Aufgabe des Installationsassistenten. Damit das Fenster nicht bei jedem neuen Aufruf des Assistenten gestartet wird, kann es über das Kontrollkästchen Diesen Bildschirm künftig übergehen deaktiviert werden. Mit der Schaltfläche WEITER kann nun der nächste Schritt erfolgen.
15.2
Das Erstellen von Installationsdisketten
In den folgenden Schritten wird für das Programm Stack-Taschenrechner ein Installationsprogramm zur Weitergabe erstellt.
15.2.1 Das Projekt, für daß das Installationsprogramm erstellt werden soll, auswählen
Festlegen des Programmes (Projekts)
Durch Betätigen der Schaltfläche DURCHSUCHEN wird das Projekt, für das das Installationsprogramm erzeugt werden soll, festgelegt. Existiert das Projekt noch nicht, kann es auch über das Selektieren des Kontrollkästchens erzeugt werden. In diesem Beispiel existiert das Programm bereits. Es befindet sich auf der dem Buch beiliegenden Diskette im Verzeichnis \Rechner.
15.2.2
Die Optionen des Installationsassistenten
Verpacken Mit der Schaltfläche VERPACKEN erstellt der Installationsassistent aus einem Visual Basic 6.0-Projekt ein Installationsprogramm, mit dem die Software professionell weitergegeben werden kann. Hierfür werden die benötigten Dateien analysiert und in ein weiteres Verzeichnis gepackt. Ist das Kontrollkästchen Abhängigkeitsdatei generieren aktiv, wird mit dem Installationsprogramm eine Datei erzeugt, die alle Abhängigkeiten des Projekts enthält. Diese Datei wird in dem gleichen Verzeichnis abgelegt, in dem sich auch das Projekt befindet.
288
Verteilen Durch Betätigen der Schaltfläche VERTEILEN, kann das Programm zum Herunterladen im Internet oder Intranet bereitgestellt werden. Diese Option gilt jedoch nur für Visual Basic-Projekte vom Typ
ActiveX-Steuerelemente,
ActiveX-EXE,
ActiveX-DLL
In der Visual Basic-Version 6.0 Learning Edition ist diese Option nicht verfügbar. Skripts verwalten Mit der Schaltfläche SKRIPTS VERWALTEN lassen sich die Verpackungsund Weitergabeskripts verwalten. Sie können hier benannt, kopiert und gelöscht werden. Für das Installationsprogramm des Taschenrechners müssen die Option INSTALLATIONSPROGRAMM ERSTELLEN und das Kontrollkästchen Abhängigkeitsdatei generieren aktiviert sein.
15.2.3
Generieren der Installationsdatei
Um ein Setup-Programm für den Rechner zu erzeugen, wird die Schaltfläche VERPACKEN betätigt. Wenn die aktuelle EXE-Datei älter ist als eine Komponente des Visual Basic Projekts, werden Sie in einem Zwischenschritt gefragt, ob die ausführbare Datei neu übersetzt werden soll. Mit Ja wird sofort eine neue EXE-Datei erzeugt, mit NEIN die alte Datei in das Setup integriert. Danach werden weitere Abhängigkeiten geprüft. Im nächsten Auswahlfenster (Abbildung 15.2) wird festgelegt, ob nur die Abhängigkeitsdatei für die Installation oder aber ein Setup-Programm erzeugt werden soll. Für die Weitergabe des Programmes Rechner wird die Option Standardmäßiges Setup-Paket verwendet.
289
Abbildung 15.2: Festlegen der Verteilungsart
15.2.4 Das Verzeichnis bestimmen, in dem das Installationsprogramm abgelegt werden soll
Das Zielverzeichnis bestimmen
Im folgenden Menü muß nun das Verzeichnis gewählt werden, in dem das Installationsprogramm abgelegt werden soll. Sollte das Verzeichnis noch nicht existieren, kann es jetzt noch über einen Dateimanager erzeugt werden. Existiert das Verzeichnis schon, kann es durch Festlegen des Laufwerks und Zielverzeichnisses ausgewählt werden. Mit der Schaltfläche WEITER Gelangt man in das nächste Auswahlfenster.
15.2.5 Wenn ActiveX-ServerKomponenten dem Installationsprogramm hinzugefügt werden müssen.
290
Das Festlegen von zusätzlichen Treibern
In dem Fenster Paket- und Weitergabe-Assistent – DAO-Treiber (Abbildung 15.3) können nun die Schnittstellentreiber für den Datenzugriff ausgewählt werden. Sollte die Applikation, zu der das Installationsprogramm erstellt wird, weitere Komponenten wie z.B. Treiber für den Datenbankzugriff, benötigen, die nicht in der Liste aufgeführt sind, können diese aus der Liste Verfügbare Treiber selektiert und dem Projekt hinzugefügt werden.
Abbildung 15.3: DAO-Treiber
Mit der Schaltfläche WEITER kann zum nächsten Auswahlfenster gewechselt werden, da in diesem Projekt keine Treiber für den Datenbankzugriff verwendet werden.
15.2.6
CAB-Optionen
In diesem Auswahlfenster wird die Verteilungsart festgelegt, indem die Größe der einzelnen Pakete entweder begrenzt, oder die gesamte Installation als ein Paket gespeichert wird. Verteilungsart
Beschreibung
mehrere CAB-Dateien
Alle benötigten Installationsdateien werden in mehrere Pakete aufgesplittet, deren Größe eine bestimmte Diskettenkapazität nicht überschreitet. Die Größe eines Pakets wird in der Auswahlbox festgelegt. Hier sind die gängigsten Diskettengrößen aufgelistet. Diese Methode empfiehlt sich für die Softwareverteilung auf einzelne Rechner sowie beim Vertrieb dieser Software, sofern die Anzahl der Disketten nicht zu groß ist.
einzelne CAB-Datei
Alle benötigten Installationsdateien werden mit der Datei SETUP.EXE in ein Verzeichnis kopiert, von dem aus die Installation durchgeführt werden kann. Diese Methode empfiehlt sich für die Softwareverteilung in einem Netzwerk oder wenn das Programm auf eine CD-ROM gebrannt werden kann.
291
Für das Erzeugen der Taschenrechner-Installationsroutine soll die Option Einzelne CAB-Datei aktiviert werden. Durch erneutes Betätigen der Schaltfläche WEITER wird zum nächsten Auswahlfenster gewechselt.
15.2.7
Festlegen des Installationstitels
In diesem Dialog wird der Name der Applikation festgelegt, der beim Installieren der Software angezeigt wird. Im allgemeinen erscheint er links oben im Installationsfenstertitel.
15.2.8
Festlegen der Menüeinträge
Nach erneutem Betätigen der Taste WEITER können nun im Dialog Paket- und Weitergabe-Assistent – Startmenüelemente (Abbildung 15.4) der oder die Einträge festgelegt werden, die automatisch im Start-Menü installiert werden sollen.
Abbildung 15.4: Start-Menü
Jedem Knoten (bei dem es sich hier um ein Menü handelt) können weitere Menüs oder Programme zugeordnet werden, die dann bei der Installation in das Start-Menü eingetragen werden. Die Blätter bilden die aufzurufenden Dateien. Ihnen kann kein weiterer Knoten oder Menüeintrag zugeordnet werden. Knoten werden mit der Schaltfläche NEUE GRUPPE und aufzurufende Dateien mit der Schaltfläche NEUES ELEMENT angelegt.
292
Mit der Schaltfläche EIGENSCHAFTEN... können die Eigenschaften des jeweiligen Elements festgelegt werden. Bei Knoten bestimmt man, ob es sich um ein Standardmenüeintrag oder um ein privates Menü handelt. Im Falle der Menüeinträge werden der Name der zu startenden Applikation, der Pfad, in der sich die ausführbare Datei befindet, und der Text, der im Menü erscheinen soll festgelegt. Um einen Gruppeneintrag zu löschen, wird die Schaltfläche ENTFERNEN bereitgestellt. Nachdem das Bearbeiten der Programmgruppe abgeschlossen ist, geht es mit WEITER zum nächsten Fenster.
15.2.9
Installationsorte der Dateien
In dem Fenster Installationsorte (Abbildung 15.5) werden alle Dateien angezeigt, die für die Installation der weiterzugebenden Applikation benötigt werden. Hierbei werden der Name und der Ort der zu kopierenden Quelldatei aufgelistet. In einer weiteren Spalte wird angegeben, wohin die Datei bei der Installation kopiert wird. Um das Zielverzeichnis der Datei zu ändern, muß das neue Zielverzeichnis aus dem Listenelement ausgewählt werden, welches beim Selektieren der dritten Spalte aufgeklappt wird.
Abbildung 15.5: Installationsorte der Dateien festlegen
Im nächsten Installationsschritt können die Dateien festgelegt werden, die auch von anderen Anwendungen verwendet werden können. Diese Dateien werden erst dann deinstalliert, wenn alle Programme deinstalliert wurden, die auch diese Dateien verwenden. Um das Installationsprogramm für den Rechner zu erzeugen, muß die Datei nicht selektiert werden.
293
15.2.10 Skriptdatei
In diesem Schritt wird der Name für die Skriptdatei festgelegt. Beim erneuten Erzeugen der Installationssoftware für den Rechner kann dann diese Datei verwendet werden, die automatisch alle Einstellungen übernimmt. Man spart sich somit den Arbeitsaufwand, immer wieder alle Optionen durchzugehen. Im Falle des Projektes Rechner sind die Einstellungen nicht so individuell und komplex, bei großen Applikationen kann es aber sehr aufwendig sein, alle Einstellungen zu reproduzieren. Nach Betätigen der Taste FERTIGSTELLEN werden folgende Verarbeitungsschritte durchgeführt: Verarbeitung von
erforderlichen Visual Basic-Laufzeitdateien,
Objekten und Verweisen,
erforderlichen Projektdateien,
Abhängigkeitsinformationen.
Dieser Prozeß kann einige Zeit in Anspruch nehmen. Dies hängt ganz von der Projektgröße und der Computerleistung ab. Es kann auch vorkommen, daß einige benötigte Dateien vom System nicht gefunden werden. In diesem Fall muß die benötigte Datei z. B. mit Hilfe eines Dateimanagers gesucht werden. Ist die gesuchte Datei gefunden, kann das Verzeichnis der Datei dem Installationsassistenten angegeben werden. Nach erfolgreicher Beendigung erscheint dann der Abschlußbericht. 15.2.11 Verpackungsbericht
Nachdem das Erzeugen der Installationssoftware beendet ist, wird ein Abschlußbericht eingeblendet. Er gibt an, wie viele Dateien erzeugt und in welchem Verzeichnis sie abgelegt wurden. Im Falle des Auftretens von Fehlern werden diese ebenfalls hier aufgeführt. Wenn eine Datei in der Applikation, für die die Installationssoftware erzeugt wurde, geändert wird, muß eine neue Installationssoftware erzeugt werden. Hierfür generiert der Installationsassistent eine BATDatei. Der Name der Datei und das Verzeichnis, in dem sie gespeichert wurde, werden ebenfalls im Verpackungsbericht angezeigt.
294
16
Das Erstellen eines Hilfesystems
In einem vorhergehenden Abschnitt wurde bei der Eigenschaft HelpContext erwähnt, daß der Komponenten ein Hilfetext zugeordnet werden kann. In modernen Applikationen ist es selbstverständlich, daß der Anwender immer Hilfe zum gerade aktuellen Bildschirm bekommt, wenn er die Taste (F1) betätigt. Aus diesem Grund soll in diesem Abschnitt mit dem Generieren einer Hilfedatei begonnen werden, die dann in das Programm Verzeichnisgröße eingeführt wird. Für das Generieren einer solchen Datei werden zwei zusätzliche Programme benötigt. Zum einen eine Textverarbeitung, mit der Dokumente im Rich Text Format (*.rtf) gespeichert werden können, zum anderen ein Hilfecompiler. Der Hilfecompiler wird ebenfalls auf der Visual Basic 6.0-CD-ROM ausgeliefert. Es befindet sich im folgenden Verzeichnis: :\Common\Tools\VB\HCW\
Da es sich bei dem Hilfecompiler um Freeware handelt, kann die neueste Version auch kostenlos aus dem Internet heruntergeladen werden. Die Adresse lautet: ftp://ftp.microsoft.com/Softlib/MSLFILES/hcwsetup.EXE
Für die Textverarbeitung WinWord 97 habe ich auf der Diskette eine Vorlagendatei gespeichert, die beim Formatieren dieser Hilfedateien Unterstützung bietet. Die Datei HILFEDATEI.DOT befindet sich auf der Diskette im Verzeichnis HILFE\WINWORD. Kopieren Sie diese Datei in das Autostart-Verzeichnis Ihres Office-Pakets, z.B. nach : C:\PROGRAMME\OFFICE97\OFFICE\STARTUP. Ab jetzt steht Ihnen unter WinWord eine neue Menüleiste zur Verfügung, mit der sich relativ leicht ein Hilfetext formatieren läßt.
295
16.1
Was ist kontextsensitive Hilfe?
Eine kontextsensitive Hilfe bietet auf Anfrage Informationen zu dem Programmteil, mit dem sich der Anwender gerade befaßt. Der Anwender bekommt also mit dieser Art von Hilfesystem automatisch dasjenige Kapitel der Hilfe angezeigt, das für den aktuellen Programmabschnitt benötigt wird. Ab Windows 95 und Windows NT 4.0 gehören die kontextsensitiven Hilfen zum standardmäßigen Umfang eines jeden Programms.
16.2
Grundlegende Begriffe für das Erstellen einer Hilfedatei
Bevor mit dem Erzeugen einer Hilfedatei begonnen werden kann, müssen einige Grundbegriffe erklärt werden. Thema. Die Hilfetexte gliedern sich in zahlreiche Themen, die aus einer zusammenhängenden Texteinheit bestehen. Jede Texteinheit wird von dem Hilfeprogramm als eine komplette Textseite verwendet. Dabei können diese Hilfeseiten beliebig lang sein. Inhaltsverzeichnis. Die Inhaltsverzeichnisse stellen in der Form, in der sie hier erzeugt werden können, unter Windows 95 und Windows NT eine Neuerung dar. Das Inhaltsverzeichnis entspricht prinzipiell dem Inhaltsverzeichnis eines Buches, jedoch handelt es sich hierbei um inhaltlich geordnete Querverweise zu den wichtigsten Themen. Die Themenbereiche der verfügen über Unterpunkte, die auf- und zugeklappt werden können, damit die Liste übersichtlicher bleibt. Schlüsselwort. Jedem Hilfethema können ein oder mehrere Schlüsselwörter zugeordnet werden. Um ein Hilfethema schneller auffinden zu können, kann mit der INDEX-Schaltfläche des Hilfeprogramms eine alphabetische Liste aller Schlüsselwörter angezeigt werden. Titel. Die Titel sind nur für die Volltextsuche von Bedeutung. Sie werden im unteren Fenster des Dialogblattes SUCHEN vom Hilfeprogramm angezeigt. Querverweise. Damit in den Hilfetexten kreuz und quer durch die Themen gesprungen werden kann, gibt es sogenannte Querverweise. Sie werden grün und unterstrichen dargestellt.
296
Identifikationsname. Das Ziel eines jeden Querverweises ist der sogenannte Identifikationsname des Themas. Er wird nur intern verwendet und kann auch nirgendwo angezeigt werden. Der Identifikationsname besteht aus einer Zeichenkette ohne Leerzeichen und in einigen Hilfesystemen auch ohne Sonderzeichen. Sequenznummern. Die Sequenznummern werden verwendet, um dem Hilfeprogramm mitzuteilen, welche Themen in welcher Reihenfolge angezeigt werden sollen, damit im Hilfeprogramm vorwärts und rückwärts geblättert werden kann. Kontextnummern. Damit von einem Steuerelement aus der richtige Hilfetext aufgerufen werden kann, werden in einzelnen Hilfethemen Kontextnummern vergeben. Bei einer solchen Nummer handelt es sich um eine Zahl vom Typ longint. In den Steuerelementen wird die Kontextnummer, die den Hilfetext für das aktuelle Steuerelement enthält, in der Eigenschaft HelpContext angegeben. Begriffserklärung. Fachausdrücke, die ohne eine Referenzierung erklärt werden sollen, können als Begriffserklärung definiert werden. Der Begriff wird im Hilfetext dann in grüner Schrift dargestellt. Wenn der Benutzer den Begriff anklickt, erscheint die Erklärung des Begriffs in einer kleinen rechteckigen Sprechblase. Überschriftenbereich. Um einen Bereich des Hilfetexts als Bereich festzulegen, der bei langen Hilfetexten nicht nach oben aus dem sichtbaren Bereich des Hilfefensters verschoben werden kann, muß dieser Text mit dem Attribut Absätze nicht trennen gekennzeichnet sein und am Anfang des Themas stehen. Der Überschriftenbereich läßt sich auch farblich abheben. Diese Einstellung läßt sich jedoch nicht in der Textverarbeitung definieren, sondern im Hilfecompiler über die Schaltfläche WINDOWS.
16.3
Der Hilfecompiler HCW
Die Version 4.x des Hilfecompilers benötigt als Betriebssystem mindestens Windows 95, Windows NT 4.0 oder eine neuere Version. In diesem Buch wird nur das Notwendigste behandelt, um eine Hilfedatei erstellen zu können, da eine ausführliche Behandlung des Themas den Umfang dieses Buches sprengen würde. Die folgenden Dateitypen werden vom Hilfecompiler erkannt und für das Erzeugen einer Hilfedatei benötigt:
297
*.rtf
Textdatei im Rich Text-Format
*.bmp
Grafikdatei im Bitmap-Format
*.wmf
Grafikdatei im Windows-Metadatei-Format
*.shg
Hypergrafikdatei
*.hpj
Projektdatei des Hilfecompilers
*.hlp
Hilfedatei von Windows (wird vom Hilfecompiler erzeugt)
*.ph
Temporäre Datei, die vom Hilfecompiler erzeugt wird
*.cnt
Inhaltsverzeichnis einer Hilfedatei (wird vom Hilfecompiler erzeugt)
16.3.1
Die Installation des HelpCompilers
Installiert wird der Hilfecompiler, indem das Programm SETUP aus dem Verzeichnis :\COMMON\TOOLS\VB\HCW\ aufgerufen wird. Wurde die Datei HCWSETUP.EXE aus dem Internet geladen, kann der Hilfecompilers installiert werden, indem diese Datei ausgeführt wird. Als erstes wird die Datei in dem aktuellen Verzeichnis entpackt, danach erscheint die Lizenzvereinbarung. Über die Schaltflächen OK und NEXT wechseln Sie in das Fenster, in dem das Zielverzeichnis, in das der Hilfecompilers installiert werden soll, ausgewählt wird. Bei der Software, die auf der Visual Basic CDROM mitgeliefert wird, hat sich jedoch ein kleiner Fehler eingeschlichen. Der Compiler läßt sich nur in Verzeichnissen installieren, die schon auf dem Rechner vorhanden sind. Er kann keine neuen Verzeichnisse anlegen. Um den Compiler also in ein eigenes Verzeichnis zu installieren, muß zunächst mit Hilfe des Explorers das neue Zielverzeichnis angelegt werden. Bei der Frage nach der Installationsart sollte Typical selektiert werden. Zum einen wird der benötigte Speicherplatz hierbei sehr gering gehalten, zum anderen werden dann auch alle benötigten Komponenten installiert.
298
Abbildung 16.1: Installationsarten des HelpCompilers
Im nächsten Fenster werden die Komponenten angezeigt, die bei der Installation des Hilfecompilers berücksichtigt werden. Wenn genügend freier Speicher auf der Festplatte vorhanden ist, können alle Optionen installiert werden. Im allgemeinen empfehle ich diese Installationsart. Jetzt wird der eigentliche Installationsvorgang gestartet, indem die gepackten Dateien des Hilfecompilers in das Zielverzeichnis kopiert werden. Wenn die Installation abgeschlossen ist, erscheint die folgende Meldung: Setup has finished installing Help Workshop. Der gesamte Help Workshop mit dem Hilfecompiler ist nun installiert und kann ohne Neustart des Computers verwendet werden. Aufgerufen wird der Hilfecompiler über den Menüpunkt HELP WORKSHOP des Menüs MICROSOFT HELP WORKSHOP. Nach dem Aufrufen des Hilfecompilers wird ein leeres Programmfenster mit einem Tip angezeigt. Ich empfehle, diese Tips regelmäßig zu lesen, da sie immer wieder gute Lösungshinweise für Probleme geben, auf die man beim Erstellen einer Hilfedatei treffen kann.
299
Abbildung 16.2: Der Startbildschirm des HelpCompilers (Version 4.x)
16.4
Die Formatierungen des Hilfetexts
Damit der Compiler die erzeugte Datei versteht, also weiß, bei welchen Textteilen es sich um Titel, Verweise oder Themenidentifikationen handelt, werden bestimmte Fußnoten verwendet. In diesem Abschnitt werden die verschiedenen Fußnoten und ihre Bedeutung vorgestellt und erklärt.
300
Zeichen
Bedeutung
Erklärung
#
Identifikationsname
Identifikationsnamen dienen als Zieladresse für Verweise und Begriffserklärungen. Sie dürfen keine Leerzeichen enthalten, jedoch dürfen die Zeichen „.“ (Punkt) und „_“ (Unterstrich) verwendet werden. Auf die Groß- und Kleinschreibung braucht keine Rücksicht genommen zu werden.
$
Titelangabe
Eine Titelangabe ist nicht unbedingt erforderlich, jedoch darf jedem Thema nur ein Titel zugewiesen werden. In der Titelangabe dürfen Sonderzeichen sowie Leerzeichen verwendet werden.
K
Schlüsselwörter
Zu einem Thema dürfen mehrere Schlüsselwörter vergeben werden, die durch ein Semikolon zu trennen sind. Das Schlüsselwort selbst kann ebenfalls aus mehreren Wörtern bestehen.
Zeichen
Bedeutung
Erklärung
+
Sequenznummern
Damit zwischen bestimmten Themen durch Vorwärts- und Rückwärtsblättern hin- und hergesprungen werden kann, müssen diese Themen zunächst über einen Sequenznamen zusammengefaßt werden. Der Sequenzname selbst darf keine Leerzeichen enthalten. Eine Sequenznummer, mit der die Reihenfolge der Themen beim Vorwärts- und Rückwärtsblettern definiert wird, wird an den Sequenznamen angehängt und von diesen durch einen Doppelpunkt getrennt. Bei der Vergabe der Sequenznummern ist darauf zu achten, daß genug Zahlen für spätere Erweiterungen freigelassen werden. Eine vollständige Sequenznummer sieht z.B. wie folgt aus: Dateiverarbeitung:0040
Tabelle 16.1: Die verschiedenen Sonderzeichen in der Hilfedatei
16.5
Erstellen einer Hilfedatei
Die Hauptschwierigkeit des Erstellens einer kontextabhängigen Hilfe besteht darin, den Hilfetext zu erstellen. Es kommt nicht selten vor, daß die Entwickler eines Programmes das Erstellen der Texte einer Hilfedatei an Fremdfirmen vergeben. Firmen oder Entwickler, die nicht über das dazu nötige Budget Verfügung, haben zwei Möglichkeiten: 1. selbst das Dokument zu erstellen oder 2. keine Hilfe zu erzeugen.
Die zweite Möglichkeit sollte nicht in Frage kommen, da es bei den heutigen Betriebssystemen und Programmen schon zum Standard gehört, Software nicht ohne Hilfedatei auszuliefern. In einem ersten Schritt muß also der Hilfetext mit einer Textverarbeitung erstellt werden. Dabei ist darauf zu achten, daß jedes Thema von einem anderen über einen harten Seitenumbruch getrennt wird. Auch Grafiken sollten noch nicht eingebunden werden. Das Einbinden der Grafiken wird in einem späteren Abschnitt getrennt behandelt. Wird eine Hilfedatei für ein Programm erzeugt, müssen einige Vereinbarungen zwischen dem Ersteller und dem Anwender der Hilfedatei (in diesem Fall handelt es sich dabei um den Entwickler des Programmes) getroffen werden. Die Schnittstelle zwischen dem Programm, das die Hilfedatei verwendet, und der Hilfedatei selbst bilden die Kontextnummern. Sie definieren die Zieladresse, zu der in der Hilfedatei verzweigt werden soll, wenn die Hilfe von einem Steuerelement aus aufgerufen werden soll.
301
Wie Sie sehen, ist das Erstellen einer Hilfedatei mit Querverweisen und Indexeinträgen nicht ganz einfach, da bei der Formatierung einer Hilfedatei sehr viele Konventionen berücksichtigt werden müssen.
16.6
Schreiben der Hilfedatei
Das eigentliche Schreiben der Hilfedatei erspare ich Ihnen, denn das Grundkonzept des Hilfetexts ist in der Datei VERZEICHNIS.TXT abgelegt. Dieser Text muß in eine Textverarbeitung geladen werden, damit er nach den gegebenen Regeln formatiert werden kann.
16.6.1
Einführen eines Titels in die Hilfedatei
Zunächst werden die Titel formatiert, z.B über die Vorgabe von. Schriftart Arial und Schriftgröße 18, und nach jedem Abschnitt wird ein harter Seitenumbruch eingeführt. Dann wird jedem Titel mit der Fußnote „$“ ein interner Titel gegeben. Dieser Titel ist nicht unbedingt notwendig, sollte aber wegen der Vollständigkeit immer mitgeführt werden.
16.6.2
Erzeugen von Querverweisen
Als nächstes werden die Namen vergeben, die als Ziel für die Verweise gelten. Hierfür wird die Fußnote „#“ verwendet. Ein Verweis in dem Dokument wird nun wie folgt eingeführt: Schreiben Sie an die Stelle, an welcher der Verweis im Dokument stehen soll, den Namen des Ziels, der mit der Fußnote „#“ definiert wurde. Es darf sich kein Leerzeichen zwischen dem Text, der als Verweis dient, und dem Namen des Ziels befinden. Jetzt wird der Text, der im Dokument als Verweis verwendet wird, doppelt unterstrichen. Dem Namen des Ziels wird das Zeichenattribut versteckt zugewiesen. In der Hilfedatei wird die Schrift des Textes von dem restlichen Text durch
die Darstellung des Verweises in einer anderen Schriftfarbe und
durch das Attribut unterstreichen
abgehoben. In Abbildung 16.3 wird das Inhaltsverzeichnis zu einer Hilfedatei im Textverarbeitungsprogramm gezeigt. Alle Themen wurden nacheinander aufgelistet und mit den Verweisen auf das jeweilige Hilfethema versehen.
302
Abbildung 16.3: Das Inhaltsverzeichnis zu einem Hilfetext
Wird in der fertigen Hilfedatei mit der linken Maustaste auf diesen Verweis geklickt, wird automatisch der Text angezeigt, in dem das Ziel des Verweises definiert wurde.
16.6.3
Erzeugen von Begriffserklärungen
Begriffserklärungen werden dort verwendet, wo ein bestimmter Begriff kurz erläutert werden soll, damit der Hilfetext für den Anwender auch dann verständlich ist, wenn er eine neue Begriffsbezeichnung enthält. Wenn der Anwender die Erklärung zu dem Begriff benötigt, klickt er ihn mit der linken Maustaste an, und die Erklärung wird in einer viereckigen Sprechblase angezeigt.
Abbildung 16.4: Begriffserklärung im Hilfetext
303
Der Text, der in der Sprechblase enthalten ist, wird ebenso erzeugt wie zuvor der Zieltext zu den Verweisen. Hinter dem Begriff, dem die Sprechblase zugeordnet werden soll, wird der Name des Zieles, der mit der Fußnote „#“ definiert wurde, geschrieben. Auch hier darf sich wieder kein Leerzeichen zwischen dem Begriff und dem Namen des Verweises befinden. Der gesamte Ausdruck muß wie folgt formatiert sein:
er zu erklärende Begriff wird unterstrichen
der Name, der das Ziel definiert, wird mit dem Attribut versteckt versehen
In der Hilfedatei wird der Begriff über einen unterbrochenen Unterstrich und über eine andere Schriftfarbe vom übrigen Text hervorgehoben.
16.6.4
Erzeugen von Hilfesequenzen
Um zwischen ähnlichen Hilfethemen mit den Schaltflächen << und >> wechseln zu können, werden sogenannte Sequenzen eingeführt. Das Fußnotenzeichen für Sequenzen ist das „+“. In der Fußnote wird der Name der Sequenz vergeben, gefolgt von der Numerierung, mit der die Reihenfolge der Hilfethemen festgelegt wird. In dem Beispielhilfetext sollen die Themen zum Formatieren der Schriftart in eine Sequenz eingebunden werden. Der Name der Sequenz ist Formatierung. Die Sequenznummer beginnt mit der Nummer 010 und wird in Zehnerschritten erhöht. Die Numerierung erfolgt in Zehnerschritten, damit jederzeit ein neues Thema in die bestehende Sequenz eingefügt werden kann. Formatierung:010
16.6.5
Einbinden von Grafiken
Um den Hilfetext etwas aufzulockern, können auch Grafiken in die Hilfedatei eingebunden werden. Es heißt nicht umsonst: Ein Bild sagt mehr als tausend Worte. Bei den Grafiken, die in die Datei integriert werden können, werden die Formate Bitmap und Metafile unterstützt. Es gibt jedoch ein Problem bei der Wahl der Grafikart, da die Hilfedatei auf den unterschiedlichsten Computern funktionieren muß. Dabei ist es egal, ob es sich bei dem Computer um ein Notebook mit Schwarzweißdisplay
304
und einer Auflösung von 640*480 Bildpunkten, oder um einen Grafikcomputer mit einem 21-Zoll-Bildschirm und einer Auflösung von 1600*1200 Bildpunkten handelt. Die geringsten Probleme werden von Bitmaps mit einer 16-Bit-Farbtiefe verursacht. Das Einbinden der Grafiken erfolgt eigentlich erst im Hilfecompiler. In der Textverarbeitung wird nur ein Eintrag in geschwungenen Klammern gemacht, um den Ort, an dem die Grafik positioniert wird, zu kennzeichnen. Für die Darstellung der Bilder im Text stehen Kommandos zur Verfügung, die in der Tabelle 16.2 kurz erklärt werden. Kommando
Beschreibung
bmc
Hier wird die Bitmap-Grafik als ein einzelnes Zeichen im Text behandelt. Dies ermöglicht, daß eine Grafik an einer beliebigen Stelle im fließenden Text eingefügt werden kann.
bml
Die Grafik wird linksbündig im Hilfetext ausgerichtet.
bmr
Die Grafik wird rechtsbündig im Hilfetext ausgerichtet.
Tabelle 16.2: Kommandos für Bilder in der Hilfedatei
Wird z.B. eine Grafikdatei mit dem Namen MENUE.BMP in die Hilfedatei eingebunden, kann sie mit den drei genannten Befehlen wie folgt in den Text eingefügt werden: {bmc Menue.bmp} {bml Menue.bmp} {bmr Menue.bmp}
Achtung! Es wird immer nur der Dateiname und niemals der Pfad angegeben, selbst wenn die Datei nicht in dem Verzeichnis liegt, in dem sich die Projektdatei und der Hilfetext befinden. Da diese Datei erst vom Compiler in die Hilfedatei eingebunden wird, wird auch erst in der Projektdatei der Name des Verzeichnisses angegeben, in dem sich die Grafikdatei befindet.
305
Abbildung 16.5: Ausschnitt einer Hilfedatei mit der Angabe von Bildern
16.7
Erzeugen einer ersten Hilfe mit dem Help Workshop
Nachdem der Hilfecompiler aufgerufen wurde, erscheint ein leeres Fenster (Abbildung 16.2), in dem ein neues Projekt erzeugt werden kann. Zuerst muß das neue Hilfeprojekt über das Menü FILE | NEW angelegt werden. In dem Fenster in Abbildung 16.6 kann zwischen zwei unterschiedlichen Projektarten gewählt werden.
Abbildung 16.6: Projektauswahl: Hilfedatei oder Inhaltsverzeichnis
Wenn sie an dieser Stelle das Erzeugen eines neuen Hilfeprojekts abbrechen möchten, wird Ihnen das nicht gelingen. Microsoft hat vergessen, der Schaltfläche CANCEL Funktionalität zu hinterlegen.
306
Bei der Auswahl Help Project handelt es sich um das Projekt, mit dem die eigentliche Hilfedatei erzeugt wird. Wird die Auswahl Help Contents gewählt, kann ein Inhaltsverzeichnis zu der Hilfedatei generiert werden. Zuerst wird jedoch der Menüpunkt Help Project benötigt. Auf die Auswahl Help Contents gehe ich im Abschnitt „Erstellen des Hilfeindexes“ nochmals genauer ein. Nachdem die Projektart Help Project ausgewählt wurde, müssen das Verzeichnis und der Name der Projektdatei festgelegt werden. Anschließend wird die Projektdatei im Help Workshop angezeigt. Diese Datei steuert die gesamte Generierung der Hilfedatei. Hier werden alle Text- und Grafikdateien, die in der Hilfedatei verwendet werden, aufgelistet. Auch können hier einige Steueroptionen für die Hilfedatei eingestellt werden. Wenn die Generierung der Hilfedatei ohne Fehler abgeschlossen werden konnte, erhält die erzeugte Datei den gleichen Namen, unter dem auch das Projekt gespeichert wurde, jedoch mit der Endung *.hlp.
16.7.1
Einbinden der RTF-Textdatei
Als erstes muß für die Übersetzung der Textdatei in die Hilfedatei die Datei, die übersetzt werden soll, in das Projekt eingebunden werden. Dies geschieht über die Schaltfläche FILES des Help Workshops. Es wird der Dialog TOPIC FILES geöffnet, mit dem die einzubindenden Dateien verwaltet werden.
Abbildung 16.7: Der Dialog Topic Files des Help Workshops
307
Über die Schaltfläche ADD können neue Dateien hinzugefügt werden, wenn der Hilfetext auf mehrere RTF-Dateien verteilt wurde. Mit der Taste REMOVE können einzelne Dateien wieder aus dem Hilfeprojekt entfernt werden. Nach dem Bestätigen mit der Taste OK werden die Dateien, die sich im Listenfenster befinden, in das Projekt übernommen. Hierfür wird der eigene Optionsschalter [Files] in der Projektdatei erzeugt.
16.7.2
Einbinden der Grafikdateien
Das Einbinden der Grafikdateien erfolgt auf die gleiche Weise wie das Einbinden der Textdateien, jedoch über die Schaltfläche BITMAP.
Abbildung 16.8: Der Dialog zum Einbinden von Bitmap-Grafiken in den Help Workshop
Mit diesem Dialog werden jetzt die Verzeichnisse festgelegt, in denen nach den Grafiken gesucht werden soll, die in der RTF-Datei angegeben wurden. Hinzugefügt werden die Verzeichnisse mit der Schaltfläche ADD, gelöscht werden sie mit der Schaltfläche REMOVE. Nach dem Bestätigen der Vorgaben mit der Taste OK wird für die Bildverzeichnisse ein neuer Eintrag unter dem Optionsschalter [Options] erzeugt.
16.7.3
Eigenschaften des Hilfefensters
Um die Eigenschaften des Hilfefensters zu verändern, gibt es den Optionsschalter WINDOWS. Wird er ausgewählt, erscheint jedoch zuerst ein Dialog, in dem das Fenster ausgewählt wird, das für die Hilfe konfiguriert werden soll (Abbildung 16.9).
308
Abbildung 16.9: Der Dialog Create a window des Help Workshops
Für das Hilfeprojekt des Tool Verzeichnisgröße wird der Fenstertyp Procedure gewählt, und in der Eigenschaft Create a window named wird der Name des zu erzeugenden Fensters eingegeben. Da die Hilfe für das Tool verwendet werden soll, wird der Name Verzeichnisstruktur vergeben. Nach dem Bestätigen der Eingabe mit der Taste OK wird der nächste Dialog (Abbildung 16.10) angezeigt, mit dem die eigentlichen Einstellungen für das Fenster durchgeführt werden.
Abbildung 16.10: Der Dialog Windows Properties des Help Workshops
Da in unserer Hilfedatei auch Sequenznummern vergeben wurden, müssen die Schaltflächen zum Durchblättern der einzelnen Sequenzen eingeschaltet werden. Diese Option wird auf dem Registerblatt BUTTONS des Dialoges WINDOWS PROPERTIES vorgenommen. Damit die Schaltflächen in der Hilfe aktiviert sind, muß die Option Browse aktiviert werden.
309
Damit die Hilfedatei jetzt in dem Tool Verzeichnisanalyse verwendet werden kann, müssen noch die ID-Nummern zu jedem Hilfethema vergeben werden, damit jedem Steuerelement ein eigenes Hilfethema zugeordnet werden kann. 16.7.4
Hinzufügen der HelpContext-ID in dem Hilfeprojekt
Damit die ID-Nummern auch ohne Probleme verwendet werden können, muß jede ID gut dokumentiert werden. Zuerst sollten der Hilfetext ausgedruckt und danach die ID-Nummern im Text ergänzt werden. Erst wenn diese Dokumentation erfolgt ist, sollten die ID-Nummern in den Text eingefügt werden. Diese Vorgehensweise gewährleistet eine saubere Programmdokumentation und ermöglicht jedem Programmierer, der sich neu in die Applikation hineindenken muß, eine schnelle Einarbeitung. Die Definition jeder ID im Hilfeprojekt erfolgt über die Schaltfläche MAP im Hilfecompiler. Mit der Schaltfläche ADD wird ein neuer Dialog geöffnet, mit dem eine neue ID erzeugt wird.
Abbildung 16.11: Der Dialog zum Definieren der ID-Nummern der Hilfedatei
In dem Textfeld Topic ID wird der Themenverweis festgelegt, in dem Eingabefeld Mapped numeric value wird die dazugehörige Hilfenummer eingegeben. Bei der verwendeten ID muß es sich um eine vorzeichenlose ganze Zahl handeln. Es sind keine Kommazahlen erlaubt. Deshalb sollte bei der Vergabe dieser IDs immer genug Raum für Zahlen für weitere Themen freigelassen werden. Im allgemeinen wird auch hier eine Zehnerschrittweite verwendet. In der Zeile Comment kann dann noch eine Beschreibung zu der erzeugten Hilfe-ID eingegeben werden. Wenn alle Themen über eine Nummer referenziert werden können, ist die Hilfedatei fertig. In dem Fenster des Hilfecompilers sollten jetzt prinzipiell die Informationen enthalten sein, wie sie in Abbildung 16.12 zu sehen sind.
310
Abbildung 16.12: Der Inhalt des Projektfensters mit allen Hilfedefinitionen
Um eine Hilfedatei zu erzeugen, die in ein Programm eingebunden werden kann, muß über die Schaltfläche SAVE AND COMPILE das gesamte Projekt in eine reguläre Hilfedatei übersetzt werden.
Abbildung 16.13: Die Ausgabe des Hilfecompilers nach erfolgreicher Übersetzung
311
Nach dem Übersetzungsvorgang gibt der Compiler aus, wo er die erzeugte Datei abgelegt und welche Besonderheiten sie hat. Es wird die Anzahl der Titel, Sprünge, Schlüsselwörter und der eingebundenen Grafiken aufgeführt. Sollten bei der Übersetzung Fehler aufgetreten sein, so werden diese hier ebenfalls beschrieben.
16.7.5
Das Einbinden der Hilfedatei in ein Visual BasicProjekt
Nach der erfolgreichen Übersetzung unseres Hilfeprojekts muß die Hilfedatei noch in das bestehende Projekt eingebunden werden. Hierfür greifen wir auf das Beispielprogramm Verzeichnisanalyse zurück. Als erstes muß in den Projekteinstellungen (PROJEKT | OPTIONEN) auf dem Registerblatt Anwendung die neu erzeugte Hilfedatei in das Feld Hilfedatei eingetragen werden. Danach wird zu jedem Steuerelement in der Eigenschaft HelpContext die ID der Hilfedatei eingetragen, die das zugehörige Hilfethema referenziert. Nach erneutem kompilieren des Projektes steht dem Anwender nun eine kontextsensitive Hilfe zur Verfügung, die durch das Betätigen der Taste (F1) aufgerufen wird und eine kurze Beschreibung zu dem jeweiligen Programmteil liefert.
16.8
Erstellen des Hilfeindexes
Das Erzeugen eines Hilfeindexes für die Datei VERZEICHNIS.HLP ist relativ einfach. Hierfür wird zunächst über das Menü FILE | NEW eine neue Datei vom Typ Help Contents erzeugt. Die Grundlage für die Indexeinträge bilden wieder die IDs, die in der Hilfedatei erzeugt wurden. Zuerst wird jedoch im Eingabefeld Default filename der Name der Hilfedatei eingetragen, zu welcher der Index erzeugt wird. Der Index kann natürlich auch für mehrere Hilfedateien erzeugt werden. Dann sollte hier die Hilfedatei eingetragen werden, auf welche die meisten Referenzierungen verweisen. In dem Eingabefeld DEFAULT TITLE wird der Titel eingetragen, der im Indexfenster in der Titelleiste angezeigt werden soll. Diese Eingaben können auch in einem speziellen Dialog gemacht werden, der über die Schaltfläche EDIT aufgerufen wird.
312
16.8.1
Hinzufügen von Indexeinträgen
Mit den Schaltflächen ADD ABOVE und ADD BELOW können neue Indexeinträge erzeugt werden. Mit der Schaltfläche ADD ABOVE wird der neue Indexeintrag vor, mit der Schaltfläche ADD BELOW nach dem aktuell selektierten Eintrag eingefügt. Wird ein neuer Eintrag über eine dieser beiden Schaltflächen hinzugefügt, wird der Dialog EDIT CONTENTS TAB ENTRY geöffnet, in dem die Angaben über den neuen Eintrag festgelegt werden.
Abbildung 16.14: Der Dialog zum Einfügen und Bearbeiten von Indexeinträgen
Es können vier verschiedene Arten von Einträgen gewählt werden.
Heading: Bei diesem Eintrag handelt es sich um eine Überschrift, der wiederum verschiedene Einträge zugeordnet werden können. Bei den untergeordneten Einträgen kann es sich dann ebenfalls um Überschriften handeln. Somit läßt sich mit Hilfe der Überschriften eine beliebige Tiefe im Index erzeugen.
Topic: Hierbei handelt es sich um die einzelnen Einträge, die auf die bestimmten Themen in der Hilfedatei zeigen.
Include: Hiermit können schon existierende Indexdateien in die aktuelle Indexdatei aufgenommen werden.
Nachdem die Art des Indexeintrags festgelegt wurde, müssen noch die Angaben zu den Indexeinträgen vervollständigt werden. Handelt es sich bei dem hinzugefügten Indexeintrag um eine Überschrift (Heading), muß nur der eigentliche Titel des Eintrags ergänzt werden. Handelt es sich um einen Themeneintrag (Topic) muß die Beschreibung Title, unter der das Thema im Index aufgeführt wird, ergänzt werden. Im Feld TOPIC ID muß der Themenverweis angegeben werden, der das Thema in der Hilfedatei identifiziert. Die beiden anderen Felder Help file und Window type müssen nicht zwingend ergänzt werden. Das Feld Help file wird dann benötigt, wenn das Thema, auf das
313
der Eintrag verweist, in einer anderen Datei als der, die in der Hilfedatei als Default-Datei definiert wurde. Um einen anderen Index einzubinden, muß im Feld Include File der Dateiname der einzubindenden Indexdatei eingegeben werden.
16.8.2
Das Bearbeiten von Indexeinträgen
Um die verschiedenen Indexeinträge zu modifizieren, stehen vier weitere Schaltflächen zur Verfügung. Mit der Schaltfläche REMOVE können bestehende Indexeinträge gelöscht werden. Damit ein Indexeintrag im Dialog EDIT CONTENTS TAB ENTRY (Abbildung 16.14) bearbeitet werden kann, kann der Dialog entweder über die Schaltfläche EDIT oder mit einem Doppelklick auf den zu bearbeitenden Eintrag geöffnet werden. Über die beiden Schaltflächen MOVE RIGHT und MOVE LEFT kann die Position eines Eintrags in der Baumhierarchie verändert werden. Mit der Schaltfläche MOVE LEFT wird der Eintrag eine Ebene nach oben, mit der Schaltfläche MOVE RIGHT eine Ebene nach unten verschoben. In Abbildung 16.15 ist die Baumstruktur der Indexeinträge für das Projekt Verzeichnisanalyse abgebildet.
Abbildung 16.15: Die Baumstruktur des Hilfeindexes zu MyWord
Beachten Sie, daß beim Vergeben des Index- und des Hilfedateinamens beide Dateien immer denselben Namen tragen und im selben
314
Verzeichnis abgelegt sein müssen. Ansonsten wird die Indexdatei nicht von der Hilfedatei gefunden.
315
17
Datenbankanbindung
In diesem Abschnitt möchte ich auf die Grundlagen der Datenbankanbindung eingehen. Hierbei werden nur die einfachsten Methoden beschrieben, da dieses Gebiet äußerst umfangreich ist. Wer sich eingehender mit der Programmierung und Visual Basic 6.0 und dem Zugriff auf Datenbanken beschäftigen möchte, dem empfehle ich das Buch „Visual Basic 6.0“ so wie Michael Kofler. Auch werde ich nicht weiter auf die Grundlagen der Datenbanken eingehen, da dieses komplexe Gebiet den Rahmen des Buches eindeutig sprengen würde. Als Grundlage für die Beispielprogramme verwenden wir eine einfache Datenbank zur Musikverwaltung. Diese Datenbank wurde mit der Datenbank Access 97 erstellt. In Abbildung 17.1 ist das Datenmodell, mit dem die Musikverwaltung arbeitet, abgebildet.
Das zugrundeliegende Datenmodell
Abbildung 17.1: Relation zur Verwaltung der Musikdaten
Ich möchte nur kurz auf das Datenmodell eingehen. In der Tabelle Interpreten werden alle Interpreten und Gruppen verwaltet. Die Titel der CDs, Musikkassetten usw. werden in der Tabelle Titel erfaßt. Die Titelanzahl eines Interpreten kann zwischen null und n liegen. In der Tabelle Tonträger wird festgelegt, welche Tonträger erlaubt sind, und in der Tabelle Musikstücke werden alle Lieder erfaßt, die auf den Tonträgern der Tabelle Titel aufgezeichnet sind. Um die einzelnen Titel
317
der Musikstücke auch nach Musikrichtung qualifizieren zu können, wird die Tabelle Musikrichtung verwendet.
17.1 Die Standard Query Language
Standardabfragesprache
Damit eine Applikation mit einer Datenbank kommunizieren kann, wird eine Standardabfragesprache (Standard Query Language, kurz SQL) verwendet. Diese Sprache ist weitgehend unabhängig vom verwendeten Datenbanksystem. In diesem Abschnitt möchte ich kurz auf die wichtigsten SQL-Befehle eingehen. Hierbei muß ich noch erwähnen, daß die Abfragesprache SQL selber ein so komplexes Thema ist, daß damit Stoff für ein eigenes Buch geliefert wird. Damit die Abfragen, die in diesem Buch verwendet werden, von Ihnen nachvollzogen werden können, habe ich den „Dialekt“ von Access 97 verwendet.
17.2 Das Datenbanktool von Visual Basic 6.0
Erlernen von SQL
Mit dem Erlernen der Abfragesprache SQL ist es wie mit dem Erlernen der meisten Programmiersprachen: Am besten experimentiert man mit ihnen. Die Beispiele in diesem Abschnitt basieren auf der Datenbank MUSIKVERWALTUNG (siehe das Verzeichnis DATENBANK auf der Diskette, die dem Buch beigefügt ist). Um die Beispiele mit Visual Basic selbst nachvollziehen zu können, starten Sie über das Menü ADD-INS|VISUAL DATA MANAGER... das Programm VisData. Nach dem Start erhalten Sie eine leeres Programmfenster. Um mit dem Programm arbeiten zu können, muß zuerst die Verbindung zu einer Datenbank hergestellt werden. Dies geschieht über das Menü DATEI|DATENBANK ÖFFNEN. Hier haben Sie die Möglichkeit, auf die verschiedensten Datenbanktypen zuzugreifen. Um eine Verbindung mit der Musikverwaltung herzustellen, wählen Sie aus dem Menü MICROSOFT ACCESS... die zu öffnende Datei.
318
Abbildung 17.2: Das Programm VisData
Jetzt werden zwei weitere Fenster geöffnet. In dem Fenster Datenbankfenster werden alle Tabellen, die sich in der Datenbank befinden, angezeigt.
Abbildung 17.3: Das Datenbankfenster von VisData
Jede Tabelle hat wiederum drei Untertitel. Im ersten werden alle Felder der Tabelle aufgeführt, im zweiten werden alle Indexe und im dritten die Eigenschaften der Felder und der Tabelle dargestellt. Das Fenster SQL-Anweisung (Abbildung 17.4) dient dem Testen von SQL-Anweisungen. Hier können sie eingegeben werden.
319
Abbildung 17.4: Das Fenster SQL-Anweisung
Nach dem Betätigen der Schaltfläche AUSFÜHREN wird die aktuelle SQL-Anweisung an die Datenbank gesendet. Zuerst wird jedoch noch in einem weiteren Dialog nachgefragt, ob es sich um eine SQLPassThrough-Abfrage handelt. Beantworten Sie diese Frage mit NEIN. Diese Frage wird bei jeder Abfrage gestellt, was mit der Zeit recht lästig werden kann. Ist die Ausführung erfolgreich gewesen, so erscheint ein weiteres Fenster (Abbildung 17.5) mit dem Ergebnis der ausgeführten Abfrage. Datensatzansicht
Abbildung 17.5: Ergebnisfenster 1 des ViaData
In dem Fenster, daß das Ergebnis der Abfrage darstellt, wird jeder Datensatz einzeln angezeigt. Diese Art der Darstellung ist im allgemeinen nicht sehr geeignet für das Überprüfen von Abfragen, da man die Datensätze nur schlecht miteinander vergleichen kann. Um das Ergebnis der Abfrage besser überprüfen zu können, ist es von Vorteil, die Datensätze tabellarisch darzustellen. Hierfür muß mit der Schaltfläche das Ergebnislayout umgestellt werden. Durch Betätigen dieser Schaltfläche wird das Steuerelement Grid für die Darstellung des SQL-Ergebnisses verwendet (Abbildung 17.6).
320
Tabellenansicht
Abbildung 17.6: Ergebnisfenster 2 des VisData
Für die Einführung in das Arbeiten mit dem VisData-Fenster wurden schon einige Befehle der SQL-Syntax verwendet. Im nächsten Abschnitt werden diese Befehle genauer behandelt.
17.2.1
Die Abfragesprache
Die Abfragen dienen in erster Linie dazu, die Informationen, die sich ungeordnet in der Datenbank befinden, nach verschiedenen Kriterien auszuwählen und in Listen zusammenzufassen. Das Ergebnis einer solchen Abfrage ist eine Tabelle, die im Hauptspeicher behalten wird. Solche Tabellen nennt man auch Sichten (englisch Views). Mit einem weiteren Abfragentyp, den sogenannten Aktionsabfragen, kann die Datenbank manipuliert werden. Es können z.B. Datensätze eingefügt, verändert oder gelöscht werden. Diese Art der Abfragen wird aber erst gegen Ende dieses Abschnitts behandelt.
Aktionsabfragen
In der folgenden Übersicht werden die wichtigsten SQL-Anweisungen zum Formulieren einfacher Abfragen behandelt. Die einzelnen Parameter sind in der Reihenfolge, in der sie auch in der SQL-Anweisung vorkommen. Um eine bessere Übersichtlichkeit zu erreichen, werden die SQL-Anweisungen in Großbuchstaben geschrieben. Grundsätzlich ist es aber egal, ob eine Anweisung in Groß- oder Kleinbuchstaben geschrieben wird. Parameter Diese Anweisung ermöglicht es, eine SQL-Abfrage mit allgemeinen Parametern zu formulieren, die erst unmittelbar vor dem Ausführen der Anweisung angegeben werden müssen. Durch diesen Befehl lassen sich SQL-Abfragen allgemeingültig definieren. Er wird hauptsächlich dann verwendet, wenn SQL-Abfragen nicht dynamisch, d.h. nach Bedarf, erzeugt werden, sondern wenn es sich um vorkompilierte Abfragen in der Datenbank handelt. Aber Achtung: Parameter ist eine Jet-spezifische Erweiterung des SQL-Sprachumfangs.
321
Select Mit Select werden die Daten aus der Datenbank gelesen. Hierfür werden die Felder, durch Kommata getrennt, aufgezählt. Mit der Anweisung From werden dann die Tabellen angegeben, in denen sich die Felder befinden. Wie die Felder, so werden auch die Tabellen durch Kommata voneinander getrennt. Wenn ein Feld in mehreren Tabellen vorkommt, muß dieses spezifiziert werden, indem der Tabellenname, durch einen Punkt getrennt, vor den Feldnamen gestellt wird. Um aus einer Tabelle alle Felder zu laden, kann das Zeichen * verwendet werden. Distinct und Distinctrow Mit diesen Befehlen kann verhindert werden, daß mehrere Datensätze mit exakt dem gleichen Inhalt angezeigt werden. Sie fassen gleiche Datensätze zusammen. As Dieser Befehl wird verwendet, um Felder oder Tabellen umzubenennen. Durch den Einsatz von As können auch mehrere Felder zu einem neuen zusammengefaßt werden. Beispiel: Interpret & " " & Titel AS Name
From Mit dieser Anweisung werden die Tabellen festgelegt, in denen sich die Felder befinden, die mit der SQL-Anweisung bearbeitet werden sollen. Where In dem Bereich Where werden die Kriterien angegeben, nach denen die Daten aus der Datenbank selektiert werden. Um alle Datensätze einer Tabelle laden zu können, muß die Where-Klausel nicht angegeben werden. Um komplexe Ausdrücke aufbauen zu können, werden weitere Funktionen und Vergleichsoperatoren (Tabelle 17.1) zur Verfügung gestellt.
322
Funktion
Beschreibung
NOT
Logische Verneinung.
AND
Logisches UND.
OR
Logisches ODER.
BETWEEN
Prüft, ob der Feldinhalt in einem vorgegebenen Intervall liegt.
=; < ; >; <>; <=; >=
Vergleichsoperatoren (gleich, kleiner, größer, ungleich, kleiner gleich, größer gleich).
EXISTS
Prüft, ob eine Ergebnistabelle, wenn z.B. eine Unterabfrage verwendet wird, mindestens einen Datensatz enthält.
IN
Prüft, ob ein Feldwert einen Wert enthält, der in einer vorgegebenen Datenmenge enthalten ist. Diese Datenmenge kann z.B. von einer Unterabfrage erzeugt worden sein.
LIKE
Vergleicht alphanumerische Zeichenketten mit vorgegebenen Mustern.
IS NULL
Prüft, ob der Feldwert eines Datensatzes den Wert NULL (nicht 0) enthält.
Tabelle 17.1: Funktionen und Vergleichsoperatoren der WHERE-Klausel
Group by Um Datensätze mit gleichem Feldinhalt zusammenzufassen, wird die Klausel Group by verwendet. Alle Felder, auf die diese Klausel angewendet werden soll, werden mit Kommata getrennt als Liste aufgeführt. Having Mit Having können nochmals Datensätze selektiert werden. Having enthält die Bedingungen für Einträge, die zuvor mit der Klausel Group by gruppiert wurden. In den Abfragen kann Having eine Alternative zu Where darstellen. Order by Mit der Klausel Order by wird angegeben, nach welchen Feldern das Ergebnis sortiert werden soll. Um eine Liste aufwärts zu sortieren, kann das Kommando ASC nachgestellt werden. Zum Abwärtssortieren wird das Kommando DESC verwendet.
323
Es existieren noch einige weitere Funktionen, jedoch werde ich hier auf sie nicht eingehen. Für die Abfragen, die in diesem Buch benötigt werden, sind die behandelten Funktionen vollkommen ausreichend.
17.3
Arbeiten mit den SQL-Kommandos
In diesem Abschnitt werden einige Beispiele zum Umgang mit den SQL-Kommandos vorgestellt, um das Arbeiten mit dieser Abfragesprache zu verdeutlichen.
17.3.1 Die ersten SQL-Abfrage
Abfrage aus einer Tabelle
Die einfachste Datenbankabfrage besteht nur aus den Anweisungen Select und From. Mit ihr lassen sich alle Felder (Spalten) einer oder mehrerer Tabellen aus der Datenbank auslesen. Mit dem folgenden Statement werden alle Felder mit den gesamten Datensätzen (Zeilen) der Tabelle Musikstücke aus der Datenbank gelesen. SELECT * FROM Musikstücke
Abbildung 17.7: Ergebnis der einfachen SQL-Abfrage
Um das Ergebnis der Datenbankabfrage auf bestimmte Felder zu beschränken, werden diejenigen Felder, die in dem Ergebnis enthalten sein sollen, hinter dem Select-Statement angegeben. Die Feldnamen werden dabei durch Kommata voneinander getrennt.
324
SELECT Nummer, Titel FROM Musikstücke
Bisher wurden immer alle Datensätze aus einer Tabelle gelesen. Um das Ergebnis auf bestimmte Datensätze zu beschränken, wird die Where-Klausel eingeführt.
Datensatzkriterien einführen
SELECT Nummer, Titel FROM Musikstücke WHERE TT = 1
Abbildung 17.8: Abfrage mit eingeschränkten Datensätzen
Durch das Einführen der Where-Klausel wird das Ergebnis der Abfrage eingeschränkt. In diesem konkreten Fall war die Bedingung, daß nur die Datensätze des Albums angezeigt werden, bei denen im Feld TT der Wert 1 enthalten ist. Das Ergebnis ist ein Ausschnitt aus dem gesamten Datenbestand und noch unsortiert. Um die Titel in aufsteigender Reihenfolge zu sortieren, wird die Klausel Order by mit dem Kommando ASC eingeführt.
Sortieren nach bestimmten Feldern
SELECT Nummer, Titel FROM Musikstücke WHERE TT = 1 ORDER BY Nummer ASC
Abbildung 17.9: Ergebnis der sortierten, eingeschränkten SQL-Abfrage
325
Es ist nicht zwingend notwendig, daß das Kommando ASC angegeben werden muß. Wird kein Parameter angegeben, wird die Liste immer aufwärts sortiert. Mit der folgenden Anweisung wird die Liste absteigend sortiert: SELECT Nummer, Titel FROM Musikstücke WHERE TT = 1 ORDER BY Nummer DESC
17.3.2
Abfragen über mehrere Tabellen
Alle bisher gemachten Abfragen beschränken sich immer nur auf eine Tabelle. Im allgemeinen reicht dies jedoch nicht aus, da man für eine informative Abfrage Daten aus verschiedenen Tabellen benötigt, um diese gegenüberstellen zu können. Um z.B. feststellen zu können, auf welchem Album welches Lied enthalten ist, müssen die beiden Tabellen Titel und Musikstücke miteinander verknüpft werden. Dies geschieht in der Where-Klausel. SELECT Titel.Titel, Nummer, Musikstücke.Titel FROM Musikstücke, Titel WHERE TT = Titel.ID
Abbildung 17.10: Das Ergebnis der verknüpften Abfrage
326
Bei diesem SQL-Statement muß auch darauf geachtet werden, daß die Tabellennamen eindeutig sind. Das Feld Titel kommt jeweils in der Tabelle Titel und Musikstücke vor. Aus diesem Grund muß der Tabellenname, getrennt mit einem Punkt, vor den Feldnamen gesetzt werden, um das jeweilige eindeutig zu identifizieren. Vor das Feld Nummer muß der Tabellenname nicht gesetzt werden, da dieses Feld nur in der Tabelle Musikrichtung vorkommt. Die From-Klausel mußte um den zweiten Tabellennamen erweitert werden, der getrennt durch ein Komma, an den ersten Tabellennamen angehängt wird. In der Where-Klausel wurde festgelegt, nach welchen Kriterien die beiden Tabellen miteinander verbunden werden. Da das Feld TT der Tabelle Musikrichtung die gleiche Bedeutung wie das Feld Id der Tabelle Titel hat, werden die Inhalte dieser beiden Tabellen durch den Operator „=“ miteinander verknüpft. Wie schon in einem Beispiel zuvor, sind die Daten unsortiert. Auch hier kann jetzt mit der Klausel Order by eine Sortierung durchgeführt werden. Die Datensätze sollen aber, anders als im ersten Beispiel, nach mehreren Kriterien sortiert werden. Hierfür müssen beide Felder, durch ein Komma getrennt, hinter der Klausel angegeben werden. Das Feld, welches als erstes aufgeführt wird, wird auch als erstes Kriterium verwendet. Ergibt das erste Kriterium z.B. zwei Datensätze, deren Reihenfolge nicht eindeutig ist, so werden diese nach dem Feld der zweiten Bedingung ausgewertet. Das folgende Statement sortiert die Datensätze zuerst nach dem Namen des Datenträgers und danach die Reihenfolge der Lieder. SELECT Titel.Titel, Nummer, Musikstücke.Titel FROM Musikstücke, Titel WHERE TT = Titel.ID ORDER BY Titel.Titel, Nummer
Vertauschen Sie einmal die beiden Feldnamen der Klausel Order by, um zu beobachten, wie sich das Ergebnis verändert.
327
Abbildung 17.11: Sortierte Ausgabe der verknüpften Tabellen
Durch Erweitern der Where-Klausel kann das Ergebnis weiter eingeschränkt werden. Um das Ergebnis auf nur ein Album zu beschränken, muß eine zweite Bedingung eingeführt werden. Die zweite Bedingung wird jetzt nicht durch ein Komma von der ersten getrennt, sondern über den logischen Operator AND mit der ersten verknüpft. SELECT Titel.Titel, Nummer, Musikstücke.Titel FROM Musikstücke, Titel WHERE TT = Titel.ID AND Titel.ID = 2 ORDER BY Titel.Titel, Nummer
In dem zweiten Teil der Where-Klausel wird bestimmt, daß es sich um das Album mit der Id = 2 handeln muß.
17.3.3
Berechnungen mit SQL-Abfragen
Bei den bisherigen SQL-Anweisungen handelte es sich um reine Datenabfragen. Es lassen sich aber auch sogenannte Aggregatfunktionen einsetzen, mit denen Berechnungen aufgrund der Datenfelder durchgeführt werden können. Zu den wichtigsten Funktionen gehören:
328
MIN
Wichtige Aggregats-
MAX
funktionen
COUNT
AVG
Diese Funktionen sind natürlich nur sinnvoll, wenn Sie auf mehrere Datensätze angewendet werden, die mit der Klausel Group by zusammengefaßt wurden. Um die Funktionsweise der Aggregatfunktionen besser zu verstehen, soll eine SQL-Anweisung geschrieben werden, mit der sich ermitteln läßt, wie viele Lieder sich auf welchem Album befinden. SELECT Titel.Titel, COUNT(Musikstücke.Titel) FROM Musikstücke, Titel WHERE TT = Titel.ID GROUP BY Titel.TITEL ORDER BY Titel.Titel
Abbildung 17.12: Ergebnis der SQL-Abfrage mit Aggregatfunktion
Am Ergebnis dieser Abfrage fällt auf, daß der Name der ersten Spalte beibehalten wurde, jedoch ist der Name der zweiten Spalte ein vom System gewählter. Bei dieser simplen Abfrage fällt es natürlich nicht schwer herauszufinden, um welchen Wert es sich bei dieser Spalte handeln könnte. Bei komplexen Abfragen, mit mehreren Aggregatfunktionen wird es schwierig, die vom System vergebenen Spaltennamen richtig zuzuordnen. Aus diesem Grund kann ein Feldname mit AS umbenannt werden. Bei der nun folgenden Anweisung handelt es sich um die gleiche Anweisung wie zuvor, mit dem Unterschied, daß der Name des zweiten Feldes der Ergebnistabelle von uns festgelegt wird. SELECT Titel.Titel, COUNT(Musikstücke.Titel) AS Anzahl FROM Musikstücke, Titel WHERE TT = Titel.ID GROUP BY Titel.Titel ORDER BY Titel.Titel
329
Durch Verwenden der eckigen Klammern „[]“ bei den Zielnamen können auch komplexere Namen, wie z.B. [Anzahl Lieder auf einem Album]
vergeben werden.
17.3.4
Abfragen zum Manipulieren des Datenbestandes
Mit den bisherigen Abfragen wurden aus den existierenden Tabellen bestimmte Datensätze gelesen, ohne den Datenbestand dadurch zu verändern. Es existieren jedoch auch Abfragen, mit denen der Datenbestand manipuliert werden kann. Folgende Datenbestandsänderungen können durchgeführt werden:
Einfügeabfrage Einfügen neuer Zeilen in eine Tabelle
Aktualisierungsabfrage Ändern von Werten in Zellen einer Tabelle
Löschabfrage Löschen von Tabellenzeilen
Für jede dieser Abfragen steht wiederum ein eigenes SQL-Kommando zur Verfügung. Einfügen von Datensätzen (Insert) Für das Einfügen von Tabellenzeilen steht die Anweisung Insert zur Verfügung. Der Aufbau dieser Anweisung lautet wie folgt: INSERT INTO Tabellenname [(Spaltei [, Spaltej ...])] quelle
Die Elemente in den eckigen Klammern sind nicht zwingend notwendig. Diese Parameter sind die Namen der Spalten, in die die angegebenen Daten eingefügt werden sollen. Sie werden als Zielspalten bezeichnet. Werden keine Zielspalten angegeben, so wird davon ausgegangen, daß in jede Spalte der Tabelle Werte eingefügt werden. Durch ihre Aufzählung wird bestimmt, in welche Spalten und in welcher Reihenfolge die Daten in die Tabelle eingefügt werden. Sind keine Spalten angegeben, wird die Reihenfolge von der Tabellendefinition übernommen.
330
INSERT INTO Titel (Interpret, Tontraeger, Titel) VALUES(3, 1, "Neuer Satz")
Mit dieser Anweisung wird ein neues Album in die Tabelle Titel eingefügt. Da es sich bei den Namen des Albums um eine Zeichenkette handelt, wird diese in Hochkommatas angegeben. Es können auch Datensätze eingefügt werden, die über Abfragen aus einer beliebigen Tabelle selektiert worden sind. Hierfür wird dann der Bereich Values durch eine Select-Anweisung ersetzt. INSERT INTO Titel (Interpret, Tontraeger, Titel) SELECT Interpret, Tontraeger, Titel FROM Titel WHERE Titel.Id = 2
Diese Abfrage macht für den Datenbestand keinen großen Sinn, jedoch zeigt sie sehr schön den Aufbau einer Insert-Abfrage, die mit dem Ergebnis einer Select-Abfrage gefüllt wird. Löschen von Datensätzen (Delete) Die Löschabfrage ist vom Aufbau her der Select-Abfrage ähnlich. Da sie aber immer Auswirkung auf die gesamte Datenzeile einer Tabelle hat, werden keine bestimmten Felder hinter der Anweisung aufgeführt Statt dessen folgt gleich die Anweisung From, die den Namen der Tabelle angibt, von der die Datensätze gelöscht werden sollen. Um nicht alle Datensätze der Tabelle zu löschen, müssen, wie auch bei der Select-Anweisung, die Kriterien für die zu löschenden Datensätze mit der Klausel Where festgelegt werden. Mit der folgenden Anweisung wird der zuletzt erzeugte Datensatz wieder gelöscht. Achten Sie aber darauf, daß dieser Wert der Id aus der Where-Klausel in Ihrer Datenbank ein anderer sein kann, als der in der unteren Anweisung verwendete. Bitte wählen Sie hier den Wert, den das System für Ihren letzten Eintrag gewählt hat.
331
DELETE FROM Titel WHERE Id = 7
Ändern von Feldern (Update) Mit der Anweisung Update werden Daten in der Tabelle verändert. Im Gegensatz zu den beiden zuvor behandelten Anweisungen Insert und Delete, die immer eine gesamte Zeile ansprechen, können mit der Anweisung Update bestimmte Spalten einer Zeile verändert werden. Um z.B. den Titel des Albums mit dem Wert Id = 3 zu verändern, wird die folgende Anweisung verwendet: UPDATE Titel SET Titel = „Neuer Titel“ WHERE Id = 3
An dieser Stelle möchte ich noch einmal darauf hinweisen, daß die SQL-Sprache weitaus komplexer ist, als in diesem Buch beschrieben. Dies ist wirklich nur ein minimaler Ausschnitt dessen, was diese Sprache leistet. Falls Sie sich verstärkt mit SQL beschäftigen müssen, dann empfehle ich Ihnen das Buch: SQL - Der Standard von Chris J. Date und Hugh Darwen ISBN: 3-8273-1345-7 (Verlag Addison-Wesley)
17.4
Datenbankprogrammierung
In diesem Abschnitt soll behandelt werden, wie man von einem Visual Basic-Programm auf die Datenbank Musikverwaltung zugreifen kann. Wie schon im Abschnitt „Arbeiten mit den SQL-Kommandos“ erwähnt, kann dieses Buch nur eine sehr kleine Auswahl über die Möglichkeiten darstellen, die es für einen Datenbankzugriff gibt. Ich werde hier auf nur zwei Möglichkeiten eingehen, wobei beide die DAO-Bibliothek verwenden. Es existieren jedoch weitaus mehr Schnittstellen (z.B. ODBC, ...). Bei der Auswahl der verschiedenen Möglichkeiten für den Datenbankzugriff kann man davon ausgehen: Je geringer der Aufwand zum Programmieren ist, um so unflexibler ist die Möglichkeit, das Programm (in bezug auf Geschwindigkeit, Ressourcenverbrauch, Anzahl der Verbindungen, ...) zu optimieren.
332
17.4.1
DAO-Bibliothek
Bei der DAO-Bibliothek handelt es sich um eine Sammlung von Objekten, Methoden und Eigenschaften, die den Zugriff auf die JET-Datenbank ermöglicht. Der Vorteil von diesem Objektmodell besteht darin, daß es nicht nur unter Visual Basic zur Verfügung steht, sondern daß auch alle anderen Office-Komponenten dieses Modell unterstützen. Die DAO-Bibliothek kann auf zwei unterschiedliche Arten eingesetzt werden. Zum einen kann sie mit datengebundenen Steuerelementen und zum anderen auch isoliert verwendet werden. Im zweiten Fall muß man sich selber um die Anzeige und die Datenänderung kümmern. Dies ermöglicht zwar eine exaktere Kontrolle der Daten, ist aber deutlich aufwendiger zu realisieren. Die DAO-Bibliothek ist in erster Linie für den Zugriff auf JET-Datenbanken optimiert und eignet sich daher auch besonders gut für den Zugriff auf Access-Datenbanken.
17.4.2
Datengebundene Steuerelemente
Das Steuerelement Data
Abbildung 17.13: Das Steuerelement Data
In Visual Basic sind die meisten Steuerelemente in der Lage, die Inhalte einer Datenbank darzustellen. Hierfür muß mit dem Steuerelement Data eine Verbindung zur Datenbank erzeugt werden. Zuvor sollte das Element jedoch einen Namen erhalten. Als Kennung für dieses Steuerelement gelten die Buchstaben dbs, woraus sich der Name dbsAlbum ergibt. Um die Verbindung zu einer Datenbank herzustellen, müssen zwei grundsätzliche Eigenschaften des Steuerelementes eingestellt werden. Zum einen ist es die Eigenschaft Connect. Damit wird schon eine Liste von Datenbanken bereitgestellt, auf die mit Visual Basic direkt zugegriffen werden kann. Diese Eigenschaft kann editiert werden, um die Liste der Datenbanken nach eigenen Wünschen zu erweitern. Für den Zugriff auf eine Access-Datenbank muß hier also der Eintrag Access ausgewählt werden.
333
Mit der zweiten wichtigen Eigenschaft DatabaseName wird der Name der Datenbank festgelegt. Wenn Sie mit der Maus auf die Schaltfläche klicken, die beim Aktivieren der Eigenschaft angezeigt wird, erscheint der Dialog (Abbildung 17.14) zum Auswählen einer Datenbankdatei.
Abbildung 17.14: Dialog zum Auswählen der Datei, die die Datenbank enthält.
Die Verbindung zur Datenbank ist somit hergestellt. Es ist jedoch nicht klar, welche Daten der Datenbank dieses Steuerelement repräsentiert. In der Eigenschaft RecordSource kann eine Tabelle aus der Datenbank ausgewählt oder ein SQL-Statement eingegeben werden. Im zweiten Fall erscheint dann der Inhalt des Steuerelementes Data für die anderen Steuerelemente, die das Steuerelement Data verwenden, als eine eigene Tabelle. Als Beispiel wird hier das folgende SQL-Statement eingegeben: SELECT Titel FROM Titel
Darstellen eines Feldes Als nächstes wird ein Textelement auf das Formular aufgebracht. Das Textelement erhält den Namen txtAlbum. Jetzt muß eine Verbindung zwischen dem Textelement und dem Datenelement hergestellt werden. Hierfür wird in der Eigenschaft DataSource der Name des DatenSteuerelementes eingetragen, das die Daten enthält, die mit dem Textelement dargestellt werden sollen. In diesem Beispiel handelt es sich um das Datenelement dbsAlbum. In der Eigenschaft DataField kann ein Feld ausgewählt werden, das in der „Tabelle“ des Daten-Steuerelementes vorkommt. Das Steuerelement dbsAlbum enthält das Feld Titel.
334
Wird das Programm jetzt gestartet, so erscheint in dem Textelement der Titel des Albums des ersten Datensatzes. Mit Hilfe der Bildlaufleisten des Daten-Steuerelementes kann in der Tabelle vorwärts und rückwärts geblättert und somit jeder Titel angezeigt werden. Es ist sogar noch mehr möglich. Da in das Textelement auch Eingaben gemacht werden dürfen, können die angezeigten Daten auch modifiziert werden. Jede Veränderung wird dann auch in der Datenbank gespeichert. Durch das Verwenden von mehreren Steuerelementen können somit ganze Datensätze angezeigt und verändert werden.
Modifizieren von Inhalten
Anzeigen von ganzen Listen Wenn aber nicht nur einzelnen Datensätzen gearbeitet werden soll, sondern ganze Listen angezeigt und verändert werden sollen, dann reichen die Standardsteuerelemente nicht mehr aus. Um den Programmieraufwand jedoch auch hierfür so gering wie möglich zu halten, werden drei weitere Steuerelemente zur Verfügung gestellt:
DBList
DBCombo
DBGrid
Für das folgende Beispiel kann das soeben erzeugte Projekt kopiert und das Steuerelement txtAlbum gelöscht werden. Danach muß die neue Komponente DBList hinzugefügt werden. Dies geschieht über das Menü PROJEKT |KOMPONENTEN. Danach muß der Eintrag MICROSOFT DATA BOUND LIST CONTROLS 6.0 ausgewählt werden. Jetzt kann das Element DBList auf dem Formular positioniert werden. Das Steuerelement erhält den Namen lstAlbum. Die Eigenschaften, die schon bei dem Textelement verwendet wurden, stehen hier ebenfalls zur Verfügung, jedoch werden sie für diese Beispiele nicht benötigt. Für die Funktionalität, für die die Steuerelemente verwendet werden, wird die Eigenschaft RowSource verwendet. Hier wird wieder das Steuerelement dbsAlbum ausgewählt. In der Eigenschaft ListField wird die Spalte ausgewählt, die in dem Listenelement dargestellt werden soll. In Abbildung 17.15 ist das Ergebnis des Beispielprogramms dargestellt.
335
Abbildung 17.15: Ergebnis des Beispielprogramms mit der ListBox
Listboxen werden im allgemeinen dort verwendet, wo der Inhalt von Tabellen oder Abfragen dargestellt, aber nicht verändert werden soll. Um nun Daten auch modifizieren zu können, wird das Steuerelement DBGrid verwendet. Hier lassen sich vollständige Tabellen anzeigen. Das Steuerelement DBGrid wird ebenfalls über das Menü PROJEKT|KOMPONENTEN. Danach muß der Eintrag MICROSOFT DATA BOUND GRID CONTROL ausgewählt werden. Auch für dieses Beispiel kann wieder das erste Beispielprogramm ohne Textelement verwendet werden. Da es sich aber bei dem Grid um ein Steuerelement handelt, mit dem gleichzeitig
mehrere Spalten und
mehrere Zeilen
dargestellt werden können, wird das SQL-Statement verändert. Das soll einige Felder aller Datensätze aus der Tabelle MUSIKSTÜCKE LADEN. SELECT TT, Nummer, Titel, Musikrichtung FROM Musikstücke ORDER BY TT, Nummer
Bei dem Grid muß jetzt nur eine Eigenschaft angepaßt werden, da die zweite Eigenschaft bei den bisher behandelten Steuerelementen immer eine Beschränkung auf die darzustellende Spalte war. Bei der Eigenschaft, die festgelegt werden muß, handelt es sich um DataSoure. Hier wird wieder das Datenelement dbsAlbum ausgewählt. Wenn das Programm jetzt gestartet wird, werden alle Datensätze und alle im Select-Statement angegebenen Felder dargestellt (Abbildung 17.16).
336
Abbildung 17.16: Ergebnis des Select-Statements in einem DBGrid
Es können nun zwar Datensätze verändert werden, aber es können keine hinzugefügt oder gelöscht werden. Das Steuerelement erlaubt diese Aktionen jedoch. Um auch die Möglichkeit zu haben, einen Datensatz zu löschen oder anzuhängen, müssen die beiden Eigenschaften
AllowAddNew und
AllowDelete
jeweils auf den Wert True gesetzt werden. Durch das Ändern der Eigenschaft AllowAddNew auf den Wert True wird eine weitere Zeile an die Liste im Grid angehängt. Sie enthält keine Daten, denn sie dient zur Neuerfassung von Daten. Um einen weiteren Datensatz in der Tabelle einzugeben, setzen Sie die Einfügemarke auf das Feld TT des leeren Datensatzes. Geben Sie jetzt den Wert 3 ein. In dem Moment, in dem der Feldwert akzeptiert wurde, wird ein neuer leerer Datensatz angehängt. Es wurde also ein neuer Titel erfaßt. Um das Beispiel abzuschließen, füllen Sie die restlichen Spalten mit den folgenden Werten: Numer = 6 Titel = "Mein neu erfasster Titel" Musikrichtung = 2
Die Eingabe eines neuen Datensatzes ist nun abgeschlossen. Wenn das Programm jetzt beendet und danach neu gestartet wird, ist der neu erfaßte Datensatz im Datenbestand integriert und wird an der richtigen Position angezeigt.
337
Datensatzanzeige aktualisieren
Um nach dem Erfassen eines Datensatzes nicht jedesmal das Programm beenden zu müssen, wird ein weiteres Steuerelement benötigt: eine Schaltfläche. Wird sie betätigt, dann wird eine Methode des Datenelementes dbsAlbum ausgeführt, um den Inhalt des Grids zu aktualisieren. Die folgenden Eigenschaften werden bei der Schaltfläche festgelegt: Name = btnRefresh Caption = "Refresh"
Die Methode zum Aktualisieren der Daten lautet Refresh. Der folgende Programmcode führt die Aktualisierung des Grids durch. Private Sub btnRefresh_Click() dbsAlbum.Refresh End Sub
Nach Betätigen der Schaltfläche BTNREFRESH wird nun der Inhalt der Abfrage neu ermittelt und im Grid angezeigt. Um einen Datensatz zu löschen, müssen alle Felder einer Zeile selektiert werden. Durch Betätigen der Taste (Entf) wird der Datensatz aus der Tabelle und aus der Anzeige entfernt. Hier muß keine Aktualisierung der Datenbankabfrage durchgeführt werden, da sich die Sortierreihenfolge nicht verändert hat. Nachteile der gebundenen Steuerelemente So, wie die Daten bisher angezeigt wurden, sind sie für einen Anwender nicht sehr übersichtlich. Aus diesem Grund soll das SQL-Statement so erweitert werden, daß der Inhalt der Feldern die nur Zahlen enthalten, mit sprechenden Texten ersetzt wird. Das folgende Statement erzeugt den neuen Datenbestand: SELECT Titel.Titel, Nummer, Musikstücke.Titel As Lied, Stil FROM Titel, Musikstücke, Musikrichtung WHERE Titel.Id = Musikstücke.TT AND Musikstücke.Musikrichtung = Musikrichtung.Id ORDER BY TT, Nummer
Das Ergebnis (Abbildung 17.17), das in dem Steuerelement grdTitel ausgegeben wird, ist jetzt sehr viel verständlicher.
338
Abbildung 17.17: Vollständige Darstellung der Daten im DBGrid
Der Nachteil, den man durch diese Darstellung in Kauf nehmen muß, ist, daß keine Datensätze mehr
verändert,
gelöscht oder
angehängt
werden können. Wie Sie sehen, ist man sehr schnell an die Grenze der Leistungsfähigkeit dieser Steuerelemente gestoßen. Im nächsten Abschnitt wird die Methode des Datenbankzugriffs beschrieben, bei dem die gesamte Verwaltung programmiert werden muß.
17.4.3
Der Datenzugriff im Programmcode
Um den Datenzugriff aus dem Programmcode zu realisieren, muß als erstes das DAO-Objekt eingebunden werden. Dies geschieht über das Menü PROJEKT|VERWEISE. Aus der Liste des aktiven Fensters wählen Sie den Eintrag MICROSOFT DAO 3.51 OBJECT LIBRARY. Nach Bestätigen mit der Taste Ok steht das DAO-Objekt zur Verfügung.
Einbinden des DAO-Objektes
Das Objekt DBEngine Das oberste Objekt in der DAO-Hierarchie ist das Objekt DBEngine. Es ist Defaultobjekt und muß deshalb in Programmcode nicht explizit gegeben werden. Die beiden wichtigsten Methoden sind
CompactDatabase und
RepairDatabase
339
Die Methode CompactDatabase Im allgemeinen sind die JET-Datenbanken größer als ihr eigentlicher Platzbedarf, den sie aufgrund der enthaltenen Daten haben sollten. Dies kommt daher, daß in den Datenbanken darauf verzichtet wird, gelöschte Datensätze tatsächlich auch zu löschen. Der Datensatz wird nicht entfernt, sondern erhält nur eine Markierung, daß er gelöscht ist. Der Grund hierfür ist, die Geschwindigkeitssteigerung die man mit diesem Verfahren erhält. Jedoch behält die Datenbank nicht nur ihren Speicher, wenn ein Datensatz gelöscht wird, sondern sie kann sich auch vergrößern, wenn Änderungen an Datensätzen durchgeführt werden, die zu Änderungen in den Indizes führen. Um eine Datenbank, die in Gebrauch war, wieder auf ihre optimale Größe zu komprimieren, stellt das Objekt DBEngine die Methode CompactDatabase zur Verfügung. Achtung: Beim Verwenden dieser Methode darf die Datenbank nicht benutzt werden. Außerdem muß geprüft werden, ob auf der Festplatte genug freier Platz vorhanden ist, um die alte und die neue Datenbankdatei speichern zu können, denn mit der Methode wird eine optimierte Kopie der alten Datenbank erzeugt. Natürlich kann die alte Datenbank gelöscht werden, wenn der Vorgang erfolgreich abgeschlossen wurde. Bei großen Datenbanken kann das Komprimieren mehrere Minuten in Anspruch nehmen. Der folgende Programmcode komprimiert die Musikdatenbank. Wenn der Vorgang erfolgreich abgeschlossen wurde, wird die alte Datenbankdatei mit dem Befehl Kill gelöscht und danach mit dem Befehl Name umbenannt. Public Sub Compress(Quelle As String) On Error GoTo Err_Compress Compactdatabase Quelle, Quelle + "new" Kill Quelle Name Quelle + "new" As Quelle Exit Sub Err_Compress: Call MsgBox("Datenbank konnte nicht komprimiert werden" & _ Chr(13) & Err.Description, vbOKOnly, & _ "Fehler", Err.HelpFile, Err.HelpContext) Exit Sub End Sub
340
Konnte die Datenbank nicht erfolgreich komprimiert werden, wird eine Fehlermeldung ausgegeben. Wenn Sie das Beispielprogramm auf der Diskette ausführen, achten Sie darauf, in welchem Verzeichnis die Datenbank liegt. Voraussichtlich müssen Sie das Verzeichnis anpassen. Dies geschieht im Programmcode durch Doppelklicken auf die Schaltfläche COMPRESS. Die Arbeitsumgebung Workspace Das Objekt Workspace wird dazu verwendet, eine oder mehrere Datenbanken gleichzeitig zu öffnen und zu verwalten. Das Objekt Workspace(0), das automatisch erzeugt wird, gilt auch als Defaultobjekt. Natürlich lassen sich auch mehrere Workspace-Objekte öffnen, um z.B. zwei unabhängige Sitzungen in einer Datenbank zu erhalten. Hiermit würde man gegenüber der Datenbank simulieren, daß zwei unterschiedliche Programme oder zwei Anwender auf die Datenbank zugreifen. In den folgenden Beispielen werden die wichtigsten Workspace-Methoden
CreateDatabase: Erzeugt eine neue Datenbank
OpenDatabase: Öffnet eine bestehende Datenbank
BeginTrans: Definiert den Anfang einer Transaktion
CommitTrans: Läßt die Datenbank die Transaktion ausführen
RollBack: Stellt den Datenbankzustand zum Zeitpunkt von BeginTrans wieder her.
behandelt und vorgestellt. Zuvor muß aber noch das Objekt Database beschrieben werden. Die Datenbank Database Für den Zugriff auf eine bestehende Datenbank wird im Regelfall das Objekt Database verwendet. Um eine bestehende Datenbank zu öffnen, wird die Funktion OpenDatabase wie folgt verwendet: Set Database = OpenDatabase(Filename [, Exclusive] [, Readonly] [, Connect])
341
Parameter
Beschreibung
Database
Das Ergebnis dieser Methode repräsentiert die geöffnete Datenbank.
Filename
Hier wird der Dateiname der zu öffnenden Datenbank angegeben.
Exclusive
Mit Exclusive kann festgelegt werden, daß die Datenbank nur von dem aktuellen Programm verwendet werden darf. Voreingestellt ist hier der Wert false. Der Vorteil für das exklusive Öffnen einer Datenbank ist, daß der Zugriff auf die Daten sehr viel schneller erfolgt.
Readonly
Wird auf eine Datenbank nur zum Lesen zugegriffen, dann sollte dieser Parameter auf True gesetzt werden, da die Leseoperationen dann besser unterstützt werden und somit auch schneller sind.
Connect
Hier können zusätzliche Verbindungsoptionen angegeben werden. Muß z.B. ein Paßwort oder eine Benutzerkennung eingegeben werden, so kann dies hier als Parameter übergeben werden.
0 Tabelle 1.2: Die Parameter der Funktion OpenDatabase
Das Objekt Database ermöglicht jetzt den Zugang zu allen weiteren Objekten der Datenbank. Wir werden uns aber nur auf die Methode OpenRecordset zum Erzeugen einer Datensatzliste auf der Basis einer Tabelle beschränken. Hierfür wird dann noch das Objekt Recordset benötigt. Das Objekt Recordset Mit dem Recordset-Objekt wird auf die Datensätze einer Tabelle oder einer Abfrage zugegriffen. Erzeugt wird das Objekt über die Methode OpenRecordset von dem Objekt Database. Das Erzeugen eines Recordset-Objektes geschieht mit dem folgenden Aufruf: Set Recordset = Database.OpenRecordset(Anweisung [, Typ] [, Optionen] [, Zugriff])
342
Parameter
Beschreibung
Recordset
Das Ergebnis der Methode repräsentiert die Datensätze aus einer Tabelle oder einer Abfrage der Datenbank.
Database
Das Objekt, welches auf die geöffnete Datenbank verweist, aus denen die Datensätze geladen werden sollen.
Anweisung
Hier wird die Quelle eingetragen, aus der die Datensätze ermittelt werden. Dabei kann es sich um eine SQL-Anweisung, eine Tabelle oder um eine Abfrage handeln.
Parameter
Beschreibung
Typ
Mit dem Typ wird festgelegt, um welche Art von Recordset es sich handelt. Es gibt fünf verschiedene Arten, jedoch wird in diesen Beispielen nur der Typ dbOpenDynaset verwendet, da mit ihm alle benötigten Funktionen realisiert werden können.
Optionen
Hierbei werden die verschiedenen Optionen für den Recordset eingestellt. Es können 11 Parameter miteinander verknüpft werden und so das Arbeiten mit dem Recordset beeinflussen. Für die Beispiele in diesem Buch sind auch diese Parameter nur von geringer Bedeutung.
Zugriff
Hierbei wird festgelegt, wie auf die Daten des Recordsets zugegriffen werden darf. Hier kann z.B. die Beschränkung festgelegt werden, daß die Datensätze nicht verändert (dbReadOnly) werden dürfen.
Tabelle 17.2: Die Parameter der Methode OpenRecordset
17.4.4
Beispiele zum Datenbankzugriff
An dieser Stelle sind alle Objekte, die für den Zugriff auf eine Datenbank nötig sind, besprochen worden. Um die Komplexität der zweiten Methode gegenüber dem Arbeiten mit den datengebundenen Steuerelementen zu zeigen, werden die drei Beispiele
Darstellen eines Datensatzfeldes in einem Textelement,
Füllen eines Listenelementes
und Darstellen von Daten in einem Grid
nochmals entwickelt. Füllen eines Listenelementes Als erstes wird jedoch nicht das Beispiel zum Anzeigen der Daten in einem Textelement, sondern das Füllen eines Listenelementes realisiert. Erzeugen Sie hierfür ein neues Projekt und positionieren Sie ein Listenelement mit Namen LSTALBUM und eine Schaltfläche mit Namen btnFuellen auf das Formular. Als nächstes muß der Verweis Microsoft DAO 3.51 Object Library. über das Menü PROJEKT|VERWEISE. Durch Betätigen der Schaltfläche BTNFUELLEN wird die Verbindung zur Datenbank hergestellt und das Listenelement gefüllt. Für das Füllen des Listenelementes wird die Funktion FillListbox entwickelt.
343
Public Function FillListbox(Liste As Object) Dim myDB As Database Dim myRec As Recordset On Error GoTo Err_FillListbox 'Den gesamten Inhalt des Listenelementes löschen Liste.Clear 'Datenbank öffnen Set myDB = OpenDatabase("d:\datenbank\musikverwaltung.mdb") 'Daten aus der Datenbank lesen Set myRec = myDB.OpenRecordset("Select Titel from Titel") 'Wenn Daten aus der Datenbank gelesen werden konnten If Not (myRec Is Nothing) Then 'Solange nicht alle Daten gelesen wurden While Not myRec.EOF 'Füge das aktuelle Datenelement in die Liste ein Liste.AddItem myRec.Fields(0) & "" 'Setze den Zeiger auf den nächsten Datensatz myRec.MoveNext Wend End If 'Datenbank wieder schliessen myDB.Close 'Arbeitsbereich wieder freigeben Exit Function Err_FillListbox: Call MsgBox("Fehler beim Füllen der Datenbank aufgetreten." _ & Chr(13) & _ Err.Description, vbOKOnly, "Fehler", Err.HelpFile, Err.HelpContext) Exit Function End Function
In diesem Beispiel braucht kein Objekt vom Typ Workspace definiert zu werden, da der Default Workspace verwendet wird. Das Füllen des Listenelementes geschieht in einer While-Schleife. Zuerst wird geprüft, ob noch ein Datensatz existiert oder ob das Ende des Datensatzergebnisses erreicht wurde. Danach wird der Inhalt aus dem ersten Feld des aktuellen Datensatzes in das Listenelement eingefügt. Der Zugriff auf das Datensatzelement erfolgt in diesem Fall über den Index, er kann aber auch über die Angabe des Feldnamens erfolgen. Liste.AddItem myRec.Fields![Titel] & ""
344
Der leere String wird immer angehängt, damit kein Fehler auftritt. Sind keine Daten in dem Feld enthalten, enthält es den Wert NULL. Durch Anhängen der leeren Zeichenkette wird dieser Nullwert dann in einen String umgewandelt. Jetzt ist der Datensatz bearbeitet worden, und mit der Anweisung MoveNext wird der nächste Datensatz aktiviert. Außer MoveNext werden noch die folgenden Methoden eines Objektes vom Typ Recordset unterstützt:
MoveFirst: Springt auf den ersten Datensatz in dem aktuellen Objekt.
MovePrevious: Springt auf den Datensatz vor dem aktuellen Objekt.
MoveNext: Springt auf den nächsten Datensatz in dem aktuellen Objekt.
MoveLast: Springt auf den ersten Datensatz in dem aktuellen Objekt.
FindFirst : Springt auf den ersten Datensatz, der das Kriterium erfüllt.
Wichtige Eigenschaften des Recordset-Objektes
MyRec.FindFirst "Titel = Live CD2"
Ändern von Feldern in Datensätzen In diesem Beispiel soll wieder ein Textelement (txtAlbum) mit dem Feldinhalt eines Datensatzes gefüllt werden. Wird aber in dem Beschriftungselement eine Änderung gemacht, soll die Änderung auch auf der Datenbank durchgeführt werden. Um zwischen den Datensätzen zu wechseln, wird eine Bildlaufleiste verwendet (hscAlbum). Dim myDB As Database Dim myRec As Recordset Dim myCounter As Long Private Sub Form_Load() On Error GoTo Err_Form_Load 'Verbindung zu DB herstellen Set myDB = OpenDatabase("d:\datenbank\musikverwaltung.mdb") 'Daten aus Tabelle lesen Set myRec = myDB.OpenRecordset("select * from Titel") 'Wenn die Tabelle Daten enthalten hat If Not (myRec Is Nothing) Then 'Inhalt des ersten Datensatzes in Tabelle schreiben txtAlbum.Text = myRec![Titel] 'Springe auf den letzten Datensatz myRec.MoveLast 'den oberen Bereich der Bildlaufleiste festlegen
345
hscAlbum.Max = myRec.RecordCount 'den unteren Bereich der Bildlaufleiste festlegen hscAlbum.Min = 1 'Springe auf den ersten Datensatz myRec.MoveFirst 'Zeiger auf aktuellen Datensatz myCounter = 1 End If Exit Sub Err_Form_Load: Call MsgBox("Fehler beim Füllen der Datenbank aufgetreten." & _ Chr(13) & Err.Description, vbOKOnly, "Fehler", _ Err.HelpFile, Err.HelpContext) End End Sub Private Sub hscAlbum_Change() 'Wenn mindestens ein Datensatz existiert If myCounter > 0 Then 'Bereite den aktuellen zum ändern vor myRec.Edit 'Weise dem Datenfeld den neuen Wert zu myRec![Titel] = txtAlbum.Text 'Aktualisiere die Datenbank myRec.Update 'Wenn der nächste Datensatz angezeigt werden soll If hscAlbum.Value > myCounter Then myRec.MoveNext myCounter = myCounter + 1 txtAlbum.Text = myRec![Titel] 'Wenn der vorhergehende Datensatz angezeigt werden soll ElseIf hscAlbum.Value < myCounter Then myRec.MovePrevious myCounter = myCounter - 1 txtAlbum.Text = myRec![Titel] End If End If End Sub
Beim Laden des Formulares muß die Bildlaufleiste initialisiert werden. Aus diesem Grund wird die Anzahl der ausgelesenen Datensätze mit der Funktion RecordCount ausgelesen. Damit diese Funktion aber einen richtigen Wert liefert, muß der Datensatzzeiger zuerst auf den letzten Datensatz bewegt werden. Wird das nicht gemacht, dann liefert die Funktion ein falsches Ergebnis. In diesem konkreten Fall liefert die Funktion den Wert 1.
346
Nachdem die Bildlaufleiste mit der Anzahl der Datensätze initialisiert wurde, kann der Datensatzzeiger wieder auf den ersten Datensatz bewegt werden. Im Ereignis Click der Bildlaufleiste wird dann die eigentliche Datenaktualisierung durchgeführt. Mit der Methode Edit des Objektes RecordSet wird die Aktualisierung vorbereitet. Jetzt werden die Daten für alle anderen Anwender gesperrt. Nach dem Verändern der Daten werden sie mit der Methode Update in die Datenbank geschrieben, und die Sperrung der Daten wird aufgehoben. Darstellen eines Recordsets in einem Grid In dem letzten Beispiel zum Arbeiten mit Datenbanken sollen die Daten in einem Grid (grdRecord) dargestellt werden. Hierfür werden zuerst die Daten mittels eines Select-Statements gelesen und danach so in das Grid gefüllt, daß jedes Datenelement jeweils einem Feld in dem Grid zugewiesen wird. Dieses Laden erfolgt beim Initialisieren des Formulares (frmGrid).
Füllen des Grids
Option Explicit Dim myDB As Database Dim myRec As Recordset Private Sub Form_Load() On Error GoTo Err_Form_Load Dim i As Integer Dim Zeile As Integer 'Verbindung zu DB herstellen Set myDB = OpenDatabase("d:\datenbank\musikverwaltung.mdb") 'Daten aus Tabelle lesen Set myRec = myDB.OpenRecordset("select Id, Nummer, Titel " &_ "from Musikstücke") 'Wenn die Tabelle Daten enthalten hat If Not (myRec Is Nothing) Then grdRecord.Cols = myRec.Fields.Count myRec.MoveLast grdRecord.Rows = myRec.RecordCount + 1 myRec.MoveFirst Zeile = 0 grdRecord.Row = Zeile 'Titelfelder des Grids beschriften For i = 1 To myRec.Fields.Count grdRecord.Col = i - 1 grdRecord.Text = myRec.Fields(i - 1).Name & "" Next
347
'Schreibe alle Datensätze ins Grid While Not myRec.EOF 'Inhalt des Datensatzes in Tabelle schreiben Zeile = Zeile + 1 For i = 1 To myRec.Fields.Count grdRecord.TextMatrix(Zeile, i - 1) = _ myRec.Fields(i - 1) & "" Next myRec.MoveNext Wend End If Exit Sub Err_Form_Load: Call MsgBox("Fehler beim Lesen der Datenbank aufgetreten" & _ Chr(13) & Err.Description, vbOKOnly, "Fehler", _ Err.HelpFile, Err.HelpContext) End End Sub
Das Grid wird jetzt mit allen Feldern und Spalten des Recordsets gefüllt, jedoch können die Spaltenbreiten nicht an den Inhalt vom Anwender angepaßt werden. Modifizieren des Zellinhaltes eines Grids
Hierfür muß der Eigenschaft AllowUserResizing der Wert flexResizeRows zugewiesen werden. Im nächsten Schritt muß die Eingabe in das Steuerelement ermöglicht werden. Hierfür müssen die beiden Ereignisse KeyDown und KeyPress mit folgendem Programmcode modifiziert werden: Private Sub grdRecord_KeyDown(KeyCode As Integer, Shift As Integer) Select Case KeyCode Case vbKeyDelete grdRecord.Text = "" End Select End Sub Private Sub grdRecord_KeyPress(KeyAscii As Integer) Select Case KeyAscii Case 8 'Backspace If Len(grdRecord.Text) > 0 Then grdRecord.Text = Left(grdRecord.Text, _ Len(grdRecord.Text) - 1) End If Case Is > 31 grdRecord.Text = grdRecord.Text & Chr$(KeyAscii) End Select End Sub
348
Natürlich kann die Funktionalität, die durch das Betätigen der Taste ausgeführt wird, beliebig erweitert werden. Z.B. kann das Kopieren von Daten aus Zellen in die Zwischenablage und umgekehrt noch realisiert werden. Wir wollen uns nun aber weiter auf das Modifizieren der Daten beschränken. Hierfür wird eine Schaltfläche (BTNSAVE) eingeführt, mit der die Daten aus dem Grid in die Datenbank gesichert werden, und eine zweite Schaltfläche (BTNRESUME), um die Änderungen nach dem letzten Speichern wieder rückgängig machen zu können.
Speichern der modifizierten Daten
Private Sub btnSave_Click() Dim i As Integer Dim Zeile As Integer myRec.MoveFirst For Zeile = 1 To grdRecord.Rows - 1 myRec.Edit For i = 1 To grdRecord.Cols - 1 myRec.Fields(i) = grdRecord.TextMatrix(Zeile, i) Next i myRec.Update myRec.MoveNext Next Zeile End Sub
Der Programmcode, der entwickelt werden muß, um den Inhalt eines Recordsets in einem Grid darzustellen, ist ein Vielfaches größer, als wenn ein datengebundenes Grid verwendet wird. Der Vorteil dieser Programmierung ist jedoch, daß man die Daten vollständig im Programmcode kontrollieren und somit modifizieren kann. Wie ich eingangs schon mehrfach erwähnt habe, ist das Programmieren mit Datenbanken ein weitaus größeres Gebiet, als es in diesem Buch behandelt wurde. Dieser kleine Einstieg soll eine Grundlage bilden, auf der nun problemlos aufgebaut werden kann.
349
A
Anhang
Inhalt der Diskette
A.1
Verzeichnis
Beschreibung
Dateien
Ein Beispielprogramm für das Arbeiten mit Dateien.
Testdatei DragDrop Gesicht
Zwei sequentielle Dateien; für das Beispielprogramm. Verzeichnis mit zwei Programmen; für die Programmierung von Drag and Drop. Programm, in dem ein Gesicht auf einem anderen Steuerelement abgelegt wird und seinen Gesichtsausdruck ändert.
Bilder
Beinhaltet die Grafiken, die in diesem Beispielprogramm mit der Methode Drag and Drop verschoben werden.
Mülleimer
Aufwendigeres Drag and Drop-Beispiel, in dem unterschiedliche Reaktionen auf ein Steuerelement realisiert werden.
Bilder
Beinhaltet die Grafiken, die in diesem Beispielprogramm mit der Methode Drag and Drop verschoben werden.
Editor
Beispiel zur Programmierung mit mehreren Fenstern, die steuerelement-Übergreifend arbeiten.
Ereignisse
Verzeichnis mit Programmen, die auf Ereignisse reagieren.
Ereignis
Zwei unabhängige Ereignisse, die sich trotzdem blockieren.
MouseMove
Grundlage eines Mal-Programms. Feststellen der Mausposition und der betätigten Tasten.
Error
Programm zum Erstellen einer Tabelle mit allen Fehlermeldungen von Visual Basic.
Grafik
Verzeichnis mit Programmen; zur Grafikprogrammierung.
Fraktal
Berechnen und Zeichnen eines fraktalen Apfelmännchens.
RGB_Farben
Programm zur Darstellung und Berechnung der RGBFarben.
Menue
Ein Beispielmenü, das mit dem Visual Basic-Menüeditor erstellt wurde.
351
Verzeichnis
Beschreibung
Rechner
Das Beispielprogramm: Stackrechner.
Rekursion
Verzeichnis mit Beispielprogrammen für rekursive Berechnungen.
Fakultaet
Berechnung der Fakultät.
Fibonacci
Berechnung der Zahl Fibonacci.
Steuerelemente CheckBox
Das Kontrollkästchen.
ComboBox
Das Kombinationsfeld.
CommonDial
Die Standarddialoge: Datei öffnen/schließen, Farben, Schrift, Drucken.
ListBox
Das Listenfeld.
Listenfelder
Die Listenfelder: Laufwerk, Verzeichnis und Datei.
MDI
Arbeiten mit MDI-Fenstern.
Optionbutton
Das Optionsfeld.
PictureBox
Das Bildfeld-Steuerelement.
Register
Die Registerblätter.
ScrollBar
Die Bildlaufleisten.
Shape
Das Figuren-Steuerelement.
TextBox
Das Texteingabeelement.
Timer
Der Zeitgeber.
Tools
Verzeichnis mit nützlichen Tools und einem Logik-Spiel.
Dir_Groesse
Ermittlung des benötigten Speichers eines Verzeichnisses mit Unterverzeichnissen.
Master
Das Logikspiel MasterMind.
Bilder Random
352
Kurze Beispielprogramme zu den Steuerelementen.
Benötigte Bilder für Drag and Drop. Auflösen eines Gleichungssystems mit dem Zufallsgenerator.
Vorlage
Grundlagenprojekt für sehr viele Beispiele.
Zahl_123
Zahlenspiel. Jede beliebige Zahl endet in der Zahl 123.
A.2
Standardbefehle
Befehl
Beschreibung
Abs
Berechnet den Absolutwert einer Zahl.
AddItem
Datensatz zu einem Listenelement hinzufügen.
ChDir
Vergleichbar mit dem Befehl cd von DOS. Er wechselt das aktive Verzeichnis.
ChDrive
Wechselt das aktive Laufwerk.
Circle
Zeichnen eines Kreises oder einer Ellipse.
Clear
Den Inhalt eines Listenelements löschen.
Close
Eine geöffnete Datei schließen.
CurDir
Liefert als Ergebnis das aktive Verzeichnis eines Laufwerks zurück.
DoEvents
Gibt die Steuerung an das Windows-Betriebssystem ab, damit andere aufgetretene Ereignisse verarbeitet werden können.
Dir
Vergleichbar mit dem Befehl dir unter DOS. Er liefert als Ergebnis alle Dateien des Verzeichnisses zurück.
DrawMode
Legt das Aussehen von Zeichnungselementen fest (z.B. Linien).
DrawStyle
Legt das Aussehen der Linien für Zeichnungselemente fest.
DrawWidth
Legt die Stärke der Linie für Zeichnungselemente fest.
End
Beendet die Ausführung des Programms.
Error
Erzeugt einen Fehler im Programmcode.
FileLen
Ermittelt die Größe einer Datei.
Format
Umwandlungsfunktion. Formatiert einen Ausdruck in eine andere Darstellung um.
Get
Lesen aus einer Datei.
Input
Lesen aus einer Datei.
LCase
Wandelt Großbuchstaben eines Strings in Kleinbuchstaben um.
Left, Left$
Schneidet einen Ausdruck nach einer bestimmten Anzahl von Zeichen rechts ab.
Line
Zeichnet eine Linie auf ein Steuerelement oder ein Formular.
Load
Lädt ein Formular in den Hauptspeicher.
Lof
Ermittelt die Länge einer Datei.
Ltrim, Ltrim$
Entfernt alle Leerzeichen, die auf der linken Seite zu Beginn der Zeichenkette stehen.
Mid, Mid$
Schneidet einen Ausdruck nach einer bestimmten Anzahl von Zeichen links und rechts ab.
353
354
Befehl
Beschreibung
MkDir
Vergleichbar mit dem Befehl md unter DOS. Er erzeugt ein neues Verzeichnis.
On Error Goto
Fehlerbehandlungsroutine.
Open
Öffnet eine Datei zum Lesen oder Schreiben.
Preserve
Erweitert den bereitgestellten Speicher eines Feldes, ohne den Inhalt der Felder zu löschen.
Print
Ausgabe in eine Datei.
Put
Schreiben in eine Datei.
Randomize
Initialisiert den Zufallsgenerator.
RemoveItem
Datensatz eines Listenelements löschen.
Resume
Wiederaufnahme des Programmablaufs nach dem Auftreten eines Fehlers bei dem Befehl, der den Fehler ausgelöst hat.
Resume Next
Wiederaufnahme des Programmablaufs nach dem Auftreten eines Fehlers sowie Ignorieren des Befehls, der den Fehler ausgelöst hat.
Right, Right$
Schneidet einen Ausdruck nach einer bestimmten Anzahl von Zeichen links ab.
RmDir
Vergleichbar mit dem Befehl rd unter DOS. Entfernt ein leeres Verzeichnis.
Rnd
Liefert eine Zufallszahl.
Rtrim, Rtrim$
Entfernt alle Leerzeichen, die auf der linken Seite zu Beginn der Zeichenkette stehen.
Time, Time$
Liefert als Ergebnis die aktuelle Systemzeit zurück.
UCase
Wandelt Kleinbuchstaben eines Strings in Großbuchstaben um.
Unload
Entfernt ein Formular aus dem Hauptspeicher.
A.3
Glossar
Eintrag
Bedeutung
ASCII
American Standardcode for Information Interchange.
Betriebssystem
Enthält alle Programme, die die Ausführung der Benutzerprogramme und ihre Verwaltung auf Systemebene steuern.
Break-Point
Siehe Haltepunkt.
Bitmap
Grafikdatei-Format.
Carrige Return
Wagenrücklauf mit Zeilenvorschub.
Compiler
Übersetzer, der eine Programmiersprache in einen für den Prozessor verständlichen Maschinencode überträgt.
Desktop
Grafische Betriebssystemoberfläche.
Designzeit
Siehe Entwurfszeit.
Endlosschleife
Eine Programmschleife, deren Abbruchbedingung nie erfüllt wird.
Entwicklungsumgebung
Programm zum Erstellen und Verwalten von Applikationen.
Entwurfszeit
Zeit, in der das Programm entwickelt, in der also direkt am Programmcode gearbeitet wird.
FiFo
„First in, first out“: Der Listeninhalt, der als erster in eine Liste eingetragen wurde, wird als erster ausgelesen.
Abbildung A.1: Arbeitsweise einer FiFo-Liste Haltemodus
Modus zum Testen des Programms. Es können einzelne Werte der Ausdrücke angezeigt oder jeder Programmschritt einzeln ausgeführt werden.
Haltepunkt
Zeile im Programmcode, an welcher der Programmablauf unterbrochen wird.
Interpreter
Ein Interpreter erklärt dem Prozessor jeden einzelnen Befehl, d.h. das Programm wird nicht in den Maschinencode übersetzt (siehe Compiler), sondern nur Zeile für Zeile interpretiert.
355
Eintrag
Bedeutung
LiFo
„Last in first out“: Der Listeninhalt, der als letzter in die Liste eingetragen wurde, wird als erster ausgelesen. Der Stackspeicher eines Computers arbeitet nach diesem Prinzip.
Abbildung A.2: Arbeitsweise einer LiFo-Liste
356
Linefeed
Siehe Zeilenvorschub.
Metafile (auch erweiterte)
Ein Grafikdatei-Format.
Modal
Ist ein Fenster im Status modal, sind alle anderen Fenster des Programms zwar sichtbar, aber nicht mehr aktiv.
Programmlaufzeit
Phase, in der die entwickelte Applikation im Betriebssystem oder der Entwicklungsumgebung ausgeführt wird.
Prozessor
Kernstück eines Computers. Er bildet einen Teil der Zentraleinheit und arbeitet die einzelnen Prozesse ab.
Pseudocode
Sprache, um die Grundstrukturen der strukturierten Programmierung zu formulieren
Wagenrücklauf
Wenn bei einem mechanischen Drucker der Druckkopf wieder auf die Ausgangsposition gesetzt wird.
Zeilenvorschub
Modus, um bei einer Datenausgabe auf die nächste Zeile wechseln zu können.
Zwischenablage
Ein Speicherbereich, der für den Datenaustausch von Programmen zur Verfügung gestellt wird.
A.4
Von Visual Basic 5.0 verwendete Dateitypen
Dateiendung
Beschreibung
.bas
Basic-Moduldatei.
.cls
Klassen-Moduldatei.
.ctl
Benutzer-Steuerelementdatei.
.ctx
Binäre Benutzer-Steuerelementdatei.
.dca
Pufferdatei eines aktiven Designers.
.dep
Abhängigkeitsdatei des Installationsassistenten.
.dob
Benutzerdokument-Formulardatei.
.dox
Binäre Benutzerdokument-Formulardatei.
.dsr
Designerdatei.
.dsx
Binäre Designerdatei.
.frm
Formulardatei.
.frx
Binäre Formulardatei.
.log
Protokolldatei für Ladefehler.
.oca
Steuerelement-Klassenbibliothekspuffer.
.pag
Eigenschaftenseite-Datei.
.pgx
Binäre Eigenschaftenseite-Datei.
.res
Ressourcendatei.
.swt
Visual Basic-Installationsassistent-Vorlagendatei.
.tlb
Remote-Automatisierungs-Klassenbibliotheksdatei.
.vbg
Visual Basic-Gruppenprojektdatei.
.vbl
Benutzersteuerelement-Lizenzdatei.
.vbp
Visual Basic-Projekt.
.vbr
Remote-Automatisierungs-Registrierungsdatei.
.vbw
Visual Basic-Projektarbeitsbereich.
.vbz
Assistent-Startdatei.
357
A.5
Zeichentabellen
!
"
#
$ % &
'
(
)
*
+
, - .
/
0
1
2
3
4 5 6
7
8
9
:
;
< = >
?
@
A
B
C
D E F
G
H
I J K L M N
O
P
Q R S T U V
W
X
Y Z [ \ ] ^
_
d
e
f g h i j
` a b c
p
q
w
k l m n o
r s t u v x y z { |
}
~
a
¡ ¢
£
¤
¥ ¦ § ¨ © ª
«
Y
¬ ® ¯ ° ±
²
³
´ µ ¶ · ¸ ¹
º
»
¼ ½ ¾ ¿ À Á
Â
Ã
Ä Å Æ Ç È É
Ê
Ë
Ì Í Î Ï Ð Ñ
Ò
Tabelle A.1: Der DOS-Zeichensatz (in Schriftart Terminal)
358
!
"
# $ %
& '
(
)
*
+ ,
-
.
/
0 1
2
3 4 5
6
7
8 9
:
;
< =
>
?
@ A
B
C D E
F
G
H I
J
K L M
N O
P Q
R
S T U
V W
X Y
Z
[
\
`
b
c
d e
a
]
^
_
f
g
j
k
l
m n
o
p q r
s
t
u
v
w
x
y
z
{
|
}
~
‚
¶
„
… †
ˆ
‰ Š ‹
Œ
‘
’
“
”
–
—
˜
™ š
›
œ
Ÿ
¡
¢
£ ¤ ¥
¦
§
¨
© ª
« ¬ -
® ¯
°
± ²
³
¶
¸
¹
» ¼ ½ ¾ ¿
h i
º
´
•
µ
‡
·
À Á Â Ã Ä Å Æ
Ç È É Ê Ë Ì
Í
Î
Ï
Ð Ñ Ò Ó Ô Õ Ö x Ø Ù Ú Û Ü Ý Þ ß à á â
ã ä å
æ ç
è é ê
ë ì
í
î
ï
ð ñ ò
ó ô õ
ö
÷
ø ù ú
û ü ý
þ
Tabelle A.2: Der ANSI-Zeichensatz von Windows (in Schriftart Arial)
!
359
!
∀ #
∃ % & ∋
(
)
∗
+
,
−
.
/
0 1
2
3
4
5
6
7
8 9
:
;
< =
>
?
≅ Α Β Χ ∆ Ε Η Ι
ϑ
Φ Γ
Κ Λ Μ Ν Ο
Π Θ Ρ
Σ
Τ Υ ς
Ω
Ξ Ψ Ζ
[
∴ ]
⊥
_
α β
χ
δ
ε
φ
γ
η ι
ϕ
κ
λ µ
ν
ο
π θ
ρ
σ
τ
υ
ϖ ω
ξ ψ ζ
{
|
}
∼
ϒ ′
≤
⁄
∞ ƒ
♦ ♥ ♠ ↔ ← ↑ °
♣
→ ↓
± ″
≥
× ∝ ∂
÷ ≠ ≡
≈
…
•
↵
ℵ ℑ ℜ ℘ ⊗ ⊕ ∅
∩ ∪ ⊃ ⊇ ⊄ ⊂ ⊆ ∈ ∉ ∠ ∇ ∏ √ ¬ ∧ ∨
⇔ ⇐ ⇑
◊ 〈
∑
〉
∫
⌠ ⌡
Tabelle A.3: Die Sonderzeichentabelle mit der Schriftart „Symbol“
360
⋅
⇒ ⇓
! " )
# $ % & ' (
* + , - . /
0
1 2 3 4 5 6 7 8 9 : ; < = > ? @
A B C
D E F G H I J K L M N O P Q R S T
U V W X
Y Z [ \ ] ^ _
`
a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~
¡ ¢ £ ¤ ¥ ¦
§ ¨ © ª « ¬ ® ¯ ° ± ² ³ ´
µ
¶ · ¸ ¹ º » ¼ ½ ¾ ¿ c À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö
×
Ø Ù Ú Û
Tabelle A.4: Die Sonderzeichentabelle mit der Schriftart „WingDings“
!
361
✁ ✂ ✃ ✄ ☎ ✆ ✇
✈ ✉ ☛ ☞ ✌
✍ ✎ ✏
✐ ✑ ✒ ✓ ✔ ✕ ✖ ✗ ✘ ✙ ✚ ✛ ✜ ✝
✞
✟
✠ ✡ ✢ ✣ ✤ ✥ ✦ ✧ ★ ✩ ✪ ✫ ✬ ✭ ✮ ✯ ✰ ✱ ✲ ✳ ✴ ✵ ✶ ✷ ✸ ✹ ✺ ✻ ✼ ✽ ✾ ✿
❀ ❁ ❂
❃ ❄ ❅ ❆ ❇ ❈ ❉ ❊ ❋ ● ❍ ■ ❏ ❐ ❑ ❒ ▲ ▼ ◆ ❖ ◗ ❘
❙
❚
❛
❜
❝ ❞
❡ ❢
❣
❤ ❥ ❦ ❧
♣ ♦ ♥ ♠ ① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ⑩ ❶ ❷ ❸ ❹ ❺ ❻ ❼ ❽ ❾ ❿ ➀ ➁ ➂ ➃ ➄ ➅ ➆
➇ ➈ ➉ ➊ ➋ ➌ ➍ ➎ ➏ ➐ ➑ ➒ ➓ ➔ ✇ ↔ ↕ ➘ ➙ ➚ ➛ ➜ ➝ ➞ ➟ ➠ ➡ ➢ ➣ ➤ ➥ ➦ ➧ ➨ ➩ ➪ ➫ ➬ ➭ ➮ ➯
➱ ➲ ➳ ➴ ➵ ➶ ➷
➸ ➹ ➺ ➻ ➼ ➽ ➾ Tabelle A.5: Die Sonderzeichentabelle mit der Schriftart „Monotype Sorts“
362
S
Stichwortverzeichnis
Anzeigesteuerelement Appearance Applikation entwickeln
Befehle ChDir ChDrive Close CurDir EOF FileLen FreeFile Get GOTO Input Kill Line Line Input LoadFile Mid, Mid$ MkDir Name Open Print Put Resume RGB RmDir Rnd Write Befehler
MousePointer Befehlstabelle BeginTrans Beispieldatenbank
Berechnungen mit Zufallsgenerator
Algorithmus Gleichungen
Gleichungsystem Lösung Programmoberfläche Bildfeldsteuerelement eigene Zeichnungen Bildlaufleisten Breitensuche Button
CAB-Dateien Cancel Caption CheckBox Click ComboBox CommitTrans CommonDialog CompactDatabase Connect CreateDatabase
DAO-Bibliothek , DAO-Objekt Data DatabaseName
363
DataField DataSource RecordSource Datei Datei öffnen/speichern Eigenschaften Dateien Beispiel Ende formatieren Größe Kanalnummer laden lesen löschen öffnen schließen schreiben Tab Umbenennen Dateien siehe Datei Dateiendungen
Dateilistenfeld Datenbankabfragen Datenbankanbindung
Datenbankprogrammierung Datengebundene Steuerelemente Datenmodell
Datensätze Ändern Einfügen Löschen Datentypen selbstdefinierte umwandeln
DBCombo DBEngine DBGrid , AllowAddNew
DataSoure Refresh DblClick DBList ListField RowSource Debugger Destruktor Drag and Drop Drucken Eigenschaften
364
Edit
Eigenschaft Tag Text ToolTipText Visible Eigenschaften Appearance Caption TabIndex (Name) Ereignisse , Click DblClick GotFocus KeyDown KeyUp Load LostFocus MouseDown MouseMove MouseUp Err Error
Farben QBColor RGB RGB_Farbenbeispiel Farbpalette Eigenschaften Fehlerbehandlung
Err Error On Error Resume Vorgehensweise
Fehlercodetabelle erstellen Felder Benutzerdefinierter Indexbereich Dynamische Felder Eindimensional Feldinhalt löschen Indexbereich ermitteln Mehrdimensionale Felder ,
neu dimensionieren selbstdefinierte Datentypen statische Felder Fenster Anzeigen ausblenden Debugger Eigenschaftsfenster entladen Formularfenster Hauptfenster laden mehrere Programmcodefenster Programmfenster Projektfenster Property ToolBox Werkzeugfenster FiFo Figurensteuerelement FindFirst Fokus erhalten verlieren Form Formular Appearance AutoRedraw BackColor Caption General Hide Load MDIChild mehrere Name Show Tag ToolTipText Unload Frame Funktionen
Call-by-Reference Call-by-Value FUNCTION - END FUNCTION
GotFocus Goto Grafik Farben Farbwert berechnen Grundlagen zur Ausgabe Line Programmierung Grundlagen
HelpCompiler Installation Hilfe Begriffserklärungen Datei erstellen Datei schreiben Eigenschaften Grafiken einbinden Helpcompiler Helpcompiler HCW
HelpContext-ID Hilfeindex Hilfesequenzen Hilfesystem kontextsensitiv Querverweis Text formatieren Titel einführen Hilfesystem
Image Installation Visual Basic
Installation VisualBasic Benutzerdefiniert Standard Systermvoraussetzungen Installationsassistent
CAB-Optionen Dateien Installationsdatei generieren Installationsdisketten erstellen Installationstitel Menüeinträge Optionen Projekt festlegen
365
starten Startmenü Zielverzeichnis bestimmen Zielverzeichnisse zusätzliche Treiber
Jet-Datenbanken
KeyDown Klasse Datenelemente
Eigenschaften Elementfunktionen
erzeugen hinzufügen Methoden
Kombinationsfeld Konstanten Beispiele Konstruktor Kontrollkästchen Name Tag ToolTipText Value
Label Laufwerklistenfeld LiFo Linie Liniensteuerelement ListBox Listenfeld alle Einträge löschen ColCharacter Datensatz eintragen Datensatz löschen ListCount Listindex Name Tag Text ToolTipText Load LostFocus
366
MasterMind
Programmcode Programmoberfläche
Spielregeln
MDI Formular Caption MDIChild Name Tag Meldungen anzeigen
Menüdesigner Checked Enabled Shortcut Shortkey Visible Menüleiste Add-Ins Ansicht Ausführen Bearbeiten Datei Debuggen Extras Projekt Methoden Microsoft Rich TextBox Control 5.0. Mid, Mid$ MouseMove Beispiel MousePointer MoveFirst MoveLast MoveNext MovePrevious
Objekt Eigenschaften Objektorientierung ODBC On Error OpenDatabase Option Explicit OptionButton Optionsfeld
Caption Name Tag ToolTipText
PictureBox Programmbeispiele Bildfeldsteuerelement ,
das erste Kombinationsfeld Listenfeldsteuerelement Optionsschalter Stack-Taschenrechner Texteingabeelement Zahlenloch Programmentwicklung
aufrufen
Programmierung Ablaufgesteuert
Ereignisgesteuert Programmstrukturen Konstanten Variablen Projekte Aufbau
Prozeduren
Call-by-Reference Call-by-Value SUB - END SUB
QBColor
Rahmensteuerelement RecordCount Recordset Registerblättersteuerelement Caption CurrentTab Name TabCount TabsPerRow Tag Registrierdatenbank DeleteSetting GetAllSettings
GetSetting HKey_Classes_Root HKey_Current_Config HKey_Current_User HKey_Dyn_Data HKey_Lokal_Machine HKey_User SaveSetting Zugriff RepairDatabase Resume RGB RGB-Farbenbeispiel RollBack RTF-Steuerelement ,
SelBold
SelItalic
SelStrikethru
SelUnderline
RTF-Steuerelement siehe Microsoft Rich TextBox Control 5.0.
Schaltfläche Schleifen DO - Schleife FOR - Schleife WHILE - Schleife , Schriftart Eigenschaften ScrollBar Shape SQL Aktionsabfragen Dialekt VisData SQL-Abfragen Aggregatsfunktionen Aktualisierungsabfrage As ASC Berechnungen DESC Distinct Distinctrow Einfügeabfrage From Group by Having Löschabfrage
367
Order by Parameter Select selektieren sortieren Vergleichsoperatoren verknüpfte Tabellen Where SQLPassThrough SSTab Standard Query Language Standarddialogbefehle ShowColor , ShowFont
ShowHelp
ShowOpen
ShowPrinter
ShowSave
Standarddialoge ,
Datei öffnen/speichern
Drucken Hilfe Schriftart Standardsteuerelemente hinzufügen Statusleiste Steuerelemente aufbringen Steuerelementfarben Systemvoraussetzungen
Tag TextBox Texteingabeelement , Textelement Alignment Border Style Caption Tiefensuche Timer Tools ,
MasterMind
Verzeichnisgröße
Update
368
Variablen Variablendeklaration Deklarationsbeispiel Kurzschreibweise Variant Variablentypen Boolean Byte Currency Date Double Integer Long Object Single String Variant , Verpackungs und weitergabeassistent
Verpackungs und Weitergabeassistent siehe Installationsassistent Verzeichnisgröße
Programmcode Programmoberfläche
Verzeichnislistenfeld Verzeichnisse erzeugen löschen wechseln Verzweigungen IF-THEN-ELSE SELECT CASE Visual Basic Grundlagen Programmoberfläche starten Visual Data Manager Datenbankfenster Ergebnisfenster SQL-Anweisung
WindowState Workspace
Zeichenkette Mid, Mid$
Zeichentabellen Zeitgeber Enabled Intervall Name Tag Ziehen und Fallenlassen DragDrop DragOver mit Reaktion
verschieben Ziehen und Fallenlassen siehe Drag and Drop Zufallsgenerator , (Name)
369
