Sandini Bib
Visual Basic 6 lernen
Sandini Bib
Sandini Bib
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
Sandini Bib
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.
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
12
A.3 A.4 A.5
Glossar............................................................................................... 355 Von Visual Basic 5.0 verwendete Dateitypen................................... 357 Zeichentabellen................................................................................. 358
S
Stichwortverzeichnis .................................................................... 363
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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).
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
(ª)(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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
(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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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-
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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.
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
'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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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).
Sandini Bib
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
Sandini Bib
Sandini Bib
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
Sandini Bib
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.
Sandini Bib
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
Sandini Bib
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.
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
'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
Sandini Bib
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
Sandini Bib
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
Sandini Bib
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
Sandini Bib
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
(!
" " / 01 . -
vbExclamation
*2
" " / 01 . #
vbInformation
,*
" " / 01 . $ 3 .3
vbDefaultButton1
% 34# 5(¢)6 7" 8 . 7 . 7 1
vbDefaultButton2
!+,
% %%6 7 5(¢) 8 . 7 . 7 1 3
158
Sandini Bib
vbDefaultButton3
+!
% % 5(¢) 8 . 7 . 7 1
vbApplicationModal
%- 8873 .3 %67 7 - 3 8873 00
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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 ...).
Sandini Bib
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
Sandini Bib
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.
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
Abbildung 10.3: Das Beispielmenü im Menüdesigner während der Designphase
Abbildung 10.4: Das fertige Beispielmenü
176
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
Sandini Bib
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
Sandini Bib
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
!
Sandini Bib
+ – * /
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
Sandini Bib
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
!
Sandini Bib
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
Sandini Bib
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
!
Sandini Bib
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
Sandini Bib
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
!
Sandini Bib
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
Sandini Bib
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
!
Sandini Bib
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
Sandini Bib
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
!
Sandini Bib
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
Sandini Bib
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
!
Sandini Bib
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
Sandini Bib
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
!
Sandini Bib
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
Sandini Bib
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
!
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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
Sandini Bib
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_