Doberenz/Gewinnus Grundlagen Profiwissen Kochbuch

Borland Delphi 7

v

Bleiben Sie einfach auf dem Laufenden: www.hanser.de/newsletter Sofort anmelden und Monat für Monat die neuesten Infos und Updates erhalten.

Walter Doberenz Thomas Gewinnus

Grundlagen Profiwissen Kochbuch

Borland Delphi 7 Das umfassende Handbuch für die Win32-Anwendungsentwicklung

Professor Dr.-Ing. habil Walter Doberenz, Altenburg Dipl.-Ing. Thomas Gewinnus, Frankfurt/Oder

Alle in diesem Buch enthaltenen Informationen, Verfahren und Darstellungen wurden nach bestem Wissen zusammengestellt und mit Sorgfalt getestet. Dennoch sind Fehler nicht ganz auszuschließen. Aus diesem Grund sind die im vorliegenden Buch enthaltenen Informationen mit keiner Verpflichtung oder Garantie irgendeiner Art verbunden. Autoren und Verlag übernehmen infolgedessen keine juristische Verantwortung und werden keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der Benutzung dieser Informationen – oder Teilen davon – entsteht. Ebenso übernehmen Autoren und Verlag keine Gewähr dafür, dass beschriebene Verfahren usw. frei von Schutzrechten Dritter sind. Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Buch berechtigt deshalb auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften.

Bibliografische Information Der Deutschen Nationalbibliothek Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.

Dieses Werk ist urheberrechtlich geschützt. Alle Rechte, auch die der Übersetzung, des Nachdruckes und der Vervielfältigung des Buches, oder Teilen daraus, vorbehalten. Kein Teil des Werkes darf ohne schriftliche Genehmigung des Verlages in irgendeiner Form (Fotokopie, Mikrofilm oder ein anderes Verfahren) – auch nicht für Zwecke der Unterrichtsgestaltung – reproduziert oder unter Verwendung elektronischer Systeme verarbeitet, vervielfältigt oder verbreitet werden. © 2007 Carl Hanser Verlag München Lektorat: Fernando Schneider Sprachlektorat: Sabine Wagner, Altenburg Herstellung: Monika Kraus Umschlagdesign: Marc Müller-Bremer, Rebranding, München Umschlaggestaltung: MCP · Susanne Kraus GbR, Holzkirchen Datenbelichtung, Druck und Bindung: Kösel, Krugzell Ausstattung patentrechtlich geschützt. Kösel FD 351, Patent-Nr. 0748702 Printed in Germany

ISBN 978-3-446-41216-3 www.hanser.de/computer

Inhaltsverzeichnis 1

Vorwort ....................................................................................................

31

Einführung ............................................................................................... 1.1 Die Ruhe vor dem Sturm ........................................................................................... 1.1.1 Software ........................................................................................................ 1.1.2 Hardware ....................................................................................................... 1.1.3 Installation von Delphi 7 ............................................................................... 1.1.4 Dokumentation .............................................................................................. 1.2 Die Windows-Philosophie ......................................................................................... 1.2.1 Mensch-Rechner-Dialog ............................................................................... 1.2.2 Objekt- und ereignisorientierte Programmierung .......................................... 1.2.3 Windows-Programmierung mit Delphi ......................................................... 1.3 Erste Schritte in Delphi ............................................................................................. 1.3.1 Einführungsbeispiel für Einsteiger ................................................................ 1.3.2 Einführungsbeispiel für Umsteiger ............................................................... 1.3.3 Auf zur Object Pascal-Programmierung! ...................................................... 1.4 Von anderen Sprachen zu Delphi .............................................................................. 1.4.1 C/Visual C++/Java ........................................................................................ 1.4.2 Turbo Pascal .................................................................................................. 1.4.3 Turbo Pascal für Windows ............................................................................ 1.4.4 Visual Basic .................................................................................................. 1.5 Neuigkeiten der Version 7 ......................................................................................... 1.5.1 Änderungen der Entwicklungsumgebung ..................................................... 1.5.2 Internet-Technologie .................................................................................... 1.5.3 Datenbanken ................................................................................................. 1.5.4 Runtime Library (RTL) ................................................................................. 1.5.5 ModelMaker .................................................................................................. 1.5.6 Dokumentation .............................................................................................. 1.6 Lernbeispiele für Einsteiger ...................................................................................... 1.6.1 Der verrückte Button .................................................................................... 1.6.2 Nostalgische Konsolen-Anwendung ...........................................................

33 33 33 34 35 35 36 36 37 39 40 40 43 53 53 53 54 55 55 57 57 59 60 60 61 61 61 61 62

6

Inhaltsverzeichnis

1.7

2

Praxisbeispiele für Fortgeschrittene .......................................................................... 1.7.1 Umwandeln von Dezimalkomma in Dezimalpunkt ...................................... 1.7.2 Abstellen des nervenden Pieptons .................................................................

63 63 64

Grundlegende Sprachelemente ................................................................ 2.1 Der Quelltexteditor .................................................................................................... 2.1.1 Bedienung ..................................................................................................... 2.1.2 Schreibweise ................................................................................................. 2.2 Ein erster Blick auf Object Pascal ............................................................................. 2.2.1 Programm, Anweisungen und Blöcke ........................................................... 2.2.2 Bezeichner .................................................................................................... 2.3 Datentypen, Variablen und Konstanten ..................................................................... 2.3.1 Deklaration von Variablen ............................................................................ 2.3.2 Einfache vordefinierte Datentypen ................................................................ 2.3.3 Arithmetische Operationen ........................................................................... 2.3.4 Strings .......................................................................................................... 2.3.5 Zeigertypen ................................................................................................... 2.3.6 Variant-Datentypen ....................................................................................... 2.3.7 Typumwandlungen von Variablen ................................................................ 2.3.8 Konstanten .................................................................................................... 2.4 Benutzerdefinierte Datentypen .................................................................................. 2.4.1 Records ......................................................................................................... 2.4.2 Statische Arrays ............................................................................................ 2.4.3 Dynamische Arrays ....................................................................................... 2.4.4 Mengen ......................................................................................................... 2.5 Kontrollstrukturen ..................................................................................................... 2.5.1 Schleifenanweisungen ................................................................................... 2.5.2 Verzweigungen ............................................................................................. 2.6 Standardfunktionen und -prozeduren ........................................................................ 2.6.1 Überblick ..................................................................................................... 2.6.2 Arithmetische Funktionen ............................................................................. 2.6.3 Stringfunktionen ............................................................................................ 2.6.4 Format-Strings .............................................................................................. 2.6.5 Datums-/Zeitroutinen .................................................................................... 2.6.6 Sonstige Funktionen und Prozeduren ............................................................ 2.7 Selbst definierte Funktionen und Prozeduren ............................................................ 2.7.1 Die Parameterliste .........................................................................................

65 65 65 66 67 68 71 74 74 75 81 82 83 84 86 88 89 89 91 95 99 102 102 104 106 106 106 109 111 114 119 121 121

7

Inhaltsverzeichnis

2.7.2 Parameterübergabe als Wert oder Referenz .................................................. 2.7.3 Standardparameter ........................................................................................ 2.7.4 Funktion oder Prozedur? ............................................................................... 2.7.5 Überladene Routinen ..................................................................................... 2.7.6 Rekursionen .................................................................................................. Lernbeispiele für Anfänger ....................................................................................... 2.8.1 Übung 1 ........................................................................................................ 2.8.2 Übung 2 ........................................................................................................ 2.8.3 Übung 3 ........................................................................................................ 2.8.4 Übung 4 ........................................................................................................ 2.8.5 Übung 5 ........................................................................................................ 2.8.6 Übung 6 ....................................................................................................... Praxisbeispiele für Fortgeschrittene .......................................................................... 2.9.1 Speichern von Records in einem statischen Array ........................................ 2.9.2 Experimente mit der Format-Funktion .......................................................... 2.9.3 Überladen von Funktionen ............................................................................

121 122 122 124 124 125 126 128 130 133 137 139 143 143 146 147

Entwicklungsumgebung ........................................................................... 3.1 Die wichtigsten Fenster im Überblick ....................................................................... 3.2 Alle Menüfunktionen und die Symbolleiste .............................................................. 3.2.1 Datei-Menü ................................................................................................... 3.2.2 Bearbeiten-Menü ........................................................................................... 3.2.3 Suchen-Menü ................................................................................................ 3.2.4 Ansicht-Menü ............................................................................................... 3.2.5 Projekt-Menü ................................................................................................ 3.2.6 Start-Menü .................................................................................................... 3.2.7 Komponenten-Menü ..................................................................................... 3.2.8 Datenbank-Menü ........................................................................................... 3.2.9 Tools-Menü ................................................................................................... 3.2.10 Fenster-Menü ................................................................................................ 3.2.11 Hilfe-Menü .................................................................................................... 3.3 Das Startformular ...................................................................................................... 3.4 Die Komponentenpalette ........................................................................................... 3.4.1 Standard ........................................................................................................ 3.4.2 Zusätzlich ...................................................................................................... 3.4.3 Win32 ........................................................................................................... 3.4.4 System ...........................................................................................................

149 149 150 150 151 152 153 153 154 155 156 156 156 157 157 158 158 159 160 161

2.8

2.9

3

8

Inhaltsverzeichnis

3.4.5 Datenzugriff .................................................................................................. 3.4.6 Datensteuerung ............................................................................................. 3.4.7 BDE .............................................................................................................. 3.4.8 Rave .............................................................................................................. 3.4.9 Dialoge .......................................................................................................... 3.4.10 Win3.1 .......................................................................................................... 3.4.11 Beispiele ........................................................................................................ 3.4.12 ActiveX ......................................................................................................... 3.4.13 Server ............................................................................................................ Der Objektinspektor .................................................................................................. 3.5.1 Eigenschaften-Seite ....................................................................................... 3.5.2 Ereignisse-Seite ............................................................................................. 3.5.3 Einstellungen ................................................................................................. Der Quelltexteditor .................................................................................................... 3.6.1 Intellisense .................................................................................................... 3.6.2 Diagramm-Seite ............................................................................................ 3.6.3 Einstellungen ................................................................................................. Weitere Fenster ......................................................................................................... 3.7.1 Projektverwaltung ......................................................................................... 3.7.2 Objekt-Hierarchie .......................................................................................... Praxisbeispiele ......................................................................................................... 3.8.1 Festlegen der Projekteinstellungen für Formulare ......................................... 3.8.2 Eine MDI-Applikation erstellen .................................................................... 3.8.3 Einen Taschenrechner entwerfen ..................................................................

161 162 162 162 163 163 164 164 165 165 165 166 167 167 167 168 169 169 169 170 171 171 177 180

Formulare und Komponenten ................................................................... 4.1 Allgemeines über Steuerelemente ............................................................................. 4.1.1 Standardeigenschaften ................................................................................... 4.1.2 Standardereignisse ........................................................................................ 4.1.3 Standardmethoden ......................................................................................... 4.2 Das Formular ............................................................................................................ 4.2.1 Formulareigenschaften .................................................................................. 4.2.2 Formularereignisse ........................................................................................ 4.2.3 Formularmethoden ........................................................................................ 4.2.4 MDI-Fenster .................................................................................................. 4.3 Die Standard-Komponenten ...................................................................................... 4.3.1 Button ...........................................................................................................

185 185 185 188 194 195 195 197 198 199 202 202

3.5

3.6

3.7

3.8

4

9

Inhaltsverzeichnis

4.3.2 Label ............................................................................................................ 4.3.3 Panel ............................................................................................................. 4.3.4 Edit .............................................................................................................. 4.3.5 Memo ........................................................................................................... 4.3.6 GroupBox ..................................................................................................... 4.3.7 CheckBox ..................................................................................................... 4.3.8 RadioButton ................................................................................................. 4.3.9 RadioGroup ................................................................................................... 4.3.10 ListBox und ComboBox ............................................................................... 4.3.11 ScrollBar ...................................................................................................... 4.3.12 MainMenu und PopUpMenu ........................................................................ 4.3.13 ActionList ..................................................................................................... 4.3.14 Frames ........................................................................................................... 4.3.15 Timer ............................................................................................................ Weitere wichtige Objekte .......................................................................................... 4.4.1 Application .................................................................................................... 4.4.2 Clipboard ...................................................................................................... 4.4.3 Printer ........................................................................................................... 4.4.4 Screen ........................................................................................................... Gitterkomponenten .................................................................................................... 4.5.1 Eigenschaften ................................................................................................ 4.5.2 Methoden ...................................................................................................... 4.5.3 Ereignisse ...................................................................................................... Lernbeispiele für Einsteiger ...................................................................................... 4.6.1 Formulareigenschaften ändern ...................................................................... 4.6.2 Eingabefilter für Editierfeld .......................................................................... 4.6.3 Ein PopUp-Menü erstellen ............................................................................ Praxisbeispiele für Fortgeschrittene .......................................................................... 4.7.1 Arbeiten mit Drag & Drop ............................................................................ 4.7.2 Einsatz der Gitterkomponente ....................................................................... 4.7.3 Eine Aktionsliste verwenden ......................................................................... 4.7.4 Rechtsbündigen Text für Editierfeld .............................................................

202 204 204 205 206 207 207 208 209 211 212 213 214 216 216 217 218 218 218 219 220 223 224 225 225 227 228 230 230 234 237 241

Techniken der Softwarentwicklung .......................................................... 5.1 Programmtest und Debugging ................................................................................... 5.1.1 Arbeitszyklus des Programmierers ................................................................ 5.1.2 Vorbereitungen zum Debugging ...................................................................

243 243 243 244

4.4

4.5

4.6

4.7

5

10

Inhaltsverzeichnis

5.1.3 Die verschiedenen Debug-Möglichkeiten ..................................................... 5.1.4 Schrittweise Abarbeitung .............................................................................. 5.1.5 Haltepunkte ................................................................................................... 5.1.6 Auswerten von Ausdrücken .......................................................................... 5.1.7 OutputDebugString ....................................................................................... Fehlerbehandlung ...................................................................................................... 5.2.1 Ein-/Ausgabeprüfung ausschalten ................................................................ 5.2.2 Try-Except .................................................................................................... 5.2.3 Try-Finally .................................................................................................... 5.2.4 Das OnException-Ereignis ............................................................................ 5.2.5 Erzeugen eigener Fehlerklassen .................................................................... Dialogfenster ............................................................................................................. 5.3.1 ShowMessage ............................................................................................... 5.3.2 MessageBox .................................................................................................. 5.3.3 MessageDlg .................................................................................................. 5.3.4 InputBox und InputQuery ............................................................................. Praxisbeispiele ......................................................................................................... 5.4.1 Erzeugen von Meldungsfenstern ................................................................... 5.4.2 Werteingabe mit der InputBox ...................................................................... 5.4.3 Zahleneingaben überprüfen ........................................................................... 5.4.4 Fehlersuche mit dem Debugger .....................................................................

245 247 249 250 251 251 252 253 254 255 256 258 258 259 263 264 266 266 268 271 272

Units und Objekte .................................................................................... 6.1 Programmieren in Units ............................................................................................ 6.1.1 Das Unit-Konzept ......................................................................................... 6.1.2 Eine Unit im Detail ....................................................................................... 6.2 Object Pascal ............................................................................................................. 6.2.1 OOP-spezifische Sprachelemente ................................................................. 6.2.2 Objekte deklarieren ....................................................................................... 6.2.3 Objekte erzeugen ........................................................................................... 6.3 OOP-Werkzeuge unter Delphi .................................................................................. 6.3.1 Der visuelle Oberflächenentwurf .................................................................. 6.3.2 Ereignisbehandlungen müssen Sie selbst programmieren! ............................ 6.3.3 Unterstützung beim Definieren eigener Klassen ........................................... 6.3.4 Die Form-Unit .............................................................................................. 6.3.5 Formulare und Komponenten zur Laufzeit erzeugen .................................... 6.3.6 VCL und Komponentenentwicklung .............................................................

277 277 277 280 284 284 285 286 290 290 291 293 295 298 299

5.2

5.3

5.4

6

11

Inhaltsverzeichnis

6.3.7 Der Objektbrowser ........................................................................................ 6.3.8 Die Objektablage ........................................................................................... Lernbeispiele für Einsteiger ...................................................................................... 6.4.1 Eine Unit für Hilfsfunktionen erstellen und einbinden .................................. 6.4.2 Von der Unit zur Klasse ................................................................................ 6.4.3 Delphi-Komponenten erst zur Laufzeit erzeugen .......................................... Kleiner OOP-Crashkurs ........................................................................................... 6.5.1 Klassen und Objekte verstehen ..................................................................... 6.5.2 Konstruktor und Destruktor .......................................................................... 6.5.3 Read-Only-Eigenschaften programmieren? .................................................. 6.5.4 Eigenschaften mit Zugriffsmethoden kapseln ............................................... 6.5.5 Vererbung .....................................................................................................

300 301 303 303 308 314 317 317 323 325 327 329

Grafikprogrammierung ............................................................................ 7.1 Das Canvas-Objekt ................................................................................................... 7.1.1 Koordinatensystem ........................................................................................ 7.1.2 Grundlegende Zeichenfunktionen ................................................................. 7.1.3 Farben ........................................................................................................... 7.1.4 Linienfarbe, Muster und Pinsel ..................................................................... 7.1.5 Linien und Stifte ............................................................................................ 7.1.6 Textausgabe .................................................................................................. 7.2 Standarddialoge ......................................................................................................... 7.2.1 Standarddialog zur Schriftauswahl ................................................................ 7.2.2 Standarddialog zur Farbauswahl ................................................................... 7.3 Grafik-Komponenten ................................................................................................ 7.3.1 Form und PaintBox ...................................................................................... 7.3.2 Image ............................................................................................................ 7.3.3 Bitmap ........................................................................................................... 7.3.4 Shape-Komponenten ..................................................................................... 7.4 2-D-Vektorgrafik ...................................................................................................... 7.4.1 Verschieben und Verdrehen von Symbolen .................................................. 7.4.2 Spiegeln und Maßstabsänderung von Symbolen ........................................... 7.5 Lernbeispiele für Einsteiger ...................................................................................... 7.5.1 Linien und Textausgabe testen ...................................................................... 7.5.2 Animierten Markierungsrahmen erzeugen .................................................... 7.5.3 Bitmaps laden ................................................................................................

337 337 339 340 346 348 349 353 355 355 357 358 358 360 362 363 364 364 367 368 368 369 371

6.4

6.5

7

12

Inhaltsverzeichnis

7.6

8

Praxisbeispiele für Fortgeschrittene ......................................................................... 7.6.1 Farben mischen ............................................................................................. 7.6.2 2-D-Vektorgrafik ..........................................................................................

373 373 377

Dateien/Streams ...................................................................................... 8.1 Übersicht ................................................................................................................... 8.1.1 Dateifunktionen ............................................................................................. 8.1.2 Dateizugriff unter Windows .......................................................................... 8.2 Textdateien ................................................................................................................ 8.2.1 Aufbau .......................................................................................................... 8.2.2 Öffnen ........................................................................................................... 8.2.3 Lesen ............................................................................................................. 8.2.4 Schreiben ...................................................................................................... 8.3 Typisierte Dateien ..................................................................................................... 8.3.1 Öffnen ........................................................................................................... 8.3.2 Lesen/Schreiben ............................................................................................ 8.3.3 Probleme mit Records ................................................................................... 8.4 Binärdateien .............................................................................................................. 8.5 Streams ...................................................................................................................... 8.5.1 Was ist ein Stream? ....................................................................................... 8.5.2 Öffnen, Schreiben und Lesen ........................................................................ 8.5.3 Kopieren von Streams ................................................................................... 8.6 Memory Mapped Files .............................................................................................. 8.6.1 Erzeugen eines MMF .................................................................................... 8.6.2 Datenaustausch über MMFs .......................................................................... 8.7 INI-Dateien ............................................................................................................... 8.8 Die Registrierdatenbank ............................................................................................ 8.8.1 Registrierungseditor ...................................................................................... 8.8.2 Grundstruktur ................................................................................................ 8.8.3 Speichern ...................................................................................................... 8.8.4 Die Klasse TRegistry .................................................................................... 8.8.5 Dateiverknüpfungen erzeugen ....................................................................... 8.9 Dateidialoge .............................................................................................................. 8.9.1 Eigene Dateidialoge erstellen ........................................................................ 8.9.2 Standard-Dialogboxen .................................................................................. 8.10 Lernbeispiele für Einsteiger ...................................................................................... 8.10.1 Drucken einer Textdatei ................................................................................

381 381 381 383 385 386 387 388 389 390 391 391 393 393 394 395 395 397 398 398 400 401 402 402 403 404 405 407 409 409 411 413 413

13

Inhaltsverzeichnis

8.10.2 Ermitteln des freien Diskettenspeichers ........................................................ 8.10.3 Speichern von Records in einer typisierten Datei .......................................... Praxisbeispiele für Fortgeschrittene .......................................................................... 8.11.1 Speichern von Variablenwerten in einem FileStream ................................... 8.11.2 Arbeiten mit Memory Mapped Files ............................................................. 8.11.3 Dateien suchen und Attribute auswerten ....................................................... 8.11.4 Kopieren von Dateien ...................................................................................

415 416 421 421 424 426 429

Datenbankprogrammierung ..................................................................... 9.1 Relationale Datenbanken ........................................................................................... 9.1.1 Datenbankformate ......................................................................................... 9.1.2 Was sind relationale Datenbanken? ............................................................... 9.1.3 Beziehungen zwischen den Tabellen ............................................................. 9.1.4 Verknüpfen von Tabellen .............................................................................. 9.1.5 Sekundärindex ............................................................................................... 9.2 Datenbankzugriff mit Bound Controls ...................................................................... 9.2.1 Komponenten für Datenzugriff ..................................................................... 9.2.2 Komponenten für Datensteuerung ................................................................. 9.2.3 Rave Reports-Komponenten ......................................................................... 9.3 Lernbeispiele für Einsteiger ...................................................................................... 9.3.1 Anlegen einer "Kundentabelle" ..................................................................... 9.3.2 Definieren von Alias und Sekundärindizes ................................................... 9.3.3 Eingabemaske mit Bound Controls ............................................................... 9.3.4 Einfacher Bericht mit Rave Report ............................................................... 9.3.5 Verknüpfen von Tabellen .............................................................................. 9.4 Praxisbeispiele für Fortgeschrittene .......................................................................... 9.4.1 Einsparen des DBNavigators ........................................................................ 9.4.2 Rechnungs-Eingabemaske ........................................................................... 9.4.3 Rechnung mit Rave Reports .........................................................................

433 433 434 434 435 436 437 438 438 439 441 444 444 447 449 453 458 460 460 465 473

10 Programmschnittstellen/Peripherie ......................................................... 10.1 Zwischenablage ......................................................................................................... 10.1.1 Das Clipboard-Objekt ................................................................................... 10.1.2 Umsetzung der Zwischenablage-Funktionen ................................................ 10.2 DLL-Programmierung .............................................................................................. 10.2.1 Grundlagen .................................................................................................... 10.2.2 Umstellung von 16 auf 32 Bit .......................................................................

481 481 481 483 484 485 485

8.11

9

14

Inhaltsverzeichnis

10.2.3 DLL-Programmierung mit Delphi ................................................................. 10.2.4 DLL-Programmierung mit C ......................................................................... 10.2.5 Einbinden in Visual Basic ............................................................................. 10.2.6 Tipps und Tricks ........................................................................................... Drucker ..................................................................................................................... 10.3.1 Das Printer-Objekt ........................................................................................ 10.3.2 Druckerkonfiguration .................................................................................... 10.3.3 Drucken von Vektor- und Rastergrafiken ..................................................... 10.3.4 Drucken in Millimetern ................................................................................. Lernbeispiele für Einsteiger ...................................................................................... 10.4.1 Arbeiten mit der Zwischenablage .................................................................. 10.4.2 Grafiken in die Zwischenablage kopieren ..................................................... 10.4.3 Ermitteln der installierten Drucker ................................................................ Praxisbeispiele für Fortgeschrittene .......................................................................... 10.5.1 Die Optionen des aktiven Druckers ermitteln ................................................ 10.5.2 DLL programmieren ..................................................................................... 10.5.3 DLL dynamisch einbinden ............................................................................

489 494 500 502 504 505 506 510 512 513 513 515 516 518 518 520 524

11 Komponentenentwicklung ....................................................................... 11.1 Überblick .................................................................................................................. 11.2 Ableiten der Komponente ......................................................................................... 11.3 Eigenschaften ............................................................................................................ 11.3.1 Eigenschaften von Aufzählungstypen ........................................................... 11.3.2 Eigenschaften von Mengentypen .................................................................. 11.3.3 Objekt-Eigenschaften .................................................................................... 11.3.4 Komponenten-Eigenschaften ........................................................................ 11.4 Methoden .................................................................................................................. 11.4.1 Allgemeines .................................................................................................. 11.4.2 Überschreiben von Methoden ....................................................................... 11.4.3 Methoden überladen ...................................................................................... 11.5 Ereignisse (Events) ................................................................................................... 11.5.1 Standardereignisse ........................................................................................ 11.5.2 Überschreiben der Standardereignisse ........................................................... 11.5.3 Neue Ereignisse ............................................................................................ 11.6 Die wichtigsten Komponententypen ......................................................................... 11.6.1 Datengebundene Komponenten .................................................................... 11.6.2 Nicht sichtbare Komponenten .......................................................................

527 527 528 530 532 533 533 535 537 538 541 542 542 543 544 544 546 546 551

10.3

10.4

10.5

Inhaltsverzeichnis

15

11.6.3 Grafische Komponenten ................................................................................ 11.7 Test der Komponente ............................................................................................... 11.8 Packages .................................................................................................................... 11.8.1 Grundsätzliches ............................................................................................. 11.8.2 Eigene Packages erzeugen ............................................................................ 11.9 Lernbeispiele für Einsteiger ...................................................................................... 11.9.1 Neue Komponenten ableiten ......................................................................... 11.10 Praxisbeispiele für Fortgeschrittene .......................................................................... 11.10.1Komponente für Digitalanzeige .................................................................... 11.10.2Multimedia-Timer-Komponente ..................................................................

553 556 557 557 559 560 560 566 566 571

12 OLE-Automation/ActiveX ......................................................................... 12.1 Begriffe ..................................................................................................................... 12.2 Automatisierung ........................................................................................................ 12.2.1 Die OLEContainer-Komponente ................................................................... 12.2.2 Arbeiten mit Automations-Servern ............................................................... 12.2.3 Zugriff auf Objekte im OLE-Container ......................................................... 12.2.4 Parameter von ActiveX-Objekten ................................................................. 12.2.5 Konvertieren von VB-Beispielen .................................................................. 12.3 Einige Automatisierungs-Beispiele ........................................................................... 12.3.1 OLE-Automatisierung mit Visio .................................................................. 12.3.2 OLE-Automatisierung mit Word .................................................................. 12.3.3 Informationen über ActiveX-Server .............................................................. 12.4 ActiveX-Code-Komponenten entwickeln ................................................................. 12.4.1 COM-Schnittstellen von Automatisierungsobjekten .................................... 12.4.2 Praktischer Entwurf ....................................................................................... 12.4.3 Instanz-Typen .............................................................................................. 12.4.4 Threading-Modell ......................................................................................... 12.4.5 Initialisieren und Entfernen von Instanzen .................................................... 12.4.6 Interface-Definition ....................................................................................... 12.4.7 Fehlerbehandlung .......................................................................................... 12.5 ActiveX-Controls ...................................................................................................... 12.5.1 Entwurf ......................................................................................................... 12.5.2 Eigenschaften ................................................................................................ 12.5.3 Einbinden von PropertyPages ....................................................................... 12.5.4 Ereignisse ...................................................................................................... 12.6 ActiveX-Forms .........................................................................................................

577 577 579 580 586 593 593 595 596 596 601 602 603 603 605 606 607 608 609 611 612 612 614 617 618 619

16

Inhaltsverzeichnis

12.7 12.8

Registrieren der ActiveX-Komponenten ................................................................... Zugriff auf .NET-Komponenten ............................................................................... 12.8.1 Was ist eine .NET-Assembly? ...................................................................... 12.8.2 Die Rolle der Typbibliotheken in .NET ........................................................ 12.8.3 Zugriff auf selbst entwickelte .NET-Komponenten ....................................... 12.9 Lernbeispiele für Einsteiger ...................................................................................... 12.9.1 OLE-Automation mit Excel .......................................................................... 12.9.2 Word über OLE-Automation steuern ............................................................ 12.10 Praxisbeispiele für Fortgeschrittene .......................................................................... 12.10.1OLE-Server registrieren ................................................................................ 12.10.2Programmieren einer ActiveX-DLL für Visual Basic .................................. 12.10.3Einbinden einer .NET-Komponente .............................................................. 12.10.4Mit C# eine .NET-Komponente für Delphi entwickeln .................................

621 622 622 623 624 626 626 631 634 634 635 646 648

13 Wissenschaft/Technik .............................................................................. 13.1 Sortieren .................................................................................................................... 13.1.1 Eine Testmenge erstellen .............................................................................. 13.1.2 Austauschverfahren (Exchange-Sort) ............................................................ 13.1.3 Auswahlverfahren ......................................................................................... 13.1.4 Bubble-Sort-Verfahren .................................................................................. 13.1.5 Shell-Sort-Verfahren ..................................................................................... 13.1.6 Auswerten von Testergebnissen .................................................................... 13.1.7 Testprogramm ............................................................................................... 13.2 Suchen ....................................................................................................................... 13.2.1 Lineares Durchsuchen ................................................................................... 13.2.2 Durchsuchen sortierter Datenfelder ............................................................... 13.3 Gauss-Algorithmus ................................................................................................... 13.3.1 Theoretische Grundlagen .............................................................................. 13.3.2 Ein einfaches Lösungsprogramm .................................................................. 13.3.3 Kritik am einfachen Gauss-Algorithmus ....................................................... 13.4 Numerische Integration ............................................................................................. 13.4.1 Rechteckapproximation ................................................................................. 13.4.2 Beispiel zur Rechteckapproximation ............................................................. 13.4.3 Weitere Integrationsverfahren ....................................................................... 13.4.4 Automatische Schrittweitensteuerung ........................................................... 13.4.5 Beispiel .........................................................................................................

655 655 655 656 657 659 661 662 663 665 665 665 667 667 670 674 676 676 678 681 681 683

17

Inhaltsverzeichnis

13.5

Berechnungen mit einer Datenbank .......................................................................... 13.5.1 Datenbank erstellen ....................................................................................... 13.5.2 Bedienoberfläche .......................................................................................... 13.5.3 Anbinden der datensensitiven Komponenten ............................................... Lernbeispiele für Einsteiger ..................................................................................... 13.6.1 Mit physikalischen Maßeinheiten formatieren .............................................. 13.6.2 Zahlen konvertieren ...................................................................................... Praxisbeispiele für Fortgeschrittene .......................................................................... 13.7.1 Rechnen mit komplexen Zahlen .................................................................... 13.7.2 Kreuzprodukt von Vektoren (OOP-Beispiel) ................................................

687 688 689 689 697 697 699 701 701 705

14 Datenstrukturen ....................................................................................... 14.1 Strings, Strings, Strings ............................................................................................. 14.1.1 API-Zugriff mit PChar .................................................................................. 14.1.2 Unicode-Zeichensatz ..................................................................................... 14.2 Dynamische Speicherverwaltung .............................................................................. 14.2.1 Pointer ........................................................................................................... 14.2.2 Verkettete Listen ........................................................................................... 14.2.3 Arbeiten mit TList-Objekten ......................................................................... 14.2.4 Memory-Streams ........................................................................................... 14.2.5 Dynamische Arrays ....................................................................................... 14.3 Lernbeispiele für Einsteiger ...................................................................................... 14.3.1 Zerlegen von Strings ..................................................................................... 14.3.2 Zum Unterschied zwischen PChar und String ............................................... 14.4 Praxisbeispiele für Fortgeschrittene .......................................................................... 14.4.1 Zweidimensionales Array auf dem Heap (Unit-Version) ............................. 14.4.2 Zweidimensionales Array auf dem Heap (OOP-Version) ............................

719 719 720 721 721 722 727 737 741 743 745 745 750 752 752 756

15 Erweitere Grafikprogrammierung ............................................................ 15.1 GDI-Programmierung ............................................................................................... 15.1.1 Arbeiten mit dem GDI .................................................................................. 15.1.2 Koordinatensysteme und Abbildungsmodi ................................................... 15.1.3 Zeichenwerkzeuge und Objekte .................................................................... 15.2 Erweiterte Bitmap-Manipulation ............................................................................... 15.2.1 Grundlagen .................................................................................................... 15.2.2 Spiegeln von Bitmaps ................................................................................... 15.2.3 Farbmanipulation ..........................................................................................

761 761 762 765 770 798 799 801 803

13.6

13.7

18

Inhaltsverzeichnis

15.2.4 Drehen von Bitmaps ...................................................................................... 3-D-Vektorgrafik ...................................................................................................... 15.3.1 Darstellungsmöglichkeiten ............................................................................ 15.3.2 Translation .................................................................................................... 15.3.3 Streckung/Skalierung .................................................................................... 15.3.4 Rotation ......................................................................................................... Lernbeispiele für Einsteiger ...................................................................................... 15.4.1 Eine umrandete Fläche mit Farbe füllen ........................................................ 15.4.2 Drag & Drop mit Grafikobjekten .................................................................. Praxisbeispiele für Fortgeschrittene .......................................................................... 15.5.1 Programmieren einer Animation mit BitBlt .................................................. 15.5.2 Darstellen einer 3-D-Vektorgrafik ................................................................

807 809 812 814 815 815 818 818 819 825 825 829

16 Applikationen ........................................................................................... 16.1 Einsteigerprogramm TEXTVERARBEITUNG ....................................................... 16.1.1 Bedienoberfläche .......................................................................................... 16.1.2 Quelltext des MDI-Rahmenfensters .............................................................. 16.1.3 Quelltext der MDI-Kindfenster ..................................................................... 16.1.4 Programmtest ................................................................................................ 16.2 Grafikprogramm Paint .............................................................................................. 16.2.1 Allgemeines .................................................................................................. 16.2.2 Ein kurzer Überblick ..................................................................................... 16.2.3 Aufbau/Programmierung ............................................................................... 16.3 Funktionsplotter FMASTER ..................................................................................... 16.3.1 Allgemeines .................................................................................................. 16.3.2 Bedienung ..................................................................................................... 16.3.3 Aufbau/Programmierung ............................................................................... 16.4 Mathematikprogramm GAUSS2 ............................................................................... 16.4.1 Bedienoberfläche Form1 ............................................................................... 16.4.2 Quellcode der Klassen-Unit GlsMtrx .......................................................... 16.4.3 Quelltext Unit1 .............................................................................................. 16.4.4 Test mit Handeingabe der Koeffizienten ....................................................... 16.4.5 Automatisches Aufstellen des Gleichungssystems ........................................ 16.4.6 Oberfläche Form2 ......................................................................................... 16.4.7 Quelltext Unit2 .............................................................................................. 16.4.8 Testbeispiel Elektrotechnik ...........................................................................

837 837 837 839 840 845 846 846 847 851 868 869 869 872 879 879 880 884 887 889 889 890 892

15.3

15.4

15.5

19

Inhaltsverzeichnis

16.5

WINCROSS – Ihr Kreuzworträtselexperte ............................................................... 16.5.1 Datenbankstruktur ......................................................................................... 16.5.2 Oberfläche ..................................................................................................... 16.5.3 Programmierung ........................................................................................... 16.5.4 Bemerkungen ................................................................................................

894 896 896 898 909

17 How-to: Sprache ...................................................................................... 17.1 Das Währungsformat ändern ..................................................................................... 17.2 Beträge formatieren und berechnen ........................................................................... 17.3 Das Datumsformat ändern ......................................................................................... 17.4 Das Zeitformat ändern ............................................................................................... 17.5 Mit Datums-/Zeitfunktionen arbeiten ........................................................................ 17.6 Auf Datum oder Zeit testen ....................................................................................... 17.7 Datumswerte vergleichen .......................................................................................... 17.8 Eine Konsolenanwendung einsetzen ......................................................................... 17.9 Eine Unit erstellen und anwenden ............................................................................. 17.10 Mit Stringlisten arbeiten ............................................................................................ 17.11 Zeichen aus einem String entfernen .......................................................................... 17.12 Auf Groß- oder Kleinbuchstaben testen .................................................................... 17.13 Auf gerade oder ungerade Werte prüfen ................................................................... 17.14 Auf Ziffern prüfen ..................................................................................................... 17.15 Auf bestimmte Datentypen testen ............................................................................. 17.16 Hilfsfunktionen testen ............................................................................................... 17.17 Einen String in einzelne Wörter zerlegen .................................................................. 17.18 Wörter aus einem String filtern ................................................................................. 17.19 Strings auf Ähnlichkeit vergleichen .......................................................................... 17.20 Termineingaben dekodieren ...................................................................................... 17.21 Geldbeträge kaufmännisch runden ............................................................................ 17.22 Einen Wert auf Bit-Ebene manipulieren .................................................................... 17.23 Byte in KiloByte umrechnen ..................................................................................... 17.24 Funktionstasten/Tastenkombinationen abfragen .......................................................

911 911 913 915 920 922 925 928 930 932 935 939 940 940 941 941 942 944 946 948 950 953 954 958 959

18 How-to: Oberfläche .................................................................................. 18.1 Ein Info-Fenster beim Start anzeigen ........................................................................ 18.2 Ein Formular automatisch zentrieren ........................................................................ 18.3 Ein Formular automatisch entfernen ......................................................................... 18.4 Ein Formular ohne Titelleiste erzeugen .....................................................................

961 961 962 964 965

20

Inhaltsverzeichnis

18.5 18.6 18.7 18.8 18.9 18.10 18.11 18.12 18.13 18.14 18.15 18.16 18.17 18.18 18.19 18.20 18.21 18.22 18.23 18.24 18.25 18.26 18.27 18.28 18.29 18.30 18.31 18.32 18.33 18.34 18.35 18.36 18.37 18.38 18.39 18.40 18.41

Ein Formular an oberster Position einblenden ........................................................... Einen Fensterhintergrund füllen ................................................................................ Das Löschen des Form-Hintergrundes verhindern .................................................... Ein Formular in der Taskleiste anzeigen ................................................................... Ein Fenster zur Laufzeit erzeugen ............................................................................. Ein ToolWindow realisieren ..................................................................................... Ein Fenster auf Icon-Größe halten ............................................................................. Die Titelleiste ausblenden ......................................................................................... Ein MDI-Child simulieren ........................................................................................ Ein Formular skalieren .............................................................................................. Eine Anwendung beim Deaktivieren schließen ......................................................... Wichtige Standardkomponenten kennen lernen ........................................................ Zahleneingaben überprüfen ....................................................................................... Ein einzelnes Zeichen eingeben ................................................................................ Mit der Enter-Taste zum nächsten Feld wechseln ..................................................... Die Zeilenzahl eines Memofeldes bestimmen ........................................................... Die Zeile/Spalte in Memofeldern bestimmen ............................................................ Das aktuelle Wort unter dem Cursor ermitteln .......................................................... Einen Zeilenumbruch erzwingen ............................................................................... Eine Undo-Funktion realisieren ................................................................................ Ränder in Memofeldern setzen ................................................................................. Einen vergrößerten Textcursor realisieren ................................................................. Einen grafischen Textcursor realisieren .................................................................... Die Mauskoordinaten anzeigen ................................................................................. Den Mausbereich verkleinern ................................................................................... Den Mauscursor ausblenden ..................................................................................... Eigene Mauszeiger verwenden .................................................................................. Auf Mausbewegungen reagieren ............................................................................... Eine Menüleiste erstellen .......................................................................................... Ein PopUp-Menü erzeugen ....................................................................................... Menüeinträge zur Laufzeit erzeugen ......................................................................... Grafiken in Menüpunkte einbinden ........................................................................... Das Systemmenü verkleinern .................................................................................... Das Systemmenü erweitern ....................................................................................... Bildlaufleisten am Fensterrand positionieren ............................................................ Mit einem Schieberegler Werte einstellen ................................................................. Verknüpfte und rastende Schalter realisieren ............................................................

966 967 969 969 970 973 975 976 977 978 980 981 984 986 987 988 989 990 991 992 993 994 996 996 997 999 1000 1003 1005 1010 1012 1014 1015 1017 1018 1020 1021

21

Inhaltsverzeichnis

18.42 18.43 18.44 18.45 18.46 18.47 18.48 18.49 18.50 18.51 18.52 18.53 18.54 18.55 18.56 18.57 18.58 18.59 18.60 18.61 18.62 18.63 18.64 18.65 18.66 18.67 18.68 18.69 18.70 18.71 18.72 18.73 18.74 18.75

Grafiken in Schaltflächen einsetzen .......................................................................... Eine RadioGroup programmieren ............................................................................. Den Anfangswert in einer Listbox setzen .................................................................. Die markierten Einträge einer ListBox ermitteln ....................................................... Die Existenz eines Listbox-Eintrags feststellen ......................................................... In Listenfeldern suchen ............................................................................................. Eine ListBox horizontal scrollen ............................................................................... Einträge in einer ListBox löschen ............................................................................. Eine intelligente ComboBox programmieren ............................................................ Eine ComboBox automatisch öffnen ......................................................................... Zwei Gitter-Komponenten synchronisieren .............................................................. Im StringGrid einen Zeilenumbruch durchführen ..................................................... Den Text im StringGrid rechtsbündig ausrichten ...................................................... Den Inhalt eines StringGrids in einer Datei sichern ................................................... Die Spalten im StringGrid automatisch anpassen ...................................................... Die blaue Zelle im StringGrid entfernen ................................................................... Grafiken im StringGrid anzeigen .............................................................................. Eine ComboBox im StringGrid anzeigen .................................................................. Zeilen in ein StringGrid einfügen/löschen ................................................................. Zellen im StringGrid farblich hervorheben ............................................................... Im StringGrid Enter- statt Tab-Taste verwenden ....................................................... Verschiedene ListView-Ansichten verwenden .......................................................... Drag & Drop in der Anwendung realisieren .............................................................. Komponenten zur Laufzeit verschieben .................................................................... Komponenten zwischen Fenstern verschieben .......................................................... Komponenten auf einer StatusBar platzieren ............................................................ Einen Schatten hinter Komponenten erzeugen .......................................................... Verschwundene Komponenten aufspüren ................................................................. Den ValueListEditor kennen lernen .......................................................................... Eine Uhr einblenden .................................................................................................. Mit dem DateTimePicker arbeiten ............................................................................ Ein Textverarbeitungsprogramm schreiben ............................................................... Ein Formular aus der DFM-Datei laden .................................................................... Kollegen mit einem IQ-Tester ärgern ........................................................................

1024 1026 1029 1030 1031 1033 1034 1035 1036 1038 1039 1040 1043 1044 1048 1050 1051 1053 1056 1058 1059 1060 1063 1066 1067 1069 1070 1072 1072 1075 1076 1078 1086 1088

22

Inhaltsverzeichnis

19 How-to: Grafikprogrammierung ............................................................... 19.1 Zwischen PaintBox und Image unterscheiden ........................................................... 19.2 Mit der ChartFX-Komponente arbeiten .................................................................... 19.3 Die ImageList einsetzen ............................................................................................ 19.4 Grafiken in einem Listenfeld anzeigen ...................................................................... 19.5 Grafiken in die Zwischenablage kopieren ................................................................. 19.6 Bitmaps zur Laufzeit zuweisen ................................................................................. 19.7 Eine Bitmap-Ressourcendatei erstellen ..................................................................... 19.8 JPEG-Grafiken als Ressourcen speichern ................................................................. 19.9 BMP in JPEG-Grafiken umwandeln ......................................................................... 19.10 Informationen über BMP-Dateien gewinnen ............................................................. 19.11 Eine RGB-Grafik manipulieren ................................................................................. 19.12 Die Scanline-Eigenschaft verwenden ........................................................................ 19.13 Mit großen Grafiken arbeiten .................................................................................... 19.14 Gedrehten Text ausgeben .......................................................................................... 19.15 Einen Bildausschnitt scrollen .................................................................................... 19.16 Bitmaps manipulieren ............................................................................................... 19.17 Eine Bitmap drehen ................................................................................................... 19.18 Eine Lupenfunktion programmieren ......................................................................... 19.19 Polygone zeichnen .................................................................................................... 19.20 Grafiken auf dem Screen ausgeben ........................................................................... 19.21 Ein Koordinatensystem erzeugen .............................................................................. 19.22 Bézierkurven darstellen ............................................................................................. 19.23 Spezialeffekte erzeugen ............................................................................................. 19.24 Verschiedene Stifte erzeugen .................................................................................... 19.25 Im Formularkopf zeichnen ........................................................................................ 19.26 Mehrzeiligen Text ausgeben ..................................................................................... 19.27 Einen Farbverlauf erzeugen ....................................................................................... 19.28 Mit Paletten arbeiten ................................................................................................. 19.29 Eine eigene Fortschrittsanzeige programmieren ........................................................ 19.30 Einen Markierungsrahmen erzeugen ......................................................................... 19.31 Grafiken mit Drag & Drop manipulieren .................................................................. 19.32 Einen Desktop-Screenshot anfertigen ....................................................................... 19.33 Einen Fenster-Screenshot erzeugen ........................................................................... 19.34 Ein Testbild programmieren ......................................................................................

1089 1089 1092 1096 1098 1099 1101 1102 1105 1108 1111 1113 1113 1113 1118 1121 1125 1128 1130 1133 1135 1137 1140 1142 1145 1147 1148 1151 1152 1155 1157 1159 1162 1165 1168

Inhaltsverzeichnis

23

20 How-to: Multimedia ................................................................................. 20.1 Zeitmessungen durchführen ...................................................................................... 20.2 Einen Screen-Saver programmieren .......................................................................... 20.3 Einen Joystick abfragen ............................................................................................ 20.4 Testen, ob eine Soundkarte installiert ist ................................................................... 20.5 Töne mit bestimmten Frequenzen ausgeben .............................................................. 20.6 WAV-Dateien abspielen ........................................................................................... 20.7 Sound-Ressourcen in ein Programm einbinden ......................................................... 20.8 Sound-Dateien aufnehmen ........................................................................................ 20.9 AVI-Dateien anzeigen ............................................................................................... 20.10 Die Ausgabefläche für AVIs anpassen ...................................................................... 20.11 Eine AVI- Komponente programmieren ................................................................... 20.12 AVI-Videos im Vollbildmodus abspielen ................................................................. 20.13 Hotspots realisieren ................................................................................................... 20.14 Hotspots auf Grafiken erzeugen ................................................................................ 20.15 Runde Fenster erzeugen ............................................................................................ 20.16 Ein CD-Laufwerk sicher erkennen ............................................................................ 20.17 Eine Audio-CD erkennen .......................................................................................... 20.18 Ein Audio-CD-Laufwerk auswählen ......................................................................... 20.19 Die Autorun-Funktion von CDs nutzen ..................................................................... 20.20 Das CD-Laufwerk öffnen und schließen ...................................................................

1173 1173 1174 1179 1189 1190 1192 1193 1195 1197 1200 1201 1207 1208 1209 1211 1213 1214 1216 1217 1218

21 How-to: Dateien/Verzeichnisse ............................................................... 21.1 Kontrollieren, ob eine Diskette eingelegt ist .............................................................. 21.2 Eine Diskette kopieren .............................................................................................. 21.3 Eine Diskette formatieren .......................................................................................... 21.4 Die Laufwerkstypen bestimmen ................................................................................ 21.5 Laufwerksinformationen ermitteln ............................................................................ 21.6 Testen, ob ein Verzeichnis existiert ........................................................................... 21.7 Ein Verzeichnis anlegen ............................................................................................ 21.8 Das Anwendungsverzeichnis bestimmen .................................................................. 21.9 Einen Verzeichnisbaum darstellen ............................................................................ 21.10 Änderungen in einem Verzeichnis überwachen ........................................................ 21.11 Die Größe einer Datei ermitteln ................................................................................ 21.12 Nach Dateien rekursiv suchen ................................................................................... 21.13 Einen Dateibetrachter realisieren ............................................................................... 21.14 Datei-Verknüpfungen nutzen ....................................................................................

1219 1219 1220 1221 1222 1224 1228 1229 1230 1231 1237 1240 1242 1244 1247

24

Inhaltsverzeichnis

21.15 21.16 21.17 21.18 21.19 21.20 21.21 21.22 21.23 21.24 21.25 21.26

Die Shell-Funktionen zum Kopieren nutzen ............................................................. Eine Datei-Komponente entwickeln .......................................................................... Eine ASCII-ANSI-Konvertierung realisieren ............................................................ Einen eindeutigen TEMP-Dateinamen erzeugen ....................................................... Kurze Dateinamen ermitteln ..................................................................................... Records in einem statischen Array speichern ............................................................ Records in einem Stream-Objekt speichern .............................................................. Einen Dateidialog realisieren .................................................................................... Dateinamen filtern ..................................................................................................... Records dynamisch auf dem Heap ablegen ............................................................... Records in einem dynamischen Array speichern ....................................................... Einen FileStream als BDE-Ersatz verwenden ...........................................................

1248 1252 1262 1263 1264 1265 1268 1271 1275 1277 1281 1284

22 How-to: Datenbanken .............................................................................. 22.1 In einem Datenbank-Memofeld suchen ..................................................................... 22.2 Ein StringGrid mit Abfrageergebnissen füllen .......................................................... 22.3 Hierarchische Datenstrukturen darstellen .................................................................. 22.4 Daten in einer ListView darstellen ............................................................................ 22.5 Mit Lookup-Feldern Tabellen verknüpfen ................................................................ 22.6 Mit Lookup-Feld und DBGrid Tabellen verknüpfen ................................................. 22.7 Vermeiden, dass im DBGrid gelöscht wird ............................................................... 22.8 Eine bestimmte DBGrid-Zelle markieren .................................................................. 22.9 Die Spalteneigenschaften eines DBGrid ändern ........................................................ 22.10 Die Sortierreihenfolge einer Tabelle ändern .............................................................. 22.11 Den Hauptindex einer Tabelle ermitteln .................................................................... 22.12 Prüfen, ob die BDE installiert ist ............................................................................... 22.13 Ein Datenbankverzeichnis auswählen ....................................................................... 22.14 Eine Datenbank mit Passwort schützen ..................................................................... 22.15 Detaildaten anzeigen ................................................................................................. 22.16 Einen zufälligen Datensatz auswählen ...................................................................... 22.17 Die Datenbankstruktur bestimmen ............................................................................ 22.18 Auf den Alias verzichten ........................................................................................... 22.19 Die Tabellenstruktur kopieren ................................................................................... 22.20 Das Löschen von Datensätzen verhindern ................................................................. 22.21 Gelöschte dBASE-Records anzeigen ........................................................................ 22.22 Mit Transaktionen arbeiten ....................................................................................... 22.23 Die Lookup-Methode verwenden ..............................................................................

1289 1289 1293 1294 1298 1302 1304 1306 1307 1308 1312 1313 1314 1315 1317 1320 1322 1324 1329 1332 1334 1335 1337 1338

25

Inhaltsverzeichnis

22.24 22.25 22.26 22.27 22.28 22.29 22.30 22.31 22.32

Zur Laufzeit ein Lookup-Feld erzeugen .................................................................... Eine Tabelle zur Laufzeit erstellen ............................................................................ Auf mehrere Datenbanken gleichzeitig zugreifen ..................................................... Bound Controls ohne BDE verwenden ..................................................................... Eine SoundEx-Funktion programmieren ................................................................... Eine tolerante Suchfunktion realisieren ..................................................................... Bound Controls selbst entwickeln ............................................................................. Eine DBCheckList programmieren ........................................................................... Ein Setup für Datenbankanwendungen erstellen .......................................................

1340 1342 1345 1346 1349 1352 1354 1360 1365

23 How-to: ADO/SQL .................................................................................... 23.1 Mit ADO auf Access-Datenbanken zugreifen ........................................................... 23.2 Mit ADO auf Microsoft SQL Server zugreifen ......................................................... 23.3 Eine UDL-Datei einrichten ....................................................................................... 23.4 Access-Tabellen aus Paradox erzeugen ..................................................................... 23.5 Paradox-Tabellen nach Access kopieren ................................................................... 23.6 Mit Shape-Befehlen arbeiten ..................................................................................... 23.7 Das TabControl unter ADO einsetzen ....................................................................... 23.8 Das PageControl unter ADO einsetzen ..................................................................... 23.9 Diagramme mit DBChart und ADO anzeigen ........................................................... 23.10 Ein einfaches SQL-Abfrageprogramm schreiben ...................................................... 23.11 Datumsangaben in SQL-Strings einbauen ................................................................. 23.12 SQL-Abfrageergebnisse in einer Tabelle sichern ...................................................... 23.13 Parameter in Abfragen verwenden ............................................................................ 23.14 Eine CheckListBox für SQL-Abfragen nutzen .......................................................... 23.15 Access-Datenbanken über DAO abfragen .................................................................

1377 1377 1380 1383 1385 1390 1393 1397 1400 1403 1409 1411 1413 1415 1417 1418

24 How-to: Drucker/Berichte ....................................................................... 24.1 Einen Drucker auswählen .......................................................................................... 24.2 In Millimetern drucken .............................................................................................. 24.3 Pixel- und Vektorgrafiken drucken ........................................................................... 24.4 Den Inhalt eines StringGrid ausdrucken .................................................................... 24.5 Eine eigene Druckvorschau programmieren ............................................................. 24.6 Eine eigene Druckausgabe realisieren ....................................................................... 24.7 Access-Reports drucken ............................................................................................ 24.8 Einen einfachen Rave Report erstellen ...................................................................... 24.9 Berechnungen in Rave-Reports ausführen ................................................................

1423 1423 1425 1427 1430 1432 1439 1443 1445 1449

26

Inhaltsverzeichnis

24.10 Parameter an Rave-Reports übergeben ...................................................................... 1453 24.11 Berichte verketten ..................................................................................................... 1455 24.12 Mit dem alten QuickReport arbeiten ......................................................................... 1455

25 How-to: Komponenten/OOP .................................................................... 25.1 Eine einfache Klasse benutzen .................................................................................. 25.2 Eigenschaften und Felder verstehen .......................................................................... 25.3 Private/öffentliche Formularmethoden aufrufen ........................................................ 25.4 Auf mehrere Formulare zugreifen ............................................................................. 25.5 Nach Komponenten suchen ....................................................................................... 25.6 Den Besitzer einer Komponente ermitteln ................................................................ 25.7 Eine Ereignisprozedur zur Laufzeit zuweisen ........................................................... 25.8 Zur Laufzeit alle Objekteigenschaften ermitteln ....................................................... 25.9 Neue Komponenten-Packages installieren ................................................................ 25.10 Aus einer Unit eine Komponente machen ................................................................. 25.11 Eine Farbauswahl-Komponente programmieren ....................................................... 25.12 Eine unsichtbare Komponente programmieren ......................................................... 25.13 Eine grafische Komponente programmieren ............................................................. 25.14 Eine Systemkomponente schreiben ........................................................................... 25.15 Word-Formulare über OLE drucken ......................................................................... 25.16 Eine .NET-Assembly einbinden ................................................................................

1459 1459 1462 1465 1467 1470 1471 1473 1474 1475 1478 1485 1489 1493 1496 1503 1505

26 How-to: Internet/Intranet ....................................................................... 26.1 Feststellen, ob TCP/IP auf dem PC installiert ist ....................................................... 26.2 Die IP-Adresse des aktiven Computers ermitteln .................................................... 26.3 Ermitteln, ob eine Internet-Verbindung besteht ......................................................... 26.4 Dateien automatisch aus dem Internet laden ............................................................. 26.5 Daten ins HTML-Format exportieren ....................................................................... 26.6 Einen WebBrowser programmieren .......................................................................... 26.7 Auf MS-Mail-Funktionen zugreifen .......................................................................... 26.8 Mailversand über OLE-Automation realisieren ........................................................ 26.9 Eine E-Mail automatisch generieren ......................................................................... 26.10 Einen Web-Link in mein Programm einbauen .......................................................... 26.11 Eine Web-Adresse aufrufen ...................................................................................... 26.12 Den Internet Information Server installieren ............................................................. 26.13 Eine einfache Web-Server-Anwendung verstehen .................................................... 26.14 ADO-Recordsets an eine ASP-Seite senden ..............................................................

1507 1507 1508 1509 1511 1512 1516 1520 1523 1525 1526 1527 1529 1535 1537

27

Inhaltsverzeichnis

26.15 26.16 26.17 26.18 26.19

Eine einfache Multi-Tier-Anwendung testen ............................................................ Ein ClientDataSet editieren ....................................................................................... Mit einer SocketConnection arbeiten ........................................................................ Mit einer WebConnection arbeiten ........................................................................... Eine 3-Tier-Applikation programmieren ...................................................................

1542 1547 1549 1553 1556

27 How-to: System ....................................................................................... 27.1 Systemzeit freigeben ................................................................................................. 27.2 Threads verstehen ..................................................................................................... 27.3 Windows-Botschaften verarbeiten ............................................................................ 27.4 Den Computer herunterfahren und neu starten .......................................................... 27.5 Ein anderes Programm starten ................................................................................... 27.6 Daten zwischen Prozessen austauschen .................................................................... 27.7 Mit der Registrierdatenbank arbeiten ........................................................................ 27.8 Binäre Daten aus der Registry laden ......................................................................... 27.9 Registry-Zweige komplett auslesen ........................................................................... 27.10 Die installierten Anwendungen anzeigen .................................................................. 27.11 Die Systemkonfiguration ermitteln ........................................................................... 27.12 Das aktuelle Betriebssystem ermitteln ....................................................................... 27.13 Alle geöffneten Windows-Fenster anzeigen .............................................................. 27.14 Die Taskliste anzeigen .............................................................................................. 27.15 Den EXE-Namen eines Prozesses ermitteln .............................................................. 27.16 Die Prozess-Priorität der Anwendung ändern ........................................................... 27.17 Die Netzwerkdialoge einbinden ................................................................................ 27.18 Den Windows-Lizenznehmer ermitteln ..................................................................... 27.19 Die Seriennummer der Festplatte ermitteln ............................................................... 27.20 Unter Windows automatisch einloggen ..................................................................... 27.21 Den System-About-Dialog anzeigen ......................................................................... 27.22 Eine laufende EXE-Datei löschen ............................................................................. 27.23 Uninstall-Routinen in ein Programm einbauen ......................................................... 27.24 Den Status der CapsLock-Taste ändern ..................................................................... 27.25 Die Anzeige kritischer Systemfehler vermeiden ....................................................... 27.26 Eine Schriftart temporär installieren .......................................................................... 27.27 Einen systemweiten Hot-Key setzen .........................................................................

1563 1563 1566 1571 1574 1576 1581 1586 1589 1591 1593 1597 1601 1603 1605 1607 1609 1611 1613 1615 1616 1618 1619 1619 1623 1624 1624 1626

28

Inhaltsverzeichnis

28 How-to: Desktop ...................................................................................... 28.1 Kontrollieren, ob Delphi aktiv ist .............................................................................. 28.2 Einen mehrfachen Programmstart verhindern ........................................................... 28.3 Programme in die Systemsteuerung integrieren ........................................................ 28.4 Eine Anwendung in die Registry einbinden .............................................................. 28.5 Control-Panel-Anwendungen aufrufen ...................................................................... 28.6 Programme vor dem Task-Manager verstecken ........................................................ 28.7 Die Taskbar Notification Area verwenden ................................................................ 28.8 Programmgruppen erzeugen ..................................................................................... 28.9 Verknüpfungen erzeugen .......................................................................................... 28.10 Die Desktop-Icons ein-/ausblenden ........................................................................... 28.11 Den Windows-Desktop-Folder ermitteln .................................................................. 28.12 Den Desktop als Canvas verwenden ......................................................................... 28.13 Deststellen, ob Active Desktop installiert ist ............................................................. 28.14 Die Taskbar ausblenden ............................................................................................ 28.15 Den Grafikmodus wechseln ...................................................................................... 28.16 Ermitteln, ob der ScreenSaver läuft ........................................................................... 28.17 Auf Bildschirmeigenschaften zugreifen .................................................................... 28.18 Testen, ob große oder kleine Fonts installiert sind .................................................... 28.19 Den Bildschirmschoner aktivieren/deaktivieren ........................................................ 28.20 Drag & Drop mit dem Explorer realisieren ............................................................... 28.21 System-Icons verwenden ........................................................................................... 28.22 Den Windows-Dialog "Datei suchen" aufrufen ......................................................... 28.23 Dateien in den Papierkorb löschen ............................................................................ 28.24 Den Papierkorb leeren ...............................................................................................

1629 1629 1630 1631 1635 1637 1638 1640 1644 1646 1648 1649 1650 1651 1653 1653 1656 1658 1660 1660 1661 1663 1665 1666 1667

29 How-to: Wissenschaft/Technik ................................................................ 29.1 Einen Wert schätzen .................................................................................................. 29.2 Die Zeit auf eine Viertelstunde genau runden ........................................................... 29.3 Zeitdifferenzen ermitteln ........................................................................................... 29.4 Eine Prüfsumme erstellen .......................................................................................... 29.5 Einen Text verschlüsseln ........................................................................................... 29.6 In einer Datei sortieren und suchen ........................................................................... 29.7 Eine Iteration verstehen ............................................................................................. 29.8 Den Abstand zwischen zwei Punkten bestimmen ..................................................... 29.9 Eine Unit für komplexe Zahlen entwickeln ............................................................... 29.10 Klassen für wissenschaftliche Anwendungen ...........................................................

1669 1669 1671 1672 1674 1676 1679 1682 1685 1687 1694

Inhaltsverzeichnis

30 How-to: Sonstiges .................................................................................... 30.1 Den Fensterinhalt in die Zwischenablage kopieren ................................................... 30.2 Die Zwischenablage automatisch speichern .............................................................. 30.3 Eine Pause realisieren ................................................................................................ 30.4 Schleifen mit der ESC-Taste abbrechen .................................................................... 30.5 Eine Schleife unterbrechen und fortsetzen ................................................................ 30.6 Copyright-Meldungen in eine DLL integrieren ......................................................... 30.7 Eine Callback-Funktion schreiben ............................................................................ 30.8 Eine Backup-Funktion schreiben .............................................................................. 30.9 Daten im MS Excel-Format exportieren ................................................................... 30.10 Ressourcen einbinden ................................................................................................ 30.11 Die Programm-Versionsnummern ermitteln ............................................................. 30.12 Mehrsprachige Anwendungen entwickeln ................................................................ 30.13 Den Quellcode versionsabhängig compilieren .......................................................... 30.14 Programmeinstellungen automatisch speichern ......................................................... 30.15 Verschwundene Komponenten aufspüren ................................................................. 30.16 Word-Dokumente in HLP-Dateien umwandeln ........................................................ 30.17 Eine HLP-Hilfedatei erzeugen .................................................................................. 30.18 Eine HLP-Inhaltsdatei hinzufügen ............................................................................ 30.19 In einer HLP-Hilfedatei blättern ................................................................................ 30.20 Eine HLP-Datei in Delphi einbinden ......................................................................... 30.21 Ein HLP-Makro aufrufen .......................................................................................... 30.22 HTML-Hilfe-Dateien erstellen .................................................................................. 30.23 HTML-Hilfe-Dateien in Delphi einbinden ................................................................ 30.24 Auf InstallShield verzichten ...................................................................................... 30.25 Ein selbstinstallierendes Programm schreiben .......................................................... 30.26 Die ZIP-Routinen richtig einsetzen ...........................................................................

29 1699 1699 1701 1705 1706 1707 1709 1710 1713 1718 1723 1727 1729 1733 1734 1736 1737 1745 1750 1753 1755 1757 1758 1763 1764 1767 1775

Anhang ..................................................................................................... 1781 A: Glossar ...................................................................................................................... 1781 B: ANSI-Tabelle ............................................................................................................ 1785 Index ........................................................................................................ 1787

Vorwort

Vorwort Trotz zunehmender Verbreitung von Microsofts .NET-Technologie gibt es heute immer noch viele Delphi-Programmierer, die ausschließlich Win32-Anwendungen erstellen wollen. Aufgrund anhaltender Nachfrage haben wir deshalb unsere erfolgreichen und inzwischen vergriffenen Titel "Borland Delphi 7 – Grundlagen und Profiwissen" und "Borland Delphi 7 – Kochbuch" geringfügig überarbeitet und in einem gemeinsamen Band zusammengefasst. Um das vorgegebene Seitenlimit nicht zu sprengen, konnte in diesem Sammelband allerdings nur ein Teil des Kochbuchs abgedruckt werden. Dies ist aber kein gravierender Nachteil, denn der komplette Inhalt befindet sich als E-Book auf der Buch-CD. Zusätzlich ist dort auch ein drittes Buch enthalten: "Datenbankprogrammierung mit Borland Delphi". Insgesamt erhalten Sie damit weit mehr als 2.500 Seiten an Informationen zu fast allen Bereichen der Anwendungsentwicklung mit Borland Delphi. Sie halten somit ein faires Angebot sowohl für Einsteiger als auch für fortgeschrittene Win32Delphi-Programmierer in den Händen: ■ Für den Einsteiger wollen wir den einzig vernünftig gangbaren Weg beschreiten, nämlich nach dem Prinzip "soviel wie nötig" eine schmale Schneise durch den Urwald der Delphi-Programmierung schlagen, bis eine Lichtung erreicht ist, die erste Erfolgserlebnisse vermittelt. Diesem Ziel dienen zum Beispiel die zahlreichen Lernrezepte und die zwei im Praxiskapitel 15 enthaltenen Crashkurse zu Grundlagen der Sprache und der OOP. ■ Für den Profi wollen wir in diesem Buch eine Vielzahl von Informationen bereitstellen, nach denen er bisher vergeblich gesucht hat. Dabei haben die Autoren vor allem aus ihrer eigenen Programmierertätigkeit, vielen Vorlesungen und Programmierer-Workshops sowie aus den zahlreichen Leserfeedbacks zu ihren Delphi-Vorgängertiteln, die seit der ersten Delphi-Version 1995 auf dem Markt sind, geschöpft.

Grundlagenbuch und Kochbuch ergänzen sich Die 16 Grundlagenkapitel unseres Buchs sind so gegliedert, dass sie einerseits eine logische Aufeinanderfolge bilden, andererseits aber auch quergelesen werden können. Programmieren lernt man aber nur durch Beispiele! Getreu diesem Motto wird die vermittelte Theorie stets mit zahlreichen Quellcode-Schnipseln untermauert. Hunderte weiterere "Koch-

32

Vorwort

buch"-Rezepte aus den unterschiedlichsten Themengebieten finden Sie in den Kapiteln 17 bis 30, welche den zweiten Teil des Buchs ausmachen. Sie werden auch in diesem dicken Buch manche Lücke entdecken und einiges finden, was in der einen oder anderen Quelle besser oder ausführlicher beschrieben ist. Trotzdem halten Sie einen halbwegs überschaubaren Breitband-Mix in den Händen, der sowohl vertikal vom Einsteiger bis zum Profi als auch horizontal von den einfachen Sprachelementen bis hin zur Entwicklung eigener Komponenten jedem etwas bietet und sich dabei bemüht, nicht den Blick für das Wesentliche im Win32-Dschungel zu verlieren.

Zur Buch-CD Die zu diesem Buch mitgegebene CD enthält alle wesentlichen Quelltexte dieses Buchs. Auch eine Installationsdatei für die Northwind-Datenbank des Microsoft SQL Servers ist dabei. Beachten Sie bitte folgende Hinweise: ■ Einige wenige der Datenbankprojekte verwenden absolute Pfadnamen, die Sie vor dem Kompilieren des Beispiels erst noch anpassen müssen. ■ Wir bitten um Nachsicht bei Zeilenumbrüchen innerhalb von Strings im gedruckten Code, die nicht immer mit dem "+"-Operator getrennt wurden. ■ Beachten Sie die zu einigen Beispielen beigefügten Liesmich.txt-Dateien, die Sie auf besondere Probleme hinweisen. ■ Informieren Sie sich auf unserer Website www.doko-buch.de über Ergänzungen und Bugfixes zum Buch. HINWEIS: Beachten Sie bitte, dass sich Inhaltsverzeichnis und Index auf den kompletten Inhalt

(also auch auf das E-Book) beziehen.

Dank an alle Helfer Beide Autoren wollen es auch diesmal nicht versäumen, sich bei Frau und Kindern ausdrücklich für deren Geduld und Nachsicht zu bedanken, die ein solches Projekt erfordert. Einen herzlichen Dank auch an die netten Damen und Herren vom Carl Hanser Verlag, allen voran unseren Lektor Fernando Schneider, die uns nach Kräften bei der schnellen Zusammenstellung dieser Neuauflage unterstützt haben. Ihnen, liebe Leserin und lieber Leser, wünschen wir die notwendige Kraft und Ausdauer auf dem Weg zum erfolgreichen Delphi-Programmierer! Altenburg und Frankfurt (Oder), im März 2007 Walter Doberenz und Thomas Gewinnus www.doko-buch.de

1

Einführung

Kapitel

1

Einführung Dieses Kapitel gewährt Ihnen erste Einblicke in die Arbeit mit Borland Delphi 7. Da für den Einsteiger das viele "Fachchinesisch" bereits das Maß des Erträglichen weit übersteigen dürfte, werden je nach Stand Ihrer Vorkenntnisse unterschiedliche Vorgehensweisen beim Durcharbeiten des Stoffs empfohlen: Einsteiger: Überspringen Sie den folgenden Abschnitt und beginnen Sie gleich mit der Installation (1.1.3). Nach einem kurzen Blick in die Windows-Philosophie (1.2) sollten Sie sich sofort an das Einführungsbeispiel 1.3.1 wagen. Fortgeschrittene: Für Sie dürfte lediglich der folgende Abschnitt 1.1.1 sowie der Abschnitt 1.4 (Neue Features von Delphi 7) von Interesse sein.

1.1 Die Ruhe vor dem Sturm Bevor es mit dem Programmieren so richtig losgehen kann, gilt es einige Vorbereitungen zu treffen.

1.1.1 Software Folgende vier Pakete von Borland Delphi 7 sind im Angebot, für welches davon Sie sich entscheiden, ist nicht zuletzt eine Frage des Geldbeutels. ■ BD 7 Personal Bereits mit diesem Einsteigerpaket (das allerdings nur dann ausreicht, wenn auf Internet- und Datenbankentwicklungen kein Wert gelegt wird) erschließt sich Ihnen die Welt der WindowsProgrammierung. Mehr als 85 Standardkomponenten, die Sie mit Ihren Programmen weitergeben können, stehen Ihnen zur Gestaltung der Benutzerschnittstelle zur Verfügung. Neben Object Pascal, OOP und visueller Vererbung haben Sie die Möglichkeit, durch DLLs und OBJDateien Funktionalität mit Entwicklungssystemen wie C oder Paradox auszutauschen. Weitere Features sind Windows-Unterstützung für OLE-Automation, Active Documents, COM-Interfaces, Packages, DLL-Debugging, Multithreading, überladene Methoden, dynamische Arrays, 64-Bit-Integer, Help-Compiler, Multimonitor und andere. Keinesfalls vergessen werden soll die jetzt in allen Versionen zur Verfügung stehende Möglichkeit der .NET-Interoperabilität, die

34

Kapitel 1

Einführung

eine Zusammenarbeit mit Komponenten erlaubt, die in Microsofts neuer .NET-Technologie entwickelt wurden. ■ BD 7 Professional Dieses für "Otto Normalverbraucher" zu empfehlende Paket verfügt zusätzlich über die umfangreiche Palette von mehr als 160 wiederverwendbaren, anpassbaren und erweiterbaren CLX-Komponenten, mit denen unter anderem auch Sie Internet-, Datenbank- und GUIAnwendungen erstellen können. Ein umfangreiches Angebot von dbExpress- and BDE-Datenbanktreibern ermöglicht das Einbinden lokaler Datenbanken in Ihre Anwendungen. In NetCLX sind Technologien zur Browser-, Server- und Datenbankentwicklung vereint, mit denen Sie skalierbare Webanwendungen (für eine große Anzahl von Benutzern und für große Datenmengen) entwickeln. Schließlich noch ein über den Rahmen dieses Buchs hinausgehender Hinweis: Durch Kombination von Delphi 7 mit Kylix brauchen Sie nur einen Funktionssatz und nur eine Codebasis, um plattformübergreifende Linux-/Windows-Anwendungen zu entwickeln. ■ BD 7 Enterprise Dieses Profi-Paket erlaubt die Entwicklung von EBusiness-Anwendungen der nächsten Generation. BizSnap ermöglicht das Erstellen von Webdiensten und -verbindungen, mit denen sich ein Unternehmen in die Anwendungen der Kunden und Lieferanten integrieren lässt. Mit WebSnap, der Delphi-Plattform zur Entwicklung von Webanwendungen, steht komponentenbasiertes RAD zur Verfügung. Mit DataSnap lassen sich mehrschichtige Anwendungen (Midas) erstellen. Last but not least bietet Ihnen nur dieses Paket eine umfangreiche XMLUnterstützung. ■ BD 7 Architect In diesem Maximalpaket ist zusätzlich die CD "Bold für Delphi" enthalten. Mit dieser Software haben Sie die Möglichkeit, die Model Driven Architecture (MDA) einzusetzen, um damit Ihre Programmentwicklungen auf Basis der UML-Technologie effektiver zu gestalten. Vollversionen von Borland Delphi 7 können Sie bei Ihrem Softwarehändler oder aber auch per Internet erwerben. Über die Borland-Webadresse www.borland.de erreichen Sie auch eine äußerst umfangreiche Liste, in der alle Features der drei Delphi-Pakete peinlichst genau aufgelistet sind. HINWEIS: Für das Verständnis bzw. Nachvollziehen von ca. 80 % der Beispiele dieses Buchs

dürfte bereits das Paket BD 7 Personal ausreichend sein, wer aber viel mit Datenbanken programmieren will, sollte allerdings zumindest über BD 7 Professional verfügen.

1.1.2 Hardware Vor der Installation von Delphi 7 sollten Sie auch über eine eventuelle Erneuerung/Ergänzung Ihrer PC-Ausrüstung nachdenken. Entgegen den doch etwas tief gestapelten Richtlinien des Herstellers empfehlen wir folgende Ausstattung:

1.1 Die Ruhe vor dem Sturm

35

■ ab 600 MHz Pentium ■ ab 128 MB RAM ■ ab ca. 500 MB Festplattenspeicher ■ Betriebssystem XP, Windows 2000, ME, NT 4.0 (ab SP5) ■ CD-ROM-Laufwerk (oder zumindest Netzzugriff auf ein solches) HINWEIS: Alle im Buch bzw. auf der Buch-CD enthaltenen Beispiele wurden unter MS Win-

dows XP vollständig getestet. Unter den übrigen Betriebssystemen erfolgten nur stichpunktartige Tests, weshalb nicht ausgeschlossen werden kann, dass es in einigen seltenen Fällen zu Fehlfunktionen kommen kann.

1.1.3 Installation von Delphi 7 Bei der Installation brauchen Sie sich eigentlich um nichts zu kümmern. Klicken Sie auf den "Delphi 7"-Eintrag und folgen Sie den Anweisungen des Setup-Programms, das je nach Paket (Personal, Professional oder Enterprise/Architect) ein unterschiedliches Angebot bereithält:

Obiger Screenshot zeigt das Angebot des Enterprise- bzw. Architect-Pakets. Im Installationsmenü des Professional-Pakets werden Sie "InterBase 6.5 Server", "Remote Debugger-Server" und "ModellMaker 6.20" vergeblich suchen. Nachdem der erfolgreiche Abschluss der Installation verkündet wurde, klicken Sie den StartButton. Unter "Programme" entdecken Sie jetzt auch "Borland Delphi 7".

1.1.4 Dokumentation Das vorliegende Buch bietet vereinbarungsgemäß keine umfassende Referenz, es kann also die Delphi-Dokumentation nicht oder nur teilweise ersetzen. Diese besteht aus diversen Handbüchern, aus der integrierten Online-Hilfe sowie aus der Companion Tools-CD.

36

Kapitel 1

Einführung

Handbücher Zur Professional-Edition werden außer einem erschreckend dünnen Heftchen "Einführung" keine weiteren Handbücher ausgeliefert. Etwas spendabler zeigt sich da die Enterprise-Edition, der zusätzlich beiliegt: ■ Das "Delphi-Entwicklerhandbuch" mit Informationen über komplexere Anwendungsentwicklungen, Datenbankanwendungen, benutzerdefinierte Komponenten, Internet/Intranet, ... ■ Die "Delphi-Sprachreferenz" mit Beschreibung der Syntax von Object Pascal, der Schnittstellen und DLLs, der Packages, des integrierten Assemblers.

Online-Hilfe Alle in den Handbüchern enthaltenen Informationen sind auch über die in Delphi integrierten Online-Hilfefunktionen abrufbar. Sehr bald wird die Online-Hilfe Ihr unentbehrlicher Begleiter bei der Anwendungsentwicklung sein, da sie aufgrund der komfortablen Windows-typischen Suchfunktionen viel schneller und effektiver bestimmte Informationen zur Verfügung stellen kann, als dies durch umständliches Nachschlagen in einem der Handbücher möglich wäre.

Companion-Tools Weitere umfangreiche Dokumentationen zu Delphi finden Sie (leider nur in Englisch) auf den beiden Companion Tools-CDs. Öffnen Sie dort die Datei index.html, um sich den Inhalt anzeigen zu lassen. HINWEIS: Im Ordner \borland finden Sie die 13 MB-Datei Online+PDF.zip mit .html- und

.pdf-Dateien zu allen wichtigen Themen!

1.2 Die Windows-Philosophie Delphi gibt Ihnen die Möglichkeit, eigene Windows-Programme mit relativ geringem Aufwand und nach nur kurzer Einarbeitungszeit selbst zu entwickeln. Es wird dabei keinesfalls von Ihnen verlangt, tiefer in das äußerst komplexe Gebiet der Windows-Programmierung einzudringen. Sie werden den Einstieg aber umso leichter schaffen, wenn Sie sich gleich zu Beginn Klarheit über die zunächst fremdartig anmutende, aber dann doch einfach und gleichzeitig genial erscheinende Windows-Philosophie verschaffen.

1.2.1 Mensch-Rechner-Dialog Die Art und Weise, wie die Kommunikation mit dem Benutzer (Mensch-Rechner-Dialog) abläuft, dürfte wohl der gravierendste Unterschied zwischen den klassischen Betriebssystemen (DOS, UNIX) und Windows sein. Unter DOS "wartet" das Programm auf eine Eingabe, indem Tastatur

37

1.2 Die Windows-Philosophie

und Maus zyklisch abgefragt werden. Alle peripheren Geräte agieren relativ unabhängig voneinander:

Programm

Unter Windows ist der Zugriff auf die Peripherie ins System integriert:

Windows-System Programm

Programme haben mit der Verwaltung von Tastatur, Maus, Bildschirm, Drucker etc. direkt nichts mehr zu tun, Windows nimmt ihnen diese Arbeit ab, indem es sich quasi wie eine "Schale" zwischen Ein-/Ausgabegeräte und Anwenderprogramm schiebt. Ein- und Ausgaben werden in so genannte "Nachrichten" umgesetzt, die zum Programm geschickt und dort kontinuierlich verarbeitet werden. Daraus ergibt sich ein grundsätzlich anderes Prinzip: Während unter DOS alle Initiativen für die Benutzerkommunikation vom Programm ausgehen, hat unter Windows der Bediener den Hut auf. Er bestimmt durch seine Eingaben den Ablauf der Rechnersitzung. Während eine DOS-Applikation den gesamten Bildschirm belegt, erfolgt die WindowsAusgabe in einem oder auch mehreren Fenstern (Formularen).

1.2.2 Objekt- und ereignisorientierte Programmierung Vergleicht man ein "normales" Programm, das aus einer langen Liste von Anweisungen besteht, mit einem Windows-Programm, so stellt man als Erstes folgenden Hauptunterschied fest: Im "normalen" Programm werden die Befehle sequenziell abgearbeitet, d.h. Schritt für Schritt hintereinander.

38

Kapitel 1

Einführung

Unter Windows laufen alle Aktionen objekt- und ereignisorientiert ab, eine streng vorgeschriebene Reihenfolge für die Eingabe und Abarbeitung der Befehle gibt es nicht mehr. Für jede Aktivität des Anwenders ist ein Programmteil zuständig, der weitgehend unabhängig von anderen Programmteilen agieren kann und muss. Ein Windows-Programmierer hat sich vor allem mit folgenden Begriffen auseinander zu setzen:

Objekte (Objects) Das sind zunächst die Elemente der Windows-Bedienoberfläche, denen wiederum Eigenschaften, Ereignisse und Methoden zugeordnet werden. Beschränken wir uns der Einfachheit halber zunächst nur auf die visuelle Benutzerschnittstelle (VCL), so haben wir es in Delphi mit folgenden (sichtbaren) Objekten zu tun: Formulare

Komponenten

Sonstige Objekte

Das sind die Fenster, in denen eine Delphi-Anwendung ausgeführt wird. In einem Formular (TForm) können weitere untergeordnete Formulare, Komponenten (siehe unten), Text oder Grafik enthalten sein. Diese tauchen als Menüs (TMenue), Schaltflächen (TButton), Bildlaufleisten (TScrollBar), Listenfelder (TListBox), Textfelder (TEdit) oder in vielfältiger Weise als ActiveX-Komponenten auf. Sie stellen die eigentliche Benutzerschnittstelle dar, über die mittels Tastatur oder Maus Eingaben erfolgen oder die der Ausgabe von Informationen dienen. Der Objektbegriff wird auch auf solche Schnittstellenelemente wie z.B. den Bildschirm (TScreen), die Windows-Zwischenablage (TClipboard), den Drucker (TPrinter), Datenbankobjekte (TTable ...) etc. ausgedehnt. Weiterhin können Sie selbst eigene Objekte programmieren.

Der Nachrichtenfluss entsteht durch Kommunikation der Objekte untereinander, d.h. durch das Versenden von Botschaften (Messages). Eine solche Botschaft besteht normalerweise aus dem Namen einer Methode, die das aufgerufene Objekt ausführen soll.

Eigenschaften (Properties) Unter diesem Begriff versteht man die Attribute von Objekten, wie z.B. die Höhe (Height) und die Breite (Width) eines Formulars oder die Farbe (Color) eines Editierfeldes. Jedes Objekt verfügt über seinen eigenen Satz von Eigenschaften, die teilweise nur zur Entwurfs- oder nur zur Laufzeit veränderbar sind.

Methoden (Methods) Das sind die im Objekt definierten Funktionen und Prozeduren, die gewissermaßen das "Verhalten" beim Eintreffen einer Nachricht bestimmen. So erzeugt z.B. die LineTo-Methode eine Linie auf der Zeichenfläche (Canvas bzw. Leinwand) eines Formulars. Eine Methode kann z.B. auch das Verhalten des Objekts bei einem Mausklick, einer Tastatureingabe oder sonstigen Ereignissen (siehe unten) definieren. Im Unterschied zu den oben genannten Eigenschaften (Properties), die eine statische Beschreibung liefern, bestimmen Methoden die dynamischen Fähigkeiten des Objekts.

1.2 Die Windows-Philosophie

39

Ereignisse (Events) Dies sind Nachrichten, die vom Objekt empfangen werden. Sie stellen die eigentliche WindowsSchnittstelle dar. So ruft z.B. das Anklicken eines Steuerelements mit der Maus in Windows ein OnClick-Ereignis hervor. Aufgabe eines Delphi-Programms ist es, auf alle interessanten Ereignisse gemäß dem Wunsch des Anwenders zu reagieren. Dies geschieht in so genannten Ereignisbehandlungsroutinen (Event-Handler).

1.2.3 Windows-Programmierung mit Delphi Herkömmliche DOS-Programmiertechniken erforderten meist als erste Aktivität das detaillierte Erstellen eines Programmablaufplans (PAP) und tiefgründige Überlegungen zur Gestaltung der Benutzerschnittstelle bzw. der Reihenfolge von Ein- und Ausgaben. Delphi befreit Sie von diesen, besonders bei größeren Projekten sehr lästigen und langwierigen Vorarbeiten und erlaubt eine systematische Vorgehensweise in folgenden vier Etappen: 1. Visueller Entwurf der Bedienoberfläche 2. Zuweisen der Objekteigenschaften 3. Verknüpfen der Objekte mit Ereignissen 4. Programmtest

Bereits in der ersten Etappe wird ein deutlicher Unterschied zur herkömmlichen Programmiertechnik sichtbar: Am Anfang steht der Oberflächenentwurf! Ausgangsbasis ist das vom Editor bereitgestellte Startformular (Form1), das mit diversen Komponenten, wie Schaltflächen (Buttons) oder Editierfenstern, ausgestattet wird. Unter Delphi finden Sie ein nahezu komplettes Angebot der Windows-typischen Komponenten. Diese werden, ähnlich wie in einem Zeichenprogramm, von einer Werkzeugleiste (Komponentenpalette) ausgewählt, mittels Maus an ihre endgültige Position gezogen und (falls nötig) in ihrer Größe verändert. In der zweiten Etappe braucht man sich eigentlich nur noch um die Objekteigenschaften zu kümmern, die von den Voreinstellungen (Defaults) abweichen. Bereits während der ersten Etappe hat man, mehr oder weniger unbewusst, Eigenschaften, wie Position und Abmessungen von Formularen und Komponenten, verändert. Bestimmte Eigenschaften, wie z.B. der Inhalt eines Editierfeldes, lassen sich allerdings erst zur Laufzeit sinnvoll zuweisen. Die dritte Etappe haucht Leben in unsere bislang nur mit statischen Attributen ausgestatteten Objekte. Hier muss festgelegt werden, wie das Formular oder die betreffende Komponente auf bestimmte Ereignisse zu reagieren haben. Delphi stellt auch hier "vorgefertigten" Rahmencode für alle zum jeweiligen Objekt passenden Ereignisse zur Verfügung. Der Programmierer füllt diesen Rahmen mit Pascal-Quellcode aus. Hier können Methoden oder Prozeduren aufgerufen werden, auch Eigenschaften anderer Objekte lassen sich während der Laufzeit neu zuweisen. In der vierten Etappe schlägt schließlich die Stunde der Wahrheit, denn ein Programm, das auf Anhieb funktioniert, gibt es so gut wie nicht. Genaueres dazu erfahren Sie im Kapitel 5.

40

Kapitel 1

Einführung

Der in diesen vier Etappen praktizierte visuelle Oberflächenentwurf, verbunden mit dem ereignisorientierten Entwurfskonzept, macht Borland Delphi zu dem, was es heute bereits ist, dem heute wohl populärsten Programmiersystem neben Microsofts Visual Basic.

1.3 Erste Schritte in Delphi Jeder Weg – und ist er noch so weit – beginnt mit dem ersten Schritt. Dieser Abschnitt bietet Ihnen deshalb einen Delphi-"Schnupperkurs", gestaffelt in zwei unterschiedliche Schwierigkeitsgrade, da wir davon ausgehen, dass der Leserkreis dieses Buchs vom absoluten Anfänger bis hin zum Routinier reicht, der schon genügend Erfahrungen in anderen Programmiersprachen gesammelt hat.

1.3.1 Einführungsbeispiel für Einsteiger Die folgende kleine Applikation kann jeder nachvollziehen, ohne dass dafür die geringsten Programmierkenntnisse erforderlich wären. Die (zugegebenerweise recht armselige) Funktionalität beschränkt sich auf ein Fenster mit gelbem Hintergrund und einer Schaltfläche, über die per Mausklick die Beschriftung der Titelleiste geändert werden kann. Das Beispiel demonstriert, mit welch geringem Aufwand man in Delphi eigene Anwendungen erstellen kann. Außerdem können die bisher eingeführten Begriffe erklärt und die Unterschiede zwischen der althergebrachten (klassischen) Programmiertechnik und der visualisierten, ereignis- und objektorientierten Windows-Programmierung deutlich gemacht werden. Der damit ausgelöste Aha-Effekt wird Sie sicher ausreichend motivieren, um manche Durststrecken der nächsten Kapitel zu überstehen. Auch ohne eine detaillierte Kenntnis der Delphi-Programmierumgebung (die ausführliche Beschreibung folgt erst im nächsten Kapitel) werden Sie keine Probleme haben, die folgende Anleitung (entsprechend den eingangs erläuterten drei Etappen) nachzuvollziehen.

1. Etappe: Visueller Entwurf der Bedienoberfläche Der Programmaufruf erfolgt über das Start-Menü bzw. über eine von Ihnen vorher eingerichtete Desktop-Verknüpfung. Gleich zu Beginn wird Ihnen von der Delphi-IDE1 standardmäßig ein Startformular (Form1) zur Verfügung gestellt, das Sie in der Bildschirmmitte sehen. Darauf platzieren Sie einen Button. Die dazu notwendige Vorgehensweise unterscheidet sich kaum von der bei einem normalen Zeichenprogramm: Wählen Sie das gewünschte Element durch Klick auf die entsprechende Schaltfläche in der am oberen Bildrand sichtbaren Komponentenpalette aus.

1

Integrated Developer Environment (Entwicklungsumgebung)

41

1.3 Erste Schritte in Delphi

Klicken Sie dann auf die Mitte des Formulars und zoomen Sie (bei gedrückt gehaltener linker Maustaste) den Button auf die gewünschte Größe.

2. Etappe: Zuweisen der Objekteigenschaften Um den Formular-Hintergrund gelb einzufärben, klicken Sie erst auf das Formular und dann auf den Color-Eintrag auf der "Eigenschaften"-Seite des Objektinspektors (ein extra Fenster am linken Bildschirmrand, das Sie auch mit der F11-Taste herbeizaubern können) und wählen Sie in der kleinen Rollbox den Eintrag clYellow.

Hier Color-Eigenschaft einstellen!

Der Formularhintergrund färbt sich sofort gelb, obwohl das Programm noch nicht gestartet ist!

42

Kapitel 1

Einführung

3. Etappe: Verknüpfen der Objekte mit Ereignissen Öffnen Sie die "Ereignisse"-Seite des Objektinspektors, wählen Sie im Objektselektor (das ist die Klappbox ganz oben) den Eintrag Button1 und doppelklicken Sie auf die noch leere Zeile des OnClick-Ereignisses.

1. Hier Button1-Objekt auswählen!

2. Hier OnClick-Ereignis besetzen!

Es öffnet sich ein Fenster (Unit1.pas) mit dem bereits vorgefertigten Rahmencode für das OnClickEreignis:

3. Hier Code ergänzen!

Fügen Sie die (im Folgenden unterstrichene) Anweisung ein: procedure TForm1.Button1Click(Sender: TObject); begin Form1.Caption := 'H a l l o D e l p h i F r e u n d e !' end;

Wenn Sie sich jetzt die "Ereignisse"-Seite des Objektinspektors anschauen, erkennen Sie neben dem OnClick-Ereignis den Eintrag Button1Click.

1.3 Erste Schritte in Delphi

43

4. Etappe: Testen Compilieren Sie das Programm durch Drücken der F9-Taste oder der Start-Schaltfläche (Symbolleiste). Sie haben nun eine zwar kleine, aber trotzdem fix und fertige Windows-Applikation vor sich. Der Button funktioniert, die Titelleiste ändert sich tatsächlich!

Einsteiger-Tipps ■ Möglicherweise waren im Verlauf der Programmentwicklung einige der Fenster (Form1, Unit1.pas, Objektinspektor) plötzlich auf Nimmerwiedersehen verschwunden. Über das Menü Ansicht|Fensterliste... (Alt+O) oder Ansicht|Objektinspektor (F11) zaubern Sie die lichtscheuen Elemente wieder zurück auf den Bildschirm. ■ Richten Sie sich über das Menü Tools|Umgebungsoptionen Ihre Werkstatt so bequem wie möglich ein. Auf der Seite "Präferenzen" sollten Sie z.B. das lästige automatische Andocken der Fenster abstellen, auf der Seite "Designer" legen Sie die Rastergröße fest. An den übrigen Einstellungen sollten Sie allerdings erst dann herumdoktern, wenn Sie kein absoluter Anfänger mehr sind.

1.3.2

Einführungsbeispiel für Umsteiger Unsere zweite Applikation ist für all diejenigen gedacht, die bereits gewisse Erfahrungen in einer Programmiersprache gesammelt haben und denen das vorangegangene Beispiel nicht mehr als nur ein müdes Lächeln entlockt hat. Gegenstand ist die Umrechnung von Euro in Dollar (und umgekehrt), also ein simpler Währungsrechner.

Zurück in die Vergangenheit Für den Umsteiger, der bereits Pascal-Praxis hat, soll zu Vergleichszwecken zunächst kommentarlos die klassische Programmiertechnik unter DOS (z.B. mit TP 5.5) demonstriert werden: PROGRAM euro_dollar; VAR kurs, euro: Real; s: Char; BEGIN REPEAT WriteLn('Umrechnung Euro <=> Dollar'); REPEAT Write('Kurs: '); ReadLn(kurs) UNTIL kurs > 0;

44

Kapitel 1

Einführung

REPEAT Write ('Euro: '); ReadLn(euro) UNTIL euro > 0; WriteLn('Sie erhalten ', euro/kurs:6:2,' Dollar!'); WriteLn('Programm beenden? (j/n)'); ReadLn(s) UNTIL s ='j' END.

Nach dem Programmstart (Run) würde Sie dann, je nach Eingabewerten, der folgende trostlose Textbildschirm erfreuen:

Sie sehen selbst, dass sich mit solch einer tristen Bedienoberfläche heute kein "Blumentopf" mehr gewinnen lässt! Wer den alten Zeiten gar zu sehr nachtrauert, der sei mit der Möglichkeit getröstet, dass man auch unter Delphi noch nostalgische Textbildschirm-Anwendungen erzeugen kann (siehe Praxisbeispiel "Konsolenanwendung" am Ende des Kapitels).

Bedienoberfläche entwerfen Ziel ist die folgende Anordnung der Komponenten Label1, Label2, Label3, Edit1, Edit2, Edit3 und Button1 auf dem Startformular (Form1): Label1

Edit1

Label2

Label3

Edit3

Edit2

Button1

Form1

1.3 Erste Schritte in Delphi

45

Ein wohl gemeinter Ratschlag für den Einsteiger: HINWEIS: Konzentrieren Sie sich in dieser ersten Etappe nur auf Lage und Abmessung der

Komponenten, nicht auf deren Beschriftung, da diese erst in der nächsten Etappe (Eigenschaften zuweisen) angepasst wird! Beim Platzieren und bei der Größenanpassung der Komponenten gehen Sie ähnlich vor, wie Sie es bereits von vektororientierten Zeichenprogrammen (Designer, Corel Draw, Visio etc.) gewöhnt sind: Auf der Werkzeugleiste am oberen Rand (Komponentenpalette) klicken Sie die Schaltfläche (für Label-Komponenten). Danach bewegen Sie den Mauszeiger zu der Stelle von Form1, an der sich die linke obere Ecke von Label1 befinden soll, drücken die Maustaste nieder und zoomen (bei gedrückt gehaltener Maustaste) das Label auf seine endgültige Größe. Völlig analog verfahren Sie mit Label2 und Label3. Nun klicken Sie die Schaltfläche (für Edit-Komponenten) und erzeugen Edit1, Edit2 und Edit3. Schließlich bleibt noch die breite Taste Button1, die Sie nun sicher ohne Probleme (Schaltfläche für Button-Komponenten) an den unteren Rand von Form1 setzen.

Eigenschaften zuweisen Unser kleines Programm besteht inzwischen aus insgesamt acht Objekten: einem Formular und sieben Komponenten. Die wichtigste Eigenschaft eines Objekts ist sein Name. Wir brauchen uns aber nicht weiter um ihn zu kümmern, denn wenn wir alle Komponenten in der oben beschriebenen Reihenfolge erstellt haben, wurden die Namen bereits von Delphi entsprechend obiger Abbildung automatisch vergeben. Auch die anderen Eigenschaften haben bereits Standardwerte. Einige davon müssen wir allerdings ändern. Dies geschieht mit Hilfe des Objektinspektors, dessen Fenster sich normalerweise in der linken Bildschirmhälfte befindet. Wenn Sie mit der Maus auf eine Komponente klicken, zeigt der Objektinspektor eine Liste ihrer Eigenschaften an. Beginnen wir mit Label1, das die Beschriftung Kurs 1: tragen soll. Die Beschriftung ist identisch mit der Caption-Eigenschaft. Standardmäßig entspricht diese der Name-Property, in unserem Fall also Label1. Um das zu ändern, klicken Sie auf das Label und tragen anschließend in dem kleinen weißen Caption-Feld des Objektinspektors die neue Beschriftung ein (die alte ist vorher mit Backspace- oder Entf-Taste "wegzuradieren"). Analog verfahren Sie mit den übrigen Labels. Bei den drei Editierfeldern Edit1, Edit2 und Edit3 ist die Text-Eigenschaft auf den Wert '1' zu ändern, auch Button1 muss natürlich eine neue Beschriftung erhalten. Schließlich klicken Sie auf eine leere Fläche von Form1, um den Objektinspektor für das Formular zu öffnen und um die Caption-Eigenschaft entsprechend der Titelleiste zu modifizieren. Da wir verhindern wollen, dass der Anwender später eine Größenänderung des Fensters vornimmt, müssen wir auch die BorderStyle-Eigenschaft ändern. Die folgende Tabelle gibt eine Zusammenstellung aller Objekteigenschaften, die von den Standardwerten (Defaults) abweichen:

46

Kapitel 1

Einführung

Name des Objekts

Eigenschaft

Neuer Wert

Form1

Caption

'Umrechnung Euro <=> Dollar'

BorderStyle

bsSingle

Label1

Caption

'Kurs 1 :'

Label2

Caption

'Euro'

Label3

Caption

'Dollar'

Edit1, Edit2, Edit3

Text

'1'

Button1

Caption

'Beenden'

TabStop

False

Die einschließenden Apostrophe (' ') für Caption- und Text-Properties weisen darauf hin, dass es sich um den Datentyp String handelt. HINWEIS: Beim Eintrag von String-Eigenschaften in den Objektinspektor müssen Sie die Apos-

trophe (' ') ausnahmsweise weglassen!

Event-Handler einstellen Sicher haben Sie inzwischen schon festgestellt, dass der Objektinspektor als eine Art "Karteikasten" organisiert ist, der aus zwei "Seiten" besteht. Die obere heißt "Eigenschaften", die untere, der wir uns jetzt zuwenden wollen, trägt die Beschriftung "Ereignisse". Klicken Sie auf dem Formular die Komponente Edit1 und aktivieren Sie anschließend die Ereignisseite des Objektinspektors. Sie zeigt eine Liste aller Windows-Ereignisse, auf die Edit1 reagieren kann. Die Euro-Dollar-Umrechnung soll immer beim Loslassen einer Taste gestartet werden, also dann, wenn sich infolge einer Neueingabe oder Korrektur der Inhalt eines der drei Editierfelder geändert hat. Klicken Sie also auf das Ereignis OnKeyUp. Die Farbe des Feldes ändert sich in Weiß, und es blinkt eine Einfügemarke. Doppelklicken Sie neben diese Marke. Das Feld enthält nun die Beschriftung Edit1KeyUp, das ist der Name der Ereignisbehandlungsroutine (Event-Handler), den uns Delphi für das OnKeyUp-Ereignis der Komponente Edit1 vorschlägt. Wir aber wollen den Namen geringfügig ändern, nämlich in EditKeyUp, weil auch die anderen beiden Editierfelder (Edit2 und Edit3) diesen Event-Handler benutzen sollen (folgende Abbildung links): Klicken Sie nun auf die Komponente Edit2 und öffnen Sie ebenfalls die Ereignisseite des Objektinspektors. Diesmal brauchen Sie den Namen des Event-Handlers nicht per Hand einzutragen. Klicken Sie einfach auf die kleine Rollbox am rechten Rand des OnKeyUp-Felds und Sie gewinnen einen Überblick über alle momentan vorhandenen Event-Handler, dies ist momentan nur EditKeyUp. Übernehmen Sie diesen Eintrag (siehe folgende Abbildung oben rechts). Wiederholen Sie den gleichen Vorgang für die Komponente Edit3.

47

1.3 Erste Schritte in Delphi

Hier den Namen des Event-Handlers ändern!

Hier den Event-Handler ausw ählen!

Ereignisroutinen hinzufügen In der Bildschirmmitte entdecken Sie ein neues Fenster (Unit1.pas), das sich bisher hinter dem Formular Form1 versteckt hat (evtl. über Ansicht|Units... bzw. Strg+F12 herbeiholen). Es ist mit folgendem "vorgefertigten" Rahmencode für den Event-Handler EditKeyUp ausgestattet: procedure TForm1.EditKeyUp(Sender: TObject; var Key: Word; Shift: TShiftState); begin end;

Anhand des Parameters Sender stellt diese Prozedur fest, von welchem Objekt (Edit1, Edit2 oder Edit3) das KeyUp-Ereignis ausgelöst wurde. Aufgabe des Programmierers ist es, diesen Event-Handler mit Leben zu erfüllen. Er muss zwischen begin und end die Pascal-Anweisungen eintragen, die dann ausgeführt werden sollen, wenn bei einer Tastatureingabe in Edit1, Edit2 oder Edit3 das Ereignis OnKeyUp (Taste loslassen) eintritt. In diesem Fall wollen wir ja den eingegebenen Kurswert in eine Gleitkommazahl umwandeln und anschließend die Dollars bzw. Euros berechnen. Tippen Sie also zwischen der ersten und letzten Zeile folgenden Quellcode ein, wobei die fettgedruckten Anweisungen bereits vorhanden sind (siehe oben) und Sie die mit // eingeleiteten Kommentaranweisungen auch weglassen können: procedure TForm1.EditKeyUp(Sender: TObject; var Key: Word; Shift: TShiftState); var kurs, euro, dollar: Single; // Variablen, mit denen gerechnet wird s: string; code: Integer; // Hilfsvariablen begin // Werte aus Editierfeldern in Variablen einlesen und prüfen:

48

Kapitel 1

Einführung

Val(Form1.Edit1.Text, kurs, code); // Kurs einlesen if code <> 0 then Exit; Val(Form1.Edit2.Text, euro, code); // Euro einlesen if code <> 0 then Exit; Val(Form1.Edit3.Text, dollar, code); // Dollar einlesen if code <> 0 then Exit; // Berechnungen mit den Variablen durchführen: if Sender = Edit3 then euro := dollar * kurs // dollar wurde eingegeben else dollar := euro / kurs; // euro oder kurs wurden eingegeben // Werte der Variablen in den Editierfeldern anzeigen: if Sender = Edit3 then // dollar geändert begin Str(euro:8:2,s); Form1.Edit2.Text := s // Anzeige von euro (8 Stellen, // davon 2 Nachkomma) end else // kurs oder euro geändert begin Str(dollar:8:2,s); Form1.Edit3.Text := s // sonst Anzeige von dollar end end;

Durch Mausklick auf die Schaltfläche Button1 soll das Programm beendet werden. Dazu ist die Close-Methode für Form1 auszuführen, bei der gleichzeitig auch alle mit dem Formular verknüpften Komponenten entladen werden. Aktivieren Sie den Rahmencode für das OnClick-Ereignis von Button1 (hier genügt ein Doppelklick auf die Komponente) und ergänzen Sie die mittlere Zeile: procedure TForm1.Button1Click(Sender: TObject); Form1.Close end;

Test Klicken Sie nun auf den Button in der Werkzeugleiste (oder F9-Taste), und im Handumdrehen wird Ihr erstes Delphi-Programm compiliert und ausgeführt! Sie werden feststellen, dass es eine vorgeschriebene Reihenfolge für die Benutzereingaben nicht mehr gibt, alle Felder werden sofort aktualisiert. In unserem Fall ist sogar (im Unterschied zum DOS-Beispiel am Anfang dieses Abschnitts) eine Umrechnung in beide Richtungen möglich. Nicht nur mittels Maus, auch mit der Tastatur (Tab-Taste) können Sie zwischen den Eingabefeldern wechseln. Button1 wurde durch Setzen seiner TabStop-Eigenschaft auf False aus dieser Reihenfolge herausgenommen. Stören Sie sich vorerst nicht daran, wenn keine Kommas bei der Eingabe akzeptiert werden und nur der Punkt als Dezimaltrenner funktioniert. Wie Sie dieses Problem beseitigen können, erfahren Sie im Praxisteil am Ende dieses Kapitels (1.6.1, "Umwandeln von Dezimalkomma in Dezimalpunkt"). Doktern Sie in aller Ruhe ein wenig am Quellcode herum, um sich den Unterschied zwischen DOS- und Windows-Programmen so richtig zu verdeutlichen.

1.3 Erste Schritte in Delphi

49

Hilfreich dürfte Ihnen bei Ihren ersten Versuchen vor allem die F12-Taste (bzw. die Schaltfläche der Symbolleiste) sein, mit der Sie schnell zwischen dem Formular und dem zugehörigen Codefenster wechseln können. Haben Sie sich scheinbar "festgefahren" und nichts geht mehr, so hilft die Tastenkombination Strg+F2 (Menü Start|Programm zurücksetzen).

Bemerkungen Bereits in diesem kleinen Beispiel steckt eine Menge an praktischem Know-how, zu dessen gründlicher Klärung hier im Einführungskapitel kein Platz ist. Folgende Hinweise sollen aber den Weg zum Verständnis ebnen: ■ Innerhalb des Event-Handlers (EditKeyUp) sind die vier typischen Schritte zur Lösung einer speziellen Programmieraufgabe klar erkennbar: 1. Variablen deklarieren (Ein- und Ausgabegrößen) 2. Inhalt der Steuerelemente den Variablen (Eingabegrößen) zuweisen 3. Mit den Variablen Berechnungen durchführen 4. Den Inhalt der Variablen (Ausgabegrößen) in den Steuerelementen anzeigen ■ Bei den Schritten zwei und vier ist zu beachten, dass in die Steuerelemente (Editierfelder) im Allgemeinen keine Zahlen, sondern Zeichenketten eingegeben werden, die durch das Programm in numerische Werte umgewandelt werden müssen (bzw. umgekehrt). Dazu dienen im obigen Beispiel die Konvertierungsroutinen Val und Str (siehe 2.6.3, Stringfunktionen). ■ Der prinzipielle Programmablauf als Aufeinanderfolge von Anweisungen und der Einbau von Verzweigungen (if ... then ...) dürfte klar ersichtlich sein (siehe 2.5.2, Verzweigungen). ■ Weitere wichtige Details, wie z.B. das Einfügen von Kommentaranweisungen, die Bedeutungslosigkeit der Groß-/Kleinschreibung, die "reservierten Wörter" (im Codefenster fettgedruckt), werden bereits hier deutlich. Noch vieles andere in diesem Einführungsbeispiel mag dem Einsteiger momentan noch absolut unverständlich vorkommen, aber lassen Sie sich nicht beirren, einiges brauchen Sie gar nicht erst zu wissen, und von anderen mysteriösen Anweisungen wird sich im Laufe der nächsten Kapitel bald der Schleier heben.

Der komplette Quelltext Unser Programm besteht aus weitaus mehr Zeilen, als wir selbst geschrieben haben. Die Projektdatei (entspricht dem Hauptprogramm) haben wir noch gar nicht zu Gesicht bekommen, sie wurde von Delphi automatisch erstellt. Um sie einzusehen, brauchen Sie nur auf den Menüpunkt Ansicht| Units... zu klicken und im Dialogfenster Project1 zu wählen (oder Projekt|Quelltext anzeigen): program Project1; uses Forms, Unit1 in 'Unit1.pas' {Form1}; {$R *.RES}

50

Kapitel 1

Einführung

begin Application.Initialize; Application.CreateForm(TForm1, Form1); Application.Run; end.

Im Normalfall haben Sie als Programmierer in der Projektdatei nichts verloren, denn Delphi hat es gar nicht gern, wenn Sie da herumschnüffeln oder ihm gar ins Handwerk pfuschen und eigenmächtig an den Einträgen herumdoktern. Als Nächstes wählen Sie Unit1: unit Unit1; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type TForm1 = class(TForm) Label1: TLabel; Edit1: TEdit; Label2: TLabel; Edit2: TEdit; Label3: TLabel; Edit3: TEdit; Button1: TButton; procedure EditKeyUp(Sender: TObject; var Key: Word; Shift: TShiftState); procedure Button1Click(Sender: TObject); private { Private-Deklarationen } public { Public-Deklarationen } end; var Form1: TForm1; implementation {$R *.DFM}

Den Sinn dieser Anweisungen müssen Sie jetzt noch nicht verstehen, nur so viel: Delphi hat z.B. in der uses-Klausel (dritte Zeile von Unit1) automatisch all die "Bausteine" (Units) eingetragen, die für das Funktionieren der Anwendung erforderlich sind. Auch eine spezielle Formularklasse (TForm1) wurde von dem Vorfahren TForm "geerbt" und mit Feldern und Ereignismethoden für die einzelnen Komponenten gefüllt (siehe Kapitel 6).

51

1.3 Erste Schritte in Delphi

Erst ab jetzt beginnt der Quellcode, den Sie selbst bearbeitet haben (mit Ausnahme des Rahmencodes der Event-Handler): ... procedure TForm1.EditKeyUp; ... // selbst bearbeiteter Quellcode end; procedure TForm1.Button1Click; begin ... // selbst bearbeiteter Quellcode end; end.

Wundern Sie sich nicht darüber, dass die Köpfe der Ereignisbehandlungsmethoden TForm1.EditKeyUp und TForm1.Button1Click diesmal ohne Parameter erschienen sind. Das ist so weit in Ordnung, da wir zwecks Einsparung von Tipparbeit von der so genannten Kurzform Gebrauch gemacht haben. Die ausführliche Deklaration der Methodenköpfe findet Delphi im interface-Abschnitt (in der Klassendefinition von TForm1).

Ereignistabelle Wie soll man ein Delphi-Listing lesen, ohne den Überblick zu verlieren? Gewissermaßen als Ersatz für den unter Windows leider nicht mehr dominierenden (linearen) Programmablaufplan (PAP) kann folgende Tabelle für etwas mehr Übersicht sorgen: Benutzeraktion

Ausgewertetes Windows- Programmreaktion Ereignis

Tastatureingabe in das Kursund in das Euro-Editierfeld

EditKeyUp

Berechnen und Anzeigen des Dollar-Wertes

Tastatureingabe in das DollarEditierfeld

EditKeyUp

Berechnen und Anzeigen des Euro-Wertes

Mausklick auf die "Beenden"Schaltfläche

Button1Click

Programm beenden

Projektdateien Während der Phase der Programmentwicklung haben wir es nicht nur mit diversen Quelltextdateien zu tun, sondern auch noch mit einer ganzen Reihe weiterer Dateien, das Ganze nennt man dann "Projekt". Wenn Sie über das Menü Datei|Alles speichern das komplette Projekt in ein extra Verzeichnis ablegen, werden Sie feststellen, dass sich dort fast ein Dutzend Files tummeln, von denen hier nur die wesentlichen vorgestellt werden sollen.

52

Kapitel 1

Symbol

Einführung

Erklärung

Projektdatei (siehe oben abgedrucktes Listing) Bilddatei für Form1 Quelltext für Unit1 (siehe abgedrucktes Listing) compiliertes Programm (ist allein ausführbar!) Windows-Ressourcendatei (Button, Label etc.) Delphi-Projektoptionen compilierte Unit1 Konfigurationsdatei Datei für Delphi Diagram Page (siehe Code-Editor)

Um ein Projekt unter Delphi 7 zu öffnen und weiter daran zu arbeiten, brauchen Sie nur die ersten drei Dateien, die anderen werden in der Regel automatisch ergänzt. Was aber, wenn das Projekt abgeschlossen ist und Sie die fertige Anwendung weitergeben wollen? Für einfache Programme (ohne Datenbank-Engine und weitere spezielle DLLs) genügt im Allgemeinen Project1.exe, um die fertige Applikation auf beliebigen Rechnern unter Windows zum Laufen zu bringen. Anderenfalls kommen Sie kaum um die Verwendung eines speziellen SetUpTools herum, das Ihnen die Dateien für die Installationsdisketten erstellt. Ein solches Hilfsprogramm wird zur Professional- und Enterprise-Version mitgeliefert (siehe Beschreibung von InstallShield im Anhang B).

Projekt-Fenster Eine übersichtliche Basis für die Arbeit mit den Projekt-Files verschafft uns das Projektfenster, das wir über das Menü Ansicht|Projektverwaltung erreichen. Sieht dieses Fenster auch momentan noch arm und verlassen aus, so wird sich das spätestens dann ändern, wenn wir uns später mit "ausgewachsenen" Programmen beschäftigen.

1.4 Von anderen Sprachen zu Delphi

53

1.3.3 Auf zur Object Pascal-Programmierung! Unser Delphi 7-Schnupperkurs ist hier zu Ende. Delphi hat für uns getan, was es tun konnte: Beim Bestücken der Bedienoberfläche mit Komponenten hat es uns großzügig unterstützt: Für jedes Formular sowie für jedes Standardereignis steht ein vorgefertigter Rahmencode bereit. Bevor Sie auch nur eine einzige Zeile Quelltext eingetippt haben, ist die Benutzerschnittstelle der Applikation vom Prinzip her bereits lauffähig. Doch damit haben Sie nur eine schöne, glänzende Fassade für Ihr Programmgebäude errichtet, denn im Inneren klafft noch gähnende Leere. Den "Innenausbau" Ihres Programmgebäudes kann Delphi Ihnen beim besten Willen nicht abnehmen, Sie selbst müssen jetzt Hand anlegen und sich dafür Schritt für Schritt die dazu notwendigen Kenntnisse aneignen. Wie bereits in beiden Einführungsbeispielen gezeigt, beginnt Ihre Arbeit als Programmierer mit dem Schreiben diverser Ereignisbehandlungsroutinen (Event-Handler). Hier teilen Sie Ihrem Programm mit, wie es auf bestimmte Benutzereingaben reagieren soll! Der Weg kann recht mühselig sein, denn der Sprachumfang von Object-Pascal ist gewaltig und für den Einsteiger schon eher mit dem undurchdringlichen Dickicht eines Urwaldes vergleichbar. Lassen Sie sich deshalb beim Studium der folgenden Kapitel nicht entmutigen, stürzen Sie sich hinein in diesen Urwald und schlagen Sie eine schmale Schneise zur Lichtung erster Erfolge! Das Dickicht wird sich erst allmählich lichten, und zwar in dem Maße, wie Sie unermüdlich Praxisbeispiele nachvollziehen und eigene Projektideen verwirklichen.

1.4 Von anderen Sprachen zu Delphi Umsteiger haben es einerseits leicht, da sie über Programmiererfahrungen verfügen, andererseits kommt es gerade bei ihnen häufig zu ganz typischen Fehlerbildern und Verwirrungen, die dem absoluten Einsteiger auf seinem noch "unbestellten Acker" fremd sind.

1.4.1 C/Visual C++/Java Die folgende Tabelle listet einige Unterschiede zwischen C und Delphi auf, die Aufzählung erhebt keinerlei Anspruch auf Vollständigkeit:

54

Kapitel 1

Anweisung

Borland Delphi (Pascal)

C++/Java

Stringbegrenzung

’Maier’

"Maier"

Zuweisung

a := b

a = b

Trennungszeichen

Anweisung1; Anweisung2

Anweisung1; Anweisung2

Kommentar

{Kommentartext}

/* Kommentartext */

Typdefinition

type person = record felder... end;

struct person { felder ... };

Variablendeklaration

var i: Integer;

int i;

Array-Deklaration

a: array[1..5] of Integer

int a[5]

Zählschleife

for i:= 1 to 100 do begin Anweisungen end;

for (i=0; i < 100; i++) { Anweisungen }

Abbruchschleife mit Anfangskontrolle

while a > b do begin Anweisungen end;

while (a > b) { Anweisungen }

Abbruchschleifemit Endkontrolle

repeat Anweisungen until a > b;

do { Anweisungen } while (a <= b);

CASE-Anweisung

case i of 1: Anwsng1 2: Anwsng2 end;

switch (I) { case 1: Anwsng1;break; case 2: Anwsng2;break; }

String in Zahl

Val(s,z,code);

z = atof(s);

Natürlicher Logarithmus

Ln(x);

Log(x);

Einführung

Mit Erleichterung wird der C++-Programmierer zur Kenntnis nehmen, dass die Groß-/Kleinschreibung als Fehlerursache nunmehr wegfällt.

1.4.2 Turbo Pascal Delphi hat den gleichen Sprachkern wie seine Pascal-Vorfahren, allerdings sind einige hundert neue Befehle hinzugekommen, denn Delphi muss auf die unglaubliche Funktionsvielfalt der Windows-API zugreifen, die sozusagen die Schnittstelle zu Windows bereitstellt. Meist sind diese Befehle in zahlreichen Objekten/Komponenten gekapselt. Da unter Windows auch Text eine spezielle Form von Grafik darstellt, müssen Sie auf das gewohnte Write(Ln) und Read(Ln) für die Interaktion mit dem Bildschirm verzichten. Die objekt- und ereignisorientierte Programmierung bedingt einen völlig anderen Programmfluss als das zeilenweise Abarbeiten von Befehlen unter Turbo-Pascal. Es ist ein Irrtum zu glauben, dass sich Ihre alten Turbo-Pascal-Programme ohne weiteres nach Delphi portieren lassen (es sei denn, mit einer Konsolenanwendung, siehe 1.6.2). In der Regel sind so grundlegende Änderungen notwendig, dass eine vollständige Neuentwicklung effektiver ist.

55

1.4 Von anderen Sprachen zu Delphi

In vielen Fällen können Sie allerdings kleinere Turbo-Pascal-Programmbausteine (Funktionen und Prozeduren) unter Delphi weiterverwenden. In den Lernbeispielen am Ende des Kapitels finden Sie dazu Anregungen.

1.4.3 Turbo Pascal für Windows Dieses glücklose Borland-Produkt war der unmittelbare Vorgänger von Delphi. Wer damit bereits gearbeitet hat, wird wohl kaum Umstellungsschwierigkeiten haben, große Teile des Quelltextes lassen sich sogar direkt portieren. Die relativ lange Einarbeitungszeit in die Entwicklungsumgebung und die mangelnde Unterstützung beim Oberflächenentwurf hatten zur Folge, dass selbst kleinere Applikationen sehr schnell Dutzende von Seiten mit unüberschaubaren Quelltexten füllten. Dies hat letztendlich dazu beigetragen, dass Borland mit Turbo Pascal für Windows nicht der große Durchbruch gelungen ist. Wen wundert's, dass die ehemals große Pascal-Anhängerschaft in ganzen Heerscharen zu Microsofts Visual Basic übergelaufen ist. Zweifelsohne hat Delphi diesen Trend inzwischen wieder umgekehrt.

1.4.4 Visual Basic Microsofts Visual Basic ist immer noch der ärgste Konkurrent zu Borlands Delphi. Es ist anzunehmen, dass sich unter den Delphi-Umsteigern viele mit Visual Basic-Erfahrung befinden. Die Umstellungsschwierigkeiten sind hier weniger inhaltlicher, sondern mehr formaler Natur, da bereits Fertigkeiten im Umgang mit einer hochentwickelten objekt- und ereignisorientierten Sprache vorliegen. Viele Sprachelemente (z.B. Schleifenkonstruktionen) sind in Visual Basic und Delphi nahezu identisch, aber gerade die kleinen Syntaxunterschiede machen dem Umsteiger das Leben schwer, da er sehr oft "rückfällig" wird. So wird in der Anfangsphase einer der häufigsten Fehler garantiert der vergessene Doppelpunkt vor dem Gleichheitszeichen bei der Zuweisung (:=) sein. Die folgende Tabelle zeigt eine Gegenüberstellung häufiger Verwechslungen: Anweisung

Borland Delphi (Pascal)

Microsoft Visual Basic

Stringbegrenzung

’Maier’

"Maier"

Zuweisung

a := b;

a = b

Trennungszeichen

Anweisung1; Anweisung2;

Anweisung1: Anweisung2

Kommentar

//Kommentartext

’Kommentartext

Typdefinition

type person = record

Type person

felder... end;

felder ... End Type

Variablendeklaration

var i: Integer;

Dim i As Integer

Arraydeklaration

a: array[1..5] of Integer;

a(1 To 5) As Integer

Zählschleife

for i:= 1 to 100 do begin

For i = 1 To 100

Anweisungen end;

Anweisungen Next i

56

Kapitel 1

Einführung

Anweisung

Borland Delphi (Pascal)

Microsoft Visual Basic

Abbruchschleife mit Anfangskontrolle

while a > b do begin

Do While a > b

Abbruchschleife mit Endkontrolle CASE-Anweisung

Anweisungen

Anweisungen

end;

Loop

repeat

Do

Anweisungen

Anweisungen

until a > b;

Loop While a <= b

case i of

Select Case i

1: Anweisung1 2: Anweisung2

Case 1: Anweisung1 Case 2: Anweisung2

end;

End Select

String in Zahl

Val(s,z,code);

z = Val(s)

Zahl in String

Str(z,s);

s = Str(z)

Integer-Division

a div b;

a \ b

Natürlicher Logarithmus

Ln(x);

Log(x)

Quadratwurzel

Sqrt(x);

Sqr(x)

Das Einschließen von Programmblöcken in die Schlüsselwörter begin und end dürfte eine der wichtigsten Umstellungen sein. Ebenso muss man sich daran gewöhnen, dass die Parameter innerhalb eines Prozedurkopfes durch Semikolons (;) und nicht durch Kommas (,) voneinander getrennt werden. Delphi wendet die objektorientierte Programmierung um einiges konsequenter an als das alte Visual Basic1. Zahlreiche VB-Eigenschaften sind in Delphi zu Objekten geworden (z.B. Font). Bei Grafikoperationen wird man zunächst über das TCanvas-Objekt stolpern, das als Abstraktion einer Zeichenfläche (Canvas = Leinwand) zu verstehen ist und das Schreiben wesentlich universellerer Zeichenroutinen ermöglicht (siehe Kapitel 7). PaintBox und Image gibt es zwar auch, aber bezüglich des Grafikpuffers mit ziemlich gegensätzlichem Verhalten! Die Ereignisbehandlungsprozeduren (Event-Handler) weisen ebenfalls einen wichtigen Unterschied auf: Zusätzlich wird auch der Name des aufrufenden Objekts (Sender) übergeben (siehe Einführungsbeispiel). Damit lassen sich, gewissermaßen als Ersatz für die fehlende Index-Eigenschaft, auch Control-Arrays erstellen. Die Entwicklungsumgebung (IDE) verlangt auch einige Umstellungen, so sind die Funktionstastenbelegungen unterschiedlich (z.B. F5 → F9), die Ereignisse erscheinen ebenfalls mit im Eigenschaftenfenster, das jetzt Objektinspektor heißt, ... und ... und ... und.

1

Visual Basic .NET ist hingegen eine vollwertige objektorientierte Sprache.

1.5 Neuigkeiten der Version 7

57

1.5 Neuigkeiten der Version 7 In diesem Abschnitt wollen wir den gestandenen Delphi 6-Programmierer kurz mit den Neuheiten der Version 7 bekannt machen2. HINWEIS: Bereits am Label ".NET-Interoperability", welches an die Verkaufspackung ange-

heftet wurde, erkennen Sie die wohl wichtigste Neuerung! Obwohl damit von einem Delphi.NET noch lange nicht die Rede sein kann, lassen sich nunmehr .NET-Komponenten in Ihre Delphi-Applikationen ähnlich wie COM-Komponenten einbinden (siehe dazu Kapitel 12 dieses Buchs). Weitere Änderungen und Erweiterungen betreffen vor allem den Datenbank- und Internetbereich. Da aber dieser Bereich nicht Schwerpunktthema dieses Buchs ist, werden wir uns auf allgemeinere Aussagen beschränken2.

1.5.1 Änderungen der Entwicklungsumgebung Außer dem sofort angenehm ins Auge stechenden Zweifarben-Look des Delphi-Hauptmenüs gibt es Neuigkeiten auf folgenden Gebieten zu vermelden:

Komponentenpalette Wer bereits die Vorgängerversion besessen hat, dessen erster Blick gilt meist der Komponentenpalette in der Hoffnung, daraus vielleicht die entscheidenden Rückschlüsse auf Neuerungen abzuleiten. Nach dem Durchklappern der einzelnen Register wird – je nach Temperament – Enttäuschung, Erleichterung oder gar gähnende Langeweile einkehren, denn hier ist scheinbar fast alles beim Alten geblieben: ■ Zusätzlich Der Zuwachs betrifft lediglich die neuen Komponenten XPColorMap, StandardColorMap und TwiLightColorMap. ■ System Nur wenn Sie eine CLX-Applikation geöffnet haben, erscheinen hier Komponenten für den Dateizugriff (DirectoryTreeView, FileListView, FileIconView, FileEdit, FileHistoryComboBox, FilterComboBox)3. ■ Win32 Ein Neuankömmling, das XPManifest, hat sich bescheiden ganz hinten angestellt.

2

Der Einsteiger sollte sich diese Lektüre für einen späteren Zeitpunkt aufsparen, da er mit den meisten Fachbegriffen ohnehin noch nicht viel anfangen kann.

2

Siehe "Borland Delphi – Datenbankprogrammierung"

3

In Delphi 6 wurde die System-Palette nur bei VCL-Applikationen angezeigt.

58

Kapitel 1

Einführung

■ Indy Intercepts und Indy I/O Handlers Diese Register sind neu hinzugekommen und stellen diverse Internet-Protokoll- Komponenten bereit (Open Source). ■ IW Standard, IW Data, IW Client Side und IW Control Auch diese Register sind neu und enthalten IntraWeb-Komponenten für Internet- bzw. IntranetAnwendungen. ■ Rave Diese neuen Komponenten sollen den altgedienten QuickReport ersetzen. Letzterer genießt noch ein Gnadenbrot, muss aber extra nachinstalliert werden. Mehr Infos siehe "Mit Rave Reports Berichte erstellen" im Entwicklerhandbuch oder im Kapitel 9 dieses Buchs. Schließlich soll noch eine verbesserte Zugriffsmöglichkeit auf überlange Register erwähnt werden: Anstatt mühsam nach rechts zu scrollen, kann jetzt auch ein DropDown-Menü aufgeklappt werden um die restlichen Komponenten bequemer zu erreichen.

Code-Fenster ■ Die automatische Vervollständigung des eingegebenen Codes arbeitet jetzt schneller (Strg+ Mausklick). ■ Neu ist die automatische Ergänzung eingegebenen HTML-Codes (Anzeige gültiger HTMLElemente). ■ Unter Benutzung der OpenTools-API können Sie eigene Manager zur benutzerdefinierten Code-Vervollständigung entwickeln. ■ Über das Menü Tools|Editor-Optionen... können Sie eigene Farben für die Sprachelemente zuweisen.

Debugger ■ Neben weiteren kleineren Verbesserungen können in der Watch-Liste mittels multipler Tabs bestimmte Gruppen eingerichtet werden. ■ Einige neue Optionen sind auf der Registerseite Tools|Debugger-Optionen...|Ereignisprotokoll eingerichtet.

.NET-Komponenten einbinden ■ Über das Menü Projekt/Typbibliothek importieren... können Sie einen CoClass-Wrapper für .NET-Assemblies erzeugen. Dieser Wrapper kann unter Verwendung der Interoperabilitätsfunktionen des Microsoft .NET Framework wie ein normaler COM-Server angesprochen werden (siehe Kapitel 12).

Compiler ■ Es gibt im Zusammenhang mit der .NET-Interoperabilität die drei zusätzlichen Compiler-Warnungen: Unsafe_Type, Unsafe_Code und Unsafe_Cast. Diese Warnungen werden standard-

1.5 Neuigkeiten der Version 7

59

mäßig angezeigt, können aber auch mittels Compiler-Direktive (z.B. $WARN UNSAFE_CODE ON) oder aber auch auf der zusätzlichen Dialogseite Projekt|Optionen...|Compiler-Meldungen aktiviert werden. ■ Über das Menü Ansicht|Zusätzliche Informationen zur Meldung erhalten Sie ein Hinweisfenster, über welches Sie Informationen über Compilermeldungen von der Borland Website herunterladen können.

1.5.2 Internet-Technologie IntraWeb ■ Mit dem neuen IntraWeb von AtoZed Software können Sie Web-Server-Anwendungen entwickeln und IntraWeb Seiten für Web-Broker- und WebSnap-Anwendungen erstellen. ■ Apache 2 wird nun als Zieltyp für Web Broker, WebSnap und SOAP unterstützt. ■ Win-CGI als Zieltyp für Web-Server-Anwendungen und Web-Dienste wurde zum Auslaufmodell erklärt, stattdessen sollen Sie einen regulären CGI-, einen ISAPI/NSAPI- oder einen Apache-Zieltyp verwenden.

Web-Services ■ Mit dem neuen UDDI-Browser können Sie WSDL-Dokumente anhand der Einträge einer UDDI-Registrierung ausfindig machen und importieren. ■ Neue Klassen und Schnittstellen ermöglichen es, Header aus den SOAP-Paketen, die zur Übertragung von Botschaften zwischen Clients und Server dienen, zu lesen und Header darin einzufügen. Nähere Informationen hierzu finden Sie unter SOAP-Header definieren und verwenden und Header in Client-Anwendungen verarbeiten.

Sonstige Erweiterungen ■ Neu hinzugefügte Ereignisse für THTTPReqResp ermöglichen das Abfangen einer HTTP-Botschaft, bevor sie gesendet wird, und die Überwachung des Übertragungsstatus während des Sendens und Empfangens langer Nachrichten. ■ Neue Ereignisse für THTTPSoapPascalInvoker ermöglichen die Implementierung von Routinen, die vor oder nach der Ausführung eines angeforderten Methodenaufrufs durch den Invoker ausgeführt werden. ■ Die Zuordnung von aufrufbaren Schnittstellen zu WSDL-Dokumenten kann nun mit verschiedenen neuen Ereignissen für TWSDLHTMLPublish genauer gesteuert werden. ■ Mit der neuen Eigenschaft Encoding der IOPConvert-Schnittstelle können Sie den Zeichensatz für codierte Botschaften festlegen, die zwischen dem Client und dem Web-Service-Provider ausgetauscht werden. ■ In selbst definierten Schnittstellen können Sie nun überladene Methoden aufrufen.

60

Kapitel 1

Einführung

1.5.3 Datenbanken Einige Datenbankkomponenten sind neu oder wurden verändert (siehe 1.5.1).

dbExpress ■ Die dbExpress-Treiber wurden für Informix SE, Oracle 9i, DB2 7.2, InterBase 6.5 und MySQL 3.23.49 aktualisiert. Für MSSQL 2000 gibt es einen neuen Treiber. ■ Die SQL-Links werden nicht weiter verbessert und nach 2002 nicht mehr zum Lieferumfang von Delphi gehören. Stattdessen soll mit dbExpress auf SQL-Datenbankserver zugegriffen werden.

DataSnap ■ Anstelle von IAppServer kommt die Schnittstelle IAppServerSOAP zum Einsatz, um Konflikte mit IAppServer zu verhindern. ■ Mittels der Eigenschaft UseSOAPAdapter von TSoapConnection können Clients für Server entwickelt werden, die mit früheren Versionen von Delphi programmiert wurden. ■ Die CORBA-Technologie wird von DataSnap nicht mehr unterstützt.

1.5.4 Runtime Library (RTL) Bemerkenswerte Änderungen gibt es in folgenden Units:

Classes ■ Die TStrings-Klasse hat zwei neue Eigenschaften: ValueFromIndex und NameValueSeparator. ■ Neue Exception-Klasse EFileStreamError und den davon abgeleiteten Klassen EFileStreamError und EFOpenError (ein zusätzlicher FileName-Parameter ermöglicht es, den Namen der den Fehler auslösenden Datei zu ermitteln).

Math ■ In der ClearExceptions-Prozedur gibt es einen neuen Standardparameter: RaisePending.

StrUtils ■ Die bisherigen Funktionen LeftStr, RightStr und MidStr unterstützten keine MBCS1-, sondern lediglich ANSI-Strings. Jede der drei Funktionen wurde durch zwei überladene Versionen für AnsiString und WideString ersetzt, die eine korrekte Behandlung von MBCS-Strings ermöglichen. ■ Es gibt eine neue String-Suchfunktion: PosEx. 1

Multi-Byte-Character Set

1.6 Lernbeispiele für Einsteiger

61

VarCmplx und Variants ■ Neue Funktionen: VarComplexLog2, VarComplexLog10, VarComplexLogN, VarComplexTimesImaginary und VarComplexTimesReal. ■ Neue globale Variant-Kontrollvariablen wie NullEqualityRule, NullStrictConvert etc.

1.5.5 ModelMaker ■ Dieses neue Tool unterstützt Sie beim Entwurf von Klassen und Schnittstellen, unter anderem mit Hilfe von UML-Diagrammen. ■ Mehr Infos siehe "Klassen und Komponenten mit ModelMaker entwerfen" im Entwicklerhandbuch bzw. in der Online-Help.

1.5.6 Dokumentation ■ Das gesamte Hilfesystem von Delphi wurde neu organisiert. Große Teile der Online-Hilfe werden nicht mehr bei der Installation automatisch eingebunden, sondern wurden auf eine extra CD Companion Tools ausgelagert (siehe dazu 1.1.4). ■ Auch eine umfassende Beschreibung aller Neuerungen von Borland Delphi 7 finden Sie in der Delphi-Hilfe, und es wäre schade um die vielen zusätzlichen Seiten unseres Buchs, würden wir dies alles hier noch einmal wiederkäuen.

1.6 Lernbeispiele für Einsteiger Bevor Sie hier beginnen, sollten Sie zumindest die beiden Einführungsbeispiele (1.3.1 und 1.3.2) absolviert haben, um die unbedingt notwendigen Bedienelemente der Delphi-Entwicklungsumgebung zu kennen.

1.6.1 Der verrückte Button Diese kleine Spielerei weist Sie auf die Möglichkeit hin, die Position von Steuerelementen nicht nur beim Entwurf, sondern erst zur Laufzeit zu ändern.

Oberfläche Öffnen Sie ein neues Projekt und legen Sie eine Button-Komponente auf dem Formular ab. Klicken Sie auf die Button-Komponente und rufen Sie den Objektinspektor auf (F11). Stellen Sie als Caption-Eigenschaft &Beenden ein.

Quellcode Wählen Sie auf der "Ereignisse"-Seite das Ereignis OnMouseMove aus und doppelklicken Sie darauf. Ergänzen Sie den Programmrumpf durch diese Zeilen:

62

Kapitel 1

Einführung

Button1.Left:=Random(Form1.ClientWidth-Button1.Width); Button1.Top:=Random(Form1.ClientHeight-Button1.Height);

Test Starten Sie das Programm und versuchen Sie den Button mit der Maus zu erwischen, um das Programm zu beenden (es wird nicht gelingen!). Drücken Sie die Taste B (oder b), um dem Spuk ein Ende zu bereiten.

1.6.2 Nostalgische Konsolen-Anwendung Testen Sie den im Einsteiger-Beispiel 1.3.2 (Euro-Dollar-Umrechnung) angegebenen "alten" Turbo-Pascal-Quellcode auf seine Funktionsfähigkeit unter Delphi!

Oberfläche Wählen Sie Datei|Neu|Weitere ... und auf der Seite "Neu" der Objektgalerie "Konsolen-Anwendung".

Quellcode Fügen Sie den angegebenen Quellcode in den Programmrumpf ein.

1.7 Praxisbeispiele für Fortgeschrittene

63

Test Nach Compilieren und Starten des Programms könnte sich, in Abhängigkeit von Ihren Eingaben, folgender Dialogbildschirm ergeben:

1.7 Praxisbeispiele für Fortgeschrittene Wer schon über ein wenig Programmiererfahrung verfügt, dem seien die folgenden zwei kleinen "Aufwärmübungen" empfohlen.

1.7.1 Umwandeln von Dezimalkomma in Dezimalpunkt Komma oder Punkt als Dezimaltrenner? Wer kennt es nicht, das leidige Problem bei der Eingabe von Gleitkommazahlen, das mit der deutschen Ländereinstellung im Windows-Desktop zusammenhängt. Radikale Abhilfe lässt sich schaffen, wenn wir in einem Tastatur-Event-Handler das Komma "herausfiltern" und in einen Punkt verwandeln.

Oberfläche Auf das Formular platzieren Sie ein Edit-Feld und einen Button.

Quelltext Das Problem ist mit einer einzigen Anweisung im OnKeyPress-Event aus der Welt geschafft: procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char); begin if key = ',' then key:= '.' end;

Test Geben Sie ein Komma ein, wird daraus wie "von Geisterhand" ein Punkt.

64

Kapitel 1

Einführung

1.7.2 Abstellen des nervenden Pieptons Drücken Sie in einer Textbox die Enter-Taste, so wird automatisch ein Piepton ausgegeben. Auf die Dauer kann diese "Fehlermeldung" nerven. Abhilfe bringt ein "Filter", der den Tastencode der Enter-Taste einfach löscht.

Oberfläche Für unsere kleine Demo brauchen wir ein Edit-Feld, eine CheckBox und einen Button.

Quelltext Normalerweise würde der folgende Event-Handler genügen: procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char); begin if key = #13 then key := #0 end;

Da wir jedoch wahlweise den Piepton aktivieren oder deaktivieren wollen, wird es ein wenig komplizierter: procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char); begin if CheckBox1.Checked then if key = #13 then key := #0 end;

Test Sie geben irgendetwas ein, betätigen die Enter-Taste und lauschen auf den Piepton!

2

Grundlegende Sprachelemente

Kapitel

2

Grundlegende Sprachelemente Für den absoluten Programmier-Anfänger ist dies das wichtigste Kapitel, denn hier werden die sprachlichen Grundlagen von Delphi (und die liegen nun einmal im alten Pascal!) geschaffen. Allerdings bringt ein lineares Durcharbeiten des Stoffes nicht viel, sondern stiftet eher Verwirrung, weil zunächst das algorithmische Denken und das Umsetzen praktischer Probleme in eine Programmstruktur geübt werden muss. Viel effektiver ist es deshalb, wenn der Newcomer gleich mit dem Abschnitt 2.8 (Lernbeispiele für Anfänger) beginnt und den vorderen Teil des Kapitels nur zum gelegentlichen Nachschlagen benutzt. Für den schon einschlägig vorbelasteten Programmierer dürfte von Interesse sein, dass wir uns im vorliegenden Kapitel auf Object Pascal sowie auf die wichtigsten Funktionen/Prozeduren der Laufzeitbibliothek (RTL = Run Time Library) konzentrieren. Die eindeutig objekt- und Windowsorientierten Bestandteile von Object Pascal sowie die visuellen Komponenten (VCL = Visual Component Library) bleiben zunächst außen vor (siehe Kapitel 4 und 6).

2.1 Der Quelltexteditor Durch dieses Fenster treten Sie in die Welt der Object-Pascal-Programmierung ein. Der Aufruf erfolgt z.B. über das Menü Ansicht|Code Explorer oder durch Klick auf die Schaltfläche der Symbolleiste.

2.1.1 Bedienung Die Bedienung lässt sich am ehesten mit der eines kleinen Textverarbeitungsprogramms vergleichen. Davon zeugen unter anderem die zahlreichen Menüfunktionen (siehe Kapitel 3). Jedes Programmmodul belegt eine eigene Seite. In den Einführungsbeispielen des Kapitels 1 konnten Sie bereits erste Erfahrungen sammeln. Bei größeren Projekten sollten Sie sich zuerst über das Menü Ansicht|Projektverwaltung einen Gesamtüberblick über die vorhandenen Module, d.h. Units, verschaffen. Durch Doppelklick auf den entsprechenden Eintrag wird das Modul dann in das Quelltextfenster übernommen.

66

Kapitel 2

Grundlegende Sprachelemente

Achten Sie auf den Code-Explorer, der standardmäßig an das Quelltextfenster angedockt ist, sich aber von dort auch wieder "abziehen" lässt. Sie finden dort die hierarchische Auflistung aller von der aktuellen Unit verwendeten Variablen/Konstanten, Methoden etc. und weiteren Units (in obiger Abbildung links).

2.1.2 Schreibweise Bevor wir uns in die Arbeit stürzen, sollten Sie über einige Eigenheiten beim Schreiben von Quelltext Bescheid wissen.

Zeilenlänge Der Quelltexteditor verkraftet Zeilen mit einer maximalen Länge von 256 Zeichen, auf eine Druckzeile dieses Buches passen aber höchstens 75 Zeichen. Im Interesse der Lesbarkeit des Codes wird angestrebt, diesen Wert nicht zu überschreiten. Dies ist problemlos möglich, da ein Zeilenumbruch für den Compiler ohne Bedeutung ist. Die Ausnahme sind Zeichenketten (Strings), denn diese müssen Sie mittels "+"-Operator verknüpfen. BEISPIEL: Zeichenketten s1 := 'Das, was Sie hier sehen, ist eine sehr lange und unübersichtliche Zeile.'; s2 := 'Das, was Sie hier sehen, ist eine kurze Zeile,' + 'die übersichtlicher ist.';

2.2 Ein erster Blick auf Object Pascal

67

Hervorhebungen und Farben Im Quelltextfenster erscheinen die reservierten Wörter standardmäßig bunt und fett gedruckt. Beim Abdruck der Listings im Buch werden wir davon jedoch keinen Gebrauch machen, da der Aufwand in keinem Verhältnis zum Nutzen steht. Um auf bestimmte Passagen gesondert hinzuweisen, werden diese durch Unterstreichung hervorgehoben. Wie Sie nachfolgender Abbildung entnehmen, haben Sie über das Menü Tools|Editor-Optionen... die Möglichkeit, unter anderem auch die Arbeit mit dem Editor Ihren Wünschen anzupassen (Seiten "Allgemein" und "Farben").

Positionsmarken Um bei umfangreicheren Quelltexten die Orientierung nicht zu verlieren, können Sie eigene Positionsmarken im Sinn von "Lesezeichen" setzen. Platzieren Sie die Einfügemarke in die gewünschte Zeile, klicken Sie mit der rechten Maustaste in den Quelltexteditor, und wählen Sie "Positionsmarken umschalten". Um zu einer Positionsmarke zu springen, brauchen Sie nur mittels rechter Maustaste "Zu Positionsmarken gehen" zu wählen.

2.2 Ein erster Blick auf Object Pascal Bereits in den Einführungsbeispielen hatten wir festgestellt, dass ein Object-Pascal-Programm aus einer Folge von Anweisungen besteht, die durch ein Semikolon (;) voneinander getrennt sind. Um den Rahmencode des Programms (Projekt-Quelltext, Einbinden der visuellen Komponenten) brauchen wir uns im Allgemeinen nicht zu kümmern, das erledigt Delphi.

68

Kapitel 2

Grundlegende Sprachelemente

2.2.1 Programm, Anweisungen und Blöcke Für den Einsteiger scheint der Sprachumfang von Object Pascal gewaltig zu sein – womit also anfangen? Die folgende Abbildung zeigt irgendeinen Quelltextausschnitt, wobei lediglich versucht wird, auf die Vielfalt von Sprachelementen und Begriffen hinzuweisen, ohne dass Sie schon jetzt etwas davon verstehen müssen:

Reserviertes Wort

Anweisungsblock

Anweisungen zur Variablendeklaration

Parameterliste

Nutzerdefinierte Prozedur

Prozeduraufruf

Variable Aufruf einer Pascal-Prozedur

Eventhandler-Prozedur

Anweisung

Reservierte Wörter

Zu den klassischen Sprachelementen gehören Typen, Variablen, Konstanten, Prozeduren, Funktionen und Units. Diese Sprachelemente (Token) müssen innerhalb einer Anweisung durch mindestens ein Leerzeichen voneinander getrennt sein.

Die Blockstruktur Object Pascal ist eine streng strukturierte und blockorientierte Sprache. Mehrere Anweisungen sind oft in Blöcke zusammengefasst, die man damit auch als "Makroanweisungen" auffassen kann. Die einzelnen Blöcke, die man beliebig ineinander verschachteln kann, werden im Allgemeinen durch die reservierten Wörter begin und end begrenzt. Um die Lesbarkeit des Codes zu erhöhen, sollten Sie durch Einrückungen die Blockstruktur deutlich hervortreten lassen.

2.2 Ein erster Blick auf Object Pascal

69

Jede Anweisung (wie auch jeder Block) wird durch ein Semikolon (;) abgeschlossen, beachten Sie dabei bitte Folgendes: HINWEIS: Vor einem Blockende (end, until ...) braucht kein Semikolon zu stehen!

Der Grund hierfür ist der gleiche wie für den Blockanfang (begin, ...), denn auch nach diesem steht kein Semikolon. Fügen Sie das Semikolon trotzdem vor end ein (was leider auch in den zahlreichen Beispielprogrammen der Delphi-Dokumentation praktiziert wird), so ist das zwar kein Fehler, bewirkt aber eine nutzlose Leeranweisung. BEISPIEL: Der gut strukturierte Quelltext einer Prozedur procedure fillArray; var i,j: Word; a: array[1..10, 1..20] of Integer; begin for i := 1 to 10 do begin for j := 1 to 20 do a[i,j] := i * j end end;

Verstehen brauchen Sie die einzelnen Anweisungen innerhalb dieses Beispiels (noch) nicht, denn dazu ist der Rest des Kapitels da.

Zulässige Zeichen Da Groß- und Kleinschreibung in Pascal keine Rolle spielen, sollte man diese Freiheit dazu nutzen, um die Lesbarkeit des Codes zu erhöhen. Wir wollen uns an folgende Konvention halten: Die "hauseigenen" Delphi-Sprachelemente (mit Ausnahme der reservierten Wörter) beginnen mit einem Groß-, die vom Programmierer selbst definierten mit einem Kleinbuchstaben. Großbuchstaben werden innerhalb eines Wortes auch dann eingesetzt, wenn dadurch die Verständlichkeit gesteigert werden kann. Die Variable gruenesEingabefeld liest sich besser als grueneseingabefeld. Als Zeichen sind Groß- und Kleinbuchstaben (außer ß und Umlaute), der Unterstrich "_" sowie die Ziffern 0 ... 9 zulässig. Da der Compiler nicht zwischen Groß- und Kleinschreibung unterscheidet, dient diese Option allein der besseren Lesbarkeit des Quelltextes durch den Programmierer. Außerdem gibt es eine ganze Reihe weiterer Zeichen bzw. Zeichenkombinationen, die als Operatoren fungieren bzw. andere Aufgaben zu erfüllen haben: Symbol(e) Erklärung :=

Zuweisung

+

Addition, Vorzeichen, Vereinigungsmenge, Stringverkettung

-

Subtraktion, Vorzeichen, Differenzmenge

70

Kapitel 2

Grundlegende Sprachelemente

Symbol(e) Erklärung *

Multiplikation

/

reelle Division Gleichheitsabfrage

= >

<

>=

<=

Abfragen "größer als" bzw. "kleiner als" Abfragen "größer/gleich als" bzw. "kleiner/gleich als"

<>

Abfrage auf Ungleichheit

.

Dezimalpunkt, Qualifizierung von Bezeichnern, Programm- oder Unit-Ende

..

Bereichsangabe

,

Trennung von Listenelementen

;

Trennung von Deklarationen bzw. Anweisungsblöcken

:

Variablendeklaration, Case-Separator

'

Zeichenkettenanfang bzw. -ende

[ ]

Anfang bzw. Ende von Mengenkonstanten

( )

Anfang bzw. Ende von Listen bzw. Klammerausdrücken

{ }

Anfang bzw. Ende von Kommentaren

//

Einleitung einer Kommentarzeile

^

Zeichen für Zeiger (Pointer)

@

Adresszeichen

$

Einleitung einer Hexadezimalzahl

#

Einleitung einer ASCII-Darstellung

(. .)

Ersatzdarstellung für [ ]

(* *)

Ersatzdarstellung für { }

Kommentare Diese dienen zur Erläuterung des Quelltextes. Für das Kennzeichnen von Kommentaren gibt es drei verschiedene Möglichkeiten (siehe obige Tabelle). BEISPIEL: Kommentare { Das ist ein Kommentar für Leute, die sich gerne die Finger verrenken! } (* Das ist ein Kommentar, wie wir ihn gern bei mehreren Zeilen verwenden! *) // Das ist ein Kommentar für eine Zeile!

Die letzte Variante ist besonders interessant, genügt doch hier lediglich die Markierung des Kommentaranfangs, das Ende wird automatisch mit dem Zeilenumbruch gesetzt. Die Delphi-Ent-

2.2 Ein erster Blick auf Object Pascal

71

wicklungsumgebung sorgt für eine farbliche Hervorhebung von Kommentaren, was die Lesbarkeit des Quelltextes erheblich erleichtert. Normalerweise werden Kommentare vom Compiler ignoriert, allerdings gibt es folgende wichtige Ausnahme, bei der genau das Gegenteil der Fall ist: HINWEIS: Hinter einem "Kommentar", der unmittelbar mit einem Dollarzeichen eingeleitet

wird (also ohne Leerzeichen dazwischen), verbirgt sich eine Compileranweisung. BEISPIEL: Compiler-Befehle {$D+}

aktiviert das Erzeugen von Debug-Informationen. {$APPTYPE CONSOLE}

kennzeichnet eine Konsolenanwendung (Textbildschirm).

2.2.2 Bezeichner Jedes Sprachelement ist durch einen so genannten Bezeichner (Identifier) gekennzeichnet. Man unterscheidet: ■ reservierte Wörter und vordefinierte (Standard-)Bezeichner ■ benutzerdefinierte Bezeichner Im Folgenden wollen wir die wichtigsten Vertreter dieser Gattungen näher vorstellen.

Reservierte Wörter und Standardbezeichner Die meisten der in der Tabelle aufgeführten Wörter1 sind von Object Pascal reserviert, also für jegliche Verwendung als benutzerdefinierte Bezeichner tabu. Einige sind so genannte Standardbezeichner, die vom Benutzer umdefiniert (quasi überschrieben) werden können, es wird jedoch dringend davon abgeraten2. Bezeichner

Erklärung

absolute

Adressendefinition

assembler

Einbinden von Assembler-Code

and

logisches UND

array

Feld (Tabelle)

as

Überprüfung von Typumwandlungen

asm

Zugriff auf den integrierten Assembler

1

Die auf das Unit- und OOP-Konzept bezogenen reservierten Wörter finden Sie nicht hier, sondern erst im Kapitel 6.

2

Das Warum werden Sie sich denken können.

72

Kapitel 2

Grundlegende Sprachelemente

Bezeichner

Erklärung

at

@-Operator zur Adressenberechnung

begin

Blockanfang

case

Fallunterscheidung

cdecl

Unterstützung von Delphi-fremden Routinen

const

Konstantendeklaration

div

ganzzahlige Division

do

Schleifenausführung

downto

unterer Endwert einer Schleife

else

Nein-Zweig einer Abfrage

end

Blockende

except

Abschnitt für Fehlerbehandlungscode

exports

Export einer Funktion/Prozedur (DLL)

external

Deklaration extern compilierter Prozeduren/Funktionen

far

Aufruf von Routinen von anderen Modulen aus

forward

Deklaration einer Funktion/Prozedur im Voraus

file

Datei

finally

immer ausgeführter Abschnitt eines geschützten Blocks

for

Beginn einer Schleife

function

Funktionsdeklaration

goto

Sprungbefehl

if

Beginn einer Bedingung

in

Element (Teilmenge)

index

Ordinalzahl für Export von Funktionen/Prozeduren aus einer DLL

inline

Einleitung von Assembler-Befehlen

label

Sprungmarke

library

Dynamische Linkbibliothek (DLL)

mod

Divisionsrest

name

Namensangabe innerhalb einer exports-Klausel

near

Aufrufkonvention Near

nodefault

Standardwert einer Eigenschaft wird gesteuert

nil

undefinierter Zeiger

not

Verneinung

of

Benennung eines Grundtyps

or

logisches ODER

on

bildet zusammen mit do eine Fehlerbehandlungsroutine

2.2 Ein erster Blick auf Object Pascal

Bezeichner

Erklärung

overload

Überladen einer Routine

packed

gepackte Struktur

procedure

Prozedurdeklaration

program

Programmdeklaration

raise

Auslösen einer Exception (Fehlerbehandlung)

record

Datensatz

repeat

Wiederholung mit Endabfrage

resident

Exportinformation verbleibt beim DLL-Aufruf im Speicher

set

Menge

shl

Verschieben nach links

shr

Verschieben nach rechts

string

Zeichenkette

then

Ja-Zweig einer Abfrage

to

oberer Endwert einer Schleife

try

geschützter Code innerhalb einer Exception-Behandlung

type

Datentyp

until

Ende einer Repeat-Schleife

var

Daten-Variable

while

Wiederholung mit Anfangsabfrage

with

Zugriff auf Record-Strukturen

xor

Exclusiv-ODER

73

Der Delphi-Quelltexteditor formatiert die reservierten Wörter automatisch in Fettschrift, wenn Sie die Standardeinstellungen der Programmierumgebung nicht ändern (Menü Tools|Umgebungsoptionen..., "Farben").

Benutzerdefinierte Bezeichner Folgenden Elementen Ihres Object-Pascal-Programms können Sie eigene Namen verordnen: ■ Units ■ Typen, Variablen, Konstanten, Recordfelder ■ Funktionen, Prozeduren, Sprungmarken (Labels) Groß- und Kleinschreibung spielen keine Rolle, allerdings gibt es für die Namensgebung folgende Beschränkungen: ■ Nur die ersten 63 Zeichen sind signifikant. ■ Das erste Zeichen muss ein Buchstabe oder der Unterstrich (_) sein.

74

Kapitel 2

Grundlegende Sprachelemente

■ Alle übrigen Zeichen können Buchstaben, Zahlen oder Unterstriche sein. ■ Leerzeichen sind nicht zugelassen. BEISPIEL: Zulässige Bezeichner a TextFile mathFunc Real2String

BEISPIEL: Verbotene Bezeichner 2Halbe &Exit String x 1

// // // //

falsch, falsch, falsch, falsch,

weil weil weil weil

erstes Zeichen eine Ziffer ist erstes Zeichen kein Buchstabe/Unterstrich ist String ein reserviertes Wort ist Leerzeichen enthalten ist

2.3 Datentypen, Variablen und Konstanten Jedes Programm "lebt" in erster Linie von seinen Variablen. Mit Variablen wird gerechnet, oder ihnen wird mittels Ergibt-Anweisung (:=) ein Wert zugewiesen, oder sie werden als Parameter an Funktionen bzw. Prozeduren übergeben. BEISPIEL: Verwendung Variablen a := 2 * b; y := sin(x);

Variablen haben im Allgemeinen einen bestimmten Datentyp (Single, Integer, String ...). Konstanten werden ähnlich wie Variablen behandelt, ihr Wert ist aber unveränderlich (mit Ausnahme der so genannten Typisierten Konstanten).

2.3.1 Deklaration von Variablen Eine Variable wird immer mit dem reservierten Wort var deklariert. Nach dem Variablenbezeichner folgt, durch Doppelpunkt (:) getrennt, der Datentyp. Mehrere Variablen des gleichen Typs können durch Komma getrennt werden. Mehrere Deklarationen sind durch Semikolon (;) zu separieren. Das reservierte Wort var braucht nur einmal am Anfang eines Deklarationsblocks zu stehen. BEISPIEL: Bei all diesen Variablen handelt es sich um globale Variablen. Was es damit auf sich hat und

welcher Unterschied zu lokalen Variablen besteht, wird Ihnen im Folgenden erklärt. var kurs,dm, dollar: Single; code: Integer; s: string;

2.3 Datentypen, Variablen und Konstanten

75

Gültigkeitsbereiche Außerhalb von Prozeduren und Funktionen deklarierte Variablen bezeichnet man als global, innerhalb von Prozeduren/Funktionen deklarierte als lokal. HINWEIS: Falls Sie einer lokalen Variablen den gleichen Bezeichner wie einer bereits existie-

renden globalen Variablen geben, so erzeugt dies eine neue Variable, die in diesem lokalen Bereich die gleich lautende globale Variable außer Kraft setzt. BEISPIEL: Gültigkeitsbereich von Variablen var s1, s2: string;

// deklariert globale Variablen

procedure testA; var s2: string; begin s1 := 'Mueller'; s2 := 'Meier' end;

// wird zuerst aufgerufen // deklariert lokale Variable // initialisiert globales s1 // initialisiert lokales s2

procedure testB; // wird später aufgerufen var s3: string; // deklariert lokale Variable begin s3 := s1; // s3 erhält den Wert 'Mueller' s3 := s2 // s3 erhält unbestimmten Wert, da globales s2 nicht initialisiert ist end;

Initialisierte Variablen Globalen Variablen können Sie bereits bei deren Deklaration einen Anfangswert zuweisen. BEISPIEL: Variablen initalisieren var s: string = 'Hallo'; i: Integer = 5;

Siehe dazu auch Typisierte Konstanten in Abschnitt 2.3.8.

2.3.2 Einfache vordefinierte Datentypen Bevor Sie Variablen deklarieren, sollte Ihnen klar sein, um welchen Datentyp es sich handeln soll. Grundsätzlich ist zwischen vordefinierten und benutzerdefinierten Datentypen zu unterscheiden. Eine Zusammenstellung vordefinierter Datentypen finden Sie in der folgenden Tabelle.

76

Kapitel 2

Grundlegende Sprachelemente

Typ

Erläuterung

Größe

Integer LongInt

vorzeichenbehaftete Ganzzahl zwischen -2 147 483 648und 2 147 483 4 Byte 647

ShortInt

kurze vorzeichenbehaftete Ganzzahl zwischen -128 und 127 63

1 Byte 63

Int64

sehr lange vorzeichenbehaftete Ganzzahl zwischen -2 und 2 -1

8 Byte

Cardinal

lange Ganzzahl zwischen 0 und 2.147.483.647

4 Byte

Byte

kurze positive Ganzzahl zwischen 0 und 255

1 Byte

Word

Ganzzahl zwischen 0 und 65 535

2 Byte

Single

einfachgenaue Gleitkommazahl mit 7-8-stelliger Genauigkeit zwischen 1.5x10-45 und 3.4x1038

4 Byte

Double

doppelt genaue Gleitkommazahl mit 15-16-stelliger Genauigkeit zwischen 5.0x10-324 und 1.7x10308

8 Byte

Extended

super genaue Gleitkommazahl mit 19-20-stelliger Genauigkeit zwischen 3.4x10-4932 und 1.1x104932

10 Byte

Comp

doppelt lange Ganzzahl zwischen -263+1 und 263-1

8 Byte

Currency

auf vier Nachkommastellen skalierte Ganzzahl zwischen 922.337.203.685.477,5808 und 922.337.203.685.477,5807

8 Byte

Real48(Real) Gleitkommazahl mit 11-12-stelliger Genauigkeit zwischen 2.9x10-39 und 1.7x1038 (ersetzt ab Delphi 4 den alten Real-Typ)

6 Byte

Boolean

Wahrheitswert (True, False)

1 Byte

ByteBool

kurzer Wahrheitswert (True, False)

1 Byte

WordBool

mittellanger Wahrheitswert (True, False)

2 Byte

LongBool

langer Wahrheitswert (True, False)

4 Byte

Char

Zeichen zwischen 0 <= Ord <= 255

1 Byte

AnsiChar

Byte-Zeichen (werden entsprechend dem erweiterten ANSI-Zeichensatz geordnet)

1 Byte

WideChar

Word-Zeichen (werden entsprechend des Unicode-Zeichensatzes geordnet). Die ersten 256 Unicode-Zeichen entsprechen den ANSIZeichen.

2 Byte

Zu den Besonderheiten der lästigen Unterscheidung zwischen so genannten Fundamental- und Generic-Datentypen informieren Sie sich bitte am Ende dieses Abschnitts. Zwar gibt es auch noch weitere Datentypen, z.B. TDateTime (siehe Datums- und Zeitfunktionen), diese lassen sich aber alle auf die oben angeführten elementaren Typen zurückführen. Im Folgenden wollen wir die einzelnen Datentypen in Gruppen zusammenfassen (die sich auch teilweise überlappen können) und näher besprechen.

77

2.3 Datentypen, Variablen und Konstanten

Ordinale Typen (Aufzählungstypen) Dazu gehören Integer, Shortint, Longint, Int64, Byte, Word, Boolean, ByteBool, WordBool, LongBool, Char, AnsiChar und WideChar. Alle Werte eines ordinalen Typs kann man auf bestimmte Weise aneinander reihen und abzählen, sie bilden demzufolge eine geordnete Menge. Folgende Standardfunktionen lassen sich auf ordinale Typen anwenden: Funktion

Rückgabewert Erläuterung

Ord

LongInteger

Pred

wie Argument

... liefert den Vorgänger des Wertes

Succ

wie Argument

... liefert den Nachfolger des Wertes

Low

wie Argument

... bestimmt den niedrigsten Wert im Typbereich

High

wie Argument

... bestimmt den höchsten Wert im Typbereich

... liefert die Position des Elements innerhalb des Typbereichs

BEISPIEL: Standardfunktionen Pred('b')

... liefert 'a'. Pred(5)

... liefert 4. Ord('b')

... ergibt 98. type tag = 1..7 High(tag)

... liefert 7.

Integer-Typen Ein Integer-Typ repräsentiert eine Untermenge der ganzen Zahlen. Dazu zählen ShortInt, Integer, LongInt, Int64, Byte und Word. Arithmetische Operationen mit diesen Typen erfolgen mit 8-Bit-, 16-Bit-, 32-Bit- oder 64-BitGenauigkeit. Bytes werden dabei zwischenzeitlich in Operanden vom Typ Word konvertiert, damit sie kompatibel mit Integer und Word sind, bevor der Ausdruck ausgewertet wird. HINWEIS: Benutzen Sie, wo immer es geht, die generischen Typen Integer und Cardinal, da

diese die beste Performance aus CPU bzw. Betriebssystem herausholen!

Hexadezimalzahlen Auch Hexadezimalzahlen gehören mit zu den Integer-Typen, nur die Art der Darstellung unterscheidet sich (Basis 16 anstatt 10)!

78

Kapitel 2

Grundlegende Sprachelemente

Im Programm wird eine Hexzahl durch ein vorangestelltes Dollarzeichen ($) gekennzeichnet. BEISPIEL: Hexzahl const c5 = $03E8;

Zur Konvertierung einer Integerzahl in die Hexdarstellung gibt es die IntToHex-Funktion. Der Rückgabewert ist ein String! BEISPIEL: Die Anweisung Label1.Caption := IntToHex(1000, 4);

zeigt den String '03E8'. Der zweite Parameter (4) entspricht der Mindestanzahl der zurückgegebenen Zeichen. Eine Rückverwandlung von der hexadezimalen Stringdarstellung in Integer-Zahlen ist mittels der bekannten StrToInt-Funktion möglich. BEISPIEL: Wenn x eine Integer-Variable ist, so liefert die Anweisung x := StrToInt('$03E8');

den Wert 1000. Praktische Anwendung finden Hexadezimalzahlen unter anderem für die Darstellung von Farbwerten (siehe dazu 7.1.3 im Grafikkapitel).

Boolesche Typen Zu dieser Untergruppe der ordinalen Typen zählen Boolean, ByteBool, WordBool und LongBool. Variablen dieser Typen können nur die Werte False (0) und True (1 bzw. <> 0) annehmen. BEISPIEL: Weil auch Boole'sche Typen Ordinaltypen sind, gilt: False < True, Ord(False) = 0, Ord(True) = 1, Succ(False) = True

Boolean ist zu bevorzugen und verbraucht am wenigsten Speicherplatz, während man auf ByteBool, WordBool und LongBool nur in Spezialfällen zurückgreifen sollte (zwecks Kompatibilität mit anderen Sprachen und der Windows-Umgebung).

Character-Typen Object Pascal definiert zwei fundamentale Character-Typen (AnsiChar und WideChar) und den generischen Character-Typ Char. Damit kann jeweils ein einzelnes Zeichen gespeichert werden. Char entspricht AnsiChar, aber Implementationen für andere CPUs und Betriebssysteme könnten Char als WideChar definieren. Wenn Code geschrieben wird, der beide Zeichen benötigt, sollten Sie die Standardfunktion SizeOf zur Ermittlung der Zeichengröße einsetzen.

2.3 Datentypen, Variablen und Konstanten

79

BEISPIEL: Sizeof SizeOf(Char)

... liefert 1 (Byte). SizeOf(WideChar)

... ergibt 2 (Byte).

Real-Typen Die Typen Real48, Single, Double, Extended und Currency umfassen die Gleit- bzw. Fließkommazahlen. Die sich dahinter verbergende rechenzeitintensive Gleitkomma-Arithmetik ist seit eh und je die Achillesferse eines Computers. Grund genug, diese aufwändige Angelegenheit nicht der Software, sondern einem Coprozessor zu übertragen, wie er standardmäßig in der CPU integriert ist (ab 486er). Real-Typen unterscheiden sich in ihrem Wertebereich, der Genauigkeit der Werte und im Speicherplatzbedarf. Der Typ Real48 ist mit dem Typ Double identisch. Diese Änderung gegenüber dem alten Real-Typ verbessert die Leistung, da Double mit Intel-CPUs kompatibel ist. Wenn Sie Quelltext neu compilieren wollen, der noch den alten Real-Typ enthält, sollten Sie diesen Typ in Real48 ändern. Die Compiler-Direktive {$REALCOMPATIBILITY ON} wandelt den Typ Real48 wieder in den alten Real-Typ um. HINWEIS: Für Real48 gilt das Gleiche wie für den alten Real-Datentyp: Finger weg davon! Er

dient nur der Abwärtskompatibilität zu früheren Versionen von Delphi und Borland Pascal. Da das Real48-Speicherformat von den Intel-CPUs nicht unterstützt wird, sind Operationen mit Real48-Typen langsamer als die mit den coprozessorunterstützten Fließkommatypen Single, Double oder Extended. Wenn im Folgenden von einem Real-Datentyp die Rede ist, so wollen wir darunter einen Vertreter der aus Single, Double und Extended gebildeten Gruppe verstehen! Der Typ Currency ist ein Festkomma-Datentyp mit vier Nachkommastellen für quasi rundungsfreie Finanzberechnungen. Der Typ Comp (von computational) ist eigentlich kein Fließkomma-Datentyp, sondern eher ein doppelt breiter LongInteger. Der entsprechende Zahlenbereich bewegt sich zwischen -9.2x1018 und 9.2x1018. Dass Comp trotzdem mit unter den Real-Typen auftaucht, hat seinen Grund darin, dass auch Comp vom Coprozessor unterstützt wird. Comp-Typen eignen sich aufgrund ihrer hohen Genauigkeit ebenfalls sehr gut für Finanzberechnungen. Eine herausragende Bedeutung kommt dem Datentyp Extended zu, denn er ist die Basis für alle Gleitkommarechnungen, die mit dem integrierten Arithmetik-Coprozessor durchgeführt werden. Auch wenn z.B. nur Single- oder Double-Variablen in mathematischen Ausdrücken auftreten, werden intern die Rechenoperationen mit der imposanten 10-Byte-Datenbreite des Extended-Formats durchgeführt. Klar, dass dadurch die Rundungsfehler drastisch vermindert werden.

80

Kapitel 2

Grundlegende Sprachelemente

BEISPIEL: Unabhängig von den deklarierten Single-Variablen wird die gesamte rechte Seite im Extended-For-

mat berechnet. var y, x1, x2, x3: Single; begin x1 := 12.367123; x2 := 3.55E6; x3 := 0.36E-15; y := (x1 + Sqrt(x1 * x1 - x2 * x3) / x2 end;

Wie Sie erkennen, steht es Ihnen frei, für Gleitkommazahlen die normale (mit Dezimalpunkt) oder die wissenschaftliche Notation (mit E-Zehnerpotenzen) anzuwenden. Der Rechenzeitbedarf ist für alle coprozessorunterstützten Datentypen gleich groß. Der einzige Grund, auf Single und Double nicht gleich gänzlich zu verzichten und stattdessen durchweg Extended zu verwenden, dürfte deshalb lediglich der geringere Speicherplatzbedarf sein.

Fundamentale und generische Typen Besonders beim Einsteiger sorgt diese Zweiteilung für Verwirrung. Der Bereich und das Format von Fundamental-Typen ist von der zugrunde liegenden CPU und dem Betriebssystem unabhängig und ändert sich nicht bei verschiedenen Implementierungen von Object Pascal. Hingegen hängen Bereich und Format von Generic-Typen von der vorhandenen CPU und dem Betriebssystem ab. Es gibt in der gegenwärtigen Delphi-Version drei Klassen von vordefinierten Typen, die zwischen Fundamental- und Generic-Typen unterscheiden: ■ Integer-Typen ■ Character-(Zeichen-)Typen ■ String-Typen Für alle anderen Klassen sind die vordefinierten Typen automatisch als Fundamental-Typen zu betrachten. In Ihren Anwendungen sollten Sie generische Typen bevorzugen, um beste Ergebnisse mit der zugrunde liegenden CPU und dem Betriebssystem zu erzielen. Dies sind Integer für vorzeichenbehaftete und Cardinal für vorzeichenlose ganze Zahlen (also anstelle Word und Byte). Zu den generischen Typen zählen neben Integer und Cardinal auch Char (für einzelne Zeichen) und ANSIString (für Zeichenketten). Die fundamentalen Typen sollten eigentlich nur dann Verwendung finden, wenn der aktuelle Bereich und/oder das Speicherformat mit der Anwendung nicht übereinstimmen. HINWEIS: Für den Einsteiger ist es kein Beinbruch, wenn er Unterschiede zwischen Generic-

und Fundamental-Typen zunächst einfach ignoriert, denn in den meisten Fällen sind die Performance-Einbußen praktisch unbedeutend.

81

2.3 Datentypen, Variablen und Konstanten

2.3.3 Arithmetische Operationen Variablen lassen sich durch arithmetische Operationen miteinander verknüpfen. Die folgende Tabelle vermittelt einen Überblick der Grundrechenarten. Operator

Operation

Operandtyp

Ergebnistyp

Beispiel

+

Addition

Real, Integer

Real, Integer

a+b

-

Subtraktion

Real, Integer

Real, Integer

c–5

*

Multiplikation

Real, Integer

Real, Integer

i*k

/

Gleitkomma-Division

Real, Integer

Extended

y/3

div

Integer-Division

Integer

Integer

a div 7

mod

Modulo (Rest)

Integer

Integer

b mod 3

Beachten Sie, dass Integer und Real in obiger Tabelle stellvertretend stehen für die verschiedenen Integer- und Real-Typen gemäß Abschnitt 2.3.2. Dabei ist Folgendes zu beachten: ■ Das Ergebnis einer Gleitkomma-Division ist immer vom Typ Extended, unabhängig vom Typ der Operanden. ■ Bei allen anderen Operationen ist das Ergebnis nur dann vom Typ Extended, wenn mindestens ein Operand vom Typ Real ist. ■ Sind beide Operanden vom Integer-Typ, so ist das Ergebnis vom Typ Int64, wenn mindestens ein Operand diesen Typ hat. Anderenfalls ist das Ergebnis ein Integer. ■ Der Wert i div j entspricht dem mathematischen Quotienten i / j, der auf einen Wert vom Typ Integer abgerundet wird. ■ Der Operator mod berechnet den Rest der Division beider Operanden. Daraus folgt:a mod b = a – (a div b) ■ Wenn b in einem der Ausdrücke a/b, a div b oder a mod b null ist, so erzeugt dies einen Laufzeitfehler. HINWEIS: Die Operatoren +, -, und * können auch als Mengenoperatoren verwendet werden.

Der Operator + dient gleichzeitig der Addition von Stringvariablen. BEISPIEL: Operatoren var i,j: Integer; m: Double; // zwei Integer und eine Real-Variable begin i := 11 div 3; // i ergibt sich zu 3 j := 11 mod 3; // j ergibt sich zu 2 m := i/j // m ergibt sich zu 1.5 end;

Sinnvollere Anwendungsbeispiele finden Sie in vielfältigster Form im Wissenschaftskapitel 13.

82

Kapitel 2

Grundlegende Sprachelemente

2.3.4 Strings Ein String ist eine Zeichenkette aus Zeichen des erweiterten ASCII-Zeichensatzes. Der String ist in Apostrophe (') einzuschließen und muss in einer Programmzeile stehen. BEISPIEL: Strings var s1: string; ... s1 := 'Hallo'; s1 := '';

// Leerstring

Kurze und lange Strings Ab Delphi 2.0 wurden neben den bislang üblichen "kurzen" Strings (255 Zeichen) auch "lange" Strings unterstützt, deren Länge die gigantische Größe von max. 2 GByte erreichen kann und somit nur noch theoretisch begrenzt ist. Hier eine Übersicht der zur Verfügung stehenden Stringtypen: Typ

Erläuterung

Größe

AnsiString

Zeichenkette quasi unbegrenzter Länge

4 Byte (Zeiger!)

ShortString

Zeichenkette max. 255 Byte

(Länge+1) Byte

WideString

wie AnsiString, aber Unicode-Zeichensatz, d.h. 2 Byte pro Zeichen

4 Byte (Zeiger!)

String

AnsiString ($H+) oder ShortString ($H-) je nach Compilereinstellung

siehe oben

Für alle Typen kann bei der Deklaration nach wie vor das reservierte Wort string verwendet werden. Die Unterscheidung besorgt eine neue Compileranweisung $H, welche Sie indirekt über die "Compiler"-Seite des Dialogfensters "Projektoptionen" beeinflussen (erreichbar über das Menü Projekt|Optionen...). Das Häkchen bei "Huge Strings" entspricht der Standardeinstellung $H+, d.h., im Normalfall werden lange Strings benutzt. An der Compiler-Standardeinstellung $H+ (siehe folgende Abbildung) sollten Sie nicht herumdoktern, denn auch durch Angabe einer Stringlänge in eckigen Klammern kann immer ein kurzer String erzeugt werden. Lange Strings können Sie aber auch explizit mit dem Standardbezeichner AnsiString deklarieren, kurze mit ShortString, wobei in diesen Fällen die Compilereinstellung unwichtig ist. BEISPIEL: Lange Strings {$H+} var s1: s2: s3: s4:

// lange Strings einschalten (kann weggelassen werden, da Standard) string; string[40]; AnsiString; ShortString

// // // //

ein ein ein ein

langer kurzer langer kurzer

String String String String

(abhängig von SH) mit max. 40 Zeichen (unabhängig von $H) (unabhängig von $H) (unabhängig vo $H)

83

2.3 Datentypen, Variablen und Konstanten

HINWEIS: Auch alle Komponenten ab Delphi 2.0 benutzen den langen String-Datentyp. Da in

alten 16-Bit-Applikationen (Delphi 1.0) mit hoher Wahrscheinlichkeit Komponenten mit Eigenschaften vom String-Datentyp vorhanden sind, müssen Sie die Anwendung aus Kompatibilitätsgründen nochmals compilieren (natürlich mit $H+). Mehr zu diesem Thema finden Sie im Kapitel 14 ("Datenstrukturen").

Zugriff auf einzelne Zeichen Sie können auch ein einzelnes Zeichen aus einem String quasi "herausschneiden", indem der Index in eckigen Klammern nachgestellt wird. Die Art des Zugriffs entspricht damit dem auf einzelne Elemente eines Arrays. BEISPIEL: Char var z: Char; s: string; ... s := 'Hallo'; z := s[1]; // z erhält das Zeichen 'H'

Bemerkungen ■ Routinen zur Stringverarbeitung finden Sie im Abschnitt 2.6.3. ■ Hinweise zu nullterminierten Strings (PChar) sind im Abschnitt 2.4.2 (nullbasierte Arrays) enthalten, ein vergleichendes Beispiel finden Sie im Praxisteil des Kapitels 14 ("Zum Unterschied zwischen PChar und String"). ■ Mehrere Strings können in Stringlisten (Datentyp TString) zusammengefasst werden.

2.3.5 Zeigertypen Ein Zeigertyp ist ein Wert, der auf Variablen eines Basistyps zeigt. Eine Variable vom Typ Pointer enthält die Speicheradresse einer Variablen. Typ

Erklärung

Größe

Pointer

Zeiger allgemein

4 Byte

PChar

Zeiger auf ein Zeichen (kompatibel zu einem nullbasierten Array, 4 Byte siehe 2.4.2)

BEISPIEL: Umwandeln eines String-Datentyps in einen PChar var p: PChar; ... p := PChar(Edit1.Text);

Die Grundlagen für die Arbeit mit Zeigern entnehmen Sie dem Abschnitt 14.2.1 (Pointer). Ein umfassendes Beispiel ist das Programm "Gauss" (Kapitel 16). Anwendungen im Zusammenhang

84

Kapitel 2

Grundlegende Sprachelemente

mit der Werteübergabe an API-Funktionen und der Programmierung von DLLs finden Sie im Kapitel 13 (Programmschnittstellen).

Prozedurale Typen Gewöhnungsbedürftig, aber durchaus erwähnenswert, sind die prozeduralen Typen, denn sie ermöglichen es, Prozeduren und Funktionen wie Variablen zu behandeln und als Parameter zu übergeben. BEISPIEL: Berechnen des Tangens eines Winkels function tan(alpha: Double):Double; begin result := Sin(alpha)/Cos(alpha); end;

Obige Funktion kann nun wie folgt getestet werden: procedure Test; type mathFunc = function(a: Double): Double; var f: mathFunc; x: Double; begin f := tan; x := f(Pi/4); end;

// Zuweisen des Namens einer Funktion // entspricht x := tan(Pi/4) und liefert die Zahl 1.000

Beachten Sie, dass die Parameterliste von mathFunc kompatibel zu tan sein muss!

2.3.6 Variant-Datentypen Eine Variable des Variant-Typs belegt 16 Byte Speicherplatz, also erheblich mehr als ein herkömmlicher Datentyp. Einem Chamäleon gleich können Variant-Variablen ihren Typ dynamisch (also zur Laufzeit) ändern. Weitere Merkmale von Variant-Variablen: ■ Sie können ganze oder reelle Zahlen, Stringwerte, Boole'sche Werte, Datum-Uhrzeit-Werte, Arrays sowie OLE-Automatisierungsobjekte aufnehmen. ■ Mit dem speziellen Wert Unassigned wird angezeigt, dass einer Variant-Variablen bislang noch keine Daten zugewiesen wurden, mit dem speziellen Wert Null (nicht zu verwechseln mit der Zahl 0!) werden unbekannte oder fehlende Daten gekennzeichnet. Variant-Variablen werden bei ihrer Erstellung stets mit Unassigned initialisiert. ■ Wenn eine Variant-Variable auf ein OLE-Automatisierungsobjekt verweist, kann auf die Eigenschaften und Methoden dieses Objektes zugegriffen werden.

85

2.3 Datentypen, Variablen und Konstanten

Lassen Sie sich aber von der beeindruckenden Flexibilität von Variant-Variablen nicht blenden und achten Sie auch auf die Schattenseiten im Vergleich zu "normalen", d.h. statisch deklarierten, Variablen: ■ Variant-Variablen belegen erheblich mehr Speicherplatz. ■ Operationen mit Variant-Variablen benötigen deutlich mehr Rechenzeit. HINWEIS: Verwenden Sie Variant-Variablen nur in den wirklich sinnvollen Fällen, z.B. dann,

wenn der tatsächlich zu verarbeitende Typ oft wechselt bzw. zum Zeitpunkt der Compilierung noch unbekannt ist.

Konvertierungsroutinen Wie die folgende Tabelle zeigt, steht für die Arbeit mit Variant-Variablen (VV) ein stattliches Sortiment an Funktionen/Prozeduren zur Verfügung. Routine

Erläuterung

VarAsType

... konvertiert eine VV zu einem bezeichneten Typ

VarCast

... konvertiert eine VV zu einem bezeichneten Typ und speichert sie

VarClear

... löscht eine gegebene VV

VarCopy

... kopiert eine gegebene VV in eine andere VV

VarFromDateTime

... liefert eine VV zurück, die eine Datums- und eine Zeitangabe enthält

VarIsEmpty

... gibt an, ob eine gegebene VV nicht zugewiesen ist

VarIsNull

... gibt an, ob eine gegebene VV NULL ist

VarToDateTime

... konvertiert eine gegebene VV in eine Datums- und Zeitangabe

VarType

... konvertiert eine VV zu einem bezeichneten Typ und speichert sie

Im Folgenden werden wir uns auf die nähere Erläuterung der VarType-Funktion beschränken: Die interne Darstellung von Variant-Variablen besteht aus Typencode und Wert (oder einer Referenz auf einen Wert). Die Funktion VarType liefert den Typencode einer Variant-Variablen: Konstante

Hex

Dez

Inhalt der Variant-Variablen

varEmpty

$0000

0

Variable hat den Wert Unassigned

varNull

$0001

1

Variable hat den Wert Null

varInteger

$0003

3

ganze 32-Bit-Zahl mit Vorzeichen (Typ Integer)

varSingle

$0004

4

Fließkommawert einfacher Genauigkeit (Typ Single)

varDouble

$0005

5

Fließkommawert doppelter Genauigkeit(Typ Double)

varCurrency

$0006

6

Fließkomma-Währungswert (Typ Currency)

varDate

$0007

7

Datum-Uhrzeit-Wert (Typ TDateTime)

varError

$000A 10

Betriebssystem-Fehlercode

86

Kapitel 2

Grundlegende Sprachelemente

Konstante

Hex

Dez

Inhalt der Variant-Variablen

varBoolean

$000B

11

Boole'scher 16-Bit-Wert (Typ WordBool)

varUnknown

$000D 13

varByte

$0011

17

vorzeichenlose ganze 8-Bit-Zahl (Typ Byte)

varString

$0100

256

Referenz auf einen dynamisch belegten, langen String

Referenz auf ein unbekanntes OLE-Objekt

Die von VarType zurückgegebenen Konstanten varXXXX sind in der System-Unit als Hexadezimalzahlen (2 Byte) definiert. HINWEIS: Beachten Sie, dass in zukünftigen Delphi-Versionen möglicherweise zusätzliche

Typencodes auftreten. BEISPIEL: Im Folgenden wird einer Variant-Variablen (v2) die Summe aus einer weiteren Variant-Variablen

(v1) und einem String (s1) zugewiesen: var v1, v2: Variant; s1, s2: string; begin v1 := 10; s1 := '200'; v2 := v1 + s1; Str(v2, s1); Str(VarType(v2), s2); ShowMessage (s1 + #13 + s2) end;

// // // // // //

Variant <= ganze Zahl String <= ganze Zahl als String Variant <= Variant(ganze Zahl) + String Variant => String VariantType => String Anzeige von s1 und s2

Als Ergebnis entsteht die Zahl 210 als Variant-Variable 2.1E+2 vom Typ varDouble (Wert 5, siehe Tabelle). Die Str-Zeichenkettenfunktion wird angewendet, um die Werte von v2 und VarType(v2) bequem untereinander in einem Meldungsfenster (ShowMessage-Prozedur) anzeigen zu können:

2.3.7 Typumwandlungen von Variablen Umwandlung mit Typbezeichner So weit das möglich ist, können Sie in Delphi Variablen in einen anderen Datentyp umwandeln, wobei als Umwandlungsfunktion der Typbezeichner dient.

2.3 Datentypen, Variablen und Konstanten

87

BEISPIEL: Umwandlung Integer in Char var i: Integer; c: Char; ... i := 65; c := Char(i);

// ASCII von 'A'

... liefert für c das Zeichen 'A'. Aber es geht auch anders, wie Sie im folgenden Beispiel sehen, obwohl wir hier genauer genommen von einer Variablen-Umwandlung reden müssten. BEISPIEL: Umwandlung einer ShortInt- in eine Char-Variable var c: Char; ... ShortInt(c) := 65;

... liefert für c das Zeichen 'A'.

Umwandlung Real-Integer Ziemlich häufig müssen Integer- und Real-Variablen ineinander umgerechnet werden. Mit den Funktionen Round und Trunc (siehe 2.6.2) ist es kein Problem, aus einer Real- eine IntegerVariable zu machen. Umgekehrt ist es noch einfacher, denn Sie können einer Real-Zahl direkt eine Integer-Zahl zuweisen bzw. Real durch Integer ersetzen. BEISPIEL: Quadratwurzel aus Integer-Zahl var x, y: Integer; xr: Single; // Hilfsvariable ... xr := x; // Real-Variable lässt sich direkt aus Integer zuweisen! y := Round(Sqrt(xr)); // Rückverwandlung in Integer mit Round-Funktion

Eine besondere Bedeutung haben solche Umrechnungen im Zusammenhang mit Grafikoperationen (siehe Kap. 7), weil deren Argumente gewöhnlich vom Typ Integer sind (Pixelkoordinaten). Das Gleiche gilt für die in den OnMouse-Event-Handlern übergebenen Koordinaten X und Y. BEISPIEL: Beim Niederdrücken der linken Maustaste werden die Quadratwurzeln von x- und y-Koordinaten

angezeigt. procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin Label1.Caption := IntToStr(Round(Sqrt(X))) + ',' + IntToStr(Round(Sqrt(Y))) end;

88

Kapitel 2

Grundlegende Sprachelemente

2.3.8 Konstanten Deklaration Mit dem reservierten Wort const definierte Bezeichner bzw. Ausdrücke können zur Laufzeit ihren Wert nicht ändern, sie sind quasi schreibgeschützt. BEISPIEL: Konstantendeklaration const a = 1; flaeche = 150 * 200; anzahl = Ord('Z') - Ord('A') + 1; titel = 'Borland Delphi';

HINWEIS: Beachten Sie, dass die den Konstanten zugewiesenen Ausdrücke sich während der

Compilierung auswerten lassen müssen (also rechts keine Variablen verwenden!). BEISPIEL: fehlerhafte Konstantendeklaration const a = 2 * x;

// erzeugt einen Compilerfehler

HINWEIS: Wie Sie auch mehrere Konstanten auf einmal deklarieren können, erfahren Sie unter

2.4.2 (Array-Konstanten).

Ganzzahlige Konstanten Liegt der Wert einer ganzzahligen Konstanten (ohne deklarierten Typ) außerhalb des LongintBereichs, wird ihr der Typ Int64 zugewiesen. BEISPIEL: Ganzzahlige Konstanten const const const const

ZahlA = 47; ZahlB = Int64(47); ZahlC: Int64 = 47; ZahlD = 5000000000;

ZahlA ist vom Typ Longint, während die anderen Konstanten vom Typ Int64 sind.

Typisierte Konstanten Diese Sonderform sorgt insbesondere beim Einsteiger für Verwirrung, denn typisierte Konstanten können später ihren Wert ändern. Dieses absonderliche Verhalten wird vom Compilerstatus {$J+} veranlasst, der standardmäßig eingestellt ist (Menü Projekt|Optionen..., "Compiler"-Seite, Häkchen bei "zuweisbare typisierte Konstanten"). Frühere Versionen von Delphi und Borland Pascal verhielten sich wie im Status {$J+}. Deshalb muss älterer Quelltext, der änderbare typisierte Konstanten enthält, im Status {$J+} compiliert werden. Zu Programmbeginn werden typisierte Konstanten mit den ihnen zugewiesenen Werten initialisiert.

89

2.4 Benutzerdefinierte Datentypen

BEISPIEL: Typisierte Konstanten const a : Byte = 1; Titel: string = 'Der Rächer'; CR: string = '#13'; Firma: string[9] = 'Sun-Soft';

// // // //

typ. Konstante typ. lange Stringkonstante dto. typ. kurze Stringkonstante

Im weiteren Programmverlauf werden typisierte Konstanten wie normale Variablen behandelt. BEISPIEL: Verwendung typisierter Konstanten a := 5; Titel := 'Das Opfer';

HINWEIS: Bei neuen Anwendungen sollten Sie anstatt typisierter Konstanten besser initiali-

sierte Variablen und den Compiler-Status {$J-} verwenden. BEISPIEL: Die beiden folgenden Anweisungen sind gleichwertig. const a: Word = 100; var a: Word = 100;

// typisierte Konstante // initialisierte Variable

2.4 Benutzerdefinierte Datentypen Ihre eigenen Datentypen definieren Sie durch das reservierte Wort type. Es ist üblich, bei der Namensvergabe ein "T" voranzustellen. Zu den wichtigsten benutzerdefinierten Datentypen zählen die strukturierten Typen (Records), Arrays, Aufzählungs-/Teilbereichstypen und Mengen.

2.4.1 Records Deklaration und Zugriff Die so genannten Strukturvariablen, gekennzeichnet durch das reservierte Wort record, haben eine feste Struktur mit eindeutigen Zugriffsmöglichkeiten. BEISPIEL: Record-Deklaration type TPerson = record name: string[30]; alter: Integer end;

definiert einen Datentyp zur Speicherung von Namen (hier max. 30 Buchstaben) und Alter einer Person. Die Deklaration einer Variablen ist damit jedoch noch nicht erfolgt! Dazu dient z.B. die Anweisung var person1, person2: TPerson;

90

Kapitel 2

Grundlegende Sprachelemente

die eine Datenspeicherung für zwei Personen zulässt. Der Schreib- bzw. Lesezugriff erfolgt z.B. mit person1.name := 'Müller'; person1.alter := 66; Label1.Caption := person2.name;

Wie Sie erkennen, wird der Name der Record-Variablen durch einen so genannten Qualifizierer, d.h. einen Punkt (.), vom Feldnamen abgetrennt.

Bereiche innerhalb eines Records Anstatt den Feldern einen bestimmten Datentyp zuzuweisen, können Sie auch die untere und obere Grenze eines Bereichs angeben. BEISPIEL: Bereiche type

TDatum = record jahr: Integer; monat: 1..12; tag: 1..31 end;

var datum: TDatum;

Der Zugriff: datum.jahr := 1995; datum.monat := 10; datum.tag := 24; heute := datum.tag;

Der Variant-Record Der Variant-Record stellt eine Sonderform dar. Er beinhaltet mehrere Felderlisten, die den gleichen Platz im Speicher belegen. Der variable Teil wird durch case eingeleitet, gefolgt vom Bezeichner eines Selektorfeldes. BEISPIEL: In Abhängigkeit davon, ob es sich bei der Person um einen Studenten oder um einen Dozenten

handelt, sollen verschiedene zusätzliche Datenfelder zur Verfügung stehen: type

TPerson = record name: string[20]; alter: Integer; case student: Boolean of True: (immatJahr, exmatJahr: Integer; stip: Single); False: (einstJahr: Integer; gehalt: Single) end;

var student1, dozent1: TPerson;

2.4 Benutzerdefinierte Datentypen

91

Der Zugriff: student1.student := True; student1.name := 'Waldmann'; student1.immatJahr := 1985; dozent1.student := False; dozent1.gehalt := 995.95;

Zugriff auf Datensätze und With-Anweisung Man kann nicht nur auf jedes einzelne Feld, sondern auch auf den gesamten Record zugreifen. BEISPIEL: Eine Person wird "geklont". person2 := person1;

Wie Sie den vorhergehenden Beispielen entnehmen, gestaltet sich der Zugriff auf die RecordFelder ziemlich umständlich. Eine Vereinfachung schafft die with-Anweisung, die es gestattet, dass innerhalb eines Blocks nur noch die Feldbezeichner angegeben werden müssen. BEISPIEL: Der Datenzugriff lässt sich wie folgt vereinfachen: with person1 do begin student := True; name := 'Waldmann'; immatJahr := 1985 end;

Da die Records mit den in den nächsten Kapiteln eingeführten Objekten eng verwandt sind, spielt auch dort die with-Anweisung eine wichtige Rolle.

2.4.2 Statische Arrays Deklaration und Zugriff Typen für ein- und mehrdimensionale Felder (Arrays) werden durch das reservierte Wort array definiert: SYNTAX:

type ArrayTypName = array [IndexTyp] of ElementeTyp

Es können auch mehrere, durch Komma getrennte Indextypen angegeben werden. Als Elementtyp ist jeder Typ erlaubt, während der Indextyp ein ordinaler (d.h. abzählbarer) Typ sein muss. BEISPIEL: Statische Arrays type TIntListe = array[1..10] of Integer; TZeichen = array['a'..'z'] of Byte; TMatrix = array[10..20, 0..5] of Single; var intL: TIntListe; z: TZeichen; m: TMatrix;

92

Kapitel 2

Grundlegende Sprachelemente

Der Zugriff: intL[4] := 100; z['a'] := 5; m[17, 0] := 12.34;

Man kann sich die Typdeklaration auch sparen und sie zusammen mit der Variablendeklaration erledigen. Das ist vor allem dann zweckmäßig, wenn nur eine einzige Variable dieses Typs im Programm benötigt wird. BEISPIEL: Ein gleichwertiger Ersatz für obige Deklarationen var intL: array[1..10] of Integer; z: array['a'..'z'] of Byte; m: array[10..20, 0..5] of Single;

Arrays aus Strukturvariablen Von besonderem Interesse sind Arrays, deren Elementtypen Strukturvariablen (Records) sind. BEISPIEL: Mit einem Typ TPerson soll ein Array aufgebaut werden, in dem 100 Personen abgespeichert

werden können: type TPersListe = array[1..100] of TPerson; var list1: TPersListe;

Der Zugriff auf die fünfte Person erfolgt z.B. mit list1[5].name := 'Einstein';

Ein entsprechendes Programm finden Sie unter 2.9.1 im Praxisteil. Übrigens ist auch bei Array-Variablen eine Zusammenfassung von Typ- und Variablendeklaration in nur einer Anweisung möglich. BEISPIEL: Obige Deklaration kann vereinfacht werden. var list1: array[1..100] of TPerson;

Strukturvariablen mit Arrays Auch die Felder von Strukturvariablen können Arrays sein. Es bedarf allerdings eines gewissen Abstraktionsvermögens, um dabei den Überblick zu behalten. HINWEIS: Denken Sie immer daran, dass durch eine Typdeklaration (mittels type) noch keine

Variable entsteht. Diese erhalten Sie erst durch Deklarieren mit var! Schauen Sie sich das folgende Beispiel genauer an, dann dürfte die Vorgehensweise anschaulich deutlich werden.

2.4 Benutzerdefinierte Datentypen

93

BEISPIEL: Die folgenden Typdeklarationen definieren die Struktur einer Fußballmannschaft. type TSpieler = record name: string[20]; alter: Integer; bundesligatore: Integer; nationalspieler: Boolean end; type TTrainer = record name: string[20]; alter: Integer; gehalt: Currency end; type TMannschaft = record name: string[30]; trainer: TTrainer; spieler: array[1..11] of TSpieler end;

Durch die folgende Deklaration entstehen zwei Fußballmannschaften: var mannschaft1, mannschaft2: TMannschaft;

Beide Mannschaften sind noch "gesichtslos", sie könnten beispielsweise wie folgt initialisiert werden: mannschaft1.name := 'Bayern München'; mannschaft2.name := 'Borussia Dortmund'; mannschaft1.trainer.name := 'Otto'; mannschaft1.spieler[1].name := 'Kliemann'; mannschaft1.spieler[2].name := 'Vollert'; ...

Damit dürfte auch klar sein, wie der Schreib-/Lesezugriff funktioniert. Um beispielsweise alle Spieler von mannschaft1 mit mehr als zehn Bundesligatoren zu Nationalspielern zu machen: for i := 1 to 11 do with mannschaft1.spieler[i] do if bundesligatore > 10 then nationalspieler := True;

Nullbasierte Arrays und nullterminierte Strings Wen wundert's, dass beide Begriffe leicht verwechselt werden, und das nicht nur vom Einsteiger! Nullbasierte Arrays werden deklariert, indem man dem ersten Element in der Deklaration des Arrays den Index Null (0) zuweist. Man verwendet diesen Array-Typ vor allem zum Speichern sog. nullterminierter Strings (Typ PChar), wie sie typisch für die Sprache C++ sind. Das Ende einer solchen Zeichenkette wird durch das Zeichen #0 markiert (nicht die Zahl 0, diese entspräche #48!). Ein nullbasiertes Array ist kompatibel zum Typ PChar.

94

Kapitel 2

Grundlegende Sprachelemente

Dies bedeutet, dass Sie in jedem Fall, in dem ein PChar erwartet wird, stattdessen auch ein nullbasiertes Character-Array verwenden können. BEISPIEL: Nullbasierte Arrays var a: array[0..31] of Char; p: PChar; begin a[1] := 'X'; p := a; ShowMessage(p[1])

// nullbasiertes Array

// zeigt Meldungsfenster mit 'X' an

Falls Sie ein Char-Array anstelle eines PChar-Wertes verwenden, konvertiert der Compiler das Character-Array in eine Pointer-Konstante, deren Wert mit der Adresse des ersten Array-Elements übereinstimmt.

Array-Konstanten Auch Konstanten lassen sich in einem Array übersichtlich speichern. BEISPIEL: Array-Konstanten const tage: array[1..7] of string = ('Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa', 'So'); var woBeginn: string; ... woBeginn := tage[1];

Etwas komplizierter wird es bei mehreren Dimensionen. BEISPIEL: mehrdimensionale Konstanten-Arrays const tabs: array[1..5, 1..2] of Word = ((50,20), (55,21), (63,35), (110,77), (200,5)); var tab1: Word;

Die Anordnung der Elemente: 1

2

3

4

5

1

50

55

63

110

200

2

20

21

35

77

5

Damit dürfte auch der Zugriff klar sein: tab1 := tabs[4,2];

// weist den Wert 77 zu

2.4 Benutzerdefinierte Datentypen

95

2.4.3 Dynamische Arrays Die Abmessungen der bisher besprochenen statischen Arrays können zur Laufzeit nicht geändert werden, was in vielen Fällen ein Nachteil ist, so dass man um dynamische Arrays nicht herumkommt. Während man unter Delphi 3 dynamische Arrays noch mit umständlichen Zeigeroperationen programmieren musste, ist dies seit Delphi 4 einfacher geworden. Dynamische Array-Variablen sind eigentlich Zeiger (4 Byte) und werden ähnlich verwaltet wie lange Strings.

Programmierung auf einen Blick Einen ersten Überblick vermittelt die folgende Aufzählung: ■ Die Deklaration eines dynamischen unterscheidet sich von der eines statischen Arrays nur dadurch, dass einfach die eckigen Klammern mit den Array-Dimensionen weggelassen werden. ■ Die Festlegung der Dimension erfolgt erst zur Laufzeit mittels SetLength-Anweisung. ■ Um ein nicht mehr benötigtes dynamisches Array freizugeben, weisen Sie der Array-Variablen den Wert nil zu. ■ Dynamische Arrays sind nullbasiert, beginnen also immer mit dem Index 0. ■ Die bereits von statischen Arrays und von der Stringverarbeitung her bekannten Funktionen Length, High und Low lassen sich auch auf dynamische Arrays anwenden. Length liefert die Anzahl der Zellen im Array, High den höchsten Index (Length–1) und Low stets den Wert 0. BEISPIEL: Zwei dynamische Double-Arrays werden referenziert, das erste davon wird mit vier Zellen erzeugt

und mit Werten gefüllt. Anschließend wird versucht, den Inhalt in das zweite Array zu kopieren. var aA, aB: array of Double; // Referenzierung begin SetLength(aA, 4); // Dimensionierung aA[0] := 3.1415; aA[1] := 0.26134; aA[2] := 300.34; aA[3] := 0.0815; aB := aA; // Zeiger wird verbogen, kein Kopieren!!! aB[0] := 99.99; aA := nil; aB := nil // Freigabe (Dereferenzierung) end;

Wenn Sie jetzt den Wert von aA[0] auslesen, werden Sie erstaunt feststellen, dass dieser nicht mehr 3.1415 ist, sondern ebenfalls den Wert von aB[0] angenommen hat (99.99). Die Ursache: Wir haben es beim Zuweisen von Zeigerreferenzen mit keinem Kopieren des Inhalts, wie wir es von statischen Arrays her gewohnt sind, zu tun. Der Zeiger aB wird lediglich auf aA "verbogen", so dass letztlich aA und aB dasselbe Array referenzieren. Die folgende Abbildung will versuchen, Ihnen diesen Sachverhalt zu verdeutlichen (der übrigens in ähnlicher Form auch auf Objektreferenzen zutrifft, siehe Kapitel 6). Die folgende Abbildung versucht, die Speicherbereichszuordnungen beim Zuweisen statischer und dynamischer Arrays zu vergleichen:

96

Kapitel 2

Grundlegende Sprachelemente

Statische Arrays var aA: array[0..3] of Double; aA[0] := 3.1415;

aA[1] := 0.26134;

aA[2] := 300.34;

aA[3] := 0.0815;

0

1

3.1415

0.26134

2

var aB: array[0..3] of Double;

3

300.34

0

1

2

3

0.0815

aB:= aA; 0

1

3.1415

0.26134

2

3

300.34

0.0815

Dynamische Arrays var aA: array of Double;

var aB: array of Double;

nil

nil

SetLength(aA, 4);

0

1

2

3

aA[0] := 3.1415;

aA[1] := 0.26134;

aA[2] := 300.34;

aA[3] := 0.0815; aB:= aA;

0

1

3.1415

0.26134

2 300.34

3 0.0815

aA:= nil;

nil

aB:= nil;

nil

Kopieren dynamischer Arrays Um ein echtes Kopieren dynamischer Arrays zu realisieren, müssen die Feldinhalte einzeln zugewiesen werden. BEISPIEL: Wie Vorgängerbeispiel, aber diesmal mit einem echten Kopierprozess (geänderte Anweisungen

fett) var aA, aB: array of Double; i : Word; begin SetLength(aA, 4);

97

2.4 Benutzerdefinierte Datentypen

SetLength(aB, 4); aA[0] := 3.1415; aA[1] := 0.26134; aA[2] := 300.34; aA[3] := 0.0815; for i := 0 to High(aA) do aB[i] := aA[i]; aB[0] := 99.99; aA := nil; aB := nil end;

// Kopieren!!!

Wenn Sie diesmal aA[0] auslesen, werden Sie feststellen, dass aA[0] seinen zugewiesenen Wert von 3.1415 beibehält. Das "Herumdoktern" an aB hatte also keinen Einfluss, denn sowohl aA als auch aB zeigen auf unterschiedliche Speicherbereiche.

Hinzufügen und Entfernen von Zellen Die SetLength-Anweisung erlaubt sowohl das Vergrößern als auch das Verkleinern der ArrayDimensionen zur Laufzeit. BEISPIEL: SetLength type TPersDat = record name: string[20]; geburt: TDateTime; student: Boolean; tel: LongInt end;

// // // //

max. 20 Buchstaben Geburtsdatum Student ja/nein Telefonnummer

var personen: array of TPersDat; // dynamisches Array wird deklariert pm, // Anzahl Datensätze index: Word; // aktuelle Datensatznummer (1,2,3 ... pm)

Datensatz an aktueller Position (index) einfügen: procedure TPerson.dsNeu; var i: Word; begin Inc(pm); SetLength(personen, pm); // Dimension erhöhen for i:= pm downto index+2 do Personen[i-1] := Personen[i-2]; Inc(index) end;

Datensatz an aktueller Position (index) löschen: procedure TPerson.dsLoesch; var i: Word; begin for i := index to pm-1 do personen[i-1] := personen[i]; Dec(pm); SetLength(personen,pm) // Dimension verkürzen end;

98

Kapitel 2

Grundlegende Sprachelemente

Zum "Abschneiden" von dynamischen Arrays kann man auch die von der Stringverarbeitung her bekannte Copy-Funktion anstatt SetLength verwenden. BEISPIEL: Alternative zur vorletzten Zeile des obigen Beispiels personen := Copy(personen,0,pm);

Auch das "Herausschneiden" einzelner Zellen ist mit dieser Funktion zu bewerkstelligen. BEISPIEL: Ein dynamisches Integer-Array wird mit sechs Zellen dimensioniert, denen die Werte von 0 bis 5

zugewiesen werden. Ab dem Feldindex 2 werden drei Zellen herauskopiert. var a: array of Word; i: Word; begin SetLength(a, 6); for i:= 0 to High(a) do a[i] := i; // Besetzen der Zellen mit 0,1,2,3,4,5 a := Copy(a, 2,3); // Herausschneiden von 2,3,4 for i := 0 to High(a) do ShowMessage(IntToStr(a[i])) // Anzeigen der Zellinhalte end;

Mehrdimensionale dynamische Arrays Mit aufeinander folgenden arry of-Konstrukten können Sie mehrdimensionale dynamische Arrays deklarieren. Zum Instanziieren (Erzeugen) ruft man SetLength mit zwei Integer-Argumenten auf. Sind z.B. x und y Integer-Variablen, wird Speicherplatz für ein x mal y großes Array zugewiesen. Der Index [0,0] bezeichnet dann die Zelle in der linken oberen Ecke dieses Arrays. BEISPIEL: Ein zweidimensionales String-Array mit sieben Spalten und drei Zeilen 0

1

2

3

4

5

6

0

Mo

Di

Mi

Do

Fr

Sa

So

1

Vormittag

Vormittag

Vormittag

Vormittag

Vormittag

Vormittag

Vormittag

2

Nachmittag

Nachmittag

Nachmittag

Nachmittag

Nachmittag

Nachmittag

Nachmittag

var woche: array of array of string; i: Word; begin SetLength(woche, 7, 3); woche[0,0] := 'Mo'; woche[1,0] := 'Di'; woche[2,0] := 'Mi'; woche[3,0] := 'Do'; woche[4,0] := 'Fr'; woche[5,0] := 'Sa'; woche[6,0] := 'So'; for i := 0 to 6 do begin woche[i,1] := 'Vormittag'; woche[i,2] := 'Nachmittag'; ShowMessage(woche[i,0] + ' ' + woche[i,1] + ' ' + woche[i,2]) // Kontrollanzeige end end;

99

2.4 Benutzerdefinierte Datentypen

Ein Novum ist die Möglichkeit, auch ungleichförmige mehrdimensionale dynamische Arrays anlegen zu können. Gehen Sie dazu in folgenden Schritten vor: ■ Rufen Sie SetLength auf, und übergeben Sie die Parameter für die erste Dimension des Arrays. ■ Rufen Sie SetLength nacheinander für jede Zelle der ersten Dimension auf und weisen Sie dabei den Speicherplatz für die zweite Dimension zu. ■ Wiederholen Sie diese Schritte für die nächsthöhere Dimension. BEISPIEL: Ein dynamisches String-Array mit sieben Spalten jeweils unterschiedlicher Zeilenzahl. 0

1

2

3

4

5

6

Mo

Di

Mi

Do

Fr

Sa

So

1

Vormittag

Vormittag

Vormittag

Vormittag

Vormittag

2

Nachmittag

0

Nachmittag

var woche: array of array of string; i: Word; begin SetLength(woche, 7); // Spaltenanzahl festlegen // pro Spalte die Zeilenzahl festlegen: SetLength(woche[0],1); SetLength(woche[1],3); SetLength(woche[2],2); SetLength(woche[3],3); SetLength(woche[4],2); SetLength(woche[5],2); SetLength(woche[6],1); // Zellen füllen: woche[0,0] := 'Mo'; woche[1,0] := 'Di'; woche[2,0] := 'Mi'; woche[3,0] := 'Do'; woche[4,0] := 'Fr'; woche[5,0] := 'Sa'; woche[6,0] := 'So'; for i := 1 to 5 do woche[i,1] := 'Vormittag'; woche[1,2] := 'Nachmittag'; woche[3,2] := 'Nachmittag'; ShowMessage(woche[5,0] + ' ' + woche[5,1]) end;

// Beispiel: 'Sa

Vormittag'

2.4.4 Mengen Das reservierte Wort set definiert eine Menge von Elementen eines Typs. Beim Feststellen der Mengenzugehörigkeit verwenden Sie das reservierte Wort in als Bezugsoperator. HINWEIS: Die leeren Klammern [] stehen für eine leere Menge, die zu allen Mengentypen kom-

patibel ist.

Einfache Mengentypen Bei diesem Typ muss es sich um Integer, Boolean oder Char handeln.

100

Kapitel 2

Grundlegende Sprachelemente

BEISPIEL: Platzieren Sie einen Button, ein Editierfeld und ein Label auf einem Formular. Das OnClick-Event

des Buttons hinterlegen Sie wie folgt: procedure TForm1.Button1Click(Sender: TObject); type TVokal = set of Char; var vokale: TVokal; begin vokale := ['a','e','i','o','u'];

Der Test auf Mengenzugehörigkeit: if Edit1.Text[1] in vokale then Label1.Caption := 'Das ist ein Vokal!' else Label1.Caption := 'Das ist kein Vokal!' end;

Aufzählungstypen Man kann Mengentypen auch durch eine in Klammern gefasste Liste von Ausdrücken (Aufzählungstyp) definieren, wobei die Ordinalwerte der oberen und unteren Grenzen im Bereich 0… 255 liegen müssen. BEISPIEL: Zunächst werden die (ordinalen) Elemente definiert, die in der Menge vorkommen dürfen: type TMonat = (Januar, Februar, Maerz, April, Mai, Juni, Juli, August, September, Oktober, November, Dezember);

Nun wird ein neuer Mengentyp definiert, der aus obigen Elementen besteht. Beachten Sie, dass in dieser Menge beliebig viele Monate, auch gleiche Monate, vorkommen dürfen! type TJahreszeit = set of TMonat;

Nachdem die Struktur der Menge klar ist, kann eine konkrete Mengenvariable deklariert werden: var sommer: TJahreszeit;

Der Zugriff: sommer := [Juni, Juli, August]; if Juli in sommer then MessageBeep(0);

HINWEIS: Die von den ordinalen Datentypen (siehe 2.3.2) her bekannten Standardfunktionen

(Pred, Succ, ...) lassen sich auf alle Aufzählungstypen anwenden. BEISPIEL: Der "Nachfolger" von ROT ist GRUEN. type TFarben = (ROT, GRUEN, BLAU); var clr: TFarben; ... if Succ(ROT) = GRUEN then clr := BLAU; if clr = BLAU then Beep;

101

2.4 Benutzerdefinierte Datentypen

Mengen als Eigenschaften Zahlreiche Eigenschaften unter Delphi lassen sich als Aufzählungstypen, d.h. als Mengen von Konstanten (Enumerations) interpretieren. BEISPIEL: TFontStyles ist eine Menge mit Schriftstilen für die Style-Eigenschaft eines Schriftobjekts (TFont).

In der folgenden Tabelle sind die verschiedenen Werte aufgeführt: Wert

Beschreibung

fsBold

Fett

fsItalic

Kursiv

fsUnderline

Unterstrichen

fsStrikeout

Durchgestrichen

Die Delphi-interne Deklaration müssen Sie sich wie folgt vorstellen: TFontStyle = (fsBold, fsItalic, fsUnderline, fsStrikeOut); // Aufzählungstyp TFontStyles = set of TFontStyle; // Mengendefinition property Style: TFontStyles; // Eigenschaftendefinition

Diese "Mengen"-Eigenschaft könnten Sie im Objektinspektor zuweisen:

!

Sie können die Zuweisung aber auch per Quelltext vornehmen: Label1.Font.Style := [fsBold, fsItalic, fsStrikeOut];

BEISPIEL: Abfrage für die Mengenzugehörigkeit: if fsBold in Label1.Font.Style then Label1.Font.Style := Label1.Font.Style + [fsUnderline];

Die Anweisung bewirkt, dass vorhandene Fettschrift zusätzlich noch unterstrichen wird. Beachten Sie, dass auf der rechten Seite eine Mengenaddition (Vereinigung) stattfindet. Auf diese und andere Mengenoperationen wollen wir aber hier nicht näher eingehen.

102

Kapitel 2

Grundlegende Sprachelemente

2.5 Kontrollstrukturen Anweisungen dieser Spezies gehören zum Einmaleins des Delphi-Programmierers. Durch sie wird der lineare Programmablauf unterbrochen.

2.5.1 Schleifenanweisungen Delphi stellt leistungsfähige Schleifenanweisungen zur Verfügung, die sich auf drei Grundtypen zurückführen lassen: For-, While- und Repeat-Schleifen. Schleifenanweisung

Erklärung

for Zähler := Anfangswert to Endwert do begin Anweisungen end;

for-Zählschleife Vorzeitiger Abbruch mit break möglich, beim Abwärtszählen muss downto verwendet werden.

repeat Anweisungen until Bedingung;

repeat...until-Bedingungsschleife Abbruchbedingung am Schleifenende

while Bedingung do begin Anweisungen end;

while...do-Bedingungsschleife Abbruchbedingung am Schleifenanfang

BEISPIEL: Die folgenden Schleifenkonstruktionen haben alle das gleiche Ergebnis, sie schreiben zehnmal

untereinander 'Hallo' :

var i: Integer; ...

Aufwärts zählende for-Schleife: for i:= 1 to 10 do

2.5 Kontrollstrukturen

103

begin Canvas.TextOut(20, i*20, 'Hallo') end;

Abwärts zählende for-Schleife: for i:= 10 downto 1 do begin Canvas.TextOut(20, i*20, 'Hallo') end;

repeat...until-Schleife: i:= 1; repeat Canvas.TextOut(20, i*20, 'Hallo'); i:= i+1 until i = 11;

while...do-Schleife: i:= 1; while i < 11 do begin Canvas.TextOut(20, i*20, 'Hallo'); i:= i+1 end;

Break und Continue Beide Anweisungen ermöglichen das vorzeitige Verlassen einer Schleife. Break entspricht einer goto-Anweisung zu einem Label, das einer Schleife unmittelbar folgt und bewirkt, dass der von einer for-, while- oder repeat-Anweisung eingeschlossene Block sofort verlassen wird. BEISPIEL: Die folgende Schleife erzeugt, genauso wie die Vorgängerbeispiele, zehnmal 'Hallo' auf dem Bild-

schirm. i:= 1; while i > 0 do begin Canvas.TextOut(20, i*20, 'Hallo'); if i=10 then Break; i:= i+1 end;

Besonders häufig benötigen Sie Break, wenn Werte "per Hand" in ein Array einzugeben sind und Sie sich dabei die Möglichkeit eines vorzeitigen Abbruchs offen halten wollen.

104

Kapitel 2

Grundlegende Sprachelemente

BEISPIEL: Mittels InputBox sollen zehn Werte in ein Integer-Array abgespeichert werden. Über die "Abbre-

chen"-Schaltfläche der InputBox ist ein vorzeitiges Verlassen der Schleife möglich. for i:=1 to 10 do if InputQuery('Wert eingeben!','Nummer' + IntToStr(i),s) then StrToInt(s,A[i]) else Break;

Eine sinnvolle praktische Anwendung finden Sie auch im Praxisteil von Kapitel 4. Im Gegensatz zu Break veranlasst das weniger interessante Continue, dass der nächste Wiederholungsschritt bearbeitet wird.

2.5.2 Verzweigungen Auch hier hält Delphi ein ausreichendes Angebot bereit.

Bedingte Verzweigungen Verzweigung

Erklärung

if Bedingung then Anweisung [else Anweisung];

einfache Verzweigung if...then...else

if Bedingung then begin Anweisungen end else begin Anweisungen end;

Blockstruktur if...then...else

case Selector of Bereich1 : Anweisungen; Bereich2 : Anweisungen; [ else A Anweisung] end;

Blockstruktur case...of...else Als Selektoren sind nur ordinale Typen (Byte, Word, Integer, Char) zulässig! Bereiche durch Punkte (..) bzw. Komma (,) separieren.

BEISPIEL: Einfache Verzweigung: if zensur = 1 then Canvas.TextOut(20, 20, 'Gratuliere') else Canvas.TextOut(20, 20, 'Verbessern!');

BEISPIEL: if-then-else-Blockstruktur: if zensur = 1 then Canvas.TextOut(20, 20, 'Sehr gut') else if zensur = 2 then Canvas.TextOut(20, 20, 'Gut') else begin Canvas.TextOut(20, 20, 'Befriedigend bis Ungenügend!'); Canvas.TextOut(20, 40, 'Schauen Sie in die Bücher!') end;

2.5 Kontrollstrukturen

105

BEISPIEL: case-Blockstruktur: case zensur of 1: Label1.Caption := 'Ausgezeichnet!'; 2,3: Label1.Caption := 'Das geht so!'; 4..6: Label1.Caption := 'Kampf der Faulheit!' else Label1.Caption := 'Das ist keine Zensur!' end;

Unbedingte Sprünge Sprünge sind ein "rotes Tuch" für den Strukturfanatiker. Deshalb dürfen sie nur auf lokaler Ebene, also innerhalb von Funktionen/Prozeduren, ausgeführt werden. In vielen Fällen erlauben sie aber deutlich elegantere Programmiervarianten. Goto und Label Außer einem selbst definierten Bezeichner kann eine Zahl zwischen 0 und 9999 als Label Verwendung finden. Jedes Label muss vorher deklariert werden und darf nur eine Anweisung markieren. BEISPIEL: Goto und Label Label 10, 20; // Deklaration begin Goto 10; ... 10: s:= 'Hier ist das erste Sprungziel!'

Exit und Break Während mit Break eine Schleife vorzeitig verlassen werden kann (siehe Schleifenanweisungen), löst Exit einen Sprung zum Ende des Anweisungsblocks aus. Die Ausführung von Exit innerhalb des Hauptprogramms beendet das gesamte Programm. Ist der aktuelle Block verschachtelt, so bewirkt Exit die Fortsetzung durch den nächsten, äußeren Block. Falls der aktuelle Block eine Prozedur/Funktion ist, veranlasst Exit die Fortsetzung der Anweisungen des aufrufenden Blocks unmittelbar nach der Aufrufstelle. BEISPIEL: Exit procedure test(a:Integer); begin if a > 10 then Exit; ... end;

106

Kapitel 2

Grundlegende Sprachelemente

2.6 Standardfunktionen und -prozeduren Funktionen und Prozeduren kann man mit Unterprogrammen vergleichen, da sie komplette Programmieraufgaben erledigen (intern also aus mehreren Anweisungen bestehen). In diesem Abschnitt wollen wir uns mit dem von Delphi bereitgestellten Standardsortiment beschäftigen. Falls Sie dieses Angebot nicht befriedigt, haben Sie jederzeit die Möglichkeit, eigene Funktionen und Prozeduren hinzuzufügen (siehe Abschnitt 2.7).

2.6.1 Überblick Funktionen und Prozeduren werden von Delphi vor allem in folgenden Units bereitgestellt:

Unit System ■ Arithmetische Routinen (Sin, Cos, Sqrt, ...) ■ Routinen für String-Bearbeitung (Copy, Insert, Val, ...) ■ Speicherverwaltungsroutinen (GetMem, FreeMem, GetHeapStatus, ...) HINWEIS: Die System-Unit ist automatisch immer eingebunden!

Unit SysUtils ■ Routinen für die String-Bearbeitung (Format, Copy, ...) ■ Routinen für Datum/Uhrzeit (Date, DateToStr, ...) ■ Routinen zur Typkonvertierung (StrToInt, VarAsType, ...) ■ E/A-Routinen (BlockRead, FileOpen, MkDir, ...)

2.6.2 Arithmetische Funktionen Diese Funktionen führen Integer- und Gleitkommaberechnungen sowie andere arithmetische oder erweiterte mathematische Operationen durch und werden von der System-Unit bereitgestellt, die automatisch in jede Anwendung eingebunden ist. Deklaration

Erklärung

function Abs(x);

... liefert den Absolutwert von x (Real oder Integer)

function ArcTan(x: Extended): Extended; ... berechnet ArcusTangens von x function Cos(x: Extended): Extended;

... liefert den Cosinus des Arguments

function Exp(x: Extended): Extended;

... berechnet Exponentialwert ex

function Int(x: Extended): Extended;

... liefert ganzzahligen Wert von x

function Ln(x: Extended): Extended;

... berechnet natürlichen Logarithmus von x

107

2.6 Standardfunktionen und -prozeduren

Deklaration

Erklärung

function Pi: Extended;

... liefert Pi (3.1415...)

function Random [(range: Word)];

... erzeugt Zufallszahl 0 ≤ x < range (ohne: 0 ≤ x < 1)

procedure Randomize;

... initialisiert Zufallszahlengenerator

function Round (x: Extended): Integer;

... rundet x auf den nächsten Integer-Wert

function Sin(x: Extended): Extended;

... berechnet Sinus (x in Rad)

function Sqr(x: Extended): (Extended);

... berechnet Quadrat von x (Real oder Integer)

function Sqrt(x: Extended): Extended;

... berechnet Quadratwurzel von x

function Trunc(x: Extended): Integer;

... wandelt Real- in Integerzahl (ohne Kommastellen)

HINWEIS: Beachten Sie, dass die Funktionen immer mit höchster Genauigkeit rechnen (Ex-

tended), die Übergabeparameter bzw. Ergebnistypen können beliebige Real-Typen (also Single, Double, Extended) sein. BEISPIEL: "Selbst gebastelter" Würfel Label1.Caption := IntToStr(Random(6)+1);

Um den Zufallsgenerator jeweils unterschiedlich zu starten, empfiehlt sich ein vorheriger Aufruf von Randomize. BEISPIEL: Da unter Delphi ein Potenzoperator fehlt, kann man diesen durch die Logarithmus- und Expo-

nentialfunktion wie folgt nachbilden: var x: Double; function potenz(a, b: Double):Double; begin result := Exp(b * Ln(a)) end; ... x := potenz(27, 1/3); Label1.Caption := Format('%g', [x]);

// ermittelt die dritte Wurzel aus 27 // Ergebnis wird angezeigt (3)

Man spart sich derlei Klimmzüge, wenn man die Unit Math einbindet und die Funktion Power verwendet (bzw. IntPower für ganzzahlige Exponenten). Allerdings handelt man sich dabei auch eine ganze Menge an unnötigem Ballast ein, was aber bei den immer großzügigeren Speicherplatzangeboten moderner PCs kaum noch ins Gewicht fällt. BEISPIEL: Die einfachere Alternative zum Vorgängerbeispiel uses Math; ... x := Power(27, 1/3);

HINWEIS: Als Übergabeparameter für arithmetische Funktionen können statt Real- auch Inte-

ger-Typen Verwendung finden.

108

Kapitel 2

Grundlegende Sprachelemente

BEISPIEL: Die Quadratwurzel aus einer Integer-Zahl wird angezeigt. var x: Integer; ... Label1.Caption := IntToStr(Round(Sqrt(x)));

Weitere trigonometrische Funktionen Wie erhalte ich den Tangens eines Winkels? Eine entsprechende Funktion wird nicht angeboten. Aber auch das ist kein Problem. Was nicht da ist, lässt sich mit den Standardfunktionen berechnen: Funktion

Berechnung aus Standardfunktionen

Tan(x)

Sin(x)/Cos(x)

ArcSin(x)

ArcTan(x/Sqrt(1-Sqr(x)))

ArcCos(x)

ArcTan(Sqrt(1-Sqr(x))/x)

Die Winkel sind durchweg in der Einheit Rad (Bogenmaß) anzugeben. Für die Umrechnung in die üblichen Grad sind folgende Beziehungen zu beachten: rad = Pi * grad /180 = 0.01745 * grad grad = 180 * rad / Pi = 57.296 * rad

BEISPIEL: Diese Funktion berechnet den Tangens eines in Grad übergebenen Winkels. function tan(grad: Double): Double; var rad: Double; begin rad := Pi * grad / 180; Result := Sin(rad) / Cos(rad) end;

Dekadischer Logarithmus Leider fehlt er in (fast) jeder Programmiersprache: der Logarithmus zur Basis 10! Angeboten wird nur die Ln-Funktion (natürlicher Logarithmus mit der Basis e = 2.71828...). Hier die Umrechnung: Log(x) := Ln(x) / Ln(10)

BEISPIEL: Mit dieser Funktion ermitteln Sie den dekadischen Logarithmus. function log(x: Double): Double; begin Result := Ln(x) / Ln(10) end;

Wer häufiger mit selbst definierten mathematischen Funktionen arbeiten muss, sollte diese in eine eigene Unit auslagern. Siehe dazu das Beispiel 6.4.1 ("Erstellen und Einbinden einer Unit").

109

2.6 Standardfunktionen und -prozeduren

2.6.3 Stringfunktionen Das Angebot an Routinen zur Stringverarbeitung ist unter Delphi sehr reichhaltig, wenn nicht gar verwirrend. Die folgende Tabelle zeigt deshalb nur die wichtigsten Zeichenkettenfunktionen: Deklaration

Erklärung

procedure AppendStr(var dest: string; const s: string);

... fügt einen angegebenen String an einen bestehenden String hinzu.

procedure AssignStr(var p: PString; const s: string);

... weist Speicher für einen neuen PString zu.

function CompareStr(const s1, s2: string): Integer;

... vergleicht Strings unter Beachtung der Groß-/Kleinschreibung.

function CompareText(const s1, s2:string): Integer;

... vergleicht Strings ohne Beachtung der Groß/Kleinschreibung.

function Concat(s1 [, s2,..., sn]:string): string;

... verbindet zwei oder mehr Strings (siehe auch +-Operator).

function Copy(s: string; index, count: Integer): string;

... liefert Teil eines Strings zurück.

procedure Delete(var s: string; index, count:Integer);

... löscht Teilstring aus einem String.

procedure DisposeStr(p: PString);

... gibt Heap-Speicherplatz frei.

function FmtLoadStr(ident: Word; const args: array of const): string;

... lädt String aus der Ressourcen-Tabelle des Programms.

procedure Insert(source: string; var s: string; index: Integer);

... fügt Teilstring in einen String ein.

function IntToStr(value: Longint): string;

... wandelt Ganzzahl in String.

function IsValidIdent(const ident: string): Boolean;

... liefert True, wenn String gültig ist.

function Length(s: string): Integer;

... liefert die Stringlänge zurück.

function LoadStr(ident: Word): string;

... lädt String-Ressource aus Datei.

function LowerCase(const s: string): string;

... wandelt String in Kleinbuchstaben.

function NewStr(const s: string): PString;

... reserviert Heap-Speicherplatz.

function Pos(subStr: string; s: string): Byte;

... sucht nach Position eines Teilstrings.

procedure Str(x [:breite[:komma]]; var s);

... wandelt num. Wert in einen String.

function StrToInt(const s: string): LongInt;

... wandelt String in Ganzzahl.

function Trim(const s: string): string;

... entfernt Leerzeichen davor und danach.

function UpperCase(const s: string): string;

... wandelt String in Großbuchstaben.

procedure Val(s; var w; var code:Integer);

... wandelt String in numerischen Wert um (Integer oder Real), code ist im Erfolgsfall 0.

110

Kapitel 2

Grundlegende Sprachelemente

BEISPIEL: Das folgende Sammelsurium von Anweisungen soll weiteres Licht in die Dunkelheit bringen. s:='Delphi'; AppendStr(s,'buch'); s:= Concat(s,'buch'); s:= s + 'buch';

Die drei letzten Zeilen führen jeweils zum Ergebnis s = 'Delphibuch'. s:='Hallo'; if CompareStr('Hallo',s)= 0 then MessageBeep(0); s:='hallo'; if CompareStr('Hallo',s)<>0 then MessageBeep(0); s:='Hax'; if CompareStr('Hallo',s)<>0 then MessageBeep(0); s:='hallo'; if CompareText('Hallo',s)= 0 then MessageBeep(0);

... erzeugt vier Pieptöne. s:= Copy('Delphibuch',4,3);

... ergibt für s den Wert 'phi'. s := s[5]; s := Copy(s,5,1);

... sind zwei äquivalente Anweisungen. s:= 'Delbuch'; Insert('phi',s, 4);

... setzt s auf den Wert 'Delphibuch'. i:= 1999; s:= IntToStr(i);

... konvertiert die Integervariable i in die Stringvariable '1999'. i := Length(s);

... weist i den Wert 4 zu. i:= Pos('hi','Delphibuch');

... setzt i auf den Wert 5. a := 3.141567; Str(a:3:2, s);

... konvertiert die Real-Variable a in den String s = '3.14'. i:= StrToInt('1995');

... weist der LongInteger-Variablen i den Wert 1995 zu. Val(s, w, code);

2.6 Standardfunktionen und -prozeduren

111

... setzt die Real-Variable w auf 3.14, wenn die Stringvariable s = '3.14'. Der Wert von code ist nur nach erfolgreicher Konvertierung 0! var s: string; ... s:= 'testString' + #0; MessageBox(0,@s[1],'info',64);

... "simuliert" eine PChar-Variable (siehe auch Beispiel 14.3.2).

Bemerkungen ■ Seit Delphi 2 stehen zwei Standardprozeduren für die Behandlung langer Strings bereit: SetLength und SetString ■ Es gibt drei Funktionen in der Unit SysUtils (Trim, TrimLeft, TrimRight), mit denen Leer- und Steuerzeichen von Strings abgeschnitten werden können.

2.6.4 Format-Strings So beeindruckend die im vorhergehenden Abschnitt zusammengestellten Stringfunktionen auch sein mögen, für die in der Praxis mannigfaltigen Anforderungen an die Umwandlung diverser Datentypen in bestimmte Zeichenkettenformatierungen steht dort im Wesentlichen nur die Str-Prozedur mit ihrem bescheidenen Leistungsumfang zur Verfügung. Grund genug, sich den so genannten Format-Strings zuzuwenden. Ein Format-String besteht aus zwei Teilen: ■ Formatierungsstring (in ' ' eingeschlossen) und ■ Argumentliste (in [ ] eingeschlossen). Der Formatierungsstring setzt sich aus einzelnen Formatierungsanweisungen zusammen, von denen jede durch ein Prozentzeichen (%) eingeleitet wird. BEISPIEL: Formatierungsstring s := Format('%6.3f',[83.99765];

weist s den Wert '83,998' zu, was etwa äquivalent zu folgender Anweisung ist: Str(83.99765:6:3,s);

Allerdings ist der Ergebnisstring hier '83.998' (man beachte den "feinen" Unterschied beim Dezimaltrennzeichen!). BEISPIEL: Format-Strings können auch wesentlich komplexere Konstruktionen sein s := Format('%d ShowMessage(s);

liefert Folgendes:

%g

%m

%2:6.3f', [12, 0.65, 83.99765]);

112

Kapitel 2

Grundlegende Sprachelemente

Vielleicht können Sie sich das Zustandekommen des Ergebnisstrings schon jetzt zusammenreimen: Die in eckige Klammern eingeschlossenen und durch Komma getrennten Zahlen (oder Variablen/ Ausdrücke) auf der rechten Seite werden durch die links stehenden, in einfache Anführungszeichen eingeschlossenen Anweisungen formatiert. Nun die Details zu den einzelnen Formatierungsstrings: ■ %d wandelt die erste Zahl der Liste (12) in einen Dezimalstring um. ■ %g wandelt die zweite Zahl der Liste (0.65) originalgetreu in einen Gleitkommastring um. ■ %m rundet die dritte Zahl der Liste (83.99765) in einen den Systemeinstellungen entsprechenden Währungsstring. ■ %2:6.3f wählt das Element mit dem Index 2 aus der Liste (das ist ebenfalls die Zahl 83.99765) und rundet es in eine sechs Zeichen breite Festkommazahl mit drei Nachkommastellen. HINWEIS: Beachten Sie auch, dass die Anzahl von Leerzeichen zwischen den einzelnen Forma-

tierungsanweisungen exakt dem Zwischenraum im Ergebnisstring entspricht!

Formatierungsanweisungen im Detail Der genaue Aufbau einer Formatierungsanweisung: SYNTAX:

"%" [index ":"] ["-"] [width] ["." prec] type

Die Bedeutung der Parameter entnehmen Sie bitte der folgenden Tabelle: Ausdruck

optional

Erläuterung

index ":"

ja

Argumente-Index (beginnt mit 0)

"-"

ja

Linksausrichtung

Width

ja

Längenangabe (Stellenzahl)

"."prec

ja

Präzision (Nachkommastellen)

type

nein

Umwandlungstyp

Argumenttyp

d

Dezimalstring

Integer

e

Wissenschaftlicher String

Gleitkomma

f

Festkommastring

Gleitkomma

g

kürzest mögliches e oder f

Gleitkomma

n

wie f mit Tausendertrennung

Gleitkomma

113

2.6 Standardfunktionen und -prozeduren

Ausdruck

optional

Erläuterung

m

Währungsstring

Gleitkomma

p

Pointer-String

Pointer

s

String

Char, String, PChar

x

Hexadezimalstring

Integer

BEISPIEL: Die Tabelle zeigt einige typische Formatierungsanweisungen. Anweisung

Ergebnisstring Bemerkung

Format('%.5d',[12])

'00012'

Auffüllen mit Vornullen

Format('%8.5d',[12])

' 00012'

Auffüllen mit Leerzeichen

Format('%-8.5d', [12])

'00012'

linksbündig

Format('%d Euro', [12])

'12 Euro'

Zeichen werden angehängt

Format('%.5e', [12.5])

'1,2500E+001'

mindestens eine Vorkommastelle

Format('%f', [12.5])

'12,50'

Standard zwei Nachkommastellen

Format('%.5f', [12.5])

'12,50000'

fünf Nachkommastellen

Format('%10.5f', [12.5])

' 12,50000'

Komma zählt mit

Format('%g', [12.5])

'12,5'

kürzest mögliche Darstellung

Format('%g', [0.00000125])

'1,25E-6'

weil kleiner 0.00001

Format('%10g',[0.00000125])

' 1,25E-6'

zehn Zeichen breit

Format('%10n',[3000000.5])

'3.000.000,50'

wie f, mit Tausendertrenner

Format('%m',[12.5])

'12,50 €'

Standarddarstellung

Format('%10m',[12.5])

' 12,50 €'

zehn Zeichen breit

Format('%.5s',['ein String'])

'ein S'

Gesamtlänge 5

Format('%g %0:.3e',[12.5])

'12,5 1,25E+001' zweimal formatiert

Bemerkungen ■ Der Index des ersten Arguments in der Liste ist 0. Wie das letzte Beispiel zeigt, ist es möglich, dasselbe Argument durch Zwangszuweisung des Index (0:) mehrfach zu formatieren. ■ Die Umwandlung von Gleitkommawerten und Währungen wird durch die globalen Variablen CurrencyString, CurrencyFormat, NegCurrFormat, ThousandSeparator, DecimalSeparator und CurrencyDecimals gesteuert, die im Dialogfenster "Ländereinstellungen" der WindowsSystemsteuerung initialisiert werden. ■ Statt der in diesem Abschnitt aus Anschaulichkeitsgründen durchweg verwendeten ZahlenLiterale lassen sich natürlich auch Variablen in die Argumentliste einsetzen. Etwas umfangreichere Beispiele finden Sie dazu im Praxisteil dieses Kapitels (2.9.2, "Experimente mit der Format-Funktion") oder aber auch im Wissenschaftskapitel (13.6.1).

114

Kapitel 2

Grundlegende Sprachelemente

2.6.5 Datums-/Zeitroutinen Zur Berechnung von Datum und Zeit hält Delphi ein umfangreiches Sortiment an speziellen Funktionen und Prozeduren bereit. Doch zunächst wollen wir uns der zahlenmäßigen Darstellung zuwenden.

Datentyp TDateTime Dies ist eigentlich ein Gleitkomma-Typ (Extended) und enthält Datums- und Uhrzeitwerte, wie sie im Wesentlichen von den Datums- und Zeitroutinen verwendet werden. Der ganzzahlige Teil eines Werts TDateTime ist die Anzahl der Tage seit dem 30.12.1899. Der Anteil nach dem Dezimaltrenner bezeichnet die Uhrzeit, sie ist gewissermaßen Bruchteil eines Tages: 1 = 24h, 0.25 = 6h oder 1h = 0.041666 ... Weitere Beispiele entnehmen Sie bitte der folgenden Tabelle. TDateTime

Datum

Uhrzeit

Bemerkung

0

30.12.1899

00:00:00

Delphi-Urknall

0.5

30.12.1899

12:00:00

-2.75

28.12.1897

18:00:00

2.25

1.1.1900

6:00:00

35065

1.1.1996

00:00:00

Silvester 96

37600.25

10.12.2002

06:00:00

Erscheinungstermin dieses Buchs?

Um die Differenz zwischen zwei Datums-/Zeitangaben zu ermitteln, ziehen Sie einfach die beiden Werte voneinander ab. Analog können Sie z.B. eine bestimmte Anzahl von Tagen zu einem bestimmten Datum addieren. BEISPIEL: 10 Tage nach dem 10.12.2001 morgens 6 Uhr. Die Zahl 37600.25 entspricht dem 10.12.2002

06:00:00 (siehe Beispiel in obiger Tabelle). ShowMessage(DateTimeToStr(37600.25 + 10));

BEISPIEL: Auf einem Formular befinden sich zwei DateTimePicker-Komponenten. Nach Klick auf den

Button wird in einer Edit-Box die Tagesdifferenz angezeigt. procedure TForm1.Button1Click(Sender: TObject); var tage: Integer; begin tage := Round(DateTimePicker1.Date - DateTimePicker2.Date);

115

2.6 Standardfunktionen und -prozeduren

Edit1.Text := IntToStr(tage) + ' Tage' end;

Datums-/Zeitroutinen Die Unit SysUtils enthält unter anderem die folgende Routinensammlung: Deklaration

Beschreibung

function Date: TDateTime;

... liefert aktuelles Datum.

function DateTimeToStr(dateTime: TDateTime): string; ... wandelt Wert vom Datums-/ Zeitformat in String. procedure DateTimeToString(var result: String; const format: string; dateTime: TDateTime);

... wandelt Wert vom Datums-/ Zeitformat in formatierten String.

function DateToStr(date: TDateTime): string;

... wandelt Wert vom Datumsformat in String.

function DayOfWeek(date: TDateTime): Integer;

... liefert den aktuellen Wochentag (So=1, Mo=2, Di=3, Mi=4, Do=5, Fr=6, Sa=7).

procedure DecodeDate(date: TDateTime; var year, month, day: Word);

... schlüsselt angegebenes Datum auf.

procedure DecodeTime(time: TDateTime; var hour, min, sec, msec: Word);

... schlüsselt angegebene Uhrzeit auf.

function EncodeDate(year, month, day: Word): TDateTime;

... liefert angegebene Werte als Datumsformat.

function EncodeTime(hour, min, sec, msec: Word): TDateTime;

... liefert angegebene Werte als Zeitformat.

function FormatDateTime(const format: String; dateTime: TDateTime): string;

... formatiert Datum und Uhrzeit mit angegebenem Format (siehe extra Tabelle).

function Now: TDateTime;

... liefert Datum und Uhrzeit.

function StrToDate(const s: string): TDateTime;

... wandelt String in Datumsformat.

function StrToDateTime(const s: string): TDateTime;

... wandelt String in Datums-/ Zeitformat.

function StrToTime(const s: string): TDateTime;

... wandelt String in Zeitformat.

116

Kapitel 2

Grundlegende Sprachelemente

Deklaration

Beschreibung

function Time: TDateTime;

... liefert die aktuelle Uhrzeit.

function TimeToStr(time: TDateTime): string;

... wandelt Zeitformat in String.

BEISPIEL: Konvertierung Label1.Caption := DateToStr(Date);

... wandelt das aktuelle Datum in einen String und zeigt es in einem Label an. Label1.Caption := DateTimeToStr(Now);

... dto. für aktuelles Datum und Uhrzeit. BEISPIEL: Das Datum 30.10.2002 wird angezeigt. var XDatum: TDateTime;.... xDatum := EncodeDate(2002, 10, 30); ShowMessage(DateToStr(xDatum));

DateTimeToString und FormatDateTime Diese beiden Formatierungsroutinen verdienen eine nähere Erörterung, brauchen sie doch einen speziellen Format-String als Übergabeparameter, mit dem der Programmierer das konkrete Erscheinungsbild der Einzelkomponenten von Datum/Zeit exakt festlegen kann. HINWEIS: Vorsicht bei zweistelligen Datumsangaben, hier gilt das nächstliegende Datum! BEISPIEL: FormatDateTime Label1.Caption := FormatDateTime('"Wir treffen uns am "dddd," dem "' + 'd. mmmm yyyy, "um" hh:mm "Uhr!"', StrToDateTime('30.09.02 11:45'));

zeigt Folgendes an:

Man beachte, dass auch der Montag richtig ist und dass die zweistellige Jahresangabe 02 nicht fälschlich als 1902 interpretiert wurde!

2.6 Standardfunktionen und -prozeduren

117

Die folgende Tabelle erläutert die Bedeutung der Bezeichner. Ihre konkrete Ausführungsform hängt auch hier von den in der Unit sysUtils enthaltenen globalen Variablen ab. Bezeichner Ergebnis

c

Datum entsprechend des in der globalen Variablen ShortDateFormat gespeicherten Formats, gefolgt von der Zeit entsprechend LongTimeFormat.

d

Tag als Zahl ohne führende Null (1–31).

dd

Tag als Zahl mit führender Null (01–31).

ddd

Tag als Abkürzung (Son–Sam) entspr. der globalen Variablen ShortDayNames.

dddd

Tag mit seinem vollständigen Namen (Sonntag–Samstag) entsprechend der globalen Variablen LongDayNames.

ddddd

Datum entsprechend der globalen Variablen ShortDateFormat.

dddddd

Datum entsprechend der globalen Variablen LongDateFormat.

m

Monat als Zahl ohne führende Null (1–12).

mm

Monat als Zahl mit führender Null (01–12).

mmm

Monat als Abkürzung (Jan–Dez) entsprechend der Variablen ShortMonthNames.

mmmm

Monat mit vollem Namen (Januar – Dezember) entspr. LongMonthNames.

yy

Jahr als zweistellige Zahl (00–99).

yyyy

Jahr als vierstellige Zahl (0000–9999).

h

Stunde ohne führende Null (0–23).

hh

Stunde mit führender Null (00–23).

nn

Minute mit führender Null (00–59).

ss

Sekunde mit einer führenden Null (00–59).

t

Zeit in dem Format entsprechend der globalen Variablen ShortTimeFormat.

tt

Zeit in dem Format entsprechend der globalen Variablen LongTimeFormat.

am/pm

12-Stunden-Format für den voranstehenden Bezeichner h oder hh, zeigt 'am' für Zeiten vor 12 Uhr mittags und 'pm' für Zeiten nach 12 Uhr mittags an.

a/p

12-Stunden-Format für den voranstehenden Bezeichner h oder hh, zeigt 'a' für Zeiten vor 12 Uhr mittags und 'p' für Zeiten nach 12 Uhr mittags an.

ampm

12-Stunden-Format für Bezeichner h oder hh, zeigt Inhalt der globalen Variablen TimeAMString vormittags sowie den von TimePMString nachmittags an.

/

Datumstrennzeichen entsprechend der globalen Variablen DateSeparator.

:

Zeittrennzeichen entsprechend der globalen Variablen TimeSeparator.

'xx'/"xx"

Zeichen, die in einfache oder doppelte Anführungszeichen eingeschlossen sind, werden so angezeigt und beeinflussen die Formatierung nicht.

BEISPIEL: Der folgende Code ermittelt eine vierstellige Jahreszahl als Integer-Wert. var baujahr: Word; datum: TDateTime;

118

Kapitel 2

Grundlegende Sprachelemente

... baujahr := StrToInt(FormatDateTime('yyyy', datum));

Das konkrete Erscheinungsbild der Datums- und Zeitanzeige hängt von globalen Variablen wie z.B. ShortDateFormat, ShortTimeFormat, ShortDayNames, DateSeparator usw. ab. BEISPIEL: s auf den Wert 'Wir treffen uns heute, am 30-09-00' setzen DateSeparator := '-'; ShortDateFormat:= 'dd/mm/yy'; s := FormatDateTime('"Wir treffen uns heute, am "ddddd', datum);

BEISPIEL: Die Anweisungsfolge var zeit: TDateTime; ... ShortTimeFormat := 'hh "h" nn "min"; Label1.Caption := FormatDateTime('t', zeit);

realisiert eine Zeitanzeige in der Form 22 h 07 min. Der Bezeichner c ist eine kompakte Zusammenfassung von kurzem Datums- und langem Zeitformat. BEISPIEL: Die Anweisung Edit1.Text := FormatDateTime('c',Now);

... erzeugt eine Anzeige wie 30.09.96 23:03:15 und ist gleichbedeutend mit Edit1.Text := FormatDateTime('ddddd tt',Now);

Noch einfacher kann man allerdings mit Edit1.Text := DateTimeToStr(Now);

zum gleichen Ergebnis kommen.

Vorsicht mit DateTimeToStr! Statt DateTimeToStr sollten Sie besser die zwar etwas umständlichere, aber dafür um so eindeutigere FormatDateTime-Funktion verwenden, da Sie damit selbst das Format bestimmen und unabhängig von den Systemeinstellungen (ShortDateFormat) bleiben. BEISPIEL: Statt var datum: TDateTime; ... Edit1.Text := DateTimeToStr(datum);

sollte man besser Edit1.Text := FormatDateTime('d/m/yyyy h:nn', datum);

nehmen. Auch werden die lästigen Sekunden nicht mit angezeigt.

119

2.6 Standardfunktionen und -prozeduren

Probleme mit dem Jahr 2000 Die seit Delphi 4 eingeführte globale Variable TwoDigitYearCenturyWindow hilft, die Fehldeutungen zweistelliger Jahresangaben bei Verwendung der Funktionen StrToDate und StrToDateTime zu vermeiden, wie sie sich durch die Jahr-2000-Umstellung auftreten können. HINWEIS: Standardmäßig hat TwoDigitYearCenturyWindow den Wert 0, so dass sich zweistelli-

ge Jahresangaben immer auf das aktuelle Jahrhundert beziehen. Hat TwoDigitYearCenturyWindow einen Wert größer 0, so wird das Bezugsjahr um diesen Wert zurückgesetzt. Zweistellige Jahreszahlen, die kleiner sind als das daraus resultierende Bezugsjahr, werden dann als Jahre im nächsten Jahrhundert interpretiert. BEISPIEL: Wir befinden uns im Jahr 1998: var datum: TDateTime; datum := StrToDate('3.4.75');

// interpretiert das Datum richtig als 3.4.1975

Wir befinden uns nun im Jahr 2000: datum := StrToDate('3.4.75');

// interpretiert Datum falsch als 3.4.2075!!!

Abhilfe schafft: TwoDigitYearCenturyWindow := 50; // setzt Bezugsjahr 50 Jahre zurück (1950) datum := StrToDate('3.4.75'); // interpretiert Datum richtig als 3.4.1975

Weitere zweistellige Datumsinterpretationen, wenn wir uns im Jahr 2000 befinden und die Variable TwoDigitYearCenturyWindow den Wert 50 hat: datum := StrToDate('3.4.02'); datum := StrToDate('3.4.49');

// 3.4.2002 // 3.4.2049

Sie sehen an diesen Beispielen, dass zweistellige Jahresangaben keine absolut zukunftssichere Lösung darstellen, da (abhängig vom aktuellen Jahr) ständig die Variable TwoDigitYearCenturyWindow neu anzupassen ist. HINWEIS: Um absolut sicherzugehen, verwenden Sie besser immer vier- statt zweistellige Jah-

reszahlen!

2.6.6 Sonstige Funktionen und Prozeduren Delphi kennt noch eine ganze Reihe weiterer Routinen, die sich keiner der bisherigen Kategorien eindeutig zuordnen lassen und die der Einsteiger erst mit fortschreitender Programmierpraxis schätzen lernen wird. Eine repräsentative Auswahl "quer durch den Gemüsegarten" zeigt die folgende Übersicht:

120

Kapitel 2

Grundlegende Sprachelemente

Deklaration

Erklärung

function Addr(x): Pointer;

... liefert Adresse von x.

function Chr(x: Byte): Char;

... liefert Zeichen, dessen ASCII-Code dem Wert von x entspricht.

procedure Dec(var x [ ; n: Longint]); ... verringert Wert von x um eins (x := x - 1) bzw. um n. function Dseg: Word;

... liefert Adresse des aktuellen Datensegments (DSRegister).

procedure GetMem(var p: Pointer; size : Word);

... reserviert Heap-Speicher, nach Aufruf enthält p die Startadresse.

procedure Halt [(Exitcode: Word)];

... beendet Programmausführung und kehrt zur Betriebssystemebene zurück.

function Hi(x): Byte;

... liefert höherwertiges Byte von x (Integer oder Word).

procedure Inc(var x [; n: Longint ]);

... erhöht den Wert von x um eins (x := x + 1) bzw. um n.

function Lo(x): Byte;

... liefert niederwertiges Byte von x (Integer oder Word).

function Ofs(x): Word;

... liefert Offsetadresse einer Variablen oder Routine x.

function Ord(x): LongInt;

... liefert Ordinalzahl eines Mengenelementes x.

function Ptr(Seg, Ofs: Word): Pointer;

... weist Pointer eine Adresse zu (Segment und Offset).

function SizeOf(x): Integer;

... gibt die Anzahl der von x belegten Bytes zurück kann Variable oder Typ sein).

function Seg(x): Word;

... liefert Segmentadresse einer Variablen oder Routine x.

(x

HINWEIS: Als Ersatz für die Chr-Funktion verwendet man oft das Doppelkreuz "#", besonders

für Zeichen mit einem ASCII-Code kleiner als 32. BEISPIEL: Einen Zeilenumbruch kann man wie folgt erzwingen: Label1.Caption := 'Hallo,' + #10#13 + 'das bin ich!';

Dabei stehen #10 für Chr(10) bzw. Zeilenanfang und #13 für Chr(13) bzw. Zeilenschaltung.

Die SizeOf-Funktion ist insbesondere bei Datenspeicherung auf Festplatte unentbehrlich. BEISPIEL: Lesen eines dynamischen Arrays mit strukturierten Daten (Personenangaben). f.ReadBuffer(persD, SizeOf(persD));

// Einlesen aller Bytes in Puffervariable

121

2.7 Selbst definierte Funktionen und Prozeduren

2.7 Selbst definierte Funktionen und Prozeduren Falls Sie mit dem von Delphi bereitgestellten Standardsortiment nicht auskommen, müssen Sie eine eigene Funktion/Prozedur entwickeln. Funktionen und Prozeduren können auch als "Unterprogramme" betrachtet werden, aus denen sich Ihre Applikation bausteinartig zusammensetzt.

2.7.1 Die Parameterliste Parameter dienen dazu, Daten an Prozeduren/Funktionen zu übertragen und von diesen zu erhalten. Mit der Deklaration einer Prozedur/Funktion legen Sie die Liste der formalen Parameter fest. Innerhalb dieser Routinen werden diese Parameter dann wie (lokale) Variablen behandelt. HINWEIS: Während bei der Deklaration die Parameterauflistungen durch Semikolon (;) vonein-

ander getrennt werden, sind sie beim Aufruf grundsätzlich durch Komma (,) separiert. Die Deklarationsreihenfolge innerhalb der Parameterliste muss selbstverständlich mit der Reihenfolge beim Aufruf übereinstimmen. BEISPIEL: Die Prozedur procedure zylinder(r,h: Double; var vol: Double); begin ... end;

// Deklaration

... wird wie folgt aufgerufen: zylinder(23.7, 50, v);

// Aufruf

Neben den Standardtypen können auch benutzerdefinierte Typen oder sogar Objekte in der Parameterliste übergeben werden. Selbst die Übergabe kompletter dynamischer Arrays (Open Arrays) ist möglich. BEISPIEL: Der folgenden Prozedur wird ein offenes Array übergeben. procedure TPersFile.ReadDaten (var persD: array of TPersDat); begin f.ReadBuffer(persD, SizeOf(persD)) end;

2.7.2 Parameterübergabe als Wert oder Referenz Wird eine Prozedur/Funktion aufgerufen, so erfolgt die Parameterübergabe normalerweise als Wert (By Value). Da man hier mit einer Kopie des Originalwertes arbeitet, ist es im Körper der Routine unmöglich, am Original etwas zu ändern. Man kann das aber durch Voranstellen des reservierten Wortes var erreichen. In diesem Fall erfolgt die Datenübergabe als Referenz (By Reference). Dabei wird intern auf das Original, also auf die Adresse der Variablen verwiesen. Der auf-

122

Kapitel 2

Grundlegende Sprachelemente

gerufenen Funktion/Prozedur ist es nunmehr möglich, am Wert "herumzudoktern", um auf diese Weise z.B. das Ergebnis einer Berechnung zu übermitteln. BEISPIEL: Bei der folgenden Deklaration wird eine Referenz auf die Variable v übergeben. procedure zylinder(r,h: Double; var v: Double); begin v := Pi * Sqr(r) * h // Ergebnisrückgabe über v end;

2.7.3 Standardparameter Ab Delphi 4 wurden Standardparameter möglich, die allerdings nur am Ende der Parameterliste auftreten dürfen und ähnlich wie initialisierte Variablen (siehe 2.3.1.) zu deklarieren sind. Beim Aufruf einer Routine, die einen Standardparameter enthält, kann der Wert für den Standardparameter einfach weggelassen werden. BEISPIEL: Standardparameter function zylinder(r: Double; h: Double = 1): Double;

Die folgenden beiden Aufrufe führen zum gleichen Ergebnis: v := zylinder(23.7, 1); v := zylinder(23.7);

// Volumen für Radius 23.7 und Höhe 1);

2.7.4 Funktion oder Prozedur? In Delphi hat man die Qual der Wahl zwischen beiden Alternativen 1. Die Entscheidung, ob man eine Routine nun besser in eine Prozedur, z.B. procedure zylinder(r,h: Double; var v: Double); begin ... end;

oder in eine Funktion function zylinder(r,h: Double): Double; begin ... end;

verpacken sollte, bleibt letztlich Ihnen überlassen. Prinzipiell sind beide Wege gangbar, da nicht nur Funktionen, sondern auch Prozeduren Werte zurückliefern können, wie die nachfolgenden Ausführungen beweisen sollen. Allerdings gelten folgende Empfehlungen: ■ Ein Funktionsaufruf wird innerhalb des Programms wie eine Variable behandelt, er kann deshalb auch als Argument in anderen Ausdrücken und Anweisungen eingesetzt werden. ■ Ist man nur an einem einzigen Rückgabeparameter interessiert, so sollte man dafür eine Funktion schreiben, bei mehreren Rückgabeparametern sind aber Prozeduren vorzuziehen.

1

In C kennt man nur Funktionen.

123

2.7 Selbst definierte Funktionen und Prozeduren

Bei Funktionen ist außerdem Folgendes zu beachten: ■ Bei der Deklaration ist ein Datentyp zuzuordnen. ■ Im Funktionskörper muss dem Namen der Funktion der Rückgabewert zugewiesen werden. Anstatt des Funktionsnamens sollte man aber besser Result verwenden. BEISPIEL: Das Volumen eines Zylinders soll zunächst mit einer Funktion berechnet werden. Um diese gleich

"vor Ort" auszuprobieren, setzen wir sie in den Deklarationsabschnitt der OnClick-Ereignisbehandlungsroutine eines Buttons, der neben einem Label auf einem Formular platziert ist: procedure TForm1.Button1Click(Sender: TObject); // Click auf Button function zylinder(r, h: Double): Double; // Übergabe: Radius und Höhe, Rückgabe: Volumen begin Result := Pi * Sqr(r) * h // Volumen = Grundfläche mal Höhe end; var v: Double; s: string; begin v:= zylinder(23.7, 50); Str(v:6:2,s); Label1.Caption := s end;

// Zwischenvariablen // Volumen für Radius 23.7 und Höhe 50 // 6-stellige Ausgabe, davon 2 Nachkommastellen // Ergebnisanzeige = 88 230.06

Zum Vergleich soll das Zylindervolumen nun über eine Prozedur ermittelt werden. procedure TForm1.Button1Click(Sender: TObject); // Click auf Button procedure zylinder(r,h: Double; var vol: Double); // Übergabeparameter: Radius und Höhe, Rückgabeparameter: Volumen begin vol := Pi * Sqr(r) * h // Volumen = Grundfläche mal Höhe end; var v: Double; s: string; // Zwischenvariablen begin zylinder(23.7, 50, v); // Volumen für Radius 23.7 und Höhe 50 Str(v:6:2,s); // 6-stellige Ausgabe, davon 2 Nachkommastellen Label1.Caption := s // Ergebnisanzeige = 88 230.06 end;

Soll die Routine nicht nur das Volumen, sondern auch noch die Oberfläche des Zylinders ermitteln, so wäre folgende Realisierung als Prozedur der als Funktion vorzuziehen: procedure zylinder(r,h: Double;var fl,vol: Double); // Übergabeparameter: Radius und Höhe, Rückgabeparameter: Oberfläche, Volumen begin fl := 2 * Pi * r * (r + h); // Oberfläche vol := Pi * Sqr(r) * h // Volumen end;

124

Kapitel 2

Grundlegende Sprachelemente

2.7.5 Überladene Routinen Diese mit Delphi 4 eingeführte Funktionalität erlaubt es, mehrere Funktionen/Prozeduren mit identischen Namen im gleichen Gültigkeitsbereich zu verwenden. Die Deklarationen haben mit overload zu erfolgen und müssen unterscheidbare (!) Parameterlisten haben. BEISPIEL: Beide Funktionen haben den gleichen Namen, aber unterschiedliche Parameterlisten. function zylinder(r,h: Double): Double; overload; // Parameter: Radius und Höhe // Rückgabewert: Volumen begin Result:= Pi * Sqr(r) * h // Volumen = Grundfläche mal Höhe end; function zylinder(r: Double): Double; overload; begin Result := Pi * Sqr(r) end;

// Übergabeparameter: Radius // Rückgabewert: Grundfläche

// Grundfläche = Pi*r*r

In Abhängigkeit vom Aufruf wird entweder das Volumen oder die Grundfläche berechnet: v := zylinder(5, 10); f := zylinder(20);

// Volumen // Grundfläche

HINWEIS: Verwenden Sie überladene Methoden und Standardparameter (siehe 2.7.3 bzw.

2.7.5), so dürfen keine zweideutigen Methodensignaturen auftreten. BEISPIEL: Unzulässige Deklarationen function zylinder(r: Double; h: Double = 1); overload; function zylinder(rad: Double); overload;

// Volumen // Grundfläche

Dem Delphi-Compiler ist es unmöglich zu entscheiden, welche der beiden Prozeduren z.B. bei folgendem Aufruf gemeint ist: v := zylinder(23.7);

HINWEIS: Ein Praxisbeispiel zum Thema "Überladen von Funktionen" finden Sie unter 2.9.3!

2.7.6 Rekursionen Bei einer Rekursion ruft sich eine Prozedur während ihrer Ausführung wiederholt von selbst auf. Delphi erlaubt eine echte rekursive Programmierung. Damit können iterative Abläufe mitunter einfacher und kompakter dargestellt werden.

125

2.8 Lernbeispiele für Anfänger

BEISPIEL: Nacheinander werden alle Zeichen einer PChar-Variablen (nullterminierter String) in einem

Meldungsfenster angezeigt. Zunächst die klassische Programmierung: procedure zeigeZeichen(p: PChar); begin while (p^ <> #0) do begin ShowMessage(p^); Inc(p) // Zeiger zum nächsten Zeichen end end;

Alternativ kann der Körper der Prozedur aber auch mittels eines rekursiven Aufrufs programmiert werden: procedure zeigeZeichen(p: PChar); begin ShowMessage(p^); Inc(p); if p^ <> #0 then zeigeZeichen(p) end;

// zum nächsten Zeichen // rekursiver Aufruf

Die Anwendung ist für beide Alternativen identisch: zeigeZeichen(PChar('Hallo'));

Nacheinander werden 'H', 'a', 'l', 'l', 'o' angezeigt.

2.8 Lernbeispiele für Anfänger In Turbo Pascal, dem Delphi-Vorgänger aus den 80er-Jahren des vergangenen Jahrhunderts, wurden Programme geschrieben, die für jede Eingabe von Daten und jede Ausgabe von Resultaten eine neue Textzeile in einem Bildschirmfenster (Konsole) erzeugten. Dieses Vorgehen war ein Erbe aus der Zeit, als lediglich Fernschreiber für die Ein- und Ausgabefunktionen von Computern zur Verfügung standen. Aber auch heute noch kann es für den absoluten Programmieranfänger durchaus sinnvoll sein, wenn er seine ersten Schritte mit Konsolentechnik durchführt. So kann er sich doch auf das zunächst Wesentliche, nämlich die Logik von Pascal-Befehlen, konzentrieren, ohne von der erdrückenden Vielfalt der Windows-Oberfläche abgelenkt zu werden. Die folgende Serie von Lernbeispielen benutzt eine solche Konsolenanwendung, um grundlegende Pascal-Sprachelemente zu üben1. Zur Vorbereitung empfiehlt sich das Beispiel 1.6.2. HINWEIS: Versuchen Sie erst eine eigenständige Lösung der Aufgaben, ehe Sie auf den

Lösungsweg schauen!

1

Dies wäre auch ein Angebot für manchen überlasteten Informatik-Lehrer, ohne grundlegende Überarbeitung des Lernstoffs eine Brücke von Pascal nach Delphi zu schlagen.

126

Kapitel 2

Grundlegende Sprachelemente

2.8.1 Übung 1 Schwerpunkte EVA-Prinzip; Datentyp Integer; Anweisungen Write(Ln), Read(Ln), if... then

Aufgabenstellung Nacheinander sind drei positive ganze Zahlen einzugeben. Das Programm soll die größte der drei Zahlen ermitteln und das Ergebnis anzeigen.

Lösungsvorschlag Einen Vorschlag (Algorithmus) für den Programmablauf zeigt der nachfolgende Plan. Start

Eingabe: a max := a Eingabe: b b > max ? ja max := b

Eingabe: c c > max ? ja max := c

Ausgabe: max

Ende

Sie erkennen daran die Grundstruktur eines jeden Programms, wobei die Anweisungen in der Reihenfolge ■ Eingabe ■ Verarbeitung ■ Ausgabe ausgeführt werden.

127

2.8 Lernbeispiele für Anfänger

Programmierung Ein Programmablaufplan (PAP), wie ihn die obige Abbildung zeigt, ist zwar heute etwas aus der Mode gekommen, für den Einsteiger kann er aber ganz nützlich sein, um die Anweisungsfolge eines Pascal-Programms besser zu verstehen: program Project1; var a, b, c, max: Integer;

// Variablendeklaration

begin WriteLn('Aufgabe 1'); // Überschrift WriteLn; Write('Geben Sie die erste Zahl ein!'); ReadLn(a); // Eingabe a max := a; // Initialisierung von max Write('Geben Sie die zweite Zahl ein!'); ReadLn(b); // Eingabe b if b > max then max := b; // Bedingung Write('Geben Sie die dritte Zahl ein!'); ReadLn(c); // Eingabe c if c > max then max := c; // Bedingung WriteLn('Das Maximum ist ', max, ' !'); // Ergebnisausgabe ReadLn // Programm wartet auf <Enter>, um zu beenden end.

Test Um das Pascal-Programm endlich auszuprobieren, öffnen Sie mit Datei|Neu|Weitere... die Objektgalerie und wählen auf der Seite "Neu" eine Konsolenanwendung. Es erscheint ein Fenster, in dem bereits ein Anweisungsskelett "vorgefertigt" ist. Fügen Sie die Variablendeklaration ein, ergänzen Sie zwischen begin und end die übrigen Anweisungen entsprechend dem obigen Pascal-Listing und starten Sie die Applikation (F9-Taste):

HINWEIS: Durch Drücken der Enter-Taste beenden Sie die Anwendung.

128

Kapitel 2

Grundlegende Sprachelemente

Bemerkungen Für alle, die – aus welchen Gründen auch immer – den Theorieteil des Kapitels in Windeseile überblättert haben, hier noch einmal die wichtigsten Pascal-Grundlagen: ■ Jedes Programm besteht aus einer Folge von Anweisungen und wird mit dem Schlüsselwort program eingeleitet und mit end. (man beachte den Punkt!) beendet. Es gibt keinen Unterschied zwischen Groß- und Kleinschreibung. ■ Jede Pascal-Anweisung wird mit einem Semikolon (;) abgeschlossen, der Zeilenumbruch spielt keine Rolle. Nach begin und vor end braucht kein Semikolon zu stehen. ■ Die mit // eingeleiteten Anweisungen sind lediglich Kommentare und für den Programmablauf bedeutungslos. ■ Vor Beginn eines Programms müssen die benötigten Variablen deklariert, d.h., ihr Name und ihr Datentyp müssen festgelegt werden. ■ Unter dem Begriff "Initialisierung einer Variablen" versteht man das Zuweisen eines Anfangswertes. ■ Read(Ln) und Write(Ln) sind die einfachsten Ein-/Ausgabeanweisungen, wie Sie sie allerdings nur bei einer Konsolenanwendung verwenden sollten. Die Endung ...Ln der Befehlswörter bewirkt einen Zeilenvorschub. ■ if... then ... (wenn ... dann ...) führt eine Anweisung in Abhängigkeit von einer Bedingung aus.

2.8.2 Übung 2 Schwerpunkte const; array; if ... then... else; IntToStr

Aufgabenstellung Nachteilig am Vorgängerbeispiel ist die Festlegung auf drei Zahleneingaben. Erweitern Sie das Programm so, dass es die Eingabe einer flexiblen Anzahl von Werten ermöglicht!

Lösungsvorschlag Der im nachfolgenden PAP dargestellte Algorithmus geht davon aus, dass die Zahlenwerte nicht mehr in Einzelvariablen a, b, c, sondern in einem statischen Array arr gespeichert werden. Stellen Sie sich ein solches Array wie ein Regal mit einzelnen Fächern vor, in denen die Zahlenwerte abgelegt werden. Die Fächer sind beschriftet mit 1, 2, 3 etc. Die Anzahl der Regalfächer beträgt Nmax. Diese Konstante ist genügend groß zu wählen, damit genügend Reserven für die größtmögliche Anzahl N von Zahlenwerten vorhanden sind.

129

2.8 Lernbeispiele für Anfänger

Start Deklaration Array: arr[1..Nmax] Eingabe: N N > Nmax ? ja i := 1 Ausgabe: Nmax überschritten! Eingabe: arr[i] (i = 1) oder (arr[i] > max) ? ja max := arr[i] i := i+1 i>N? nein

Ausgabe: max

Ende

Programmierung Die Umsetzung des PAP in ein Pascal-Programm dürfte Ihnen dann leicht fallen, wenn Sie das Vorgängerbeispiel verstanden haben: program Project1; {$APPTYPE CONSOLE}

// Compilerbefehl für Konsolenanwendung

uses SysUtils;

// enthält IntToStr-Funktion

const Nmax = 10;

// maximale Anzahl von Werten

var arr: array[1..Nmax] of Integer; i, n, max: Integer;

// statisches Array // weitere Variablen

begin WriteLn('Uebung 2'); WriteLn; Write('Geben Sie die gewuenschte Anzahl von Werten ein! ');

130

Kapitel 2

Grundlegende Sprachelemente

ReadLn(n); if n > 10 then WriteLn('Es duerfen maximal nur 10 Werte eingegeben werden!') else begin for i := 1 to n do // Beginn der Schleife begin Write('Geben Sie die ' + IntToStr(i) + '. Zahl ein! '); ReadLn(arr[i]); // Eingabe des i-ten Wertes in das Array if (i = 1) or (arr[i] > max) then max := arr[i] end; // Ende der Schleife WriteLn('Das Maximum ist ', max, ' !') end; ReadLn end.

Test

Bemerkungen ■ Die Kommentare im Quelltext beschränken sich bewusst nur auf die Neuigkeiten gegenüber dem Vorgängerbeispiel, vor allem auf den Array-Zugriff und die for ... to-Schleifenanweisung, die genau n Mal durchlaufen wird. ■ Die IntToStr-Funktion (Unit SysUtils) verwandelt den Array-Index i (Datentyp Integer) in eine Zeichenkette (Datentyp String), damit eine Ausgabe über Write ermöglicht wird.

2.8.3 Übung 3 Schwerpunkte Char, dyn. Array, SetLength-Funktion; nil; repeat

Aufgabenstellung Unser Vorgängerbeispiel ist dann unbrauchbar, wenn mehr als Nmax Werte eingegeben werden sollen. Gemäß der Devise "Mein Rechner hat ja eh genug Speicher !" wird deshalb der Dünnbrettbohrer das Array von vornherein sehr reichlich überdimensionieren, z.B. für 1000 Werte. Ein ernst-

131

2.8 Lernbeispiele für Anfänger

hafter Programmierer kann sich aber mit solch einer verschwenderischen Lösung nicht zufrieden geben. Erweitern Sie das Programm für die Eingabe einer beliebigen Anzahl von Werten! Ein weiterer Kritikpunkt: Im Vorgängerbeispiel wurde das Programm nach einem einzigen Durchlauf beendet, danach war ein Neustart erforderlich. Ergänzen Sie das Programm so, dass es nach Ermitteln des Maximums entweder wieder von vorn beginnt oder aber beendet werden kann!

Lösungsvorschlag Start Deklaration dyn. Array: arr

Eingabe: N Arraygröße festlegen i := 1

Eingabe: arr[i] (i = 1) oder (arr[i] > max) ? ja

max := arr[i]

i := i+1 i>N? nein Ausgabe: max

Eingabe: c c = 'y' ? nein Ende

Wir ersetzen das statische durch ein dynamisches Array, dessen endgültige Dimension erst zur Laufzeit festgelegt zu werden braucht. Damit wird unser Array immer exakt so groß, wie es der Anzahl der einzugebenden Werte entspricht. Indem wir eine weitere (äußere) Schleife hinzufügen,

132

Kapitel 2

Grundlegende Sprachelemente

ermöglichen wir einen Rücksprung zum Programmanfang. Eine Schlussabfrage entscheidet dann darüber, ob die Schleife fortgesetzt wird.

Programmierung Der Programmablauf weist viele Analogien zum Vorgängerbeispiel auf, deshalb wird nur auf die Neuigkeiten per Kommentar hingewiesen: program Project1; {$APPTYPE CONSOLE} uses SysUtils; var arr: array of Integer; // dynamisches Array i, n, max: Integer; c: Char; // Zeichenvariable begin WriteLn('Aufgabe 3'); WriteLn; repeat // Beginn der äußeren Schleife Write('Geben Sie die gewuenschte Anzahl von Werten ein! '); ReadLn(n); SetLength(arr, n); // Dimensionierung des Arrays for i := 0 to n-1 do // Array ist nullbasiert! begin Write('Geben Sie die ' + IntToStr(i+1) + '. Zahl ein! '); ReadLn(arr[i]); if (i=0) or (arr[i] > max) then max := arr[i] end; WriteLn('Das Maximum ist ', max, ' !'); arr := nil; // dynamisches Array freigeben WriteLn('Wollen Sie das Programm beenden? (y/n) '); ReadLn(c); // Eingabe von 'y' oder 'n' until c = 'y' // Abbruchkontrolle der äußeren Schleife end.

Test Bis auf die letzten beiden Zeilen entspricht der Bildschirm dem Vorgängerbeispiel.

2.8 Lernbeispiele für Anfänger

133

HINWEIS: Nach Eingabe von 'y' bzw. 'n' müssen Sie die Enter-Taste drücken!

Bemerkungen ■ Ein dynamisches Array wird wie ein statisches deklariert, nur dass die Dimensionsangabe weggelassen wird. ■ Die SetLength-Anweisung setzt das Array zur Laufzeit auf die gewünschte Größe. Der untere Index beginnt mit null, deshalb wird im Feld arr(0) die erste Zahl gespeichert. ■ Mit nil (eine Zeigervariable auf "nichts") wird der vom Array belegte Speicherplatz wieder freigegeben. ■ Die repeat ... until-Schleifenanweisung verlangt am Ende eine Abbruchbedingung. ■ Benötigt man nur ein einzelnes Zeichen, so sollte man anstatt des String- den Char-Datentyp verwenden. In unserem Beispiel dient die Variable c der Entgegennahme einer Benutzereingabe ('y' bzw. 'n').

2.8.4 Übung 4 Schwerpunkte procedure, Double, Str,High, lokale und globale Variablen; verschachtelte Schleifen

Aufgabenstellung Es gibt kein Programm, was man nicht noch weiter verbessern könnte. Den Anwender des Vorgängerbeispiels stört es vor allem, dass man die Entscheidung über die Anzahl der einzugebenden Zahlen bereits zu Beginn treffen muss und später keine Möglichkeit mehr hat, dies zu korrigieren. Verändern Sie das Vorgängerprogramm so, dass die Zahleneingabe zu einem beliebigen Zeitpunkt beendet werden kann! Da sich von einer Zahlenreihe weitaus mehr Informationen gewinnen lassen als nur der Maximalwert, sollen Sie noch ein weiteres Problem lösen: Ergänzen Sie das Programm um die Ausgabe von Minimum und Durchschnitt!

Lösungsvorschlag Trotz der erweiterten Funktionalität erscheint der nachfolgend abgebildete PAP keinesfalls komplizierter als das Vorgängerbeispiel zu sein. Dies wurde vor allem durch die Auslagerung der Berechnungsfunktionen für Maximum, Minimum und Durchschnitt in ein Unterprogramm (eine Prozedur) erreicht. Zwei ineinander verschachtelte repeat...until-Schleifen steuern die Benutzereingaben. Das dynamische Array wird nicht sofort auf die endgültige Länge gebracht, sondern vor jeder Zahleneingabe um ein Feld vergrößert.

134

Kapitel 2

Grundlegende Sprachelemente

Start Deklaration dyn. Array: arr i := 0 i := i + 1 Array um ein Feld vergrößern Eingabe: arr[i]

Eingabe: c Letzte Zahl ?

nein

Berechne Max, Min, Durchschnitt

Unterprogramm

Ausgabe: Max, Min, Durchschnitt

Eingabe: c Programm beenden ? nein Ende

Programmierung Aufgrund der vielen Analogien zum Vorgängerbeispiel wird auch hier nur auf die Besonderheiten per Kommentar hingewiesen: program Project1; {$APPTYPE CONSOLE} uses SysUtils; var arr: array of Integer; i, max, min: Integer; av: string; c: Char;

// globale Variablen deklarieren

// zur Abfrage einer Abbruchbedingung

2.8 Lernbeispiele für Anfänger

135

procedure berechne; // Beginn Unterprogramm var i, n: Integer; sum: Double; // lokale Variablen deklarieren begin min := arr[0]; max := arr[0]; sum := arr[0]; // Variablen initialisieren n := High(arr); // höchster Array-Index = Anzahl Werte - 1 for i := 1 to n do begin if (arr[i] > max) then max := arr[i] else if (arr[i] < min) then min := arr[i]; sum := sum + arr[i] end; sum := sum / (n+1); // Durchschnitt berechnen Str(sum:5:2, av) // String formatieren end; // Ende UP begin // Beginn Hauptprogramm WriteLn('Aufgabe 4'); WriteLn; repeat i := 0; repeat i := i + 1; Write('Geben Sie die ' + IntToStr(i) + '. Zahl ein! '); SetLength(arr, i); ReadLn(arr[i-1]); WriteLn('War das die letzte Zahl? (j/n) '); ReadLn(c) until c = 'j'; berechne; // Prozeduraufruf (quasi Unterprogramm) WriteLn('Das Maximum ist ', max, ' !'); WriteLn('Das Minimum ist ', min, ' !'); WriteLn('Der Durchschnitt ist ' + av + ' !'); WriteLn('Wollen Sie das Programm beenden? (j/n) '); ReadLn(c); until c = 'j'; arr := nil end. // Ende Hauptprogramm

Test Was eigentlich ein Vorteil sein sollte, nämlich die freie Entscheidung über den Abbruch der Zahlenkette, erscheint lästig durch die nervige Abfrage War das die letzte Zahl?:

136

Kapitel 2

Grundlegende Sprachelemente

Sie könnten die Bedienung etwas vereinfachen, wenn Sie anstatt einer Zahleneingabe z.B. das Zeichen 'e' eingeben und damit die Berechnung starten würden. Die Abfrage War das die letzte Zahl? wäre dann überflüssig. Wenn Sie auch dieses Beispiel ohne größere Schwierigkeiten bewältigt haben, sind Sie auf dem besten Weg zu einem guten Pascal-Programmierer, denn Sie haben bereits ein Gefühl für die wichtigsten sprachlichen Grundlagen entwickelt. Die Zeit ist also reif, um die langweilige Text-Konsole endgültig zu verlassen und zu einer attraktiven Windows-Oberfläche überzugehen. Aber nicht nur der trostlose schwarze Textbildschirm, sondern auch die mühselige Bedienung, bei der der Rechner die Reihenfolge der Benutzereingaben zwangsweise vorgibt, muss Ihnen ein Dorn im Auge gewesen sein. Dies sollte ein weiterer Grund sein, das zeilenorientierte Ur-Pascal zu verlassen und zur objekt- und ereignisorientierten Delphi-Programmierung überzugehen.

Bemerkungen ■ Eine Zählvariable i wird auf globaler Ebene (gültig innerhalb des gesamten Programms) benutzt, eine andere Zählvariable i auf lokaler Ebene (gültig innerhalb der Prozedur berechnen). Beide sind nicht identisch und beeinflussen sich deshalb auch nicht, denn eine lokale Variable hat immer Vorrang vor einer gleichnamigen globalen Variablen. ■ Die lokale Variable sum enthält anfangs die Summe und zuletzt den Durchschnitt, wird also zweifach "benutzt". Etwas übersichtlicher ist es, wenn Sie stattdessen eine weitere lokale Variable verwenden. ■ Die Str-Prozedur (aus der Unit SysUtils) wandelt den Durchschnitt (eine Gleitkommazahl) in eine Zeichenkette (av) um, wobei insgesamt fünf Stellen, davon zwei Nachkommastellen, angezeigt werden. ■ Die Funktion High erwartet als Argument eine Array-Variable und liefert deren höchsten Index. Da die Indizierung eines dynamischen Arrays stets mit Null beginnt, ist die Anzahl der Felder immer um eins höher als der Rückgabewert von High.

137

2.8 Lernbeispiele für Anfänger

■ Ein Unterprogramm (sprich Prozedur) ist immer dann zweckmäßig, wenn (wie in unserem Fall) die Übersichtlichkeit des Programms erhöht werden soll oder aber wenn gleiche Codeabschnitte mehrfach ausgeführt werden sollen. Außerdem wird eine Wiederverwendbarkeit des Quellcodes erheblich erleichtert (siehe nächstes Beispiel).

2.8.5 Übung 5 Schwerpunkte Objekt- und ereignisorientierte Programmierung unter Delphi, StrToInt-Prozedur.

Aufgabenstellung Wir wollen die langweiligen Konsolenanwendungen endlich hinter uns lassen und uns nun zeitgemäßen Windows-Applikationen zuwenden. Lösen Sie mit einer Windows-Anwendung das gleiche Problem (Maximumbestimmung von drei Integer-Zahlen) wie im ersten Lernbeispiel!

Lösungsvorschlag Starten Sie Delphi. Es wird Ihnen ein Formular mit der Beschriftung Form1 angeboten. Mit Komponenten der Standard-Seite der Komponentenpalette gestalten Sie die folgende Benutzerschnittstelle, bestehend aus drei Label- und drei Edit-Komponenten sowie einem Button und einem Panel:

Ändern Sie in der Eigenschaften-Seite des Objektinspektors (F11) die folgenden Anfangswerte: Objekt

Eigenschaft

Neuer Anfangswert

Form1

Caption

Maximum von drei Integer-Zahlen

Label1

Caption

A

Label2

Caption

B

Label3

Caption

C

138

Kapitel 2

Grundlegende Sprachelemente

Objekt

Eigenschaft

Neuer Anfangswert

Button1

Caption

Maximum

Panel1

Font.Size

12

BevelOuter

BvLowered

"

Programmierung Drücken Sie die Taste F12, um sich den von Delphi vorgefertigten Quelltext von Unit1 anzuschauen. Da geht es bereits ziemlich objektorientiert zu, aber was das im Einzelnen bedeutet, braucht Sie hier nicht weiter zu interessieren. Das Einzige, was für Sie zu tun bleibt, ist das Hinzufügen einer Ereignisbehandlungsroutine (Event-Handler) für das OnClick-Ereignis von Button1. Dieser Event-Handler beantwortet die Frage: "Was soll passieren, wenn der Anwender mit der Maus auf die Schaltfläche klickt?" Zunächst müssen Sie den Event-Handler öffnen. Klicken Sie auf Button1, drücken Sie die F11Taste und wechseln Sie zur Ereignisse-Seite des Objektinspektors. Wählen Sie das OnClick-Ereignis durch Doppelklick aus. Im Quelltextfenster von Unit1 erscheint jetzt der vorgefertigte Rahmencode des Event-Handlers. Ergänzen Sie den Rahmencode, so dass der Event-Handler schließlich wie folgt aussieht: procedure TForm1.Button1Click(Sender: TObject); var a, b, c, max: Integer; begin a := StrToInt(Edit1.Text); max := a;

// Eingabe a

b := StrToInt(Edit2.Text); if b > max then max := b;

// Eingabe b

c := StrToInt(Edit3.Text); if c > max then max := c;

// Eingabe c

Panel1.Caption := 'Das Maximum ist ' + IntToStr(max) + ' !' end;

// Ausgabe Maximum

Test Wenn Sie die Programmbedienung mit der der Konsolenanwendung vergleichen, so stoßen Sie auf ein Hauptmerkmal der objekt- und ereignisorientierten Programmierung: Eine fest vorgeschriebene Reihenfolge für die Benutzereingaben gibt es nicht mehr!

2.8 Lernbeispiele für Anfänger

139

HINWEIS: Wer das Beispiel wie beschrieben abgetippt hat, darf nur Ganzzahlen eingeben, an-

sonsten stürzt das Programm ab! Allerdings beinhaltet der Quellcode auf der BuchCD eine Fehlerbehandlung.

Bemerkungen ■ Genauso wie im Konsolen-Beispiel haben wir es auch innerhalb eines Event-Handlers mit Pascal-Anweisungen zu tun, die zeilenweise abgearbeitet werden. ■ Im Unterschied zur Konsolenanwendung (ReadLn/WriteLn) ist die Ein-/Ausgabe der Zahlen etwas umständlicher. Deren Werte sind zunächst in der Text-Eigenschaft der drei Editierfelder enthalten und müssen mit Hilfe der StrToInt-Funktion vom Datentyp String in den IntegerDatentyp umgewandelt werden. Die Ergebnisausgabe erfolgt umgekehrt mittels IntToStr-Funktion, deren Ergebnis der Caption-Eigenschaft von Panel1 zugewiesen wird. ■ Um die Übersichtlichkeit nicht zu gefährden, wurde im hier abgedruckten Listing auf jegliche Art von Fehlerbehandlung verzichtet. Testen Sie, was passiert, wenn Sie in eines der drei Editierfelder ein Zeichen eingeben, das die StrToInt-Funktion nicht in eine Integer-Zahl verwandeln kann. ■ Wo sind das einleitende program und das abschließende end. geblieben? Wählen Sie den Menüpunkt Projekt|Quelltext anzeigen und Sie sehen, dass an diesem Pascal-Fundament nicht gerüttelt wurde. Allerdings beschäftigt sich das Hauptprogramm nur noch mit dem Initialisieren der Windows-Applikation und dem Erzeugen des Formulars. Der spezifische Anwendungscode wurde nach Unit1 ausgelagert.

2.8.6 Übung 6 Schwerpunkte Portieren eines Pascal-Programms nach Delphi; Edit- und ListBox-Komponente; Enter-Taste auswerten; Array kopieren.

140

Kapitel 2

Grundlegende Sprachelemente

Aufgabenstellung Mittlerweile sind Sie auf den Geschmack gekommen und wollen sich an etwas Anspruchsvolleres heranwagen: Verwandeln Sie das Konsolenprogramm aus dem vierten Lernbeispiel in eine Windows-Applikation!

Lösungsvorschlag Da Sie die allgemeine Vorgehensweise bereits am Vorgängerbeispiel geübt haben, werden sich die folgenden Erläuterungen nur auf das Spezifische beschränken. Die folgende Abbildung zur Gestaltung der Benutzerschnittstelle ist lediglich als Anregung zu verstehen. Ein Editierfeld (Edit1) dient zur Eingabe der Zahlen, die per Enter-Taste in ein Listenfeld (ListBox1) übernommen werden sollen. Für die bequeme Bedienung sind weiterhin zwei Schaltflächen (Button1, Button2) und drei Panel-Komponenten vorgesehen.

Programmierung Im implementation-Abschnitt von Unit1 tragen Sie zunächst folgenden Code ein, wie er bereits aus der entsprechenden Konsolenanwendung bekannt ist: var arr: array of Integer; max, min: Integer; av: Double;

// globale Variablen deklarieren

procedure berechne; // Beginn Unterprogramm var i, n: Integer; sum: Double; // lokale Variablen deklarieren begin min := arr[0]; max := arr[0]; sum := arr[0]; // Variablen initialisieren n := High(arr); // höchster Array-Index = Anzahl Werte - 1 for i := 1 to n do begin

2.8 Lernbeispiele für Anfänger

141

if (arr[i] > max) then max := arr[i] else if (arr[i] < min) then min := arr[i]; sum := sum + arr[i] end; av := sum / (n+1) // Durchschnitt berechnen end; // Ende UP

Der folgende Event-Handler für das OnKeyPress-Ereignis von Edit1 überträgt den Eintrag aus dem Editierfeld in die ListBox, wenn die Enter-Taste gedrückt wird. Anschließend wird der Eintrag im Editierfeld gelöscht, um für neue Zahleneingaben bereit zu sein. HINWEIS: Tippen Sie den Rahmencode eines Event-Handlers niemals per Hand ein, sondern er-

zeugen Sie ihn über die Ereignis-Seite des Objektinspektors! procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char); begin if Key = #13 then // Enter-Taste begin ListBox1.Items.Add(Edit1.Text); // Editierfeld => ListBox Edit1.Text := '' // Editierfeld löschen end end;

Der folgende Event-Handler wertet das OnClick-Ereignis von Button1 aus. Der Inhalt der ListBox wird ausgelesen und in das dynamische Array kopiert. Da der erste Eintrag einer ListBox (genauso wie das erste Feld des dynamischen Arrays) den Index null hat, kann man das Kopieren elegant in einer for ... to-Schleife erledigen. Nach Aufruf der Prozedur berechne erfolgt die Ergebnisanzeige: procedure TForm1.Button1Click(Sender: TObject); // Berechne var i, n: Integer; s: String; begin n := ListBox1.Items.Count; // Anzahl der ListBox-Einträge feststellen if n > 0 then // mindestens ein Eintrag in der ListBox begin SetLength(arr,n); // Array dimensionieren for i := 0 to n-1 do arr[i] := StrToInt(ListBox1.Items[i]); // in ListBox kopieren berechne; // UP-Aufruf Panel1.Caption := IntToStr(max); // Ergebnisanzeige Panel2.Caption := IntToStr(min); Str(av:5:2, s); // Gleitkommazahl formatieren Panel3.Caption := s end end;

Der letzte Event-Handler ermöglicht das Löschen der gesamten Zahlenreihe, um wieder von vorne beginnen zu können:

142

Kapitel 2

Grundlegende Sprachelemente

procedure TForm1.Button2Click(Sender: TObject); // Löschen begin ListBox1.Items.Clear; arr := nil; // Array freigeben Panel1.Caption := ''; Panel2.Caption := ''; Panel3.Caption := '' end;

Test Geben Sie eine Zahlenkolonne ein (jede Zahl mit Enter-Taste abschließen):

Bemerkungen ■ Da unsere Zahlenreihe auch in der Listbox gespeichert wird, könnte man auf das dynamische Array gänzlich verzichten und damit den Code etwas vereinfachen (siehe Beispiel in 5.4.4). ■ Vergleichen Sie intensiv den Quelltext dieses Programms mit dem der Konsolenanwendung (2.8.4). Nach einiger Übung dürfte es Ihnen nicht schwer fallen, weitere "alte" Pascal-Programme auf ähnliche Weise mit Delphi "aufzumöbeln". Dabei dürfte das "Zusammenschieben" der Benutzerschnittstelle nicht das Problem sein. Dreh- und Angelpunkt ist vielmehr das Aufbrechen des linearen Programmablaufs und seine zweckmäßige Verteilung auf verschiedene Event-Handler. ■ Unter Delphi hat der klassische Programmablaufplan (PAP) außerhalb von Prozeduren bzw. Event-Handlern seine Bedeutung weitestgehend verloren, da es keine festgelegte Reihenfolge der Benutzereingaben mehr gibt.

143

2.9 Praxisbeispiele für Fortgeschrittene

2.9 Praxisbeispiele für Fortgeschrittene 2.9.1 Speichern von Records in einem statischen Array Grundlage für das Beispiel ist eine kleine Personaldatenbank, in welcher der Name, das Geburtsdatum, das Geschlecht und die Telefonnummer abgespeichert werden sollen. Bei der Umsetzung werden wir auf kein Standard-Datenbankformat (Paradox, dBase ...) zurückgreifen, sondern auf einen benutzerdefinierten Datentyp (Record). Die einzelnen Records werden in einem eindimensionalen Array abgespeichert, auf das bekanntlich über einen Feldindex (entspricht einer lfd. Nummer) zugegriffen werden kann. BEISPIEL: Stellen Sie sich eine solche Recordstruktur wie ein Regal vor, das aus mit 1, 2, 3 ... durch-

nummerierten Schubkästen besteht. Jeder Person entspricht ein Schubkasten, dieser wiederum ist in einzelne Fächer für Name, Geburtsdatum ... aufgeteilt. Feldindex

1

2

3

4

...

name

Wagner

Maier

Schultze

Richter

...

geburt

28.11.54

8.2.71

3.4.75

30.9.81

...

geschlecht

w

M

M

w

...

Nr

03447 90580

02762 89670

04288 30024

31575 45600

...

Oberfläche Platzieren Sie (entsprechend der Abbildung) auf dem Startformular fünf Labels, drei Editierfelder, eine CheckBox und fünf Buttons:

Quelltext Fügen Sie in den Private-Abschnitt von TForm1 die folgenden drei Methodendeklarationen ein:

144

Kapitel 2

private { Private-Deklarationen procedure dsInit; // procedure dsSpeichern; procedure dsAnzeigen;

Grundlegende Sprachelemente

} Methode zum Initialisieren aller Datensätze // dto. zum Speichern eines Datensatzes // dto. zum Anzeigen

Wir hätten auch auf obige Methodendeklarationen verzichten können und stattdessen drei ganz normale Prozeduren in den Implementation-Abschnitt einfügen können. Die gewählte Vorgehensweise ist aber eleganter und übersichtlicher (insbesondere im Hinblick auf die objektorientierte Programmierung). Im Implementation-Abschnitt definieren wir zunächst unseren Record, um dann eine eindimensionale Array-Variable mit der gewünschten Anzahl von Feldern (10) zu deklarieren: type TPerson = record name: string[20]; geburt: TDateTime; geschlecht: Boolean; nr: Integer end; const pmax = 10;

// // // // //

Typ der Strukturvariablen max. 20 Buchstaben Geburtsdatum männlich = True, weiblich = False Telefonnummer

// max. Anzahl von Personen = Größe des Arrays

var personen: array[1..pmax] of TPerson; index: Byte = 1;

// Array-Variable // aktueller Feldindex

Nun zu den Methoden-Implementationen: procedure TForm1.FormCreate(Sender: TObject); // Programmstart begin dsInit; // initialisiert alle Datensätze dsAnzeigen // und zeigt den ersten an end;

Es folgen die drei nutzerdefinierten Methoden: procedure TForm1.dsInit; // setzt alle Personen auf Standardwerte var i: Integer; begin for i := pmax downto 1 do with personen[i] do begin name := ''; geburt := StrToDate('31.12.99'); geschlecht := False; nr := 9999999 end end;

Von der Anzeige in den Speicher: procedure TForm1.dsSpeichern; begin personen[index].name := Edit1.Text;

145

2.9 Praxisbeispiele für Fortgeschrittene

if Edit2.Text <> '' then personen[index].geburt := StrToDate(Edit2.Text); personen[index].geschlecht := CheckBox1.Checked; personen[index].nr := StrToInt(Edit3.Text) end;

Vom Speicher in die Anzeige: procedure TForm1.dsAnzeigen; begin Label1.Caption := IntToStr(index); // Index anzeigen Edit1.Text := personen[index].name; Edit2.Text := DateToStr(personen[index].geburt); CheckBox1.Checked := personen[index].geschlecht; Edit3.Text := IntToStr(personen[index].nr) end;

Zu den vier Bewegungstasten: procedure TForm1.Button3Click(Sender: TObject); // vorwärts (>) begin if index < pmax then begin dsSpeichern; Inc(index); dsAnzeigen end end; procedure TForm1.Button2Click(Sender: TObject); // rückwärts (<) begin if index > 1 then begin dsSpeichern; Dec(index); dsAnzeigen end end; procedure TForm1.Button1Click(Sender: TObject); begin dsSpeichern; index := 1; dsAnzeigen end;

// zum Anfang (|<)

procedure TForm1.Button4Click(Sender: TObject); // zum Ende (>|) begin dsSpeichern; index := pmax; dsAnzeigen end;

Test Nach Programmstart können die Standardwerte mit den Daten einzelner Personen überschrieben werden. Wie bei einem "richtigen" Datenbankprogramm bewegen Sie sich mit den Tasten durch die Datensätze. Damit enden aber schon die Gemeinsamkeiten, denn leider ist die ganze Mühe umsonst gewesen, wenn Sie das Programm verlassen. Dann wird auch der Inhalt des Arbeitsspeichers gelöscht, und die mühselig eingegebenen Personen sind beim Neustart auf Nimmerwiedersehen verschwunden. Wie Sie die Daten in die persistente Form überführen, d.h. auf Festplatte abspeichern können, erfahren Sie im Dateikapitel im Beispiel 8.10.3.

146

Kapitel 2

Grundlegende Sprachelemente

2.9.2 Experimente mit der Format-Funktion Sollten Sie immer noch Schwierigkeiten mit dem Verständnis der vielen verschiedenen Formatstrings haben, probieren Sie doch einfach folgendes kleines Testprogramm aus.

Oberfläche Neben einem Edit-Feld (Eingabe der numerischen Werte) und einer Combobox (Eingabe bzw. Auswahl des Formatstrings) brauchen Sie lediglich ein Panel (ein Label tut es auch) für die Anzeige (siehe Laufzeitabbildung am Schluss). In die Items-Eigenschaft der Combobox tragen Sie mit Hilfe des Stringlisten-Editors z.B. folgende Werte für diverse Formatierungsstrings ein:

Quelltext Wir wollen den Ergebnisstring immer dann neu anzeigen, wenn wir in das Editierfeld eine andere Zahl eingegeben haben (OnChange-Event auswerten): procedure TForm1.Edit1Change(Sender: TObject); var n : Double; code : Integer; begin Val(Edit1.Text,n,code); if code = 0 then Panel1.Caption := Format(ComboBox1.Text,[n]) else Panel1.Caption := 'Fehler' end;

Test Nach Programmstart können Sie sich nun von der Wirksamkeit unterschiedlichster Formatstrings überzeugen. Um ein Ergebnis wie das unten angezeigte zu erreichen, wäre folgende Anweisung nötig: Panel1.Caption := Format("%8.2f",[12345678.066]);

2.9 Praxisbeispiele für Fortgeschrittene

147

2.9.3 Überladen von Funktionen Gleichnamige Funktionen/Prozeduren/Methoden dürfen sich im gleichen Gültigkeitsbereich befinden, wenn sie unterschiedliche Parameterlisten haben und die Deklaration mit der overload-Direktive erfolgt. In diesem Demobeispiel sollen die Grundfläche und das Volumen eines Zylinders mit zwei gleichnamigen Funktionen zylinder berechnet werden.

Oberfläche Wir wollen das Ergebnis gleich vorwegnehmen und zeigen, welcher Anblick sich zur Laufzeit bieten soll:

Quelltext Der implementation-Abschnitt von Unit1: var r, h: Single; code: Integer; s: string;

148

Kapitel 2

Grundlegende Sprachelemente

Die Funktion zur Volumenberechnung braucht als Übergabeparameter den Radius und die Höhe: function zylinder(r,h: Double): Double; overload; begin Result:= Pi * Sqr(r) * h // Volumen = Grundfläche mal Höhe end;

Die Funktion zum Berechnen der Grundfläche benötigt nur den Radius als Übergabeparameter: function zylinder(r: Double): Double; overload; begin Result := Pi * Sqr(r) // Grundfläche = Pi*r*r end;

Der Button für die Berechnung der Grundfläche: procedure TForm1.Button1Click(Sender: TObject); var f: Single; begin Val(Edit1.Text, r, code); f := zylinder(r); Str(f:6:2,s); // 6-stellige Ausgabe, davon 2 Nachkommastellen Panel1.Caption := s // Ergebnisanzeige end;

Der Button für die Berechnung des Volumens: procedure TForm1.Button2Click(Sender: TObject); var v: Single; begin Val(Edit1.Text, r, code); Val(Edit2.Text, h, code); v := zylinder(r, h); Str(v:6:2,s); // 6-stellige Ausgabe, davon 2 Nachkommastellen Panel2.Caption := s // Ergebnisanzeige end;

Test Dazu gibt es nicht viel zu sagen – geben Sie einen Radius und eine Höhe ein und überzeugen Sie sich selbst, ob alles wie geplant funktioniert!

3

Entwicklungsumgebung

Kapitel

3

Entwicklungsumgebung Haben wir uns in den beiden vorangegangenen Kapiteln nach dem Prinzip "so viel wie nötig" auf die zum Aufbau einfacher Programme erforderlichen Bedienfunktionen beschränkt, so wollen wir jetzt einen tieferen Blick in die Integrierte Entwicklungsumgebung (IDE) von Borland Delphi 7 werfen. Sie gewinnen einen Überblick über die wichtigsten Fenster, die Komponentenpalette und die zahlreichen Menüfunktionen, die Sie beim visuellen Oberflächenentwurf unterstützen. Allerdings sollten Sie dieses Kapitel nicht linear von vorne nach hinten durcharbeiten, sondern nur zum gelegentlichen Nachschlagen verwenden.

3.1 Die wichtigsten Fenster im Überblick Delphi präsentiert Ihnen nach dem Start eine Bedienoberfläche mit mehreren "frei schwebenden" einzelnen Fenstern, von denen die Abbildung die wichtigsten vier zeigt:

150

Kapitel 3

Entwicklungsumgebung

■ Hauptfenster (mit Menü- und Symbolleisten und der mehrseitigen Komponentenpalette) ■ Startformular (Ihr Betätigungsfeld!) ■ Objektinspektor (die angedockte Objekt-Hierarchie sollten Sie zunächst wegklicken) ■ Quelltexteditor (mit angedocktem Code-Explorer) Welche praktischen Vorteile die Arbeit mit einer solchen, in mehrere lose Einzelfenster aufgeteilten, Programmierumgebung mit sich bringt, werden Sie zu einem späteren Zeitpunkt so richtig zu würdigen wissen. Vorerst müssen Sie sich erst an das scheinbare Durcheinander gewöhnen. HINWEIS: Um nicht zu sehr durch darunter liegende Ikonen des Windows-Desktop irritiert zu

werden, empfiehlt sich ein einfarbiger Hintergrund. In den folgenden Abschnitten sollen nun die einzelnen Fenster mit ihren Bedienelementen bzw. Menüfunktionen etwas genauer unter die Lupe genommen werden.

3.2 Alle Menüfunktionen und die Symbolleiste Häufig benötigte Menüaufrufe werden auf die Symbolleiste (Speedbar) gelegt und/oder können über Tastatur (Shortcuts) erreicht werden.

3.2.1 Datei-Menü Dieses Windows-typische Menü sieht in Delphi um einiges komplexer aus als z.B. in Word, da hier zwischen mehreren Dateitypen unterschieden werden muss und ein Programm (Projekt) nicht aus einem einzigen, sondern aus mehreren Files bzw. Modulen besteht (Projektdatei *.DPR, Quelltextmodul *.PAS, ...). Menüaufruf

Button Taste

... öffnet ein Untermenü, wo Sie ein neues Projekt eines bestimmten Typs auswählen.1

Öffnen

... fügt zum Projekt eine einzelne Datei hinzu (daneben Liste der zuletzt geöffneten Projekte/ Module).

Projekt öffnen...

Strg+F11

Neu Öffnen Speichern

1

Erläuterung

Neu

... lädt vorhandenes Projekt von einem Verzeichnis nach Delphi. ... öffnet Liste der zuletzt benutzten Projekte und Module.

Strg+S

Meistens wird das der Typ "Anwendung" sein.

... speichert die an allen geöffneten Dateien vorgenommenen Änderungen.

151

3.2 Alle Menüfunktionen und die Symbolleiste

Menüaufruf

Button Taste

Erläuterung

Speichern unter...

... speichert die aktive Datei unter neuem Namen in ein Verzeichnis.

Projekt speichernunter ...

... speichert Projektdatei (*.DPR) unter neuem Namen in ein Verzeichnis.

Alles speichern

Umsch+ Strg+S

... speichert alle geöffneten Dateien.

Schließen

... beendet die Arbeit am aktuellen Projekt ohne Delphi zu verlassen.

Alle schließen

... schließt alle geöffneten Dateien.

Unit verwenden...

Alt+F11

... fügt eine weitere Unit hinzu.

Drucken...

... druckt geöffnetes Quelltextfenster bzw. Formular.

Beenden

... schließt Projekt und beendet Delphi.

3.2.2 Bearbeiten-Menü Hier handelt es sich ebenfalls um ein Windows-typisches Standardmenü, das große Ähnlichkeit mit dem gleichnamigen Menü eines Textverarbeitungs- bzw. Zeichenprogramms hat. Menüaufruf

Taste

Erläuterung

Rückgängig

Strg+Z

... macht die vorhergehende(n) Operation(en) rückgängig.

Widerrufen

Umsch+ Strg+Z

... macht den letzten Rückgängig-Schritt unwirksam.

Ausschneiden

Strg+X

... entfernt markierte Elemente und überschreibt die Zwischenablage damit.

Kopieren

Strg+C

... kopiert Komponenten oder Quelltext in die Zwischenablage.

Einfügen

Strg+V

... fügt Komponenten oder Quelltext aus Zwischenablage ein.

Löschen

Strg+Entf ... entfernt die markierten Elemente ohne Kopieren in Zwischenablage.

Alles auswählen

... alle Komponenten des Formulars werden markiert1.

Am Raster ausrichten

... verschiebt markierte Komponenten zum nächsten Rasterpunkt.

Nach vorne setzen Nach hinten setzen

... stellt die markierte Komponente vor (nach) alle anderen Komponenten des Formulars2.

1

Objektinspektor zeigt in diesem Fall nur die gemeinsamen Eigenschaften an.

2

Diesen Vorgang nennt man auch "Ändern der ZOrder" der Komponenten.

152

Kapitel 3

Menüaufruf

Taste

Entwicklungsumgebung

Erläuterung

Ausrichten...

... öffnet das Dialogfenster Ausrichtung für Komponenten.

Größe...Skalierung...

... öffnet Dialogfenster Größe für gleiche Breite bzw. Höhe bzw. Größenänderung von Komponenten.

Tabulatorreihenfolge

... öffnet das Dialogfenster Tabulatorreihenfolge bearbeiten.

Erstellungsfolge...

... öffnet das Dialogfenster Erstellungsfolge für das Erzeugen unsichtbarer Komponenten zur Laufzeit1.

Unterg. Elemente vertauschen

Layout aller oder nur der ausgewählten Komponenten wird gespiegelt (Ändern der Leserichtung).

Elemente fixieren

... verankert alle Komponenten in ihrer momentanen Position und Größe2.

Zur Schnittstelle hinzufügen...

... fügt neue Funktion, Prozedur oder Eigenschaft zu ActiveX-Komponente hinzu.

3.2.3 Suchen-Menü Ein ähnliches Menü findet sich auch in vielen Textverarbeitungsprogrammen. Es unterstützt Sie beim Schreiben Ihres Objekt-Pascal-Quellcodes. Menüaufruf

Taste

Erläuterung

Suchen...

Strg+F

... öffnet das Dialogfenster Text suchen.

In Dateien suchen...

... öffnet das Dialogfenster Text suchen.

Ersetzen...

Strg+R

... öffnet das Dialogfenster Text ersetzen3.

Suche wiederholen

F3

... setzt den Suchvorgang fort.

Inkrementelle Suche

Strg+E

... Suche ohne Dialogfenster.

Zeilennummer...

Alt+G

... öffnet das Dialogfenster Zeilennummer4.

Laufzeitfehler suchen...

... stoppt an Adresse des letzten Laufzeitfehlers.

Symbol anzeigen...

... öffnet das Dialogfenster für Suche im Objekt-Browser.

1

Standardmäßig entspricht das der Reihenfolge, mit der diese Komponenten (z.B. Timer) zur Entwurfszeit abgesetzt wurden.

2

Änderungen sind nur noch über den Objektinspektor möglich.

3

Die meisten Einstellungen sind die gleichen wie im Dialogfeld "Text suchen".

4

Die aktuelle Zeilen- und Spaltennummer wird in der Statuszeile des Quelltexteditors angezeigt.

153

3.2 Alle Menüfunktionen und die Symbolleiste

3.2.4 Ansicht-Menü Über dieses Menü lassen sich diverse Fenster öffnen. Menüaufruf

Button

Taste

Erläuterung

Projektverwaltung

Strg+Alt+F11

... öffnet das Fenster für die Projektverwaltung.

Objektinspektor

F11

... öffnet das Fenster des Objektinspektors.

Objekt-Hierarchie

Umsch+Alt +F11

... öffnet Fenster für Objekt-Hierarchie.

To-Do-Liste

... öffnet Liste für die noch zu erledigenden Programmierarbeiten

Ausrichtungspalette

... öffnet Werkzeugleiste zum Ausrichten von Komponenten.

Browser

Umsch+ Strg+B

... öffnet Objekt-Browser.

Code-Explorer

Umsch+ Strg+E

... öffnet Code-Explorer.

Komponentenliste Fensterliste...

... zeigt Liste der verfügbaren Komponenten an. Alt+O

... zeigt Liste der geöffneten Fenster.

Zusätzliche Informationen zur Meldung

... öffnet Fenster mit Meldungshinweisen

Debug-Fenster

... öffnet Untermenü für HaltepunktListe, Liste der überwachten Ausdrücke, lokale Variablen, Threads.

Umschalten Formular/Unit

F12

... schaltet um zwischen Formularansicht und Quelltexteditor.

Units...

Strg+F12

... zeigt Liste der Quelltext-Dateien.

Formulare...

Umsch+F12

... zeigt Liste aller Formulare.

Typbibliothek

... öffnet den Typbibliothekseditor.

Neues Editierfenster

... öffnet Fenster mit einer Kopie des aktuellen Quelltextes.

Symbolleisten...

... zeigt Untermenü für Symbolleisten an.

3.2.5 Projekt-Menü Alle Grundeinstellungen, die mit dem Kompilieren des Projekts zusammenhängen, nehmen Sie hier vor.

154

Kapitel 3

Menüaufruf

Dem Projekt hinzufügen...

Button

Entwicklungsumgebung

Taste

Erläuterung

Umsch+F11

... fügt Unit/Formular dem Projekt hinzu.

Aus dem Projekt entfernen...

... entfernt Unit/Formular aus dem Projekt.

Typbibliothek importieren...

... zeigt die im System registrierten Typbibliotheken an.

Der Objektablage hinzufügen...

... öffnet Dialogfenster zum Hinzufügen neuer Formulare etc. zur Objektablage.

Quelltext anzeigen

... zeigt den Quelltext der Projektdatei an.

Sprachen

... ruft Sprach-Experten auf

Neues Projekt hinzufügen...

... fügt neue Anwendung, DLL oder Package zur Projektgruppe hinzu.

Projekt1 compilieren

Strg+F9

... startet die Kompilierung des Projekts (nur die geänderten Dateien!).

Projekt1 erzeugen

... startet die Kompilierung des Projekts (alle Dateien!).

Syntaxprüfung von Projekt1

... startet Kompilierung ohne die einzelnen Module zu verknüpfen (schnell!).

Alle Projekte compilieren

... kompiliert die geänderten Projekte der Projektgruppe.

Alle Projekte erzeugen

... kompiliert alle Projekte der Projektgruppe.

Optionen für Web-Distribution

... bereitet ein fertiges ActiveX-Steuerelement oder ActiveForm für die Distribution vor.

Optionen...

Umsch+Strg+ ... legt Optionen von Anwendung, F11 Compiler und Linker fest und verwaltet die Verzeichnisse.

3.2.6 Start-Menü Dieses Menü stellt unterschiedliche Möglichkeiten für den Test Ihres Programms zur Verfügung: Menüaufruf

Start

Button Taste

F9

Erläuterung

... kompiliert das Programm und führt es aus.

Mit Prozess verbinden...

... erlaubt Debugging eines laufenden Prozesses.

Parameter...

... übergibt Kommandozeilenparameter.

ActiveX-Server eintragen

... trägt Server in die Windows-Registry

155

3.2 Alle Menüfunktionen und die Symbolleiste

Menüaufruf

Button Taste

Erläuterung

ActiveX-Server austragen

ein bzw. entfernt ihn (nur für ActiveXProjekte!).

COM+-Objekte installieren

... erlaubt Ausführung von COM+Objekten.

Gesamte Routine

F8

... Programm wird zeilenweise ausgeführt(1 Prozedur → 1 Schritt).

Einzelne Anweisung

F7

... Programm wird zeilenweise ausgeführt (1 Anweisung → 1 Schritt).

Nächste Quelltextzeile

Umsch+F7

... Programm hält bei nächster Zeile an.

Zur Cursorposition gehen

F4

... Programmausführung bis zur Cursorposition.

Ausführungsposition anzeigen

... positioniert Cursor an Ausführungspunkt.

Programm Pause

... unterbricht vorübergehend die Programmausführung.

Programm zurücksetzen

Strg+F2

Untersuchen...

... beendet Programm und gibt Speicherplatz frei. ... öffnet Fenster zur Eingabe eines zu untersuchenden Ausdrucks.

Auswerten/Ändern...

Strg+F7

... öffnet Dialogfeld "Auswerten/Ändern".

Ausdruck hinzufügen...

Strg+F5

... öffnet Dialogfeld "Darstellung überwachter Ausdrücke".

Haltepunkt hinzufügen

... öffnet Untermenü zum Setzen diverser Haltepunkte (Debugger).

3.2.7 Komponenten-Menü Dieses Menü ermöglicht Ihnen die Modifikation der Komponentensammlung, die für Ihre DelphiApplikation zur Verfügung steht. Menüaufruf

Erläuterung

Neue Komponente...

... öffnet den Komponentenexperten.

Komponente installieren...

... öffnet Dialogfeld "Komponenten installieren".

ActiveX importieren ...

... öffnet Dialogfenster "ActiveX-Element importieren".

Komponentenvorlage erzeugen...

... öffnet Fenster zum Erstellen einer neuen Komponentenschablone.

Packages installieren

... öffnet Fenster "Projektoptionen" (Seite "Packages").

Palette konfigurieren...

... ermöglicht die Anpassung der Komponentenpalette (Dialogfenster "Umgebungsoptionen").

156

Kapitel 3

Entwicklungsumgebung

3.2.8 Datenbank-Menü Der Zugriff auf Datenbanken spielt in Delphi eine zentrale Rolle, was den Einsatz eines extra Menüs für entsprechende Funktionalitäten rechtfertigt. Menüaufruf

Erläuterung

Explorer

... ermöglicht Verbindungsaufnahme zu einem entfernten Datenbanksystem.

SQL-Monitor

... beobachtet aktuelle SQL-Verbindungen.

Formular-Experte...

... unterstützt Sie beim Erstellen von Formularen.

3.2.9 Tools-Menü Hinter diesem Menüpunkt verbergen sich diverse Funktionalitäten und vorerst zwei ausgewachsene Zusatzprogramme zur Bildbearbeitung und zur Arbeit mit Datenbanken. Menüaufruf

Erläuterung

Umgebungsoptionen...

... öffnet Dialogfenster "Umgebungsoptionen".

Editor-Optionen...

... öffnet Dialogfenster "Editoreigenschaften".

Debugger-Optionen...

... öffnet Dialogfenster "Debugger-Optionen".

Optionen für ÜbersetzungsTools

... zu Einstellungen für integrierte Übersetzungsumgebung.

Objektablage...

... öffnet das Dialogfenster "Objektablage".

Übersetzungswörterbuch...

... öffnet Übersetzungswörterbuch.

Tools konfigurieren...

... erlaubt Hinzufügen, Löschen und Bearbeiten von Tools.

Datenbankoberfläche

... Hilfsprogramm zum Erstellen von Datenbanktabellen.

Bildeditor

... pixelorientiertes Zeichenprogramm für Icons etc.

Editor für Package-Sammlung

... zum Anzeigen und Bearbeiten von Package-Libraries.

Rave Designer

... zum Anfertigen von Datenbankberichten.

3.2.10 Fenster-Menü Über dieses Menü (mit wechselhaften Einträgen) können Sie schnell die (geöffneten) Fenster der Entwicklungsumgebung erreichen, z.B.:

157

3.3 Das Startformular

3.2.11 Hilfe-Menü Das Windows-typische Hilfe-Menü von Delphi bietet weitaus mehr als die standardmäßigen Suchfunktionen. Menüaufruf

Button

Erläuterung

Delphi-Hilfe

... ruft allgemeines Hilfefenster auf.

Delphi-Tools

... ruft Hilfefenster für Delphi-Tools auf.

Windows SDK

... öffnet Hilfefenster für Win32 Developer's References.

Borland-Homepage

... versucht einen Internet-Zugang zur BorlandHomepage.

Borland Community-Seite

... dto. für Mitglieder der Borland Community.

Delphi-Homepage

... dto. zu Angeboten und Vertrieb.

Delphi- Entwickler-Support

... dto. für Entwickler.

Delphi Direct...

... Zusatzmodul für vereinfachte Internet-Suche.

Anpassen...

... öffnet Fenster für OpenHelp.

Info...

... zeigt Copyright und Versionsnummer von Delphi.

HINWEIS: Denken Sie daran, dass die integrierte Online-Hilfe auch immer dann zur Stelle ist,

wenn Sie mit der Maus ein unbekanntes Element der Entwicklungsumgebung (z.B. einen Menüeintrag) aktivieren bzw. die Schreibmarke in ein unbekanntes Wort des Quelltextes setzen und dann die F1-Taste betätigen.

3.3 Das Startformular Da ein Windows-Programm in der Regel in einem oder mehreren Fenstern abläuft, sind Fenster bzw. Formulare auch die Basiselemente jeder Delphi-Applikation. Bereits unmittelbar nach Programmstart wird Ihnen ein "Blanko"-Formular namens Form1 angeboten, das gewissermaßen als Container für die darauf "aufzusteckenden" Komponenten dient. Ein Formular ist standardmäßig mit den Windows-typischen Checkboxen zum Verkleinern auf Symbolgröße, Vergrößern/Verkleinern und Schließen ausgestattet. Änderungen können über den Objektinspektor vorgenommen werden, z.B. mit BorderStyle. Setzen Sie diese Eigenschaft z.B. auf bsDialog, so wird dieses Formular später zum Dialogfenster, das nur noch über eine einzelne Checkbox (zum Schließen) verfügt und dessen Abmessungen nicht mehr verändert werden können. Bereits in den Einführungsbeispielen (Kapitel 1) haben Sie gelernt, wie man bestimmte Eigenschaften, wie z.B. die Beschriftung der Titelzeile (Caption) oder die Hintergrundfarbe (Color), einstellt. Das generelle Outfit eines Formulars (Farbe und Höhe der Titelzeile, Randbreite ...) können Sie mit Delphi allerdings nicht beeinflussen, denn das ist Sache der Einstellungen des WindowsDesktop (Systemsteuerung|Anzeige ...).

158

Kapitel 3

Entwicklungsumgebung

HINWEIS: Ausführliche Informationen zu den "Innereien" von Formularen und Komponenten

finden Sie in Kapitel 4.

3.4 Die Komponentenpalette Komponenten (manchmal auch als Dialog- bzw. Steuerelemente bezeichnet) sind die Grundbausteine Ihrer Delphi-Applikation. Es gibt auch Komponenten, die nur zur Entwurfs-, aber nicht zur Laufzeit sichtbar sind (MainMenu, Timer etc.), da sie ihre Arbeit quasi im Hintergrund verrichten. Das umfangreiche (und erweiterungsfähige) Sortiment ist in verschiedene Kategorien aufgeteilt, die griffbereit in den Registerseiten der Komponentenpalette untergebracht sind. Das vorhandene Sortiment kann vom Nutzer gekürzt bzw. erweitert werden (siehe Menü Komponente). Die Schaltfläche erscheint auf jeder Seite der Komponentenpalette. Wenn Sie darauf klicken, wird der Auswahlmodus beendet (keine aktive Komponente), und Sie können die normale Arbeitsweise fortsetzen. Im vorliegenden Buch werden wir vor allem mit Komponenten der Registerseiten Standard, Zusätzlich, Win32, System, Datenzugriff, Datensteuerung, BDE, QReport, Dialoge, Win 3.1, Beispiele, ActiveX und Server arbeiten (alle anderen siehe unsere weiteren Bücher [Borland Delphi 7 – Datenbankprogrammierung] bzw. [Borland Delphi 7 Kochbuch]). In den folgenden Tabellen sind nur die wichtigsten Komponenten aufgeführt, wie Sie nach einer Standardinstallation zur Verfügung stehen.

3.4.1 Standard Hier handelt es sich um die allgemein bekannten Basiselemente der Windows-Oberfläche. Name

Icon

Verwendungszweck

MainMenu

Menüentwurf (Menüleiste oder DropDown-Menü)

PopupMenu

PopUp-Menüs (erscheinen lokal bei rechtem Mausklick)

Label

reine Textanzeige (ohne Nutzerzugriff)

Edit

einzeilige Texteingabe und -anzeige

Memo

mehrzeilige Texteingabe und -anzeige

Button

Schaltfläche (z.B. zum Starten einer Operation)

CheckBox

Ja-/Nein-Option

RadioButton

exklusive Ja/Nein-Optionen

159

3.4 Die Komponentenpalette

Name

Icon

Verwendungszweck

ListBox

Auswahlliste

ComboBox

editierbare Auswahlliste

ScrollBar

Bildlaufleiste

GroupBox

Rahmen für allgemeine Gruppe

Panel

Unterlage für andere Komponentengruppen (z.B. Toolbar)

RadioGroup

gruppiert ein Schalterfeld

ActionList

Aktionsliste

Eine Beschreibung dieser Komponenten erfolgt in Kapitel 4.

3.4.2 Zusätzlich Diese Dialogelemente haben im Allgemeinen eine etwas komplexere Funktionalität als die Standardkomponenten. Name

Icon

Verwendungszweck

BitBtn

Schaltfläche mit eingelagerter Grafik

SpeedButton

Toolbar-Schaltfläche

MaskEdit

Formatieren der Dateneingabe

StringGrid

Zeilen- und spaltenweise Anzeige von Zeichenketten

DrawGrid

Zeilen- und spaltenweise Datenanzeige

Image

Anzeige einer Grafik (*.BMP, *.ICO, *.WMF)

Shape

Anzeige von Kreis, Ellipse, Rechteck (auch abgerundet)

Bevel

Rechteck oder Rahmen (auch Linie) mit 3-D-Effekt

ScrollBox

Erzeugen von Bildlaufbereichen auf dem Formular

CheckListBox

wie Listbox, aber mit Kontrollfeldern

ControlBar

Layout-Manager zum Andocken von Symbolleisten

Splitter

Trennleiste zum Teilen des Formulars

StaticText

wie Label, aber mit Fenster-Handle

160

Kapitel 3

Name

Icon

Entwicklungsumgebung

Verwendungszweck

ApplicationEvents

zum Abfangen von Ereignissen des Application-Objekts

ValueListEditor

zur Anzeige zweispaltiger Stringlisten (Name|Wert)

ColorBox

ComboBox zur Farbauswahl

Chart

zur Darstellung unterschiedlichster Diagrammtypen

ActionManager

zur Verwaltung und Anzeige aller Aktionen einer Anwendung

ActionMainMenuBarActionToolBar CustomizeDlg

Dialogfeld zum Anpassen von Aktionsabschnitten

3.4.3 Win32 Hier handelt es sich größtenteils um Steuerelemente, wie sie vor langer Zeit mit dem Übergang von 16 zu 32 Bit (Windows 95) neu eingeführt wurden. Name

Icon

Verwendungszweck

TabControl

Notizbuchregister (ähnlich TabSet in Delphi 1.0)

PageControl

Notizbuchregister für mehrseitige Dialogfelder(Nachfolger von TabbedNotebook )

ImageList

Bilderliste für TreeView und ListView

RichEdit

Memo-Komponente für Textdateien unbegrenzter Länge mit unterschiedlichen Formatierungsmöglichkeiten

TrackBar

Regler zum Einstellen von Werten in einem bestimmten Bereich

ProgressBar

Fortschrittsanzeige eines Hintergrundprozesses

UpDown

schrittweises Verändern von Einstellwerten

HotKey

für Tastenkürzel mit Kombinationen mit Strg, Umsch und Alt

Animate

Fenster zum tonlosen Anzeigen von AVI-Clips

DateTimePicker

Listenfeld zur Auswahl von Datum/Zeit aus einem Kalender

MonthCalendar

Kalender, in dem ein einzelner Monat dargestellt ist (neu!)

TreeView

hierarchische (baumartige) Liste von Elementen

ListView

Elementeliste, auf verschiedene Weise anzuzeigen

HeaderControl

größenveränderliche Darstellung eines Tabellenkopfes

161

3.4 Die Komponentenpalette

Name

Icon

Verwendungszweck

StatusBar

Statusleiste mit mehreren Panels (unterer Formularrand)

ToolBar

zum Anfertigen von Werkzeugleisten

CoolBar

Symbolleiste mit untergeordneten Steuerelementen, die selbstständig verschoben werden können

PageScroller

definiert einen Anzeigebereich für ein schmales Fenster (z.B. Symbolleiste)

ComboBoxEx

ComboBox mit erweiterter Funktionalität (Grafik)

3.4.4 System Dieses Sammelsurium von Dialogelementen greift mehr oder weniger direkt auf die WindowsSystemsteuerung zu. Name

Icon

Verwendungszweck

Timer

Bereitstellen eines Zeitintervalls

PaintBox

Zeichnen auf rechteckiger Fläche innerhalb des Formulars

MediaPlayer

Aufnahme bzw. Abspielen von Multimedia-Dateien

OLEContainer

Einbetten/Verknüpfen von OLE-Objekten

DDEClientConv

Einrichten einer Client-Verbindung zu einem DDE-Server

DDEClientItem

Festlegen der zu übertragenden Client-Daten

DDEServerConv

Einrichten einer Server-Verbindung zu einem DDE-Client

DDEServerItem

Festlegen der zu übertragenden Server-Daten

3.4.5 Datenzugriff Mit diesen (zur Laufzeit unsichtbaren) Komponenten wird der Zugriff auf verschiedenste Datenquellen vermittelt. Name

Icon

Verwendungszweck

DataSource

liefert die Schnittstelle zwischen einer Datenquelle und den Komponenten zur Datensteuerung (Bound Controls)

ClientDataSet

repräsentiert eine datenbankunabhängige Datenmenge im Arbeitsspeicher

DataSetProvider

stellt Daten aus einer Datenmenge bereit (Vermittler zwischen Remote-Datenbank-Server und Client-Datenmenge)

162

Kapitel 3

Entwicklungsumgebung

3.4.6 Datensteuerung Auch unter dem Begriff "Bound Controls" bekannt, lassen sich diese Komponenten mit Datenzugriffskomponenten verbinden, um verschiedenste Datenbankinhalte anzuzeigen. Name

Icon

Verwendungszweck

DBGrid

Darstellung einer Datenmenge im Tabellengitter

DBNavigator

zum Bewegen zwischen den Datensätzen, Einfügen und Löschen

DBText

datensensitive Anzeige eines Wertes

DBEdit

einzeiliges Eingabefeld zum datensensitiven Anzeigen und Bearbeiten

DBMemo

mehrzeiliges Eingabefeld zum datensensitiven Anzeigen und Bearbeiten

DBImage

datensensitive Anzeige einer BLOB-Grafik

DBListBox

datensensitives Listen- bzw. Kombinationsfeld zur Anzeige bzw. Auswahl

DBComboBox DBLookupListBox DBLookupComboBox

datensensitives Listen- bzw. Kombinationsfeld, mit dem Daten aus verknüpften Tabellen angezeigt und bearbeitet werden können

3.4.7 BDE Diese Komponenten dienen dem direkten Zugriff auf Ihre lokale Datenbasis (Borland Database Engine), wie sie im Allgemeinen bei jeder Delphi-Installation mit eingerichtet wird. Für die Beispiele unseres Buchs genügen zwei Komponenten: Name

Icon

Verwendungszweck

Table

zum direkten Zugriff auf eine Datenbanktabelle und ihre Felder

Query

zum SQL-basierten Zugriff auf bestimmte Datensätze

3.4.8 Rave Die Rave-Komponenten (als Nachfolger des in die Jahre gekommenen QuickReport) ermöglichen das Anfertigen repräsentativer Datenbankberichte. Mehr dazu im Kapitel 9.

163

3.4 Die Komponentenpalette

3.4.9 Dialoge Name

Icon

Verwendungszweck

OpenDialog

Dialogfenster Datei öffnen

SaveDialog

Dialogfenster Datei speichern

OpenPictureDialog

wie OpenDialog, aber mit Bereich für Grafikvorschau

SavePictureDialog

wie SaveDialog, aber mit Bereich für Grafikvorschau

FontDialog

Dialogfenster Zeichensätze

ColorDialog

Dialogfenster Farben

PrintDialog

Dialogfenster Drucken

PrinterSetupDialog

Dialogfenster Drucker einrichten

FindDialog

Dialogfenster Suchen

ReplaceDialog

Dialogfenster Ersetzen

3.4.10 Win3.1 Diese Relikte aus der alten Windows 3.1-Zeit passen nicht mehr so recht zum modernen Outfit der 32-Bit-Windows-Versionen, haben aber bis heute hartnäckig ihren angestammten Platz verteidigt. Bei Neuentwicklungen sollten Sie sich aber an den Komponenten der rechten Spalte orientieren. Win16 (alt) Symbol

Win32 (neu) Name

Symbol

Name

DBLookupList

DBLookupListBox

DBLookupCombo

DBLookupComboBox

TabSet

TabControl

Outline

TreeView

Header

HeaderControl

TabbedNotebook

PageControl

Notebook

PageControl

164

Kapitel 3

Win16 (alt) Symbol

Entwicklungsumgebung

Win32 (neu) Name

Symbol

FileListBox

Für die Dateiauswahl sollten Sie möglichst die OpenDialog- oder SaveDialog-Komponente (Seite "Dialoge") verwenden.

DirectoryListBox

Name

DriveComboBox Die Win 3.1-Komponenten werden lediglich aus Kompatibilitätsgründen noch mitgeführt und haben z.B. dann Bedeutung, wenn Sie ein von Ihnen unter Delphi 1.0 entworfenes Projekt unter Delphi 7 weiterentwickeln wollen.

3.4.11 Beispiele Diese Komponenten gehören nicht zum Delphi-Kernprodukt und sind deshalb auch nicht durchgehend in der Online-Hilfe dokumentiert, sie sollen Ihnen lediglich Anregungen für eigene Entwicklungen geben. Name

Icon

Verwendungszweck

Gauge

Fortschrittsanzeige als Balken-, Text- oder Tortendiagramm

ColorGrid

Gitter zur Farbenauswahl

SpinButton

Schalter zur schnellen Erhöhung bzw. Erniedrigung von Eingabewerten

SpinEdit

Kombination von Wipp-Regler und Editierfeld

DirectoryOutline

hierarchische Auflistung von Laufwerk- und Verzeichnisstruktur

IBEventAlerter

Alarmsimulation für Ereignisse

Calendar

einfacher Monatskalender in Gitterform

HINWEIS: Den Quellcode finden Sie im Verzeichnis \Delphi7\Source\Samples (eine Standard-

installation vorausgesetzt).

3.4.12 ActiveX Hier finden Sie einige Steuerelemente (OCXe), vor allem von Fremdanbietern, die dem universellen Microsoft ActiveX-Standard entsprechen. Solche Komponenten können Sie z.B. auch mit Visual Basic entwickeln.

165

3.5 Der Objektinspektor

3.4.13 Server Hier erwartet Sie eine unglaublich lange Liste aller möglichen Automationsserver, das sind meist ziemlich komplexe Anwendungsobjekte, die sich für die (OLE-)Automation eignen, also von Delphi aus aufgerufen und quasi "ferngesteuert" werden können. Ein kleiner Auszug soll genügen: Name

Icon

Verwendungszweck

WordApplication

Zugriff auf Microsoft Word

WordDocument

Aufruf eines Word-Dokuments

ExcelApplication

Zugriff auf Microsoft Excel

ExcelQueryTable

Aufruf einer Excel-Tabelle

AccessApplication

Zugriff auf Microsoft Access

AccessReport

Aufruf eines Access-Berichts

3.5 Der Objektinspektor Die prinzipielle Arbeitsweise mit dem Objektinspektor haben Sie in den Einführungsbeispielen bereits hinreichend kennen gelernt. Er besteht aus zwei Seiten, den "Eigenschaften" und den "Ereignissen". Im Objektselektor, das ist die oberste Zeile des Objektinspektors, erscheinen Name und Typ der gerade aktiven (angeklickten) Komponente bzw. des Formulars. Sie können aber auch mit der Rollbox des Objektselektors die gewünschte Auswahl treffen.

3.5.1 Eigenschaften-Seite Am Beispiel eines Anzeigefeldes (Label-Komponente) wollen wir uns den prinzipiellen Aufbau der Eigenschaftenseite verdeutlichen: In der linken Spalte finden Sie den Namen und in der rechten die Standardeinstellungen, die von Ihnen wahlweise verändert werden können. Meistens wird Ihnen dabei eine Auswahl von Werten angeboten, z.B. für alle möglichen Farbeinstellungen (Color). Manchmal müssen Sie aber auch direkt etwas eingeben, z.B. für die Beschriftung (Caption). HINWEIS: Im Objektinspektor sind nur die Eigenschaften zu sehen, die bereits zur Entwurfszeit

geändert werden können (siehe Online-Help). Auf weitere Eigenschaften ist der Zugriff nur zur Laufzeit (per Code) möglich. Das manchen Eigenschaften (z.B. Font) vorangestellte Plus (+) weist darauf hin, dass es sich hier genau genommen um einen Objekttyp handelt, der sich erst eine (oder auch mehrere) Ebene(n) tiefer in einzelne Eigenschaften aufsplitten lässt. Durch Doppelklick öffnen Sie diese "Sub-Properties".

166

Kapitel 3

Entwicklungsumgebung

3.5.2 Ereignisse-Seite Die zweite Registerseite des Objektinspektors zeigt die Events, auf welche dieses Objekt reagieren kann. Das OnClick-Ereignis tritt z.B. dann ein, wenn mit der Maus auf die Komponente geklickt wird. In der rechten Spalte wird nur dann etwas angeboten, wenn so genannte Ereignisbehandlungsmethoden (Event-Handler) zur Verfügung stehen. BEISPIEL: Dem OnClick-Ereignis von Button6 kann entweder einer der bereits vorhandenen Event-Handler

zugewiesen werden (siehe Abbildung), oder aber Sie erstellen im Quelltexteditor einen eigenen Event-Handler (siehe unten).

Den Rahmencode erstellt Delphi für Sie (durch Doppelklick in die noch leere Spalte oder nach direktem Doppelklick auf Button6):

3.6 Der Quelltexteditor

167

procedure TForm1.Button6Click(Sender: TObject); begin // Hier müssen Sie den Code des Event-Handlers einfügen! end;

3.5.3 Einstellungen Das äußere Erscheinungsbild des Objektinspektors (und viele andere Einstellungen der Entwicklungsumgebung) können Sie über das Menü Tools|Umgebungsoptionen... beeinflussen:

3.6 Der Quelltexteditor Dieses Fenster ist der eigentliche "Arbeitsplatz" des Delphi-Programmierers. Bereits im Kapitel 2 konnten Sie sich hier hinreichend "austoben", so dass nur noch einige wenige ergänzende Bemerkungen fällig sind.

3.6.1 Intellisense Delphi unterstützt Sie nach besten Kräften beim Schreiben Ihres Codes. So werden z.B. nach Eintippen eines Objektbezeichners alle für dieses Objekt überhaupt möglichen Eigenschaften und Methoden in einer PopUp-Klappbox zur Auswahl angeboten. Damit kommen Sie überhaupt nicht erst auf den Gedanken, etwas Fehlerhaftes oder Unsinniges einzugeben. Man bezeichnet deshalb dieses hilfreiche Feature auch als Intellisense.

168

Kapitel 3

Entwicklungsumgebung

BEISPIEL: Sie wollen die Caption-Eigenschaft von Label1 zuweisen.

Die Klappbox erscheint allerdings erst nach Eingabe des Punktes ("."), der in der OOP generell als Trennzeichen zwischen dem Namen des Objekts und seinen Eigenschaften bzw. Methoden dient (siehe Kapitel 6). Die Übernahme des ausgewählten Eintrags erfolgt durch Klick auf den Eintrag oder nach Betätigen der Enter-Taste.

3.6.2 Diagramm-Seite Hinter der "Code"-Seite des Quelltexteditors verbirgt sich die Seite "Diagramm", die vor allem in Verbindung mit dem Fenster "Objekt-Hierarchie" von Bedeutung ist. Mit einem kleinen grafischen Designer können Sie hier grundlegende Zusammenhänge zwischen den Objekten verdeutlichen und kommentieren. Zum Erstellen eines Diagramms ziehen Sie die Elemente aus der Objekt-Hierarchie in diese Registerkarte. BEISPIEL: Aus der in 3.7.2 erörterten Objekt-Hierarchie können Sie per Drag & Drop die folgende Dia-

grammdarstellung gewinnen:

3.7 Weitere Fenster

169

Wirklich nützlich erweist sich die "Diagramm"-Seite allerdings erst beim Programmieren von komplexeren Applikationen, wie vor allem Datenbankanwendungen (mit Datenmodulen etc.).

3.6.3 Einstellungen Über das Menü Tools|Editor-Optionen... bieten sich Ihnen vielfältige Möglichkeiten zum individuellen Einrichten Ihres Arbeitsplatzes:

3.7 Weitere Fenster Ohne den Anspruch auf Vollständigkeit auch nur annähernd erfüllen zu können, sollen hier zwei weitere wichtige Fenster kurz vorgestellt werden.

3.7.1 Projektverwaltung Diese "Schaltzentrale" Ihres Projekts sollte für Sie immer dann der Anlaufpunkt sein, wenn wieder einmal der Gesamtüberblick über die sich im Laufe der Programmentwicklung angesammelten zahlreichen Formulare, Datenmodule, Units usw. verloren gegangen ist. Geöffnet wird dieses wichtige Fenster über das Menü Ansicht|Projektverwaltung bzw. mit Strg+Alt+F11.

170

Kapitel 3

Entwicklungsumgebung

BEISPIEL: Eine Ansicht aus dem Praxisbeispiel 3.8.1:

3.7.2 Objekt-Hierarchie Dieses Fenster zeigt in einem Baumdiagramm die in einem Formular (oder Datenmodul oder Frame) platzierten Komponenten an. Dabei werden die logischen Beziehungen der Komponenten sowie die Eigenschaftsbeziehungen dargestellt. BEISPIEL: Ein Formular und seine Objekthierarchie (wenn Sie in der Objekthierarchie auf ein bestimmtes

Objekt (Edit1) klicken, wird es auf Form1 markiert)

Ist ein Knoten im Baumdiagramm mit einem roten Fragezeichen im gelben Kreis markiert, ist das Element nicht vollständig oder fehlerhaft definiert. BEISPIEL: Eine DataSource-Komponente, deren DataSet-Eigenschaft unbesetzt ist.

171

3.8 Praxisbeispiele

HINWEIS: Das lästige Andocken dieses Fensters an den Objektinspektor können Sie verhindern,

indem Sie über das Menü Tools|Umgebungsoptionen... auf der Seite "Präferenzen" das Autom. Andocken beim Ziehen deaktivieren.

3.8 Praxisbeispiele Obwohl wir in den folgenden Beispielen vor allem den Umgang mit der Entwicklungsumgebung trainieren wollen, werden dabei einige Sprachkenntnisse aus Kapitel 2 vorausgesetzt. Es wäre auch wünschenswert (nicht Bedingung), wenn Sie schon einmal einen neugierigen Blick in Kapitel 4 (Formulare und Komponenten) geworfen hätten.

3.8.1 Festlegen der Projekteinstellungen für Formulare Normalerweise besteht eine Applikation nicht nur aus einem, sondern aus mehreren Formularen. Welches von denen soll nun beim Programmstart angezeigt werden, wie werden die übrigen aufgerufen? Diese und andere Fragen lassen sich mit den "Projekteinstellungen" der Entwicklungsumgebung beantworten. Eine kleine Beispielapplikation (die bezüglich ihrer Funktionalität nicht ganz ernst zu nehmen ist) soll zeigen, um was es geht.

Oberfläche Wir brauchen vier Formulare (Form2 ... Form5), die von einem Hauptformular (Form1) aus aufgerufen werden sollen. Letzteres hat fünf Schaltflächen:

Die anderen Formulare fügen wir über Datei|Neu|Formular hinzu, sie erhalten jeweils eine Schaltfläche, damit ein "Zurück" zum Hauptformular möglich ist. Für den Zweck unseres Beispiels ist eine weitergehende Funktionalität der Unterformulare unwichtig, wir überlassen es aber Ihrer Fantasie, etwas Abwechslung in das triste Grau zu bringen. Wie wäre es z.B. mit Image-Komponenten,

172

Kapitel 3

Entwicklungsumgebung

deren Picture-Eigenschaft man mit Hilfe des Objektinspektors einer WMF- oder BMP-Datei zuweist? Nur als kleine Anregung ein Vorschlag für das zweite Formular:

HINWEIS: Vergessen Sie bitte nicht, die Stretch-Property der Image-Objekte auf True zu setzen,

sonst kann es sein, dass nur ein winziger Bildausschnitt angezeigt wird, so dass Sie zur Laufzeit überhaupt nichts sehen. AutoSize hingegen sollte auf seiner Standardeinstellung (False) bleiben.

Quelltext Im Quelltext von Unit1 gibt es für Sie nicht viel zu tun, denn jedes Formular kann mittels seiner Show-Methode zur Anzeige gebracht werden. procedure TForm1.BitBtn1Click(Sender: TObject); begin Form2.Show end; procedure TForm1.BitBtn2Click(Sender: TObject); begin Form3.Show end; procedure TForm1.BitBtn3Click(Sender: TObject); begin Form4.Show end; procedure TForm1.BitBtn4Click(Sender: TObject); begin Form5.Show end; procedure TForm1.BitBtn5Click(Sender: TObject); begin Close end;

Stellvertretend für die dann noch übrigen Formulare hier die Ereignisbehandlungsroutine für den "Zurück"-Button von Form2:

173

3.8 Praxisbeispiele

procedure TForm2.Button1Click(Sender: TObject); begin Close end;

Test Wir starten unsere Applikation (F9) und werden insgesamt viermal "zurückgepfiffen", z.B.:

Natürlich, unsere Unit1 hat ja noch keinerlei Kenntnis von den restlichen Form-Objekten, die von hier aus aufgerufen werden sollen! Also muss ihre uses-Klausel um die Namen von Unit2 bis Unit5 ergänzt werden, was Delphi dankenswerterweise für uns erledigt (wenn wir auf "Ja" klicken). Der zweite Startversuch sollte dann aber klappen. Verfolgen wir gemeinsam die verschiedenen "Entwicklungsphasen" eines geplagten "Autors", und leiden wir mit ihm!

Das Hauptformular erscheint nicht nur beim Start als Erstes, sondern wartet auch noch ganz am Schluss mit einer wichtigen Besonderheit auf: HINWEIS: Beenden Sie das Hauptformular, so werden automatisch auch alle Unterformulare ge-

schlossen.

Ein Blick in die Projektoptionen Halt, trotz aller Freude über die ach soooo spaßigen Bildchen, wir sind noch nicht fertig! Erst jetzt können wir uns dem eigentlichen Problem, den Projektoptionen, zuwenden.

174

Kapitel 3

Entwicklungsumgebung

Wir haben es bis jetzt als selbstverständlich angenommen, dass bei Programmstart Form1 erschienen ist. Dabei hat uns aber der Zufall geholfen, denn das Startformular ist gleichzeitig auch das Hauptformular. Ein Blick in das Dialogfenster "Projektoptionen" (Menü Projekt|Optionen...) belehrt uns, dass das durchaus nicht selbstverständlich ist, denn auch jedes andere Formular kann durch Verändern der Combobox-Einstellung in die Rolle des Hauptformulars schlüpfen:

Alle Formulare der linken Liste werden automatisch dem Startcode der Projektdatei hinzugefügt und zur Laufzeit erstellt. Wir wollen diese Aussage überprüfen und wählen dazu das Menü Ansicht|Units.... Es erscheint nicht nur die Liste aller Units, sondern (ganz oben) auch der Name der Projektdatei:

HINWEIS: An der Projektdatei sollte man lieber nicht herumdoktern!

Aber anschauen darf man sich die Projektdatei allemal. Hier der Quelltext von Project1.dpr, wie ihn Delphi automatisch erstellt hat:

175

3.8 Praxisbeispiele

program Project1; uses Forms, Unit1 in 'Unit1.pas' Unit2 in 'Unit2.pas' Unit3 in 'Unit3.pas' Unit4 in 'Unit4.pas' Unit5 in 'Unit5.pas'

{Form1}, {Form2}, {Form3}, {Form4}, {Form5};

{$R *.RES} begin Application.Initialize; Application.CreateForm(TForm1, Form1); Application.CreateForm(TForm2, Form2); Application.CreateForm(TForm3, Form3); Application.CreateForm(TForm4, Form4); Application.CreateForm(TForm5, Form5); Application.Run; end.

Die Methode CreateForm erzeugt ein neues Formular des TForm-Typs, der durch den ersten Parameter angegeben wird, und weist es der Form-Objektvariablen zu, die durch den zweiten Parameter definiert ist. Besitzer (Owner) des neuen Formulars ist, wie könnte es anders sein, das Application-Objekt. Das Hauptformular wird durch den ersten Aufruf von CreateForm erzeugt. Bitte widerstehen Sie aber der Verlockung, diese Regel zu durchbrechen und an den Quelltext der Projektdatei Hand anzulegen, überlassen Sie das besser Delphi. HINWEIS: Wenn Sie eine Projektdatei manuell bearbeiten, umgehen Sie Delphis automatisierten

Projektverwaltungsmechanismus und riskieren Compilierfehler und andere Probleme. Nehmen Sie deshalb Manipulationen lieber im Dialogfenster "Projektoptionen" (siehe obige Abbildung) vor. Wenn Sie dort die "Hauptformular"-Einstellung ändern (z.B. Form2), erscheint Form2 als Erstes im linken Listenfeld "Automatisch erzeugen". Sie können die Reihenfolge ändern, indem Sie Formulare an neue Positionen ziehen und ablegen. Die Reihenfolge der entsprechenden FormCreate-Methoden in der Projektdatei passt sich automatisch an.

Was hat es mit den "verfügbaren Formularen" auf sich? Diese im rechten Listenfeld des Dialogfensters "Projektoptionen" aufgeführten Formulare werden zwar im Projekt verwendet, aber nicht automatisch erstellt. Wir wollen auch das überprüfen und verwenden die Schaltflächen mit den Pfeilen, um Form2 bis Form5 vom linken in das rechte Listenfeld zu verschieben. Ein anschließender Blick in die Projektdatei zeigt, dass nur noch das Hauptformular generiert wird:

176

Kapitel 3

Entwicklungsumgebung

begin Application.Initialize; Application.CreateForm(TForm1, Form1); Application.Run; end.

Der Programmtest (F9) scheint zunächst keinen Argwohn zu erregen, denn das Hauptformular erscheint prompt – so als wäre nichts gewesen. Das Desaster folgt erst dann, wenn Sie versuchen, ein Unterformular aufzurufen:

Die Ursache dieser "fachchinesischen" Fehlermeldung dürfte klar sein: Von Form2 bis Form5 wurden keine Instanzen gebildet (siehe Projektdatei), also greifen die vier Form.Show-Methoden ins Leere. Wir können uns behelfen, indem wir alle vier Event-Handler von Unit1 so ergänzen, wie es hier exemplarisch für den Aufruf von Form2 gezeigt wird: procedure TForm1.BitBtn1Click(Sender: TObject); begin Application.CreateForm(TForm2, Form2); Form2.Show end;

Einen neckischen Nebeneffekt, der manchmal sogar erwünscht sein kann, hat diese Sache allerdings. Es lassen sich auch mehrere Instanzen des gleichen Unterformulars erzeugen:

177

3.8 Praxisbeispiele

Als Einsteiger sollte man aber vorerst von derartigen Manipulationen die Finger lassen und das Erzeugen von Formularinstanzen lieber (wie oben beschrieben) indirekt, d.h. im Dialogfenster "Projektoptionen", vornehmen. Wie Sie die lose herumflatternden Fensterchen in eine standesgemäße MDI-Applikation einbinden, erfahren Sie im folgenden Praxisbeispiel.

3.8.2 Eine MDI-Applikation erstellen Dieses Beispiel soll eine sinnvolle Weiterentwicklung des Vorgängerbeispiels sein. Die dort noch lose herumflatternden Fenster können nicht als der Weisheit letzter Schluss angesehen werden. Der erfahrene Windows-Programmierer bringt mit einer MDI-Applikation Ordnung in das Chaos. Sie lernen unter anderem auch, wie schnell man mit Delphi eine Menüleiste erstellen kann. Gehen Sie in folgenden Schritten vor, um das vorhandene Projekt in eine standesgemäße MDI-Anwendung zu verwandeln:

1. Anpassen der Oberfläche von Form1 Ändern Sie die FormStyle-Property des Hauptformulars (Form1) in fsMDIForm. Entfernen Sie alle Buttons von der Oberfläche, denn wir wollen die Unterformulare, so wie es sich gehört, über ein Menü aufrufen. Fügen Sie deshalb eine MainMenu-Komponente (Seite "Standard" der Komponentenpalette) hinzu. Nach einem Doppelklick auf die Menükomponente öffnet sich der Menüeditor, und im Handumdrehen ist das Menü erstellt. Wie Sie der Tabelle entnehmen, haben wir teilweise die Name-Eigenschaften der einzelnen Menüobjekte gekürzt. Das Menü sollte z.B. folgende Struktur haben: 1. Ebene

2. Ebene

Name

Datei

Beenden

Beenden

Ansicht

Wehe, man weiß mal etwas nicht!

Wehe

Das hochnotpeinliche Verhör!

Peinlich

Die Auswirkungen sind katastrophal!

Auswirkung

Das aber kann die Lösung nicht sein!

Loesung

Nebeneinander

Nebeneinander

Fenster

Überlappend

Ueberlappend

Symbole anordnen

Symboleanordnen

Das Menü können Sie bereits zur Entwurfszeit aufklappen:

178

Kapitel 3

Entwicklungsumgebung

2. Anpassen des Quellcodes von Form1 Hier der komplett überarbeitete implementation-Abschnitt von Unit1: uses Unit2, Unit3, Unit4,Unit5;

Beginnen Sie mit den OnClick-Event-Handlern der vier Einträge des Ansicht-Menüs. HINWEIS: Wenn Sie (zur Entwurfszeit) auf einen Menüeintrag klicken, erscheint sofort der

Rahmencode des entsprechenden Event-Handlers! procedure TForm1.WeheClick(Sender: TObject); begin TForm2.Create(Self) end;

// Wehe, man weiß ....

procedure TForm1.PeinlichClick(Sender: TObject); // Das hochnotpeinliche ... begin TForm3.Create(Self) end; procedure TForm1.LoesungClick(Sender: TObject); begin TForm5.Create(Self) end;

// Die Auswirkungen sind ...

procedure TForm1.AuswirkungClick(Sender: TObject); // Das aber kann die ... begin TForm4.Create(Self) end;

Wie Sie gesehen haben, werden die einzelnen Unterformulare nicht wie bisher mit Form2.Show, Form3.Show usw. aufgerufen, sondern sie werden erst zur Laufzeit erzeugt. Der Owner ist Form1, das MDI-Hauptfenster (anstatt Self kann als Argument des Create-Konstruktors auch Form1 eingesetzt werden). Das allerdings setzt voraus, dass Form2 ... Form5 zu Programmbeginn nicht automatisch erstellt werden dürfen. Nur das Hauptformular genießt dieses Privileg! Ändern Sie also über Projekt|Optionen... die Projekteinstellungen wie folgt:

179

3.8 Praxisbeispiele

Als Nächstes widmen Sie sich den Event-Handlern der Fenster-Menüeinträge. HINWEIS: Tile, Cascade und ArrangeIcons sind Methoden des MDI-Hauptfensters! procedure TForm1.NebeneinanderClick(Sender: TObject); // Nebeneinander begin Tile end; procedure TForm1.UeberlappendClick(Sender: TObject); begin Cascade end;

// Überlappend

procedure TForm1.SymboleanordnenClick(Sender: TObject); // Als Symbole ... begin ArrangeIcons end;

Schließlich bleibt noch das Datei-Menü: procedure TForm1.BeendenClick(Sender: TObject); begin Close end;

// Beenden

3. Anpassen von Form2 bis Form5 Den anderen Formularen müssen Sie begreiflich machen, dass sie nunmehr zu MDI-Kindfenstern "versklavt" werden. Setzen Sie deshalb deren FormStyle-Eigenschaft auf fsMDIChild. Das war es dann auch schon – doch halt! Noch eine winzige Ergänzung im Quellcode ist vorzunehmen, d.h., ein Event-Handler für das OnClose-Ereignis ist für jedes Kindfenster wie folgt zu ergänzen: procedure TForm2.FormClose(Sender: TObject; var Action: TCloseAction); begin

180

Kapitel 3

Entwicklungsumgebung

Action := caFree end;

Wenn Sie diesen Event-Handler vergessen, funktioniert Ihre MDI-Applikation zwar auch, die Kindfenster lassen sich aber nicht entfernen (sie schrumpfen lediglich auf Symbolgröße zusammen und fristen ein kümmerliches Dasein am unteren Rand des Mutterfensters).

Test Nach Programmstart erscheint zunächst nur das leere Rahmenfenster. Fügen Sie nun über das Ansicht-Menü nach Belieben Kindfenster hinzu und ordnen Sie diese über das Fenster-Menü auf verschiedene Weise an.

3.8.3 Einen Taschenrechner entwerfen Demonstriert wird ein funktionsfähiger "Taschenrechner", der bezüglich seiner Features zwar noch einige Wünsche offen lässt, dafür aber ein ideales Übungsfeld für den fortgeschrittenen Einsteiger ist.

Oberfläche Eröffnen Sie ein neues Projekt und bestücken Sie das Startformular (Form1) wie folgt:

181

3.8 Praxisbeispiele

Button17 Label1 Button12 Button7 Button13 Button1

Button14

Button10

Button15

Button11

Button18

Button16

Ändern Sie im Objektinspektor die folgenden Eigenschaften: Name des Objekts

Eigenschaft

neuer Wert

Form1

Caption

'Taschenrechner'

BorderStyle

bsSingle

Caption

'0.0'

Alignment

taRightJustify

AutoSize

False

Color

clYellow

Font.Size

12

Caption

'0', '1', ... '+','=', 'Aus'

Label1

Button1... Button18

Quellcode War das "Zusammenschieben" der Oberfläche noch ziemlich einfach, so stellt die Programmierung doch schon höhere Anforderungen an Ihr logisches Denkvermögen. Wir beschränken uns (wie fast immer) auf die Wiedergabe des implementation-Abschnitts von Form1. Zu Beginn müssen wir uns Gedanken über die auf Modulebene benötigten Variablen machen. Zumindest werden drei benötigt: zwei für die beiden Operanden und eine für den Typ der Operation: var strBuff1, strBuff2: string; op: Char;

// Operandenspeicher // Operation (+,-,*,/)

Damit unser Programm "weiß", welchen der beiden Operanden Sie gerade eingeben, wird eine so genannte "Zustandsvariable" mode eingeführt, sie hat den Wert 1 oder 2. mode: Byte = 1;

// 1 = ersten Operand eingeben (Startwert) // 2 = zweiten Operand eingeben

182

Kapitel 3

Entwicklungsumgebung

Beginnen wir mit dem einfachsten Problem, dem Löschen der Anzeige: procedure TForm1.Button17Click(Sender: TObject); // Anzeige löschen begin StrBuff1 := ''; StrBuff2 := ''; Label1.Caption := ''; mode:=1 end;

Allen Schaltflächen des Ziffernblocks (Button1 bis Button11) wird mit Hilfe des Objektinspektors ein gemeinsamer Event-Handler für das OnClick-Ereignis zugewiesen (wer die Vorgehensweise nicht kennt, sollte sich das Einführungsbeispiel 1.3.2 nochmals genauer anschauen). Der EventHandler wird bei jeder Eingabe eines Zeichens aufgerufen, d.h. mehrmals pro Operand: procedure TForm1.ZeiButtonClick(Sender: TObject); // zeichenweise Zahleneingabe var zei: Char; // eingegebenes Zeichen begin if Sender = Button10 then zei := '0'; if Sender = Button1 then zei := '1'; if Sender = Button2 then zei := '2'; if Sender = Button3 then zei := '3'; if Sender = Button4 then zei := '4'; if Sender = Button5 then zei := '5'; if Sender = Button6 then zei := '6'; if Sender = Button7 then zei := '7'; if Sender = Button8 then zei := '8'; if Sender = Button9 then zei := '9'; if Sender = Button11 then zei := '.'; if mode = 1 then begin // erste Zahl wird eingegeben strBuff1 := strBuff1 + zei; Label1.Caption := strBuff1 end else begin // zweite Zahl wird eingegeben strBuff2 := strBuff2 + zei; Label1.Caption := strBuff1 + ' ' + op + ' ' + strBuff2 end end;

Erst nach Klick auf eine der vier Operationstasten ist die Eingabe des ersten Operanden abgeschlossen, und die Variable op erhält das Zeichen der Operation. Die Zustandsvariable mod wechselt auf den Wert 2, und es beginnt die Eingabe des zweiten Operanden. Auch hier weisen Sie dem OnClick-Ereignis der vier Schaltflächen einen gemeinsamen Event-Handler zu: procedure TForm1.OpButtonClick(Sender: begin if mode = 1 then begin if Sender = Button14 then op:= '+'; if Sender = Button12 then op:= '*'; StrBuff2:=''; Label1.Caption := Label1.Caption + ' mode := 2 end end;

TObject);

// Operation auswählen

if Sender = Button15 then op:= '-'; if Sender = Button13 then op:= '/'; ' + op;

Nach Klicken der Ergebnistaste (=) soll Folgendes passieren: procedure TForm1.IstButtonClick(Sender: TObject); var res, op1, op2: Double;

// Ergebnis berechnen

183

3.8 Praxisbeispiele

code : Integer; s: string; begin if mode = 2 then begin Val(strBuff1, op1, code); Val(strBuff2, op2, code); case op of '+': res:= op1 + op2; '-': res := op1 - op2; '*': res := op1 * op2; '/': res := op1 / op2 end; s:= Format('%g',[res]); Label1.Caption := s; mode := 1; strBuff1 := '' end end;

// strBuff1 in Zahl op1 rückverwandeln // strBuff2 in Zahl op2 rückverwandeln // Operation durchführen

// Ergebnis als Gleitkommazahl formatieren // ... und anzeigen // zurück zum Anfangszustand (Eingabe des ersten Operanden)

Auch das "Ausschalten" 1 des Rechners sollte funktionieren: procedure TForm1.Button18Click(Sender: TObject); // Rechner ausschalten begin Close end;

Test Speichern Sie Ihr Projekt in einem vorher angelegten Verzeichnis (Ordner) ab. Klicken Sie dazu die Schaltfläche bzw. benutzen Sie das Menü Datei|Projekt speichern unter... Klicken Sie nun auf den Button in der Werkzeugleiste (oder F9-Taste) und überzeugen Sie sich von der Funktionsfähigkeit unseres "Superhirns":

1

Man sollte wohl besser von einem "Zerstören" des Rechners sprechen, denn mit dem Ausschalten endet die Lebensdauer des Programms (es verschwindet aus dem Hauptspeicher).

184

Kapitel 3

Entwicklungsumgebung

Da wir auf eine Fehlerbehandlung verzichtet haben, reagiert Delphi bei einer Division durch Null ziemlich hysterisch:

Im Quellcodefenster hat Delphi freundlicherweise die betreffende Anweisung markiert:

Verbesserungsvorschläge Die folgende "Meckerliste" können Sie durchaus als konstruktive Anregung für eigene Verbesserungen verstehen: ■ Schönheitsfehler: In der Ergebnisanzeige erscheint ein Dezimalkomma anstatt eines Dezimalpunktes. ■ Eine Vorzeichenumkehr ist noch nicht vorgesehen. ■ Es können nur zwei, nicht mehrere Operanden miteinander verknüpft werden, auch eine Klammerrechnung ist nicht möglich. ■ Es wäre auch schön, wenn wir die Zahlen nicht nur per Mausklick, sondern auch direkt über die Tastatur eingeben könnten.

4

Formulare und Komponenten

Kapitel

4

Formulare und Komponenten Ziel des Kapitels ist es, dem Einsteiger mit einem Minimum an Aufwand und Vorkenntnissen den Weg zur vorrangig visuell geprägten Windows-Anwendungsprogrammierung auf Basis von Formularen und Standardkomponenten zu ebnen. Für den notwendigen Tiefgang durch Verlagerung des Schwerpunktes auf die objektorientierte Programmierung sorgt erst das OOP-Kapitel 6. HINWEIS: Da dieses Buch keine vollständige Referenz bereitstellt, diese Rolle kann die inte-

grierte Online-Hilfe viel effektiver übernehmen1, werden im vorliegenden Kapitel nur die aus der Sicht des Praktikers wichtigsten Eigenschaften, Ereignisse und Methoden in Form von Übersichten und kurzen Kommentaren bzw. knappen Beispielen zusammengestellt. Umfangreichere Demoprogramme finden Sie im abschließenden Praxisteil, der Sie auch zu eigenen Experimenten anregen soll.

4.1 Allgemeines über Steuerelemente Die wichtigsten sichtbaren Objekte, mit denen wir es beim visuellen Entwurf der Bedienoberfläche zu tun haben, sind Steuerelemente, d.h. Formulare und Komponenten, wie z.B. Button, Edit, Label etc. Bekanntlich verfügen diese Objekte über Eigenschaften (Properties), Methoden (Methods) sowie über Ereignisse (Events), auf die sie reagieren können (siehe Kapitel 1, Einführung).

4.1.1 Standardeigenschaften Eigenschaften (Properties) können Sie zur Entwurfszeit (über die Eigenschaften-Seite des Objektinspektors) oder zur Laufzeit per Programmcode setzen. Es gibt eine Vielzahl von Properties, über die (fast) alle Komponenten verfügen und die deshalb nur einmal erklärt werden müssen:

1

Auf das entsprechende Steuerelement klicken und dann die F1-Taste betätigen.

186

Kapitel 4

Formulare und Komponenten

Eigenschaft Datentyp

Erklärung

Default

Align

TAlign

... legt fest, wie Komponente gegenüber ihrem Container ausgerichtet werden soll: alNone, alTop, alBottom, alLeft, alRight, alClient

alNone

Anchors

TAnchors

... bestimmt, wie Komponente im Container verankert ist, wenn sich dessen Größe ändert: akLeft, akTop, akRight, akBottom

[akLeft, akTop]

Caption

String

... beinhaltet die Beschriftung der Komponente Name

Color

TColor

... legt Farbe bzw. Hintergrundfarbe (Formular) unterschiedlich fest, z.B. clBlack, clGreen, clRed, clBtnFace

Ctl3D

Boolean

... legt 2-D- oder 3-D-Ansicht fest

True

Cursor

TCursor

... bestimmt das Aussehen des Mauszeigers im Bereich der Komponente

crDefault

DockSite

Boolean

... kann Komponente Ziel von Drag & DockOperationen sein?

False

DragCursor

TCursor

... bestimmt Mauszeigerform über Komponente crDrag bei Drag & Drop

DragKind

TDragKind

... bestimmt, ob Komponente normal gezogen oder zwecks Andocken verschoben wird:dkDrag oder dkDock

dkDrag

DragMode

TDragMode

... bestimmt Verhalten bei Drag & Drop: cmManual oder cmAutomatic

cmManual

Enabled

Boolean

... legt fest, ob Komponente auf BenutzereinTrue gaben (Tastatur- bzw. Mausereignisse) reagiert

+Font

TFont

... ist das Schriftartobjekt mit den Eigenschaften Color, Height, Name, Pitch, Size und +Style

System,10dpi, ...

Height

Integer

... Gesamthöhe bzw. -breite der Komponente (in Pixeleinheiten)

bei Entwurf festgelegt

Width HelpContext

THelpContext ... Kontextnummer für Aufruf einer Hilfeseite aus der Help-Datei (F1-Taste)

Null (0)

Hint

String

Hilfetext (gelbes Schildchen)

leer

ShowHint

Boolean

... soll angezeigt werden?

False

Left

Integer

... linker bzw. oberer Randabstand (in Pixeleinheiten)

bei Entwurf festgelegt

Top Name

TComponent- ... ist die wichtigste Eigenschaft (ein Namen Name muss eindeutig sein, niemals doppelt vergeben!)

PopUpMenu

TPopupMenu ... legt Namen des PopUp-Menüs fest (RMT)

in Entwurfsreihenfolge

187

4.1 Allgemeines über Steuerelemente

Eigenschaft Datentyp

Erklärung

Default

TabOrder TabStop

TTabOrder Boolean

... bestimmt Tabulatorreihenfolge bzw. ob überhaupt angehalten wird

Null (0) True

Tag

LongInteger

... speichert für diverse Zwecke eine Zahl

Null (0)

Visible

Boolean

... ist Komponente sichtbar oder unsichtbar?

True

Einfache Objekteigenschaften BEISPIEL: Die folgenden beiden Anweisungen sorgen für das Erscheinen eines kleinen gelben Hinweisschild-

chens mit der Aufschrift "Beenden", wenn Sie mit der Maus auf die Schaltfläche Button1 zeigen. Button1.Hint := 'Beenden'; Button1.ShowHint := True;

Es ist müßig, hier weitere Beispiele zu bringen, denn Demonstrationen zu (fast) allen Standardeigenschaften finden Sie in vielfältigster Form in den Quelltexten dieses Buchs. Einige Eigenschaften werden im Zusammenhang mit den zugehörigen Ereignissen erklärt, so z.B. DockSite, DragCursor, DragKind im Zusammenhang mit Drag&Drop- bzw. Drag&Dock-Operationen.

Komplexe Objekteigenschaften Das im Objektinspektor manchen Eigenschaften (z.B. Font) vorangestellte Kreuzchen (+) verweist darauf, dass es sich hier genauer genommen um ein Objekt handelt, das sich in weitere Eigenschaften (z.B. Color, Height) bzw. Objekte (Style) aufsplitten lässt:

188

Kapitel 4

Formulare und Komponenten

BEISPIEL: Anstatt der direkten Zuweisung im Objektinspektor (siehe obige Abbildung) könnten die Font-

Eigenschaften einer PaintBox auch per Quellcode festgelegt werden. PaintBox1.Font.Size := 8;

weist der Schrift innerhalb der Paintbox die Größe 8 zu. Paintbox1.Font.Style := [fsbold];

wählt das Schriftattribut fett aus.

4.1.2 Standardereignisse Auf der Ereignisse-Seite des Objektinspektors finden Sie eine Auflistung der für die betreffende Komponente auswertbaren Events. Wir wollen uns hier nur auf die Standardereignisse beschränken, die für die meisten Komponenten gleichermaßen zutreffen:

Mausereignisse (Überblick) Wenn sich der Mauscursor über einer Komponente befindet, können für dieses Objekt die folgenden Mausaktivitäten ausgewertet werden: Ereignis

... tritt ein wenn

OnClick

... auf die Komponente geklickt wird.

OnDblClick

... auf die Komponente doppelt geklickt wird.

OnMouseDown

... eine Maustaste niedergedrückt wird.

OnMouseUp

... eine Maustaste losgelassen wird.

OnMouseMove

... die Maus bewegt wird.

OnClick und OnDblClick In der Kopfzeile wird nur der Sender-Parameter übermittelt: SYNTAX:

procedure TForm1.FormClick(Sender: TObject);

Beachten Sie, dass jeder Doppelklick leider auch ein "normales" Klickereignis auslöst. Man sollte deshalb überlegt zu Werke gehen, wenn (was nicht empfohlen wird) für ein Objekt beide Events gleichzeitig besetzt werden.

OnMouseDown und OnMouseUp Hier ist die Parameterliste wesentlich länger: SYNTAX:

procedure FormMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);

Shift

→ Status beim Eintreffen des Ereignisses

189

4.1 Allgemeines über Steuerelemente

Button

→ Taste, die Ereignis verursacht hat

X, Y

→ Mauskoordinaten

Hier die möglichen Werte von Shift und Button: Shift

Button

Bedeutung

ssLeft

mbLeft

linke Maustaste gedrückt

ssMiddle

mbMiddle

mittlere Maustaste gedrückt

ssRight

mbRight

rechte Maustaste gedrückt

BEISPIEL: Beim Niederdrücken der rechten Maustaste über dem Formular wird ein Piepton erzeugt: procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin if Shift = [ssRight] then MessageBeep(0) end;

Das gleiche Ergebnis liefert aber auch: procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin if Button = mbRight then MessageBeep(0) end;

wodurch natürlich die Frage nach dem Sinn des Button-Parameters aufkommt.

OnMouseMove ... tritt im Unterschied zu den anderen Mausereignissen auch dann ein, wenn keine Maustaste gedrückt ist: SYNTAX:

procedure TForm1.FormMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);

Im Unterschied zu OnMouseUp/OnMouseDown fehlt der Button-Parameter. Die Bedeutung der übrigen Parameter ist die gleiche. BEISPIEL: Beim Bewegen der Maus über das Formular werden die Mauskoordinaten in einem Label ange-

zeigt. procedure TForm1.FormMouseMove(Sender: TObject; Shift: TShiftState; X,Y: Integer); begin Label1.Caption := IntToStr(x) + ' ' + IntToStr(y) end;

190

Kapitel 4

Formulare und Komponenten

Tastaturereignisse (Überblick) Wenn eine Komponente den Fokus hat, lassen sich für dieses Objekt folgende Keyboard-Events auswerten: Ereignis

... tritt ein, wenn

OnKeyPress

... eine Taste gedrückt wird.

OnKeyDown

... die Taste nach unten bewegt wird (mit Tastaturintervall).

OnKeyUp

... eine Taste losgelassen wird.

OnKeyPress Neben dem obligatorischen Sender-Parameter wird auch das Zeichen der Taste übermittelt: SYNTAX:

procedure TForm1.FormKeyPress(Sender: TObject; var Key: Char);

Der Parameter Key ist vom Typ Char, deshalb registriert OnKeyPress das ASCII-Zeichen der gedrückten Taste. Tasten ohne ASCII-Zeichen (z.B. Shift oder F10) erzeugen kein OnKeyPressEreignis, Tastenkombinationen (wie z.B. Shift+A) nur dann, wenn die Feststelltaste ausgeschaltet ist. Zum Auswerten von Nicht-ASCII-Tasten (oder Tastenkombinationen) muss man die Ereignisbehandlungsroutinen OnKeyDown oder OnKeyUp verwenden. BEISPIEL: In das Editierfeld können nur Ziffern eingegeben werden. procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char); begin if not (Key in ['0'..'9']) then Key := #0 end;

OnKeyDown und OnKeyUp Diese Ereignisse übergeben eine grundsätzlich andere Parameterliste als OnKeyPress: procedure TForm1.Edit1KeyUp(Sender:TObject; var Key:Word; Shift:TShiftState);

OnKeyDown und OnKeyUp können auf alle Tasten der Tastatur (einschließlich Funktionstasten und Tastenkombinationen mit den Tasten Umschalt, Alt und Strg) reagieren. Da der Parameter Key vom Typ Word ist, müssen aber die virtuellen Tastaturcodes aus der Windows-Unit (siehe Anhang) verwendet werden. BEISPIEL: Beim Loslassen der Strg-Taste innerhalb eines Editierfeldes wird ein Piepton erzeugt: procedure TForm1.Edit1KeyUp(Sender:TObject; var Key:Word;Shift:TShiftState); begin if Key = VK_CONTROL then MessageBeep(0) end;

Wenn Sie auch auf "normale" Tasten reagieren wollen, müssen Sie den ASCII-Code mittels der Ord-Funktion umwandeln.

191

4.1 Allgemeines über Steuerelemente

BEISPIEL: Die Eingabe von 'a' oder 'A' wird beim Niederdrücken angezeigt. procedure TForm1.Edit1KeyDown(Sender: TObject; var Key: Word; Shift: TShiftState); begin Panel1.Caption := ''; if Key = Ord('A') then Panel1.Caption := 'Taste A wurde gedrückt!' end;

Auswerten von Tastenkombinationen ... ist nur innerhalb eines OnKeyDown- bzw. OnKeyUp-Event-Handlers möglich (also nicht bei OnKeyPress!). Zur Ermittlung des Status von Alt, Strg und Shift dienen folgende Werte des Typs TShiftState: Wert

Bedeutung

ssShift

Umschalttaste gleichzeitig gedrückt

ssCtrl

Strg-Taste gleichzeitig gedrückt

ssAlt

Alt-Taste gleichzeitig gedrückt

BEISPIEL: Erzeugt einen Piepton, wenn der Anwender Strg+F8 drückt. procedure TForm1.FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState); begin if ((Shift = [ssCtrl]) and (Key = VK_F8)) then MessageBeep(0) end;

Leider klappt das Zusammenspiel von Tastatur und Maustasten nur, wenn Sie Umschalt-Tasten (Shift, Alt, ...) verwenden. BEISPIEL: Man würde nach Änderung des obigen Beispiels in if ((Shift = [ssLeft]) and (Key = VK_F8)) then MessageBeep(0)

erwarten, dass die F8-Taste gemeinsam mit der linken Maustaste den gewünschten Ton produziert. Fehlanzeige, denn es passiert ... nichts, da F8 eine flankengesteuerte Taste ist!

KeyPreview ... ist eigentlich hier fehl am Platz, denn es handelt sich nicht um ein Ereignis, sondern um eine Formulareigenschaft, die Sie auch im Objektinspektor zuweisen könnten. KeyPreview steht aber im engen Zusammenhang mit den Tastaturereignissen und soll deshalb bereits an dieser Stelle besprochen werden. Hat KeyPreview den Wert True, so gehen, unabhängig vom aktiven Steuerelement, die Tastaturereignisse OnKeyDown, OnKeyUp und OnKeyPress zuerst an das Formular. Hier können gewisse Vorentscheidungen gefällt werden. Erst danach wird das Tastaturereignis an das Steuerelement weitergereicht. Wenn KeyPreview den Wert False hat (Voreinstellung), werden die Ereignisse sofort zum Steuerelement weitergegeben.

192

Kapitel 4

Formulare und Komponenten

BEISPIEL: Platzieren Sie ein Label, ein Editierfeld und eine CheckBox auf dem Formular. Werten Sie das

OnKeyUp-Event des Formulars wie folgt aus: procedure TForm1.FormKeyUp(Sender: TObject; var Key: Word; Shift: TShiftState); begin Label1.Caption := Label1.Caption + Chr(Key) end;

Mit der CheckBox ändern Sie die KeyPreview-Eigenschaft des Formulars: procedure TForm1.CheckBox1Click(Sender: TObject); begin if CheckBox1.Checked then KeyPreview := True else KeyPreview := False end;

Bei aktiviertem Kästchen geben Sie in das Editierfeld etwas ein, und Sie werden feststellen, dass die Eingaben zunächst zum Formular umgeleitet werden und dort im Label erscheinen. Wenn der Fokus außerhalb des Editierfeldes ist, können Sie auch direkt in das Label schreiben.

HINWEIS: Eine Ausnahme bilden die Bewegungstasten (Tab, Cursortasten, ...). Nur wenn das

aktive Steuerelement derartige Tasten zulässt, können Sie diese mit KeyPreview bereits auf Formularebene abfangen.

Weitere Ereignisse Die folgenden Events finden sich ebenfalls bei einer Vielzahl von Objekten: Ereignis

... tritt ein, wenn

OnChange

... Eigenschaften der Komponente geändert werden.

OnEnter

... Komponente den Fokus erhält.

OnExit

... Komponente den Fokus verliert.

OnStartDrag

... wenn Benutzer beginnt, die Komponente oder ein darin befindliches Objekt mit der linken Maustaste zu ziehen.

OnDragDrop

... Objekt über der Komponente abgelegt wird.

OnDragOver

... Objekt über die Komponente gezogen wird.

4.1 Allgemeines über Steuerelemente

193

Ereignis

... tritt ein, wenn

OnEndDrag

... Drag & Drop beendet ist.

OnStartDock

... das Andocken der Komponente unmittelbar bevorsteht.

OnDockOver

... Objekt über Komponente gezogen wird (Parameter Accept gibt an, ob das untergeordnete Objekt angedockt werden kann).

OnDockDrop

... andockbares Objekt über Ziel abgelegt wird.

OnUnDock

... angedocktes Objekt getrennt wird.

OnGetSiteInfo

... OnDockDrop bevorsteht und informiert, wo Objekt angedockt werden kann.

OnEndDock

... Drag & Dock beendet ist.

Es gibt zahlreiche Ereignisse, die im Zusammenhang mit dem Andocken von Steuerelementen ausgelöst werden. Wer sich mit der herkömmlichen Drag & Drop-Technik gut auskennt, wird auch Drag & Dock leicht verstehen, da es hier analog zugeht. OnStartDock entspricht z.B. dem Ereignis OnStartDrag einer Drag & Drop-Operation. Die DragKind-Eigenschaft entscheidet darüber, ob das Steuerelement auf klassische Weise gezogen wird (dkDrag) oder zum Zweck des Andockens an eine andere Komponente (dkDock). BEISPIEL: Um auf einfachste Weise das Verschieben von Steuerelementen zu demonstrieren, weisen Sie einer

Edit-Komponente im Objektinspektor die folgenden Eigenschaften zu: DragKind := dkDock und DragMode := dmAutomatic. Die DockSite-Eigenschaft des Formulars setzen Sie auf True. Nach dem Programmstart können Sie das Editierfeld mit der Maus anfassen und an eine beliebige Stelle verschieben, wobei es zwischenzeitlich die folgende fensterähnliche Form annimmt:

Nun können Sie die diversen Ereignisse auswerten, z.B. dass sich die Komponente nach dem Loslassen an den linken Fensterrand andocken soll: procedure TForm1.FormDockDrop(Sender: TObject; Source: TDragDockObject; X,Y: Integer); begin if Source.Control is TEdit then Edit1.Left := 0 end;

Ein ausführliches Anwendungsbeispiel zu Drag & Drop finden Sie unter 4.7.1 im Praxisteil dieses Kapitels.

194

Kapitel 4

Formulare und Komponenten

Ereignisse sind Eigenschaften Sie können tatsächlich Ereignisse genauso wie Eigenschaften einander zuweisen! BEISPIEL: Ein Formular mit zwei Buttons. Button1 soll den gleichen OnClick-Event-Handler benutzen wie

Button2. Button2.OnClick := Button1.OnClick

Obige Zuweisung können Sie entweder im OnCreate-Ereignis von Form1 unterbringen oder aber Sie benutzen dazu die "Ereignisse"-Seite des Objektinspektors. Der Event-Handler: procedure TForm1.Button1Click(Sender: TObject); begin if Sender = Button1 then ShowMessage('Es wurde auf Button1 geklickt!') else if Sender = Button2 then ShowMessage('Es wurde auf Button2 geklickt!') end;

Anhand des Sender-Parameters unterscheidet der Event-Handler, von welchem Objekt das Ereignis ausgelöst wurde. Näheres dazu finden Sie im OOP-Kapitel (Ereignisbehandlungen, 6.3.2).

4.1.3 Standardmethoden Hier einige wichtige Methoden, über die fast alle Objekte verfügen: Methode

Erläuterung

BeginDrag

... startet DragDrop sofort (True) oder verzögert (False).

BringToFront

... bringt Steuerelement nach vorne.

Dragging

... ermittelt, ob ein Steuerelement gezogen wird (True/False).

Hide

... setzt die Eigenschaft Visible der Komponente auf False.

Refresh

... ruft Repaint auf.

Repaint

... das Steuerelement wird sofort neu gezeichnet.

Show

... setzt die Eigenschaft Visible der Komponente auf True.

SendToBack

... legt Steuerelement hinter alle überlappenden Steuerelemente.

SetFocus

... das Steuerelement erhält den Fokus.

BEISPIEL: Die Einfügemarke blinkt im Editierfeld. Edit1.SetFocus;

195

4.2 Das Formular

4.2 Das Formular Eine Windows-Applikation läuft gewöhnlich in einem oder mehreren Fenstern ab, die sozusagen als Container für die Anwendung fungieren. Das von TForm abgeleitete Formular ist deshalb das wichtigste Objekt. Im allgemeinen Sinn wäre ein Formular auch als Komponente zu betrachten, jedoch ist es aus praktischen Gründen zweckmäßiger, zwischen Formular und den darin enthaltenen Komponenten zu unterscheiden.

4.2.1 Formulareigenschaften Die folgende Tabelle zeigt die wichtigsten (so genannten Schlüsseleigenschaften) eines Formulars. Einige davon entsprechen den anfangs bereits aufgelisteten Standardeigenschaften, werden aber aufgrund ihrer spezifischen Bedeutung nochmals mit aufgeführt. Eigenschaft

Datentyp

Erklärung

Default

ActiveControl

TWinControl

Komponente, die den Fokus hat

keine

AutoScroll

Boolean

Bildlaufleisten erscheinen, wenn Formular verkleinert wird

True

BorderStyle

TFormBorderStyle Art des Rahmens:

bsSizeable

bsDialog → nicht größenveränderlich; einfaches Dialogfenster bsSingle → nicht größenveränderlich; einfache Rahmenlinie bsNone → nicht größenveränderlich; keine sichtbare Rahmenlinie, keine Schalter Symbol und Vollbild, kein Steuermenü bsSizeable → größenveränderlicher Standardrahmen BorderIcons

TBorderIcons

Ikonen, die in Titelleiste angezeigt werden: True biSystemMenu → System-Menü

True

biMinimize → Minimieren-Schaltfläche

True

biMaximize → Maximieren-Schaltfläche

False

biHelp → Hilfetexte in PopUp-Fenster Caption

String

in der Titelleiste angezeigter Text

wie Name

ClientHeight

Integer

Höhe bzw. Breite des Clientbereichs in Pixeln

wie im Editor

Color

TColor

Hintergrundfarbe

clBtnFace

Ctl3D

Boolean

drei- oder zweidimensionales Aussehen

True

ClientWidth

196

Kapitel 4

Formulare und Komponenten

Eigenschaft

Datentyp

Erklärung

Default

Cursor

TCursor

Aussehen des Mauszeigers

crDefault

Enabled

Boolean

Formular reagiert auf Maus-, Tastatur- und True Timer-Ereignisse oder nicht

+Font

TFont

Textausgaben für nachfolgende Texteigen- Systemschrift schaften (Color, Name, Size, Style, siehe Font-Dialogfenster)

FormStyle

TFormStyle

Formulartyp (normal, MDI-Rahmenfenster, fsNormal MDI-Kindfenster, immer oben)

Height Width

Integer

Gesamthöhe bzw. -breite des Formulars in Pixeln

wie im Editor

LeftTop

Integer

Abstand der linken bzw. oberen Kante des Formulars zum Bildschirmrand in Pixeln

-1

KeyPreview

Boolean

siehe 4.1.2

False

Position

TPosition

Größe und Position des Formulars

poDesigned

WindowState

TWindowState

Größe des Formulars beim Programmstart fest (normal, maximal, Ikone)

wsNormal

Setzen Sie Position auf poScreenCenter, so erscheint das Formular nach dem Programmstart immer exakt in Bildschirmmitte. Die folgende Skizze verdeutlicht einige weitere wichtige Eigenschaften, die Aussehen und Abmessungen eines Formulars bestimmen: BorderIcons.biSystemMenu

BorderIcons.biMaximize Caption

BorderIcons.biMinimize

Height

BorderStyle

ClientHeight

ClientWidth

AutoScroll

Width

197

4.2 Das Formular

Bemerkungen ■ Einige Kombinationen der Eigenschaften BorderStyle und BorderIcons verbieten sich gegenseitig. Man kann z.B. nicht BorderIcons auf biMaximize oder biMinimize und zugleich BorderStyle auf bsDialog setzen. ■ Bei biSystemMenu = False werden auch die anderen Symbole nicht angezeigt! ■ Das Verändern von Formulareigenschaften zur Laufzeit kann ungewollt Ereignisse auslösen, so wird z.B. beim Zuweisen von BorderStyle auch OnShow ausgelöst! ■ Im Kapitel 7 (Grafik) werden unter anderem ausführlich Height und Width sowie ClientHeight und ClientWidth erklärt.

4.2.2 Formularereignisse Beim Öffnen bzw. Schließen eines Formulars treten Ereignisse in dieser Reihenfolge auf: OnCreate

OnShow

OnPaint

OnActivate

Form erscheint

OnResize

Arbeiten mit dem Programm ........ Programm beenden

OnCloseQuery

OnClose

Form weg

OnHide

OnDestroy

Hier eine Zusammenstellung aller Formular-Events, die neben den am Kapitelanfang aufgelisteten Standardereignissen von Bedeutung sind:

198

Kapitel 4

Formulare und Komponenten

Ereignis

... tritt ein, wenn

OnCreate

... das Formular zum ersten Mal erzeugt wird.

OnActivate

... das Formular aktiviert wird (in den Vordergrund kommt).

OnClose

... das Formular geschlossen wird.

OnCloseQuery

... das Formular nach einer Abfrage geschlossen wird.

OnDragDrop

... ein gezogenes Objekt auf dem Formular abgelegt wird.

OnDragOver

... ein Objekt über das Formular gezogen wird.

OnPaint

... vorher verdecktes Formular neu gezeichnet werden muss.

OnResize

... die Größe eines Formulars verändert wird.

OnShow

... bevor das Formular sichtbar wird.

OnHide

... das Formular unsichtbar gemacht wurde.

OnDeactivate

... zu einer anderen Windows-Applikation gewechselt wird.

OnDestroy

... wenn das Formular (oder Hauptfenster) entfernt wird.

OnMouseWheel

... wenn am Mausrad gedreht wird.

OnMouseWheelDown OnMouseWheelUp

... falls das OnMouseWheel-Ereignis nicht ausgewertet wird und das Mausrad nach oben bzw. unten gedreht wird.

HINWEIS: Das OnResize-Event ist günstig, um die Abmessungen von Komponenten an Größen-

änderungen des Formulars anzupassen. BEISPIEL: Eine ScrollBar "klebt" am unteren Rand des Formulars, egal wie Sie zur Laufzeit die Formular-

größe ändern (Kind-Eigenschaft der ScrollBar ist sbHorizontal). procedure TForm1.FormResize(Sender: TObject); begin ScrollBar1.Top := Form1.ClientHeight – ScrollBar1.Height; ScrollBar1.Width := Form1.ClientWidth; ScrollBar1.Left := 0 end;

4.2.3 Formularmethoden Einen Überblick über wichtige Formularmethoden vermittelt die folgende Tabelle. Methode

Erläuterung

Cascade

... ordnet die Kindfenster eines MDI-Hauptformulars hintereinander an.

ClientToScreen

... transformiert Client-Koordinaten in globale Bildschirmkoordinaten.

Close

... ruft CloseQuery auf und schließt das Formular, wobei OnClose-Ereignis ausgelöst wird.

CloseQuery

... liefert True, wenn Formular geschlossen werden kann und löst vorher OnCloseQuery-Ereignis aus.

199

4.2 Das Formular

Methode

Erläuterung

Create

... erzeugt eine Formularinstanz (Konstruktor) und löst OnCreate-Ereignis aus.

Destroy

... entfernt die Formularinstanz (Destruktor) und löst OnDestroy-Ereignis aus.

GetFormImage

... liefert die Bitmap des Formulars.

Hide

... versteckt das Formular (Visible = False).

Next

... macht nächstes Kindfenster einer MDI-Form zum aktiven Fenster.

Previous

... macht vorhergehendes Kindfenster einer MDI-Form zum aktiven Fenster.

Print

... druckt das Formular (Clientbereich).

ScreenToClient

... Umkehrung von ClientToScreen.

SetFocus

... gibt dem Formular den Eingabefokus und ruft die SetFocus-Methode des aktiven Steuerelements auf.

Show

... setzt Visible = True und zeigt Formular im Vordergrund an.

ShowModal

... Formular muss geschlossen werden, bevor fortgesetzt werden kann.

Wie Sie sehen, lösen einige Methoden gleich lautende Ereignisse aus (z.B. Show => OnShow). Bei Methodenaufrufen innerhalb einer Formular-Unit kann der Objektbezeichner auch weggelassen werden. BEISPIEL: Schließen von Form1. procedure TForm1.Button1Click(Sender: TObject); begin Close end;

// abgekürzt für Form1.Close

BEISPIEL: Der Clientbereich von Form1 wird ausgedruckt (Standarddrucker). procedure TForm1.Button2Click(Sender: TObject); begin Print end;

// abgekürzt für Form1.Print

4.2.4 MDI-Fenster Ein Windows-Programm läuft oft als MDI-Applikation ab, d.h., innerhalb eines Rahmen- bzw. Mutterfensters können sich mehrere so genannte Kindfenster tummeln1. Diese werden vom Mutterfenster verwaltet und so "an der Leine gehalten", dass sie z.B. auch dessen Bereich nicht verlassen können:

1

Textverarbeitungsprogramme, z.B. Word für Windows, sind meist als Multiple Document Interface- Applikation aufgebaut. Die einzelnen Dokumente sind die Kindfenster.

200

Kapitel 4

Formulare und Komponenten

Wenn Sie ein MDI-Kindfenster auf Vollbild vergrößern, so erscheint dessen Titel eingefasst in eckigen Klammern neben dem Titel des Hauptfensters, und sein Menü (falls vorhanden) ersetzt das des Hauptfensters:

Weitere Einzelheiten entnehmen Sie dem Praxisbeispiel 3.8.2 ("Eine MDI-Applikation erstellen").

201

4.2 Das Formular

FormStyle-Eigenschaft Ein Formular wird zum Hauptformular (auch MDI-Rahmenfenster genannt), wenn Sie dessen FormStyle-Eigenschaft auf fsMDIForm setzen. HINWEIS: Innerhalb einer Applikation gibt es immer nur ein einziges MDI-Rahmenfenster!

Ein untergeordnetes Formular (Child-Window) entsteht, wenn dessen FormStyle-Property auf fsMDIChild geändert wird.

Projektoptionen Über das Menü Projekt|Optionen... lassen Sie in der Regel nur das Hauptformular automatisch erstellen, da meist beliebig viele Instanzen eines Kindfensters zur Laufzeit hinzugefügt werden sollen. Als Ersatz für die Show-Methode dient dann der Aufruf des Create-Konstruktors. Dabei ist der Owner immer das Hauptformular (Self). BEISPIEL: Erzeugen eines neuen Kindfensters. procedure TForm1.NeuesKindfensterClick(Sender: TObject); begin TForm2.Create(Self) end;

HINWEIS: Entfernen Sie aus den Projektoptionen das automatische Erstellen der Kindfenster!

Sie dürfen diese dann allerdings nicht mehr mit Show aufrufen (Zugriffsverletzung)!

Anordnen der Kindfenster Ein MDI-Hauptfenster verfügt über die Methoden Tile, Cascade und ArrangeIcons, mit denen Sie die vorhandenen Kindfenster nebeneinander, überlappend oder als Symbole anordnen können. Zu diesem Zweck hat fast jede MDI-Applikation ein Fenster-Menü, in dem Sie diese Optionen auswählen können. procedure TForm1.NebeneinanderClick(Sender: TObject); // Fenster|Nebeneinander begin Tile // ordnet Kindfenster nebeneinander an end;

In diesem Zusammenhang erwähnenswert sind noch die Methoden Next und Previous, die in einer Formularfolge das nächste bzw. das vorangehende Kindfenster zum aktiven Formular machen.

Schließen der Kindfenster Im Unterschied zu einem normalen Formular verschwindet ein Kindfenster nicht, wenn es durch Aufruf der Close-Methode geschlossen werden soll.

202

Kapitel 4

Formulare und Komponenten

Mit dem Zuweisen von Action := acFree im OnClose-Ereignis werden die Fenster quasi vernichtet, und der von ihnen belegte Speicher wird freigegeben (caMinimize = Standard). Beachten Sie auch die CloseQuery-Methode des übergeordneten MDI-Formulars. Diese ruft die Methode CloseQuery der Kindfenster auf, um den Rückgabewert zu ermitteln (True, wenn Kindfenster geschlossen werden darf). Ein entsprechendes Beispiel finden Sie unter 3.8.2.

4.3 Die Standard-Komponenten Im Schnelldurchgang wollen wir kurz auf die interessantesten Features dieser wohl am häufigsten benötigten Komponenten eingehen.

4.3.1 Button Die Befehlsschaltfläche ist wohl kaum aus einer Anwendung wegzudenken und verdient es deshalb, an erster Stelle genannt zu werden. Default Diese Eigenschaft verbindet den Button mit der Enter-Taste. Das bedeutet, wenn Sie auf die EnterTaste drücken, wird die OnClick-Ereignisprozedur ausgeführt, vorausgesetzt, die Schaltfläche hat den Fokus. Wenn der Fokus an ein Steuerelement weitergegeben wird, das keine Schaltfläche ist, wird diejenige Schaltfläche wieder zur Standardschaltfläche, deren Default-Eigenschaft auf True gesetzt ist.

Cancel Mit dieser Property wird festgelegt, ob der Button auf die ESC-Taste mit einem OnClick-Ereignis reagiert oder nicht (standardmäßig False). Action Diese ab Delphi 4 eingeführte Eigenschaft ist im Zusammenhang mit der ebenfalls neu eingeführten ActionList-Komponente von Bedeutung (siehe Ende dieses Abschnitts).

4.3.2 Label Dieses harmlose, aber unverzichtbare Bezeichnungsfeld dient, im Gegensatz zum Editierfeld, häufig nur zur Anzeige von statischem (unveränderbarem) Text, den man per CaptionProperty im Objektinspektor zuweist.

4.3 Die Standard-Komponenten

203

Transparent = True setzt die Color-Eigenschaft außer Kraft und lässt den Formularhintergrund durchscheinen. Mit AutoSize legt man fest, ob sich das Label automatisch vergrößern soll, wenn sein Inhalt dies erfordern sollte, oder ob der Rest des Textes einfach abgeschnitten wird. HINWEIS: Die Standardeinstellung AutoSize = True bringt Unruhe in den Clientbereich (Fla-

ckern bei der Größenanpassung)! Es ist deshalb zu empfehlen, AutoSize auf False zu setzen und das Label auf die größtmöglichen Abmessungen zu zoomen. Die Align-Eigenschaft ist meist alNone, da man ein Label nur in seltenen Fällen an die Ränder des Formular-Clientbereichs "klebt" bzw. es diesen ganz ausfüllen lässt. Hervorzuheben ist die Alignment-Eigenschaft, welche die Ausrichtung des Textes ermittelt bzw. setzt: taLeftJustify, taRightJustify, taCenter. Mit WordWrap legen Sie fest, ob ein Zeilenumbruch stattfinden soll:

Sie können einen Zeilenumbruch auch per Quellcode erzeugen (also unabhängig von WordWrap), indem Sie die entsprechenden Steuerzeichen für Zeilenschaltung und Zeilenvorschub einfügen. Label1.Caption := 'Das ist ein Text,' + #13#10 + 'der umbricht!';

Eine kaum beachtete Eigenschaft ist ShowAccelChar. Diese Ignoranz rächt sich aber bitter, wenn man Beschriftungen mit einem "Kaufmanns-UND" (z.B. 1 & 1) darstellen will. Da ShowAccelChar standardmäßig True ist, wird das unmittelbar auf ein "&" folgende Zeichen als Tastenkürzel interpretiert und mit einer Unterstreichung versehen (wird das Tastenkürzel vom Benutzer eingegeben, erhält das der Eigenschaft FocusControl zugewiesene Steuerelement den Eingabefokus). Label2 := ' 1 & 1 – Internet GmbH';

ergibt die fehlerhafte Beschriftung 1_ 1 Internet GmbH. Erst durch Voranstellen von ShowAccelChar := False;

bzw. dessen Zuweisen im Objektinspektor erhalten wir das richtige Ergebnis 1 & 1 Internet GmbH. HINWEIS: Um trotz ShowAccelChar = True ein kaufmännisches UND auszugeben, müssen

zwei &-Zeichen hintereinander gestellt werden (&&). Zeichen, die nicht über die Tastatur erreichbar sind, erzeugen Sie mit dem entsprechenden ASCIICode (siehe Tabelle im Anhang).

204

Kapitel 4

Formulare und Komponenten

BEISPIEL: Erzeugen von Copyright  2001 Label1.Caption := 'Copyright ' + #169 + ' 2001'

4.3.3 Panel Schöner anzusehen als das Label ist die Panel-Komponente, dafür sorgen allein schon 3-DEigenschaften wie BevelInner, BevelOuter, BevelWidth.

Die Caption-Property ist allerdings auf nur eine Zeile beschränkt. Man verwendet diese Komponente deshalb weniger zur Textanzeige, sondern meistens nur als Unterlage (Container) für andere Komponenten, die man auf diese attraktive Weise optisch gruppieren möchte.

4.3.4 Edit Im Unterschied zum Label besteht im Editierfeld die zusätzliche Möglichkeit, den Text zur Laufzeit zu bearbeiten oder zu markieren. All dies geschieht durch Manipulation der TextProperty. Es ist allerdings nur einzeiliger Text möglich. Hervorzuheben sind neben der ReadOnly-Eigenschaft (Schreibschutz bzw. Verwendung als reiner Textbetrachter) folgende Properties: MaxLength ... legt die maximale Anzahl einzugebender Zeichen fest (Standard 0 = keine Längenbegrenzung). SelLength, SelStart, SelText Diese Properties beziehen sich auf einen markierten Textausschnitt (SelLength = Zeichenanzahl, SelStart = Anfangsposition, SelText = Inhalt). Eine Alignment-Eigenschaft wie beim Label werden Sie leider vergeblich suchen, eine Lösung des Problems finden Sie aber im Praxisbeispiel 4.7.4. An Methoden sollten Sie sich die folgenden einprägen: Clear ... löscht den Inhalt. CopyToClipBoard, PasteFromClipboard ... kopiert den markierten Text in die Zwischenablage bzw. fügt ihn von dort ein.

4.3 Die Standard-Komponenten

205

BEISPIEL: Ab Position 10 werden zwanzig Zeichen in die Zwischenablage kopiert. with Edit1 do begin SelStart := 10; SelLength := 20; CopyToClipBoard end;

Übrigens können Sie zur Laufzeit für jedes Editierfeld ein PopUp-Menü aufrufen, über das die wichtigsten Operationen direkt ausführbar sind:

PassWordChar ... erlaubt das verdeckte Eingeben eines Passwortes. Sie können das gewünschte Zeichen im Objektinspektor oder per Quellcode zuweisen. Edit1.PassWordChar := '*';

HINWEIS: Die LabeledEdit-Komponente (Seite "Zusätzlich") ist quasi eine Kreuzung zwischen

Label- und Edit-Komponente.

4.3.5 Memo Während in der Edit-Komponente lediglich eine Zeile darstellbar ist, können Memo-Felder auch mehrzeilige Texte aufnehmen. Ansonsten hat diese Komponente viele gleich lautende Eigenschaften (z.B. SelText, SelStart, SelLength), auf die deshalb hier nicht noch einmal eingegangen wird. WantReturns Ist diese Eigenschaft True, so können Sie mittels Enter-Taste einen Zeilenumbruch einfügen. Die Default-Eigenschaft eines eventuell vorhandenen Buttons wird damit außer Kraft gesetzt (siehe 4.3.1)! Bleibt WantReturns auf False, müssten Sie nach wie vor Strg+Enter für einen Zeilenumbruch verwenden.

206

Kapitel 4

Formulare und Komponenten

WordWrap Damit bestimmen Sie, ob der Text im Eingabefeld am rechten Rand umbrochen wird (True). Der Umbruch wird lediglich auf dem Bildschirm angezeigt, der Text selbst enthält keinerlei Zeilenumbrüche, die nicht eingegeben wurden. Wenn WordWrap False ist, entsteht eine neue Zeile nur dort, wo auch ein Zeilenumbruch in den Text eingefügt wurde. Lines Zwar gibt es auch eine Text-Eigenschaft, doch ist diese für die praktische Arbeit weniger gut geeignet. Sie arbeiten besser mit der Lines-Eigenschaft, die einen gezielten Zugriff auf einzelne Zeilen gestattet und die Sie im Stringlisten-Editor oder auch per Quellcode zuweisen können. ScrollBars Damit können horizontale oder vertikale Bildlaufleisten aufgrund der Konstanten ssNone, ssHorizontal, ssVertical und ssBoth hinzugefügt werden. BEISPIEL: Der folgende Code with Memo1 do begin Clear; ScrollBars := ssBoth; Lines[0] := 'Das ist die 1. Zeile eines Memofeldes!'; for i := 2 to 10 do Lines.Add('Das ist die ' + IntToStr(i) + '. Zeile!') end;

führt zu diesem Ergebnis:

HINWEIS: Hat WordWrap den Wert True, brauchen Sie keine horizontale Bildlaufleiste.

4.3.6 GroupBox Die Funktionalität dieser Komponente ähnelt dem Panel. Mit der GroupBox umgibt man mehrere Steuerelemente mit einem Rahmen. So können diese quasi zu einer "Bedieneinheit" zusammengefasst werden. HINWEIS: Beachten Sie beim Entwurf, dass zuerst der Rahmen angelegt werden muss und erst

dann die Steuerelemente innerhalb der GroupBox abgelegt werden können.

4.3 Die Standard-Komponenten

207

4.3.7 CheckBox Bei der Checkbox entscheidet die Checked-Eigenschaft (True/False) darüber, ob die Option gewählt wurde oder nicht. Für den Programmierer bietet sich zusätzlich die Möglichkeit, über State den dritten Zustand zu bestimmen (cbGrayed).

CheckBox1.Checked := True; if CheckBox1.State = cbGrayed then .....

4.3.8 RadioButton Diese Komponente dient zur Auswahl von Optionen innerhalb einer Anwendung. Wie bei der CheckBox gibt es auch beim RadioButton eine Checked-Eigenschaft. Im Unterschied zu dieser kann aber innerhalb einer Gruppe immer nur ein einziger RadioButton aktiv sein (siehe Abb. unten). Meist fasst man mehrere RadioButtons mittels GroupBox (oder Panel) zu einer Optionsgruppe zusammen:

HINWEIS: Ein gemeinsamer Event-Handler für alle RadioButtons einer Gruppe ist zweckmäßig,

wenn sofort auf das OnClick-Ereignis reagiert werden soll.

208

Kapitel 4

Formulare und Komponenten

BEISPIEL: Mit vier RadioButtons (siehe obige Abbildung) wird die Hintergrundfarbe des Forms geändert.

(Vergessen Sie nicht, im Objektinspektor das OnClick-Ereignis jedes einzelnen RadioButtons auf den gemeinsamen Event-Handler RadioButtonClick einzustellen!) procedure TForm1.RadioButtonClick(Sender: TObject); begin if Sender = RadioButton1 then Color := clBlack; if Sender = RadioButton2 then Color := clWhite; if Sender = RadioButton3 then Color := clRed; if Sender = RadioButton4 then Color := clBlue end;

4.3.9 RadioGroup Mit weniger Aufwand kann man das gleiche Ergebnis wie mit einzelnen RadioButtons auch mit einer RadioGroup erreichen. Letztere erhält ihre RadioButtons über die Items-Eigenschaft zugewiesen. ItemIndex Diese Eigenschaft bestimmt, welcher Eintrag ausgewählt ist (0, 1, 2, ..., -1 = keiner). Columns Mit dieser Eigenschaft legen Sie die Spaltenanzahl einer RadioGroup fest (Standard = 1). BEISPIEL: So füllen Sie eine RadioGroup per Quelltext. with RadioGroup1 do begin with Items do begin Add('Schwarz'); Add('Weiss'); Add('Rot'); Add('Blau') end; ItemIndex := 0 // Schwarz ist aktiv end;

HINWEIS: Sie können die Items-Eigenschaft alternativ auch im Objektinspektor einstellen. Es

öffnet sich der Stringlisten-Editor (eine Zeile = 1 RadioButton).

4.3 Die Standard-Komponenten

209

Der folgende Event-Handler führt zum gleichen Ergebnis wie im Vorgängerbeispiel zum RadioButton: procedure TForm1.RadioGroup1Click(Sender: TObject); begin Case RadioGroup1.ItemIndex of 0: Color := clBlack; 1: Color := clWhite; 2: Color := clRed; 3: Color := clBlue end end;

4.3.10 ListBox und ComboBox In einem Listenfeld ist eine Auflistung von Einträgen enthalten, von denen der Benutzer mittels Maus oder Tastatur einen oder mehrere auswählen kann. Ein Kombinationsfeld ist eine Mischung aus Editier- und Listenfeld. Es erlaubt also Eingaben und kann, im Unterschied zum Listenfeld, "aufgeklappt" werden.

Ähnlich der RadioGroup ist auch der Inhalt einer List-/ComboBox als Stringliste (Items) organisiert, woraus sich ein nahezu identischer Zugriff ergibt. Items Diese Eigenschaft ermittelt bzw. setzt einen Zeichenkettenausdruck über einen ItemIndex. Der Index beginnt mit 0 (Null) für den ersten Eintrag. Gleichzeitig können über das Items-Objekt weitere Einträge hinzugefügt bzw. gelöscht werden. BEISPIEL: Zuweisen des aktuell ausgewählten Eintrags, Hinzufügen, Löschen Label1.Caption := Listbox1.Items[ListBox1.ItemIndex]; Listbox1.Items.Add('Eintrag 16'); Listbox1.Items.Clear;

210

Kapitel 4

Formulare und Komponenten

Items.Count ... gibt die Anzahl von Einträgen zurück. ItemIndex ... setzt bzw. ermittelt die Position (Index) des aktuellen Eintrags (-1 = kein Eintrag). Sorted ... legt fest, ob die Einträge in alphabetischer Reihenfolge angeordnet werden sollen (True oder False). DropDownCount ... entspricht der Anzahl der sichtbaren Einträge (8 = Standard). Text ... setzt bzw. ermittelt den Eintrag für das aktivierte Element (ComboBox). OnClick-Ereignis ... bezieht sich nicht, wie man vielleicht vermuten könnte, auf das Editierfeld der ComboBox (oben), sondern tritt nur auf, wenn auf einen Eintrag der aufgeklappten Liste geklickt wird! OnDropDown-Ereignis (ComboBox) ... tritt auf, wenn die ComboBox aufgeklappt wird. Style Damit können Sie festlegen, wie der Eingabe- und der Listenbereich angezeigt werden. Die Werte für Style haben für ComboBox und ListBox unterschiedliche Bedeutung. Für die ComboBox: Style

Bedeutung

csDropDown

Die manuelle Eingabe von Text ist möglich. Alle Einträge sind Strings und haben dieselbe Höhe.

csSimple

Es entsteht ein Eingabefeld mit einem feststehenden Listenfeld. Die Länge der Liste wird über die Höhe des Kombinationsfeldes festgelegt.

csDropDownList

Es kann manuell kein Text eingegeben werden. Alle Einträge sind Strings und haben dieselbe Höhe.

csOwnerDrawFixed

Die manuelle Eingabe von Text ist möglich. Alle Einträge der Liste haben die Höhe, die in der Eigenschaft ItemHeight festgelegt ist.

csOwnerDrawVariable

Die manuelle Eingabe von Text ist möglich. Die Listeneinträge können unterschiedlich hoch sein.

Müssen die Listeneinträge angezeigt werden und hat Style den Wert csOwnerDrawFixed oder csOwnerDrawVariable, tritt das Ereignis OnDrawItem ein. Wenn Style den Wert csOwnerDrawVariable hat, tritt zusätzlich das Ereignis OnMeasureItem ein.

211

4.3 Die Standard-Komponenten

Für die ListBox: Style

Bedeutung

lbStandard

Die Einträge sind Strings mit gleicher Höhe.

lbOwnerDrawFixed

Die Höhe der Einträge ist mit der Eigenschaft ItemHeight festgelegt.

lbOwnerDrawVariable

Die Einträge können unterschiedlich hoch sein.

4.3.11 ScrollBar Die dafür übliche Bezeichnung "Bildlaufleiste" ist eigentlich etwas irreführend, denn Sie benutzen diese Komponente weniger zum Scrollen von Bild- bzw. Fensterinhalten (dazu haben diese Objekte meist eigene ScrollBars), sondern vielmehr als eine separate Einstellmöglichkeit im Sinne eines "Reglers" für unterschiedlichste Zwecke. Folgende Eigenschaften sind hervorzuheben: Kind Durch Zuweisen von sbHorizontal bzw. sbVertical legen Sie fest, ob es sich um eine horizontale oder um eine vertikale ScrollBar handeln soll. Max, Min, Position Diese Integer-Eigenschaften legen den größten bzw. kleinsten Einstellungswert fest bzw. bestimmen den aktuellen Wert (zwischen Max und Min). LargeChange, SmallChange Klickt man ober- oder unterhalb des "Schiebers", so wird der aktuelle Wert (Position) um LargeChange geändert, beim Klicken auf die Begrenzungspfeile hingegen nur um SmallChange. LargeChange Min

Max Position

SmallChange

OnChange Dieses Ereignis spielt eine zentrale Rolle, da es immer dann eintritt, wenn die Position des Schiebers verändert wurde.

212

Kapitel 4

Formulare und Komponenten

BEISPIEL: Wenn Sie die Einstellung der ScrollBar ändern, soll in einem Label die aktuelle Position angezeigt

werden. procedure TForm1.ScrollBar1Change(Sender: TObject); begin Label1.Caption := IntToStr(ScrollBar1.Position) end;

HINWEIS: Wenn eine ScrollBar den Eingabefokus hat, so blinkt der Schieber!

4.3.12 MainMenu und PopUpMenu Diese beiden Komponenten sind zur Laufzeit unsichtbar. Es ist deshalb absolut unwichtig, an welcher Stelle sie im Formular positioniert werden. Die eigentlichen Menüs nehmen erst nach ihrer Bearbeitung im Menüeditor (durch Doppelklick auf die Komponente aufrufen) die endgültige Gestalt an. Die dabei entstehenden Menüeinträge sind in Delphi ganz normale Objekte mit Eigenschaften und Ereignissen. BEISPIEL: Ein Event-Handler für das OnClick-Ereignis eines Menüobjekts mit dem Namen Beenden: procedure TForm1.BeendenClick(Sender: TObject); begin Close end;

Checked Diese Eigenschaft setzt ein Häkchen vor den Menüeintrag (True/False). Enabled, Visible ... aktivieren/deaktivieren den Menüeintrag bzw. machen ihn sichtbar/unsichtbar. ShortCut ... dient zur Auswahl einer Tastenkombination, über die das OnClick-Ereignis des Menüobjekts ausgelöst wird.

4.3 Die Standard-Komponenten

213

Weitere Hinweise zum Menüentwurf erhalten Sie im Praxisteil des Kapitels (4.6.3) oder aber auch im folgenden Abschnitt.

4.3.13 ActionList Dies ist eine Sammlung von TAction-Objekten. Ein solches Objekt kapselt eine Operation, die von anderen Objekten der Benutzerschnittstelle, die über eine Action-Eigenschaft verfügen (wie z.B. Menüeinträge oder Buttons, in diesem Zusammenhang als Clients bezeichnet), als Reaktion auf ein Ereignis (z.B. Mausklick) mit einem Zielobjekt (z.B. Edit- oder Memo-Komponente) durchgeführt werden soll ... Machen Sie sich keine Sorgen, wenn auch Sie mit diesen "Erklärungen" aus der Delphi-Hilfe nichts anfangen können – auch den Autoren ging es zunächst nicht anders. Kurz und bündig: Eine Aktionsliste erstellen Sie mit dem Aktionslisten-Editor, der sich durch Doppelklick auf die ActionList-Komponente öffnet. Das PopUp-Menü (rechte Maustaste) weist Ihnen den weiteren Weg. BEISPIEL: Wir wollen ein Bearbeiten-Menü erstellen. Wählen Sie über die rechte Maustaste "Neue Stan-

dardaktion" und dann im Dialogfenster die Aktionen TEditCopy, TEditCut und TEditPaste.

Setzen Sie eine MainMenu-Komponente auf das Formular, öffnen Sie per Doppelklick den Menüeditor und weisen Sie dem ersten Eintrag die Caption-Eigenschaft "Bearbeiten" zu. Die Untereinträge brauchen Sie nicht auszufüllen, klicken Sie einfach nur auf die leeren blauen Felder (Abbildung unten rechts) und weisen Sie die gewünschte Action-Eigenschaft zu. Die Eintragungen der Caption-Eigenschaften und Tastenkürzel (ShortCuts) für die Menüobjekte erfolgen automatisch!

214

Kapitel 4

Formulare und Komponenten

Nun können Sie z.B. noch zu Testzwecken diverse Memo- und/oder Editierfelder auf das Formular setzen, und schon kann das Programm gestartet werden. Das Bearbeiten-Menü wird beim Ausschneiden, Einfügen und Kopieren von Texten und Grafiken professionell funktionieren, ohne dass Sie auch nur eine einzige Zeile Quellcode schreiben mussten! Auch für das sinnvolle gegenseitige Verriegeln der Menüeinträge ist gesorgt, wenn z.B. kein Text im Memofeld selektiert wurde, dann erscheinen die Einträge "Ausschneiden" und "Kopieren" gesperrt. Mehr zum Thema erfahren Sie im Praxisbeispiel 4.7.3.

4.3.14 Frames Hier geht es um eine besondere Art von Formular, das in andere Formulare (oder auch andere Frames) eingefügt werden kann. Wenn Sie aber versuchen, ein "Frames-Control" von der Komponentenpalette ("Standard"-Seite) auf das Formular zu ziehen, wird Ihr Entdeckertrieb zunächst von einem Meldungsfenster jäh gestoppt:

Wählen Sie Datei|Neu|Frame. Das neu hinzugekommene Frame-Objekt bestücken Sie dann, wie vom Formularentwurf gewohnt, mit Komponenten.

4.3 Die Standard-Komponenten

215

BEISPIEL: Ein Frame-Objekt mit zwei Editierfeldern und einer CheckBox

Wenn Sie das Frame-Symbol in der Komponentenpalette klicken, wird eine Dialogbox aufgerufen, die die im Projekt bereits vorhandenen Frame-Objekte zur Auswahl anbietet. BEISPIEL: Drei Frame-Objekte stehen zur Auswahl bereit.

Jetzt können Sie die Frame-Objekte auf dem Formular (oder auch innerhalb eines anderen FrameObjekts) platzieren. BEISPIEL: Frame2 aus dem Vorgängerbeispiel wird zweimal in Form1 eingefügt. Die von Delphi automatisch

vergebenen Objektbezeichner lauten Frame21 (linker Frame) und Frame22 (rechter Frame).

Der Zugriff auf die in einem Frame platzierten Objekte spiegelt die Hierarchie der Verschachtelung wider.

216

Kapitel 4

Formulare und Komponenten

BEISPIEL: Zugriff auf Edit1 im rechten Frame des Vorgängerbeispiels Form1.Frame22.Edit1.Text := 'Hallo';

Nachdem ein Frame erstellt und gespeichert wurde, kann die Komponente weiterhin als Unit verwendet werden und die Änderungen der eingefügten Komponenten (einschließlich anderer Frames) erben. Außerdem erbt ein eingebettetes Frame-Objekt alle Änderungen, die an der Komponente vorgenommen werden, von der es abgeleitet ist.

4.3.15 Timer Obwohl der Timer nicht zu den Komponenten der "Standard"-Palette gehört (Sie finden ihn auf der Seite "System"), soll er aufgrund seiner Wichtigkeit hier mit erwähnt werden. Diese (zur Laufzeit unsichtbare) Komponente ruft in bestimmten Zeitabständen das OnTimer-Ereignis auf. Wesentlich ist die Interval-Eigenschaft, sie legt die Zeit (in Millisekunden) fest. Der Wert 0 (Null) sperrt den Zeitgeber. BEISPIEL: Wählen Sie die Interval-Eigenschaft 1000, so wird im Sekundentakt die Uhrzeit angezeigt. procedure TForm1.Timer1Timer(Sender: TObject); begin Label1.Caption := TimeToStr(Time) end;

HINWEIS: Beachten Sie, dass das Timer-Ereignis abhängig vom Betriebssystem maximal 18,2

Mal pro Sekunde aufgerufen werden kann! Einige Systemereignisse (z.B. MouseDown in der Kopfzeile) bewirken, dass der Timer angehalten wird. Wenn Sie sich das "Autorennen" im Praxisteil von Kapitel 6 näher anschauen, so werden Sie feststellen, dass die Animationen ebenfalls mit Hilfe eines Timers realisiert wurden.

4.4 Weitere wichtige Objekte Delphi hat noch weitaus mehr Objekte zu bieten als jene, die Sie auf der Komponentenpalette entdecken.

217

4.4 Weitere wichtige Objekte

4.4.1 Application Das wohl wichtigste der "unsichtbaren" Delphi-Objekte ist Application aus der Unit Forms. Dies ist eine Variable vom Typ TApplication und eine Instanz Ihres Programms. Folgende Methoden bzw. Eigenschaften des Application-Objekts sind von besonderem Interesse: Eigenschaft/Methode

Erklärung

Initialize

Initialisieren des Programms

Run

Starten der Programmausführung

Terminate

Methode, die die Programmausführung beendet

ProcessMessages

Freigabe von Rechenzeit für andere Anwendungen

MessageBox

Methode, die ein modales Meldungsfenster ausgibt

ExeName

Name der EXE-Datei

CreateForm

Methode, mit der ein Formular erzeugt wird

HelpFile

Eigenschaft zum Auswählen des HelpFiles

BEISPIEL: Meldungsfenster erzeugen (siehe Kapitel 5). Application.MessageBox('Das Programm wird beendet', 'Info', 49);

BEISPIEL: Typisches Delphi-Hauptprogramm (Menü Projekt|Quelltext anzeigen) program Project1; ... begin Application.Initialize; Application.CreateForm(TForm1, Form1); Application.Run; end.

ApplicationEvents Im Zusammenhang mit dem Application-Objekt ist das Steuerelement ApplicationEvents von Interesse, das Sie auf der Seite "Zusätzlich" der Komponentenpalette entdecken. Da das Application-Objekt alle Ereignisse an ApplicationEvents weiterleitet, hat Letzteres gleichnamige Ereignisse. Mit der Activate-Methode kann die Reihenfolge des Empfangs der Ereignisse gesteuert werden.

218

Kapitel 4

Formulare und Komponenten

HINWEIS: Jedes Formular kann ein eigenes ApplicationEvents-Objekt besitzen!

4.4.2 Clipboard Das Clipboard-Objekt repräsentiert die Windows-Zwischenablage. Um damit arbeiten zu können, müssen Sie die Unit Clipbrd in die uses-Klausel der Form-Unit aufnehmen. AsText Mit Hilfe dieser Eigenschaft können Sie Text in die Zwischenablage bringen und aus ihr abrufen. Clipboard.AsText := 'Hallo'; Label1.Caption := Clipboard.AsText;

// Text in Zwischenablage kopieren // Text aus Zwischenablage einfügen

Assign Um Bilder in der Zwischenablage zu platzieren oder daraus abzurufen, verwenden Sie diese Methode: Clipboard.Assign(Image1.Picture); Image2.Picture.Assign(ClipBoard);

// Bild in Zwischenablage kopieren // Bild aus Zwischenablage einfügen

Formats, FormatCount, HasFormat Formats liefert eine Liste aller aktuellen Formate in der Zwischenablage, FormatCount gibt die Anzahl der Formate an. Durch die Methode HasFormat lässt sich feststellen, ob ein bestimmtes Format in der Zwischenablage enthalten ist.

4.4.3 Printer Wenn Sie die Unit Printers einbinden, kann das Programm Druckerausgaben auf Printer.Canvas mit den gleichen Methoden vornehmen, wie z.B. auf das Canvas-Objekt eines Formulars (siehe Grafik-Kapitel 7). BEISPIEL: Mit dem folgenden Code drucken Sie ein kleines Quadrat in die linke obere Ecke. Printer.BeginDoc; Printer.Canvas.Rectangle(10,10,100,100); Printer.EndDoc;

Weitere Informationen finden Sie im Kapitel 10.

4.4.4 Screen Dieser Komponente entspringt eine Objektklasse, die den gesamten Bildschirm wiedergibt. Standardmäßig steht bereits beim Start von Delphi eine Variable Screen (Instanz von TScreen) zur Verfügung.

219

4.5 Gitterkomponenten

HINWEIS: Alle Screen-Eigenschaften sind nur zur Laufzeit verfügbar und können nicht zuge-

wiesen, sondern nur gelesen werden (Read Only)! Für Koordinatenangaben sind folgende Screen-Eigenschaften von Interesse: Eigenschaft

Erläuterung

Width

Breite des Bildschirms in Pixel

Height

Höhe des Bildschirms in Pixel

PixelsPerInch

Anzahl Pixel pro Zoll (abhängig vom Bildschirmtreiber)

Fonts

Schriftarten, die vom Bildschirm unterstützt werden

BEISPIEL: Platzieren einer visuellen Komponente (hier TEdit) exakt in Bildschirmmitte Edit1.Left:= (Screen.Width - Edit1.Width) div 2; Edit1.Top:= (Screen.Height - Edit1.Height) div 2;

BEISPIEL: Die Anweisung a := Screen.Width / Screen.PixelsPerInch * 2.54;

setzt die (Real-)Variable a auf die Bildschirmbreite (in cm). BEISPIEL: Bildschirmschriftarten in einer Listbox in alphabetischer Reihenfolge anzeigen ListBox1.Sorted := True; ListBox1.Items := Screen.Fonts;

HINWEIS: Verwenden Sie die Methoden ScreenToClient und ClientToScreen von TForm, um

Koordinatenumwandlungen vorzunehmen!

4.5 Gitterkomponenten Da es aus Gründen des Umfangs unmöglich ist, dass in diesem Kapitel sämtliche Delphi-Komponenten vorgestellt werden1, sollen als Beispiele TDrawGrid und TStringGrid herausgegriffen werden, die Sie auf der Registerseite "Zusätzlich" der Komponentenpalette finden. Mit diesen beiden Komponenten stellt Delphi zwei sehr komplexe und leistungsfähige Dialogelemente zur tabellenförmigen Datenanzeige und -eingabe zur Verfügung. Bei Verwendung eines Gitterelements wird die Grids-Unit automatisch zur uses-Anweisung der Formular-Unit hinzugefügt. Die Vielzahl von ineinander verzahnten Eigenschaften, die sich teilweise auf untergeordneter Ebene weiter aufsplitten (Options), bildet ein scheinbar heilloses Wirrwar, in dem man sich auf 1

Außerdem kann diese Aufgabe viel effektiver von der integrierten Online-Hilfe wahrgenommen werden.

220

Kapitel 4

Formulare und Komponenten

Anhieb nicht zurechtfindet. Die Konzentration auf das Wesentliche ist also vonnöten, damit der Überblick nicht gänzlich verloren geht.

4.5.1 Eigenschaften Hier die Schlüsseleigenschaften (L = nur zur Laufzeit, S = schreibgeschützt): Eigenschaft

Erläuterung

BorderStyle

... mit oder ohne Rahmen um das Gitter (bsSingle, bsNone)

Col

... aktuelle Spalte (die Fokus besitzt)

ColCount

... Anzahl der Spalten (Default = 5)

ColWidths[i]

... Breite der i-ten Spalte (Pixel)

DefaultColWidth

... Anfangsbreite aller Spalten (Default = 64 Pixel)

DefaultDrawing

... legt fest, ob Zelle und ihr Inhalt automatisch gezeichnet werden (Default = True)

L

S

x x

DefaultRowHeight ... Anfangshöhe aller Zeilen (Default = 24 Pixel) EditorMode

... legt fest, ob sich Gitter im automatischen Editiermodus befindet

x

FixedColor

... Farbe der unbeweglichen Zeilen und Spalten (s.u.)

FixedCols

... Anzahl der unbeweglichen Spalten (Default = 1)

FixedRows

... Anzahl der unbeweglichen Zeilen (Default = 1)

GridHeight

... Gitterhöhe (Pixel, s.u.)

GridLineWidth

... Breite der Gitterlinien (Pixel)

GridWidth

... Gitterbreite (Pixel, s.u.)

x x

LeftCol

... welche Spalte ganz links erscheint

x

Options

... Erscheinungsform des Gitters und Reaktion auf Benutzereingaben, wird aus verschiedenen Ja-/Nein-Parametern gebildet

Row

... aktuelle Zeile (die Fokus besitzt)

RowCount

... Anzahl der Zeilen (Default = 5)

RowHeights[i]

... Höhe der i-ten Zeile (Pixel)

ScrollBars

... legt fest, ob Bildlaufleisten vorhanden sind (s.u.)

Selection

... selektiert einen Ausschnitt (s.u.)

x

TopRow

... welche Zeile ganz oben erscheint

x

VisibleColCount

... Anzahl der sichtbaren Spalten

x x

VisibleRowCount

... Anzahl der sichtbaren Zeilen

x x

x x

x x

■ Zeilen- bzw. Spaltenindizes beginnen mit null (0). ■ Für DefaultDrawing = False müssen Zellen und ihr Inhalt innerhalb des OnDrawCell-Ereignisses neu gezeichnet werden.

221

4.5 Gitterkomponenten

■ Für EditorMode = True befindet sich das Gitter so lange im Editmodus, wie die Eigenschaft Options den Wert goEditing enthält. Ist goEditing = False, bleibt das Setzen von EditorMode ohne Auswirkungen.Wenn EditorMode= False und goEditing=True und goAlwaysShowEditor=False, kann der Anwender durch Drücken von Enter (bzw. F2) in den Editiermodus gelangen. ■ Eine Liste möglicher Werte für FixedColor finden Sie unter der Color-Eigenschaft. ■ Die vier möglichen Werte für Scrollbars sind:scNone (Keine Bildlaufleiste) scHorizontal (Bildlaufleiste an der unteren Kante)scVertical (Bildlaufleiste an der rechten Kante) scBoth (beide Bildlaufleisten vorhanden, Standard) Für Selection ist der in der Grids-Unit enthaltene Typ TGridRect zu verwenden, der einen rechteckigen Bereich definiert. BEISPIEL: Es wird ein Ausschnitt mit den Zeilen 1 bis 3 sowie den Spalten 3 und 4 festgelegt: var SRct: TGridRect; begin SRct.Top := 1; SRct.Bottom := 3; SRct.Left := 3; SRct.Right := 4; StringGrid1.Selection := SRct end;

Options ist eine Menge von Boole'schen Werten, die sich auf den Typ TGridOption zurückführen lassen, der wiederum auf dem Typ TGridOption basiert: TGridOptions = set of TGridOption;

BEISPIEL: Die folgende Anweisung erlaubt das Ändern der Zellengröße und das Editieren des Inhalts (alles

andere bleibt auf False!): DrawGrid1.Options := [goRowSizing, goEditing];

Diese Werte sollten Sie besser direkt im Objektinspektor zuweisen. Hier eine Zusammenstellung: Wert

Default

Wenn True, dann ...

goFixedHorzLine

True

... erscheint eine horizontale Linie zwischen den Zeilen, in denen kein Bildlauf durchgeführt werden kann.

goFixedVertLine

True

... erscheinen vertikale Linien zwischen Spalten, in denen kein Bildlauf durchgeführt werden kann.

goHorzLine

True

... erscheinen horizontale Linien zwischen den Zeilen.

goVertLine

True

... erscheinen vertikale Linien zwischen den Spalten.

goRangeSelect

True

... kann der Anwender eine Reihe von Zellen gleichzeitig auswählen. Wenn goEditing = True, kann der Anwender keine Reihe von Zellen mehr auswählen.

222

Kapitel 4

Formulare und Komponenten

Wert

Default

Wenn True, dann ...

goDrawFocusSelected

False

... wird die Fokus-Zelle in der gleichen Farbe dargestellt, mit der bereits andere Zellen in einem ausgewählten Block dargestellt sind. Bei False behält die Fokus-Zelle die Farbe der nicht ausgewählten Zellen (Color-Eigenschaft).

goRowSizing

False

... kann Breite von nicht fixierten Zeilen geändert werden.

goColSizing

False

... kann Höhe von nicht fixierten Spalten geändert werden.

goRowMoving

False

... kann der Anwender unter Verwendung der Maus eine Zeile an eine andere Stelle ziehen.

goColMoving

False

... kann der Anwender unter Verwendung der Maus eine Spalte an eine andere Stelle ziehen.

goEditing

False

... kann der Anwender den Gitterinhalt bearbeiten.

goAlwaysShowEditor

False

... befindet sich das Gitter im automatischen Bearbeitungsmodus, wenn goEditing = True. Dann braucht der Anwender nicht die Enter-Taste (oder F2) zu drücken, bevor er den Inhalt der Zelle bearbeitet (s.u.).

goTabs

False

... kann der Anwender mit Hilfe der Tab- und UmschaltTab-Tasten von einer Spalte zu der nächsten Spalte springen.

goRowSelect

False

... lassen sich nur ganze Zeilen statt einzelner Zellen auswählen.

goThumbTracking

False

... wird durch Gitterinhalt geblättert, während man die Bildlaufleiste des Gitters betätigt, bei False wird so lange nicht geblättert, bis man an neuer Stelle angelangt ist.

Falls goAlwaysShowEditor = False und goEditing = True, muss der Anwender die Enter- oder F2Taste drücken, bevor er den Inhalt einer Zelle editieren kann. Die Einstellung goEditing = False und goAlwaysShowEditor = True hat keinen Effekt.

Die zusätzlichen Eigenschaften des StringGrid Die StringGrid-Komponente vereinfacht die Bearbeitung von Zeichenketten und zugehörigen Objekten unter Beibehaltung der gesamten Funktionalität der Komponente DrawGrid. Es kommen lediglich vier neue Eigenschaften hinzu: Eigenschaft

Erläuterung

Cells[i,j]

... Zugriff auf den Inhalt einer bestimmten Zelle

Cols[i]

... Zugriff auf den Inhalt einer kompletten Spalte

Objects[i,j]

... Zugriff auf ein bestimmtes Objekt einer Zelle

Rows[i]

... Zugriff auf den Inhalt einer kompletten Zeile

223

4.5 Gitterkomponenten

Cells ist ein zweidimensionales Array von Strings, dessen Abmessungen durch die Eigenschaften ColCount und RowCount festgelegt sind. Die erste Spalte bzw. erste Zeile haben den Index 0! BEISPIEL: Die folgenden Anweisungen tragen in jedes Feld eines String-Gitters den Zeilen- und den Spalten-

index ein: with StringGrid1 do for i := 0 to ColCount - 1 do for j:= 0 to RowCount - 1 do Cells[i,j] := IntToStr(i)+','+IntToStr(j);

Alle Strings aus einer bestimmten Spalte bzw. Zeile (samt zugehöriger Objekte) kann man mit den Eigenschaften Cols bzw. Rows erreichen, die vom Typ TStrings ist. BEISPIEL: Die folgende Anweisung knüpft an obigen Quelltext an und füllt eine Listbox mit den Werten der

zweiten Zeile: ListBox1.Items := StringGrid1.Rows[1];

Alle mit den Strings verbundenen Objekte sind in der Eigenschaft Objects zu finden. BEISPIEL: Eine Grafik (Typ TBitmap) wird mit der Gitterzelle der fünften Spalte und dritten Zeile verknüpft: StringGrid1.Objects[5, 3] := TESTBMP;

4.5.2 Methoden Hier haben wir es nur mit zwei typischen Schlüsselmethoden zu tun: Methode

Erklärung

CellRect

... erzeugt ein Rechteck vom Typ TRect (s.u.)

MouseToCell

... ermittelt Spalte und Zeile der Zelle, auf der sich Mauscursor befindet

BEISPIEL: Mit der Deklaration var Rectangle: TRect;

und der Anweisung Rectangle := DrawGrid1.CellRect(3, 2);

enthalten die vier Record-Variablen Rectangle.Top, Rectangle.Bottom, Rectangle.Left und Rectangle.Right die Koordinaten der Zelle in der dritten Spalte und zweiten Zeile. Eine spezielle Methode zum Löschen des Inhalts aller Zellen einer Zeile gibt es nicht, so dass man sich selbst helfen muss. BEISPIEL: Die Prozedur löscht die im Parameter rowNr übergebene Zeile. procedure deleteRow(rowNr: Word; grd: TStringGrid); var i : Word;

224

Kapitel 4

Formulare und Komponenten

begin with grd do begin Row := rowNr; if (Row = RowCount-1) then RowCount := RowCount-1 // letzte Zeile else begin for i := rowNr to RowCount-2 do Rows[i] := Rows[i+ 1]; // nicht letzte Zeile RowCount := RowCount-1 end end end;

4.5.3 Ereignisse Die meisten der Schlüsselereignisse sind von bestimmten Eigenschaften bzw. von Werten der Options-Eigenschaft abhängig. Ereignis

... tritt ein, wenn

OnColumnMoved

... der Anwender mit der Maus eine Spalte verschiebt (nur wenn in OptionEigenschaft GoColMoving = True)

OnDrawCell

... der Inhalt einer Zelle neu gezeichnet werden muss (nur für Eigenschaft DefaultDrawing = False)

OnGetEditMask

... der Inhalt einer Zelle unter Verwendung einer Editiermaske neu gezeichnet werden muss (nur wenn in Option-Eigenschaft GoEditing = True)

OnGetEditText

... der Text einer Zelle neu gezeichnet werden muss (nur wenn GoEditing = True)

OnRowMoved

... der Anwender mit der Maus eine Zeile verschiebt (nur wenn in OptionEigenschaft GoRowMoving = True)

OnSelectCell

... der Anwender eine Zelle auswählt

OnSetEditText

... der Anwender Text im Gitter bearbeitet

OnTopLeftChanged

... wenn sich die Eigenschaften TopRow oder LeftCol ändern (obere Zeilennummer oder linke Spaltennummer beim Durchscrollen)

BEISPIEL: Synchronisieren von zwei Gitterkomponenten procedure TForm1.StringGRid1TopLeftChanged(Sender: TObject); begin StringGrid2.TopRow := StringGrid1.TopRow; StringGrid2.LeftCol := StringGrid1.LeftCol end;

Wie von Geisterhand macht das zweite Gitter die Bewegungen des ersten mit, so dass in beiden Gittern der gleiche Ausschnitt angezeigt wird.

4.6 Lernbeispiele für Einsteiger

225

4.6 Lernbeispiele für Einsteiger 4.6.1 Formulareigenschaften ändern Im folgenden Testprogramm wollen wir zeigen, wie die BorderStyle- und die FormStyle-Eigenschaft eines Form-Objekts zur Laufzeit zugewiesen werden können, und die Gelegenheit auch dazu nutzen, um eine RadioGroup zu programmieren.

Oberfläche Platzieren Sie zwei RadioGroup-Komponenten und einen Button auf dem Formular (siehe Laufzeitabbildungen am Schluss). Weisen Sie der Items-Eigenschaft der RadioGroup1 im String-ListenEditor die Einträge gemäß der Abbildung zu:

Auf die gleiche Weise programmieren Sie die zweite RadioGroup, nur dass diese zwei Einträge erhält: fsNormal und fsStayOnTop. Setzen Sie die ItemIndex-Eigenschaft beider RadioGroups auf 0, damit bei Programmbeginn jeweils der erste Eintrag selektiert ist.

Quelltext Öffnen Sie den Objektinspektor für RadioGroup1 und wählen Sie auf der "Ereignisse"-Seite das OnClick-Ereignis aus. Durch Doppelklick auf den leeren Eintrag öffnet sich automatisch der Rahmencode des Event-Handlers, den Sie dann wie folgt ergänzen: procedure TForm1.RadioGroup1Click(Sender: TObject); begin case RadioGroup1.ItemIndex of 0: BorderStyle := bsDialog; 1: BorderStyle := bsNone; 2: BorderStyle := bsSingle; 3: BorderStyle := bsSizeable end end;

Analog verfahren Sie mit RadioGroup2: procedure TForm1.RadioGroup2Click(Sender: TObject); begin case RadioGroup2.ItemIndex of

226

Kapitel 4

Formulare und Komponenten

0: FormStyle := fsNormal; 1: FormStyle := fsStayOnTop end; end;

Test Nach Programmstart können Sie Outfit und Verhalten des Formulars beliebig ändern:

Hier der Mitleid erregende Anblick unseres Formulars ohne Titelleiste und Rand:

"Sich ja nicht unterkriegen lassen ..." ist die Devise, wenn Sie die FormStyle-Eigenschaft auf fsStayOnTop setzen. Egal wie Sie es auch anstellen, das Formular lässt sich durch andere Formulare nicht verdecken und bleibt immer an oberster Position.

Bemerkungen ■ Wie Sie gesehen haben, müssen Sie, um Fenster zu erzeugen, die aus dem "Rahmen fallen", d.h., die über keinerlei Umrandung verfügen, die BorderStyle-Eigenschaft auf bsNone setzen. Das erledigen Sie normalerweise im Objektinspektor anstatt wie in unserem Beispiel per Code. ■ Leider dürfen rahmenlose Fenster keine Menüleiste haben. Für das Entfernen des Formulars müssen Sie also programmtechnisch selbst vorsorgen, zum Beispiel mit einem extra "Schließen"-Button oder mit einem Timer.

4.6 Lernbeispiele für Einsteiger

227

4.6.2 Eingabefilter für Editierfeld Eingaben in ein Editierfeld kann man durch Auswerten des OnKeyPress-Events nach bestimmten Kriterien filtern. In unserem Beispiel sollen damit gleich drei Probleme gelöst werden: ■ Das Abstellen des lästigen Pieptons nach Betätigen der Enter-Taste.Wen hat das nicht schon genervt? ■ Das Unterdrücken aller Zeichen außer 0, 1, ... 9, dem Dezimalpunkt, dem Dezimalkomma und der Backspace-Taste.Man braucht dies ziemlich oft für Editierfelder, bei denen nur Zahleneingaben zulässig sind. ■ Das automatische Umwandeln eines Dezimalkommas in einen Dezimalpunkt. Auch dieses Feature wird relativ häufig benötigt, um Missverständnisse auszuschließen. Wünschenswert ist das Vorhandensein einer ANSI-Tabelle (siehe Anhang), um den Tastaturcode der zu filternden Zeichen festzustellen.

Oberfläche Ein Formular und eine Edit-Komponente genügen.

Quellcode Wählen Sie im Objektinspektor das OnKeyPress-Event aus. Alle drei Filter werden in einen ifthen-else-Block eingebaut. procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char); begin if Key = #13 then // wenn <Enter> Key := #0 else if not (Key in [#8,#44, #46,#48 .. #57]) then // nur BS, ".", ",", 0...9 Key := #0 else if Key = ',' then Key := '.' // Dezimalkomma => Dezimalpunkt end;

Test Wie Sie sich auch bemühen, es wird Ihnen nicht gelingen, auch nur einen einzigen Buchstaben einzugeben. Auch vom nervenden Piepton bleiben Sie verschont. Wie von Geisterhand wird aus dem Dezimalkomma ein Dezimalpunkt.

228

Kapitel 4

Formulare und Komponenten

4.6.3 Ein PopUp-Menü erstellen Jede zeitgemäße Windows-Applikation stellt kontextsensitive PopUp-Menüs bereit. Diese erscheinen nach Klick mit der rechten Maustaste auf ein bestimmtes Objekt der Bedienoberfläche. Das folgende kleine Testprogramm zeigt, wie Sie mit Delphi im Handumdrehen Ihre eigenen Programme mit PopUp-Menüs "nachrüsten" können.

Oberfläche Auf dem Startformular (Form1) platzieren Sie außer einem Editierfeld (Edit1) und einer Schaltfläche (Button1) auch eine PopUp-Menü-Komponente (PopUpMenu1), die Sie auf der Standardseite der Werkzeugleiste finden:

Klicken Sie einmal auf die PopUpMenu-Komponente und anschließend im Objektinspektor auf den Items-Eintrag. Es erscheint ein neues Fenster: der Menü-Designer. Klicken Sie dort auf das leere eingerahmte Feld und tragen Sie die erste Menüzeile ein ("Text schwarz"):

Parallel taucht dieser Eintrag auch als Caption-Eigenschaft im Objektinspektor auf, so dass Sie dort editieren können. Auf diese Weise wird das komplette Menü fertig gestellt. Für die Trennlinie verwenden Sie einen Trennstrich (-). Was aber, wenn Ihnen ein Menüeintrag nicht gefällt, Sie zwischen zwei Menüzeilen eine weitere einfügen oder gar ein Submenü erstellen möchten? Kein Problem, drücken Sie über dem MenüEntwurfsfenster die rechte Maustaste. Das diesmal "in eigener Sache" erscheinende PopUp-Menü bietet Ihnen unter anderem auch die Optionen Einfügen, Löschen und Untermenü erstellen an.

229

4.6 Lernbeispiele für Einsteiger

Quelltext Jeder Menüeintrag ist genauso ein Objekt wie jede andere Komponente und verfügt über Eigenschaften und Methoden. Allerdings gibt es nur ein Ereignis, das OnClick-Event. Wir wollen aus Übersichtlichkeitsgründen nur eine einzige Ereignisbehandlungsroutine schreiben, die wir PopUp1Click nennen. Entfernen Sie aus der Typdeklaration von Form1 die nicht benötigten Ereignismethoden und fügen Sie die für PopUp1Click hinzu: type TForm1 = class(TForm) Edit1: TEdit; Button1: TButton; PopupMenu1: TPopupMenu; Textschwarz1: TMenuItem; Textrot1: TMenuItem; Textgrn1: TMenuItem; N1: TMenuItem; Textlschen1: TMenuItem; procedure Button1Click(Sender: TObject); procedure PopUp1Click(Sender: TObject); end;

// hinzufügen!

Da wir aus Bequemlichkeitsgründen auf eine Namensänderung der Menüeinträge verzichtet haben, hat der Editor die Namen selbst auf Grundlage der Caption-Property nach bestem Wissen und Gewissen "zusammengebastelt". Dabei werden Umlaute einfach ignoriert. Die Ereignisbehandlung müssen wir komplett neu erstellen, die Herkunft des Menüklicks ergibt sich aus der allgemeinen Sender-Objektvariablen: procedure TForm1.PopUp1Click(Sender: TObject); begin with Edit1 do begin if Sender=TextSchwarz1 then Font.Color := clBlack; if Sender=TextRot1 then Font.Color := clRed; if Sender=TextGrn1 then Font.Color := clGreen; if Sender=TextLschen1 then Text := '' end end;

Wenn Sie diese Methode hinzugefügt haben, müssen Sie das Menüentwurfsfenster öffnen, auf den entsprechenden Eintrag klicken und dann die Ereignisse-Seite des Objektinspektors aufschlagen. Dort weisen Sie dem OnClick-Ereignis den Bezeichner PopUp1Click zu.

Test Starten Sie das Programm und drücken Sie über dem Editierfeld die rechte Maustaste (möglichst rechts neben dem Text, damit dieser nicht markiert wird). Es passiert – nichts! Kein Wunder, denn woher soll die Komponente Edit1 denn von ihrem Glück wissen, dass ihr ein PopUp-Menü zugeordnet wurde?

230

Kapitel 4

Formulare und Komponenten

Deshalb: Setzen Sie die PopupMenu-Eigenschaft von Edit1 auf PopupMenu1! Dieser Bezeichner wird in der kleinen Rollbox daneben ausgewählt. Über die PopupMenu-Eigenschaft verfügen Formulare und (fast) alle sichtbaren Komponenten. Falls Sie diese Property nicht besetzen, dürfen Sie sich später nicht wundern, wenn die rechte Maustaste keine Wirkung zeigt. Haben Sie das Versäumte nachgeholt, können Sie über das PopUp-Menü die Schriftfarbe der Textbox ändern sowie deren Inhalt löschen:

Bemerkungen ■ Durch Setzen der Properties Visible, Enabled, Checked u.a. (siehe Objektinspektor) zur Laufzeit können Sie Menüeinträge verschwinden lassen, sperren oder mit einem Häkchen versehen. ■ Hinter dem Namensbezeichner N1 verbirgt sich der unverdienterweise in den Status eines "Objekts" erhobene Menü-Trennstrich. ■ Wie Sie eine normale Menüleiste erstellen, wird im Beispiel 3.8.2 beschrieben.

4.7 Praxisbeispiele für Fortgeschrittene 4.7.1 Arbeiten mit Drag & Drop Das Ziehen und Loslassen von Objekten ist ein typisches Windows-Feature. Wie Sie in diesem Kapitel erfahren haben, verfügen fast alle visuellen Steuerelemente über entsprechende Eigenschaften (DragMode, DragCursor), Methoden (BeginDrag, Dragging) und Ereignisse (OnDragDrop, OnDragOver, OnStartDrag, OnEndDrag).

Oberfläche Lassen Sie uns ganz einfach beginnen und zunächst zeigen, wie man den Inhalt eines Editierfeldes in ein Bezeichnungsfeld ziehen und ablegen kann. Platzieren Sie deshalb auf dem Formular ein Editierfeld und ein Label.

4.7 Praxisbeispiele für Fortgeschrittene

231

Quelltext Das Programmieren eines vollständigen Drag & Drop-Zyklus verlangt das Besetzen von vier Event-Handlern, die gleichzeitig die vier Etappen des Ziehens und Ablegens demonstrieren: 1. Start der Drag & Drop-Operation (BeginDrag-Methode der Quelle aufrufen) Der einfachste Weg wäre, im Objektinspektor die DragMode-Eigenschaft von Edit1 auf dmAutomatic zu ändern. Dann beginnt der Ziehvorgang automatisch nach einem Mausklick. Allerdings bekommen Sie dann Schwierigkeiten, wenn Sie in Edit1 ganz normal nur Text eingeben wollen. Ohne dass Sie es wollen, würde dann ungefragt auch eine Drag & Drop-Operation gestartet werden. Es ist deshalb günstiger, DragMode auf dmManual zu belassen (Standardeinstellung) und stattdessen eine Ereignisbehandlungsroutine für das OnMouseDown-Event zu schreiben: procedure TForm1.Edit1MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin if Button = mbLeft then Edit1.BeginDrag(False) // Immediate-Parameter = False end;

Der Aufruf der BeginDrag-Methode mit dem Parameter False bewirkt, dass das Ziehen nicht sofort beginnt, sondern erst nach einer winzigen Mausbewegung. Damit ist es möglich, auf normale Mausklicks zu reagieren. Ein Aufruf mit True würde hingegen zum gleichen Ergebnis führen wie das Setzen der Eigenschaft BeginDrag = dmAutomatic. 2. Akzeptieren des gezogenen Elements (OnDragOver-Event des Ziels auswerten) Label1 empfängt ein OnDragOver-Ereignis, wenn der Inhalt von Edit1 über Label1 gezogen wird. Durch Ändern der Form des Mauszeigers soll die Bereitschaft zum Ablegen signalisiert werden. Das erreichen Sie durch Setzen des Variablenparameters Accept auf True: procedure TForm1.Label1DragOver(Sender, Source: TObject; X, Y: Integer; State: TDragState; var Accept: Boolean); begin if Source is TEdit then Accept := True end;

Beachten Sie, dass obiger Code beliebige Editierfelder als Quelle der Drag & Drop-Operation akzeptiert. Soll nur Edit1 ablegen dürfen, ändern Sie die Anweisung wie folgt: if Source = Edit1 then Accept := True;

Durch Auswerten des State-Parameters könnten Sie unterscheiden, ob das gezogene Element in das Zielobjekt hineinbewegt wird (state = dsDragEnter), sich über diesem bewegt (state = dsDragMove) oder dieses verlässt (state = dsDragLeave). 3. Ablegen des Elements (OnDragDrop-Event des Ziels auswerten) Ein akzeptiertes Element kann durch Loslassen der Maustaste abgelegt werden. Was dabei konkret passieren soll, schreiben Sie in den Event-Handler für das OnDragDrop-Ereignis der Zielkomponente (Label1):

232

Kapitel 4

Formulare und Komponenten

procedure TForm1.Label1DragDrop(Sender, Source: TObject; X, Y: Integer); if Source is TEdit then Label1.Caption := Edit1.Text end;

4. Beenden der Drag & Drop-Operation (OnEndDrag-Event der Quelle auswerten) Die Quelle des Ziehvorgangs (Edit1) erhält nach Loslassen der Maustaste über ihr OnEndDragEreignis eine Benachrichtigung, ob der Ziehvorgang erfolgreich abgeschlossen werden konnte: procedure TForm1.Edit1EndDrag(Sender, Target: TObject; X, Y: Integer); begin if Target = nil then MessageBeep(0) // kein Drag & Drop end;

In vorliegendem Fall soll ein Piepton erzeugt werden, wenn Drag&Drop misslungen ist. Im Erfolgsfall enthält der Variablenparameter Target das Objekt, in welches das gezogene Element abgelegt wurde. HINWEIS: Beachten Sie, dass alle Drag & Drop-Event-Handler die Parameter X,Y übergeben,

d.h., auch die aktuellen Mauskoordinaten könnten während des Ziehens und Loslassens ausgewertet werden.

Test Nach dem Programmstart versuchen Sie, in das Editierfeld irgendetwas einzugeben und es dann per Drag&Drop (also bei gedrückt gehaltener linker Maustaste) in das Label zu verschieben. HINWEIS: Achten Sie auf die unterschiedlichen Formen des Mauszeigers während des Zieh-

vorgangs! Ein einfacher Klick in das Editierfeld wird mit einem Piepton quittiert.

Listenfeld als Quelle für Drag & Drop Nun können wir eine etwas kompliziertere Aufgabe in Angriff nehmen. Fügen Sie als weitere Drag & Drop-Quelle ein Listenfeld (ListBox1) hinzu. Um die Listbox möglichst bequem mit irgendwelchen Einträgen zu füllen, greifen wir etwas tiefer in die Trickkiste von Object Pascal und deklarieren gleich zu Beginn des implementation-Abschnitts eine Array-Konstante ... const monate: array[1..12] of string = ('Januar','Februar','März','April', 'Mai','Juni','Juli','August', 'September','Oktober','November',Dezember');

... die wir bei Programmstart auslesen: procedure TForm1.FormCreate(Sender: TObject); var i: Integer; begin

4.7 Praxisbeispiele für Fortgeschrittene

233

for i := 1 to High(monate) do ListBox1.Items.Add(monate[i]) end;

Befähigen Sie die Listbox, als Quelle für Drag & Drop zu fungieren (dabei spielen eventuelle Zielobjekte keine Rolle!): procedure TForm1.ListBox1MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin if Button = mbLeft then ListBox1.BeginDrag(False) end;

Diese beiden bereits vorhandenen Event-Handler des Zielobjekts Label1 müssen erweitert werden: procedure TForm1.Label1DragOver(Sender, Source: TObject; X, Y: Integer; State: TDragState; var Accept: Boolean); begin if (Source is TListBox) or (Source is TEdit) then Accept := True end; procedure TForm1.Label1DragDrop(Sender, Source: TObject; X, Y: Integer); var i:Integer; begin if Source is TListBox then begin i := (Source as TListBox).ItemIndex; Label1.Caption := (Source as TListBox).Items[i] end; if Source is TEdit then Label1.Caption := Edit1.Text end;

Für das Beenden des Ziehvorgangs nutzen wir den bereits vorhandenen Event-Handler von Edit1, wir benennen ihn im Objektinspektor lediglich von Edit1EndDrag in EndDrag um: procedure TForm1.EndDrag(Sender, Target: TObject; X, Y: Integer); begin if Target = nil then MessageBeep(0) // kein Drag & Drop end;

Weisen Sie auch dem OnEndDrag-Event von ListBox1 diesen Handler zu!

Test Sie können diesmal sowohl den Inhalt des Editierfeldes als auch den in der Listbox ausgewählten Eintrag nach rechts in das Label ziehen:

234

Kapitel 4

Formulare und Komponenten

Bemerkungen Wenn Sie das gleich lautende Beispiel von der Buch-CD ausprobieren, werden Sie als Unterschied feststellen, dass Sie alle drei Objekte beliebig hin und her verschieben können, denn jede Komponente ist dort gleichzeitig Quelle und Ziel von Drag&Drop (aus Übersichtlichkeitsgründen haben wir hier beim Abdruck des Listings auf diese Erweiterung verzichtet).

4.7.2 Einsatz der Gitterkomponente Zur tabellenförmigen Datenanzeige stellt Delphi die beiden Komponenten DrawGrid und StringGrid zur Verfügung. Beide sind eng miteinander verwandt, wobei das StringGrid zweifelsohne die leistungsfähigere Variante ist. Dies ist ein typischer Fall von Vererbung, denn es entspricht vollständig dem DrawGrid und besitzt darüber hinaus zusätzliche Eigenschaften für einen vereinfachten indizierten Zugriff auf die Zellen. Das folgende kleine Demoprogramm ermöglicht die Eingabe von max. zehn Personennamen und deren Geburtsjahr und berechnet daraus deren Alter. Es benutzt dazu eine repräsentative Auswahl der wichtigsten Funktionen der StringGrid-Komponente. Angesichts des undurchschaubaren Wirrwarrs der teilweise miteinander verzahnten über 50 (!) Schlüsseleigenschaften, -methoden und -ereignisse ist eine solche Beschränkung dringend erforderlich, um Licht in das Dunkel zu bringen.

Oberfläche Wir platzieren auf dem Formular (Form1) eine Gitter-Komponente (StringGrid1), eine Listenbox (Listbox1) und eine Schaltfläche (Button1). Für StringGrid1 werden im Objektinspektor nur folgende, von den Standardwerten abweichende, Eigenschaften geändert: RowCount = 11; ColCount = 4, ScrollBars = ssVertical. Die restlichen Eigenschaften werden per Quelltext zugewiesen.

235

4.7 Praxisbeispiele für Fortgeschrittene

Quelltext In der Typdeklaration von TForm1 müssen Sie die Methode calcYears hinzufügen. Wieso das, werden Sie sich fragen, wieso wollen wir calcYears nicht als normale Prozedur realisieren? Die Antwort: Wenn wir calcYears als Methode von TForm1 programmieren, so vereinfacht sich der Zugriff auf die Steuerelemente von Form1 (z.B. braucht anstatt Form1.StringGrid1 nur noch StringGrid1 geschrieben zu werden). type TForm1 = class(TForm) ... procedure calcYears; end; ... implementation

// selbst hinzufügen!

Bei Programmstart werden Aussehen und Eigenschaften des Gitters festgelegt: procedure TForm1.FormCreate(Sender: TObject); var i:Integer; begin with StringGrid1 do begin ColWidths[0] := 30; // Breite der Fixspalte verringern Cells[0,0] := 'Nr.'; Cells[1,0] := 'Name'; Cells[2,0] := 'Geburtsjahr'; Cells[3,0] := 'Alter';

Fixspalte mit Zeilennummern ausfüllen: for i := 1 to RowCount-1 do Cells[0,i] := IntToStr(i);

Alle True-Optionseinstellungen zuweisen: Options := [goFixedVertLine, goFixedHorzLine, goHorzLine, goVertLine, goRowMoving, goColSizing, goEditing, goTabs] end end;

Das Berechnen des Alters der Person: procedure TForm1.calcYears; var heute : TDateTime; geb, jahr, monat, tag : Word; code : Integer; begin heute := Now; DecodeDate(heute, jahr, monat, tag); with StringGrid1 do

// aktuelles Datum ermitteln // aktuelle Jahreszahl berechnen

236

Kapitel 4

begin EditorMode := True; if Cells[2,row] <> '' then begin Val(Cells[2,row], geb, code); Cells[3,row] := IntToStr(jahr-geb) end end end;

Formulare und Komponenten

// sonst keine Zuweisung möglich! // nur, wenn Geburtsjahr eingetragen ist // Geburtsjahr in Zahl umwandeln // Differenz berechnen und zuweisen

Nun zur Auswertung der Tastatureingaben: procedure TForm1.StringGrid1KeyPress(Sender: TObject; var Key: Char); begin with StringGrid1 do begin // Alter nach Eingabe des Geburtsjahrs berechnen: if col = 2 then if key = Chr(13) then calcYears; // Enter-Taste // Eingaben in Alter-Spalte sperren: if col = 3 then EditorMode := False else EditorMode := True end end;

Bei einem Mausklick soll die aktuelle Zeile übernommen werden: procedure TForm1.StringGrid1Click(Sender: TObject); begin with StringGrid1 do ListBox1.Items := Rows[Row] end;

Test Starten Sie das Programm und versuchen Sie, die Breite der Spalten Ihren Wünschen anzupassen. Dazu müssen Sie auf die senkrechten Trennlinien innerhalb der oberen (fixierten) Zeile klicken und diese (bei gedrückt gehaltener Maustaste) auseinander ziehen (GoColSizing). Dabei stellen Sie fest, dass die Korrektur der Fixspalten-Breite zur Laufzeit (per Maus) nicht möglich ist. Aus diesem Grund wurde dies bereits im OnFormCreate-Event-Handler mittels ColWidths-Zuweisung erledigt. Nun füllen Sie das Gitternetz aus, wobei alle Eingaben mit der Enter-Taste abzuschließen sind. Das Alter erscheint automatisch nach Eingabe des Geburtsjahres. Danach kann mit Cursor- oder TabTaste (GoTabs) zur nächsten Zelle "gewandert" werden. Die Anzeige rechts im Listenfeld erfolgt synchron dazu.

4.7 Praxisbeispiele für Fortgeschrittene

237

HINWEIS: Lassen Sie sich nicht irritieren, wenn im Datengitter Zeilen vertauscht sind. Sie kön-

nen das selbst nachvollziehen, indem Sie die entsprechende Zeilennummer (auf der Fixspalte) anklicken und mit der Maus verschieben (GoRowMoving).

Bemerkungen ■ Erst im OnCreate-Ereignis von Form1 werden endgültiges Aussehen und Eigenschaften des Gitters festgelegt. ■ Die Zuweisung der Options-Einstellungen führt zu einer ziemlich langen Quelltextzeile, da man die im Objektinspektor vorgenommenen Einstellungen überschreibt und alle True-Werte berücksichtigen muss. Sie können sich das auch sparen, wenn Sie diese Einstellungen bereits im Objektinspektor vornehmen (dazu auf die Option-Zeile doppelklicken!). ■ Das Alter wird nicht per Hand eingegeben, sondern vom Programm aus der Differenz von aktuellem Datum und Geburtsjahr ermittelt. Dazu wird dem TForm1-Objekttyp eine extra Methode calcYears hinzugefügt.

4.7.3 Eine Aktionsliste verwenden Eine ActionList ist eine Sammlung von TAction-Objekten. Die offensichtliche Bedeutung der TActionList-Objekte wird dadurch unterstrichen, dass sie sich sogar einen Platz am Ende der Standard-Seite der Komponentenpalette erkämpfen konnten:

Ein TAction-Objekt kapselt eine Operation, die von anderen Objekten der Benutzerschnittstelle, wie z.B. Menüeinträge oder Buttons (in diesem Zusammenhang als Clients bezeichnet), als Re-

238

Kapitel 4

Formulare und Komponenten

aktion auf ein Ereignis (z.B. Mausklick) mit einem Zielobjekt (z.B. Edit- oder Memo-Komponente) durchgeführt werden soll. Demonstriert werden soll der Einsatz einer ActionList am Beispiel eines standardmäßigen "Bearbeiten"-Menüs mit den Einträgen "Ausschneiden", "Kopieren" und "Einfügen". Um zu vergleichen, wollen wir das Problem zunächst klassisch und erst danach mit Action-Objekten lösen.

Oberfläche (klassische Realisierung) Eine MainMenu-Komponente (der Sie im Menü-Editor das dargestellte Aussehen verleihen), zwei Memo- und eine Edit-Komponente sollen für die Demo genügen:

Quelltext (klassische Realisierung) Ausschneiden: procedure TForm1.Ausschneiden1Click(Sender: TObject); begin Memo1.CutToClipboard; Memo2.CutToClipboard; Edit1.CutToClipBoard end;

Kopieren: procedure TForm1.Kopieren1Click(Sender: TObject); begin Memo1.CopyToClipBoard; Memo2.CopyToClipBoard; Edit1.CopyToClipBoard end;

4.7 Praxisbeispiele für Fortgeschrittene

239

Einfügen: procedure TForm1.Einfgen1Click(Sender: TObject); begin Memo1.PasteFromClipboard; Memo2.PasteFromClipboard; Edit1.PasteFromClipboard end;

Fazit: Es ist allerhand monotoner Code zu schreiben. Aber das soll sich ja dank Action-Objekten ändern. Eröffnen Sie also ein neues Formular.

Oberfläche (mit Action-Objekten) Diese entspricht exakt der Vorgängerversion plus TActionList-Komponente. Doppelklicken Sie auf diese Komponente, und es öffnet sich der Aktionslisten-Editor. Klicken Sie mit der rechten Maustaste auf die Liste und wählen Sie "Neue Standard-Aktion". Wählen Sie die folgenden Standard-Bearbeitungsaktionen: ■ TEditCopy (kopiert den selektierten Text in die Zwischenablage) ■ TEditCut (schneidet markierten Text aus und kopiert ihn in die Zwischenablage) ■ TEditPaste (fügt Text aus der Zwischenablage in die Zielkomponente ein) Nach dem OK bietet der Aktionslisten-Editor folgenden Anblick:

Für jede dieser Aktionen könnten Sie im Objektinspektor die vorgegebenen menütypischen Eigenschaften ändern bzw. Ereignisse (OnExecute) besetzen. Wir belassen es aber bei den Standardeinstellungen (siehe Ergänzungen am Schluss).

240

Kapitel 4

Formulare und Komponenten

Klappen Sie nun das Menü auf und weisen Sie den drei Menüobjekten im Objektinspektor die entsprechende Action-Eigenschaft zu:

Quelltext (mit Action-Objekten) Darum brauchen Sie sich nicht mehr zu kümmern!

Test Wenn Sie beide Versionen vergleichen, werden Sie feststellen, dass unser Standard-Action-Objekt die komplette Funktionalität eines Bearbeiten-Menüs kapselt. Auch die Shortcuts sind bereits zugewiesen. Auch die Menüeinträge sind sinnvoll gegeneinander verriegelt, wenn also z.B. kein Text selektiert wurde, so sind auch "Ausschneiden" und "Kopieren" gesperrt. In der klassischen Programmierversion müssten Sie sich darum auch noch extra kümmern. So aber brauchten Sie keine einzige Zeile Quellcode zu schreiben – überzeugt?

Ergänzungen OnExecute-Ereignis für Action-Objekte In unserem Beispiel wurde das OnExecute-Ereignis der drei Action-Objekte nicht ausgewertet, sondern zunächst an das ActionList- und dann an das Application-Objekt weitergereicht. Falls man es aber auswertet, wird nur der zugewiesene Code abgearbeitet und das Ausführen des Action-Objekts verhindert. BEISPIEL: Es ertönt nur der Piepton, kopiert wird nicht. procedure TForm1.Kopieren2Execute(Sender: TObject); begin Beep end;

OnExecute-Ereignis für ActionList-Objekte Das Ereignis OnExecute einer ActionList bezieht sich auf alle in ihr enthaltenen Action-Objekte. Mit dem Handled-Parameter können Sie entscheiden, ob das Ereignis weitergereicht wird.

241

4.7 Praxisbeispiele für Fortgeschrittene

BEISPIEL: Vor dem Kopieren ertönt ein Piepton. procedure TForm1.ActionList1Execute(Action: TBasicAction; var Handled: Boolean); begin if Action = Kopieren2 then Beep end;

BEISPIEL: Es ertönt nur der Piepton, Ausschneiden, Kopieren und Einfügen werden nicht ausgeführt. procedure TForm1.ActionList1Execute(Action: TBasicAction; var Handled: Boolean); begin if Action = Kopieren2 then Beep; Handled := True end;

4.7.4 Rechtsbündigen Text für Editierfeld Eine Align-Eigenschaft für Editierfelder werden Sie im Objektinspektor vergeblich suchen, so dass der Inhalt immer linksbündig ausgerichtet wird. Insbesondere in Eingabemasken, wo untereinander Zahlen angezeigt werden sollen, macht das keinen guten Eindruck. Selbsthilfe ist also wieder einmal angesagt, verbunden mit einer kleinen Stippvisite in die OOP-Niederungen.

Oberfläche Ein leeres, nacktes Formular – ja, das ist kein Witz! Da wir eine neue Klasse TEditRight entwerfen müssen, können wir mit dem auf der Komponentenpalette angebotenen Editierfeld leider nichts anfangen.

Quelltext Diesmal können wir den interface-Abschnitt nicht so einfach links liegen lassen. In die Klassendeklaration von TForm1 tragen wir vorausschauend auch schon eine OnClick-Ereignisbehandlung für das neue Editierfeld ein. type TForm1 = class(TForm) procedure FormCreate(Sender: TObject); procedure Edit1Click(Sender: TObject); end;

// selbst eintragen!!!

Unser Neuling erbt von TEdit und überschreibt dessen CreateParams-Methode: TEditRight = class(TEdit) public procedure CreateParams(var Params: TCreateParams); override; end; var Form1: TForm1;

Da wir unser Editierfeld nun nicht mehr von der Komponentenpalette beziehen, ist eine Objektvariable erforderlich:

242

Kapitel 4

Formulare und Komponenten

Edit1: TEditRight;

Nun zum implementation-Abschnitt: procedure TEditRight.CreateParams(var Params: TCreateParams); begin inherited CreateParams(Params); // ererbte Methode aufrufen Params.Style := Params.Style or ES_RIGHT // Eigenschaft auf rechtsbündig erweitern end;

Wie aus dem Nichts wird unser neues Editierfeld beim Laden des Formulars erzeugt und initialisiert: procedure TForm1.FormCreate(Sender: TObject); begin Edit1 := TEditRight.Create(Self); // Instanz erzeugen Edit1.Parent := Self; // zuordnen zu Form1 Edit1.Text := 'Edit1'; Edit1.SetBounds(50,50,150,0); // Abmessungen (Left, Top, Width) zuweisen Edit1.OnClick := Edit1Click // OnClick-Ereignisbehandlung zuweisen end;

Der Event-Handler für OnClick soll einen Signalton erzeugen und den Inhalt des Editierfelds löschen: procedure TForm1.Edit1Click(Sender: TObject); begin Beep; Edit1.Text := '' end; end.

Test Starten Sie das Programm und erfreuen Sie sich am rechtsbündigen Text.

Bemerkung Natürlich könnte man auch gleich eine neue Komponente mit Alignment-Property entwickeln und auf der Komponentenpalette platzieren, aber der Aufwand lohnt nur dann, wenn Sie ein solches Editierfeld tatsächlich sehr häufig in Ihren Projekten brauchen.

5

Techniken der Softwarentwicklung

Kapitel

5

Techniken der Softwarentwicklung Zum täglichen Brot des Programmierers gehören das Testen von Programmen und die Fehlersuche. Delphi stellt dafür ein weit gefächertes Instrumentarium zur Verfügung1. Das vorliegende Kapitel stellt einige wichtige Arbeitstechniken vor.

5.1 Programmtest und Debugging Das Aufspüren von Laufzeit- und logischen Fehlern kann ziemlich zeitraubend sein. Deshalb sollten Sie regen Gebrauch von dem in die Delphi-IDE "eingebauten" Debugger machen, er hilft Ihnen Zeit und Nerven zu sparen.

5.1.1 Arbeitszyklus des Programmierers Normalerweise befindet sich die Delphi-Entwicklungsumgebung (IDE) in einem von drei Zuständen, zwischen denen Sie beim Entwickeln bzw. Testen Ihres Quelltextes ständig, bewusst oder unbewusst, wechseln: ■ Entwurfsmodus ■ Laufzeitmodus ■ Unterbrechungsmodus Welcher dieser Zustände gerade aktuell ist, entnehmen Sie im Zweifelsfall der Titelleiste des Hauptfensters, wo hinter dem Projektnamen in eckigen Klammern ein Hinweis dann erfolgt, wenn Sie sich nicht im Entwurfsmodus befinden. Die folgende Abbildung soll den Übergang zwischen den drei Arbeitszuständen verdeutlichen:

1

Wer dieses Handwerkszeug einigermaßen beherrscht, der spart viel Zeit und Nerven.

244

Kapitel 5

Techniken der Softwarentwicklung

Entwurfsmodus

Programm zurücksetzen Strg+F2

Programm zurücksetzen Strg+F2

Start

Pause

Laufzeitmodus

Fortsetzen

Unterbrechungsmodus

Der Normalzustand während der Programmentwicklung ist natürlich der Entwurfsmodus, denn nur hier können bzw. sollten Sie Änderungen an Ihrem Projekt vornehmen. Nachdem Sie das Programm gestartet haben (F9-Taste), befinden Sie sich im Laufzeitmodus. Durch Strg+F2 bzw. über den Menüpunkt Start|Programm zurücksetzen kehren Sie in jedem Fall in den Entwurfsmodus zurück. Besonders wichtig für das Debugging (siehe folgender Abschnitt) ist der Unterbrechungsmodus. Man erreicht ihn durch Klick auf Start|Programm-Pause oder durch das Setzen von Haltepunkten (Breakpoints). Nach Laufzeitfehlern stellt sich der Unterbrechungsmodus automatisch ein. HINWEIS: Beenden Sie Delphi nicht bei laufendem Debugger! Ein System-Reset ist unvermeid-

lich, und alle vorgenommenen Änderungen sind futsch!

5.1.2 Vorbereitungen zum Debugging Die Bedienung des Debuggers ist für den Einsteiger ziemlich unübersichtlich, da Einstellungen und Zugriff über verschiedene Menüs erfolgen (Projekt|Optionen, Tools|Debugger-Optionen, Start, Ansicht|Debug-Fenster, PopUpMenü Fehlersuche, ...). Im Folgenden wollen wir Sie deshalb nur mit den grundlegenden Arbeitsmethoden vertraut machen. Wählen Sie den Menüpunkt Projekt|Optionen... und anschließend die Seite "Compiler". Im "Debuggen"-Rahmen setzen Sie Häkchen bei "Debug-Informationen" und "Lokale Symbole" (normalerweise sind das bereits die Voreinstellungen). Jetzt ist dafür gesorgt, dass Ihre Anwendungen zusammen mit symbolischer Debug-Information compiliert werden.

5.1 Programmtest und Debugging

245

Der Debugger wird automatisch aktiviert. Falls trotzdem im Start-Menü die Debugger-spezifischen Befehle (F7, F8 etc.) nicht verfügbar sind, müssen Sie den Debugger manuell aktivieren. Wählen Sie dazu Tools/Debugger-Optionen und setzen Sie unten links das Häkchen bei "Integrierte Fehlersuche". Der Komfort des Debugging hat allerdings seinen Preis: Der Umfang der EXE-Datei wächst. HINWEIS: Um den Umfang der EXE-Datei zu minimieren, sollten Sie nach Abschluss der Pro-

grammentwicklung Ihr endgültiges Projekt einer Schlankheitskur unterwerfen und noch einmal ohne Debug-Informationen compilieren.

5.1.3 Die verschiedenen Debug-Möglichkeiten Aus der Vielfalt der Möglichkeiten, die das Debugging unter Delphi mittlerweile bietet, wollen wir uns hier auf die wichtigsten Betriebsarten beschränken (siehe auch Menü Start): ■ Einzelne Anweisung ausführen (F7) ■ Gesamte Routine ausführen (F8) ■ Anweisungen bis zum Haltepunkt (Breakpoint) ausführen ■ Anweisungen bis zur Cursorposition ausführen (F4) ■ Haltepunkt mit einer Bedingung verknüpfen ■ Ausdrücke berechnen und auswerten

246

Kapitel 5

Techniken der Softwarentwicklung

Die folgende Abbildung verdeutlicht den Unterschied zwischen den drei erstgenannten Betriebsarten: Einzelschritt

START

a := 320; b := b+1; WriteLn('Der Wert von a:', a); WriteLn('Der Wert von b:', b); WriteLn('Der Quotient : ',a / b); WriteLn('Maximum : ',max(a, b)); WriteLn('Das wars...');

function max(a,b:Integer):Single; if a > b then max := a else max := b end end;

Prozedurschritt

START

a := 320; b := b+1; WriteLn('Der Wert von a:', a); WriteLn('Der Wert von b:', b); WriteLn('Der Quotient : ',a / b); WriteLn('Maximum : ',max(a, b)); WriteLn('Das wars...');

Breakpoint

START

a := 320; b := b+1; WriteLn('Der Wert von a:', a); WriteLn('Der Wert von b:', b); WriteLn('Der Quotient : ',a / b); WriteLn('Maximum : ',max(a, b)); WriteLn('Das wars...');

Breakpoint

Um die einzelnen Betriebsarten auszuprobieren, können Sie natürlich eine beliebige Anwendung nehmen. BEISPIEL: Ein einfaches Demoprogramm, das sich an obige Abbildung anlehnt, besteht aus einem Formular

mit zwei Buttons ("Start" und "Beenden") und einer ListBox zur zeilenweisen Anzeige 1. Nach jedem Klick auf den "Start"-Button wird der Wert einer globalen Variablen b um eins erhöht und mit Hilfe einer Funktion max mit dem Wert einer lokalen Variablen a verglichen. Hier der implementation-Abschnitt: var b:Integer = 10; function max(a,b: Integer): Single; begin 1

// initialisierte Variable // Maximum von a und b

Das Programm hat, wie Sie sehen, keinerlei sinnvolle Funktion – aber hier geht es nur um die Erläuterung eines Prinzips.

5.1 Programmtest und Debugging

247

if a > b then Result:= a else Result:= b end;

Button "Start": procedure TForm1.Button1Click(Sender: TObject); var a: Integer; s: string; begin a:= 320; Inc(b); with ListBox1.Items do begin Add('Der Wert von a: ' + IntToStr(a)); Add('Der Wert von b: ' + IntToStr(b)); Str(a/b:8:4, s); Add('Der Quotient a/b: ' + s); Str(max(a,b):8:2, s); Add('Das Maximum : ' + s); Add('Das war es dann ...'); Add('-------------------') end end;

Button "Beenden": procedure TForm1.Button2Click(Sender: TObject); begin Close end;

5.1.4 Schrittweise Abarbeitung Wir beziehen uns bei den folgenden Erläuterungen auf das Vorgängerbeispiel.

Einzelschritt-Modus Statt wie gewohnt das Programm mit F9 zu starten, wählen Sie das Menü Start|Einzelne Anweisung. Danach betätigen Sie schrittweise F7. Delphi befindet sich nun im Unterbrechungsmodus, was Sie an der Titelleiste des Hauptfensters erkennen, denn dort erscheint die Beschriftung "[Angehalten]". Im Quelltext können Sie den Programmfortschritt beobachten (grüner Pfeil und blaue Zeilenmarkierung). Die aktuelle Zeile wird auch "Ausführungsposition" genannt.

248

Kapitel 5

Techniken der Softwarentwicklung

Die Werte einzelner Variablen in der Ausführungsposition können Sie nun per gelber QuickInfo kontrollieren, indem Sie den Mauscursor darauf setzen und einen Moment verweilen. HINWEIS: Beachten Sie, dass Sie auch im Einzelschritt-Modus alle notwendigen Benutzer-

eingaben selbst vornehmen müssen. Bei unserem Beispiel ist unmittelbar nach Erscheinen des Formulars der "Ausführen"-Button zu klicken, sonst passiert – nichts! Genauso müssen Sie nach Durchlaufen aller Zeilen den "Beenden"-Button klicken, um das Programm zu schließen und in den Entwurfsmodus zurückzukehren. Für diese wie für alle anderen Betriebsarten des Debuggers gilt, dass Sie über Strg+F2 (bzw. das Menü Start|Programm zurücksetzen) den Debug-Modus verlassen können, um in den normalen Entwurfsmodus zurückzukehren.

Prozedurschritt Bei dieser Variante verfahren Sie völlig analog zum Einzelschritt, nur dass Sie diesmal das Menü Start|Gesamte Routine klicken bzw. die F8-Taste benutzen. Sie werden in unserem Beispiel beobachten, dass bei den Anweisungen innerhalb der max-Funktion nicht angehalten wird. Den Prozedurschritt werden Sie also nur dann verwenden, wenn es schnell gehen muss und Sie die Fehlerursache außerhalb einer aufgerufenen Funktion/Prozedur vermuten.

5.1 Programmtest und Debugging

249

Ab Cursorposition Beim Debuggen umfangreicherer Anwendungen ist es höchst lästig, wenn das Programm immer wieder beginnend mit der ersten Anweisung schrittweise durchgearbeitet werden muss, bis endlich die interessante Stelle erreicht ist. Aber das geht auch wesentlich schneller: Setzen Sie einfach den Cursor in eine Zeile vor einer "verdächtigen" Anweisung und betätigen Sie F4 (bzw. Menü Start| zur Cursorposition gehen). Das Programm hält an dieser Stelle. Jetzt können Sie sich mit F7 oder auch F8 schrittweise weiter vorwärts tasten.

5.1.5 Haltepunkte Quelltext-Haltepunkte setzen Von den verschiedenen Typen von Breakpoints, die Sie über das Menü Start|Haltepunkt hinzufügen setzen können, ist der Quelltext-Haltepunkt der wichtigste. Klicken Sie einfach mit der Maus auf den linken breiten grauen Rand des Quelltextfensters, und es erscheint ein gewaltiger roter Punkt, auch die gesamte Zeile wird rot markiert. Genauso einfach lassen sich die Haltepunkte wieder entfernen – Sie brauchen nur draufzuklicken. Nach Programmstart (F9) werden alle Anweisungen bis vor die Breakpoint-Zeile ausgeführt. Anschließend können Sie schrittweise mit F7 bzw. F8 fortfahren. Natürlich lassen sich auch mehrere Breakpoints setzen. Eine sehr praktikable Möglichkeit ist das Setzen von Haltepunkten nicht zur Entwurfs-, sondern erst zur Laufzeit. Sie starten dazu Ihr Programm ganz normal mit F9. Nachdem z.B. das Eröffnungsformular erschienen ist, holen Sie das entsprechende Quelltextfenster nach vorne und setzen den oder die Haltepunkt(e). Nun klicken Sie z.B. einen Button, und das Programm setzt die Ausführung bis zum Haltepunkt fort. Besonders dann, wenn Sie mehrere Breakpoints gesetzt haben, sind Sie für eine Übersicht dankbar. Wählen Sie dazu das Menü Ansicht|Debug-Fenster|Haltepunkte (Strg+Alt+B). Es erscheint die Liste der Haltepunkte. Wie Sie der folgenden Abbildung entnehmen, werden die Haltepunkte anhand ihrer Zeilennummer unterschieden. Um herauszufinden, welche Zeilennummer zu welchem Breakpoint gehört, setzen Sie nur den Cursor in die entsprechende Zeile und lesen die Nummer unten links in der Statuszeile des Quelltextfensters ab.

250

Kapitel 5

Techniken der Softwarentwicklung

Abbruchbedingung setzen Jeder Haltepunkt kann mit einer Abbruchbedingung verknüpft werden. Öffnen Sie zunächst die Liste der Haltepunkte (Strg+Alt+B) und klicken Sie dann mit der rechten Maustaste auf den Breakpoint, dem Sie eine Bedingung zuordnen möchten. Im PopUp-Menü wählen Sie "Eigenschaften". In das sich öffnende Dialogfenster wird von Ihnen z.B. die Bedingung b = 18 eingetragen und mit "OK" bestätigt:

Wenn Sie jetzt unser Demoprogramm normal starten (F9), müssen Sie achtmal auf den Button klicken, bis die Ausführung bei b = 18 schließlich unterbrochen wird.

5.1.6 Auswerten von Ausdrücken Im Einzelschrittmodus (z.B. mit F7) arbeiten Sie sich bis zu einer bestimmten Quelltextzeile vor, anschließend wählen Sie das Menü Start|Auswerten/Ändern oder Strg+F7. In das sich öffnende Fenster geben Sie den zu berechnenden Ausdruck ein und klicken "Auswerten":

Alternativ können Sie auch eine bestimmte Variable bzw. einen Ausdruck im Quelltext mit der Maus markieren und sich anschließend mit Strg+F7 das obige Fenster anzeigen lassen.

251

5.2 Fehlerbehandlung

5.1.7 OutputDebugString Für den Profi bietet sich eine weitere recht praktische Möglichkeit des Debuggings mit der OutputDebugString-Anweisung, die an fast jeder gewünschten Stelle des Programms untergebracht werden kann. Etwas gewöhnungsbedürftig ist allerdings die Syntax: HINWEIS: Sie müssen die Variablen etc., die Sie anzeigen wollen, erst in einen PChar-Datentyp

umwandeln. BEISPIEL: Fügen Sie diese Anweisung in unser Beispielprogramm ein. OutputDebugString(PChar('Zustand von A:' + IntToStr(a)));

Nach der Ausführung bietet das Ereignisprotokoll (Ansicht|Debug-Fenster|Ereignisprotokoll) den folgenden Anblick:

Damit dürfte sich die Funktion für das asynchrone Debuggen von Programmen oder HintergrundThreads hervorragend eignen.

5.2 Fehlerbehandlung Ein Anwendungsprogramm kann weitestgehend1 fehlerfrei sein, spätestens im Zusammenhang mit der Ein- und Ausgabe von Dateien treten aber garantiert Fehler auf, die es abzufangen gilt. Vier verschiedene Möglichkeiten der Fehlerbehandlung bieten sich an: ■ Ausschalten der Fehlermeldungen über Compilerschalter und Abfragen des Fehlercodes mit IOResult ■ Fehlerbehandlung mit Try-Except-Blöcken ■ Fehlerbehandlung mit Try-Finally-Blöcken ■ Fehlerbehandlung über OnException-Ereignis Eine pauschale Empfehlung kann eigentlich nicht gegeben werden. Die Autoren haben jedoch die Erfahrung gemacht, dass sich insbesondere Dateioperationen mit der konventionellen Variante am besten überwachen lassen (wohl auch, weil man die meisten Fehlercodes mittlerweile im Kopf hat). 1

DAS fehlerfreie Programm dürfte es wohl nicht geben. Sie sollten dies jedoch nicht zum Anlass nehmen, "Bananensoftware" (... reift beim Anwender) zu entwickeln. Schlechte Beispiele dieser Art finden sich auf (fast) jeder Festplatte.

252

Kapitel 5

Techniken der Softwarentwicklung

Fehler in Berechnungen (Division durch null etc.) sollten Sie auf alle Fälle mit Try-Except abfangen. Die bisher praktizierte Variante, derartige Fälle durch eine If-Klausel auszuschließen, ist viel zu umständlich und zu langsam. HINWEIS: Bei den Datenbank-Objekten TTable und TQuery bieten sich mit den OnXXXError-

Ereignissen weitere Ansatzpunkte für eine gezielte Fehlerbehandlung.

5.2.1 Ein-/Ausgabeprüfung ausschalten Die "konventionelle" Methode dürfte den Pascal-Programmierern bekannt vorkommen. Nach dem Ausschalten der Fehlermeldungen mit {$i-} können auftretende Fehler zu einem späteren Zeitpunkt über die Funktion IOResult abgefragt werden. BEISPIEL: "Konventionelle" Fehlerbehandlung AssignFile(f,'c:\test.txt'); {$i-} Rewrite(f); {$i+} if IOResult <> 0 then begin showmessage('Datei konnte nicht geöffnet werden ...') halt; end;

Die wichtigsten Fehler beim Arbeiten mit Dateien: Code

Bemerkung/Hinweis

2

Datei nicht gefunden (Reset, Append, Rename, Erase).

3

Pfad nicht gefunden (Reset, Append, Rename, Erase, ChDir, MkDir, RmDir).

4

Zu viele Dateien geöffnet (Reset, Rewrite, Append),

5

Zugriff auf Datei verweigert (Reset, Rewrite, Append, Rename, Erase, MkDir, RmDir, Read, Write).

abhängig vom Eintrag Files in der CONFIG.SYS.

Ursache: Benutzt durch anderen Prozess, keine Rechte im Netz etc. 15

Ungültiges Laufwerk (GetDir, ChDir).

16

Aktuelles Verzeichnis kann nicht gelöscht werden (RmDir).

17

Umbenennen über Laufwerke hinweg nicht erlaubt (Rename).

100

Lesefehler von Diskette/Festplatte (Read).

101

Schreibfehler auf Diskette/Festplatte (Close, Write, Writeln). Ursache: Ziellaufwerk voll.

253

5.2 Fehlerbehandlung

5.2.2 Try-Except Programmblöcke, die einen Fehler auslösen können, werden in so genannten Try-Except-Blöcken "gekapselt":

Try Programmcode, der einen Fehler auslösen kann Fehler

Except Fehlerbehandlungsroutine

Normaler Ablauf

End

Tritt innerhalb des geschützten Blocks (d.h. zwischen Try und Except) ein Fehler auf, wird die Programmausführung in diesem Block unterbrochen und hinter Except fortgesetzt. Sollte wider Erwarten doch kein Fehler auftreten, wird der Except-End-Block nie durchlaufen. BEISPIEL: Try-Except procedure LadeDatei(dateiname:string); var f : file; begin try AssignFile(f,dateiname); Reset(f); { hier tritt evtl. ein Fehler auf } except messagebox(0,'Dateiladefehler','Problem',16); exit; end; ... end;

Tritt im Bereich zwischen try und except ein Fehler auf, werden alle Anweisungen zwischen except und end ausgeführt. Neben der pauschalen Anzeige einer Dialogbox können Sie auch gezielt einzelne Fehlerklassen behandeln. Verwenden Sie dazu das on do-Konstrukt.

254

Kapitel 5

Techniken der Softwarentwicklung

BEISPIEL: "Gezielte" Fehlerbehandlung procedure LadeDatei(dateiname:string); ... except on EInOutError do Messagebox(0,'Dateiladefehler','Problem',16); end end;

Bei den beiden oben genannten Varianten der Fehlerbehandlung wird die Programmausführung normal fortgesetzt. Möchten Sie jedoch, dass der Fehler zu einem Programmabbruch führt, können Sie diesen im Except-End-Block erneut auslösen. Verwenden Sie dazu die Anweisung Raise. BEISPIEL: "Beabsichtigtes" Auslösen eines Fehlers ... except on EInOutError do begin Messagebox(0,'Dateiladefehler','Problem',16); Raise // Fehler erneut auslösen end end;

HINWEIS: Ein einfaches Praxisbeispiel mit Try-Except finden Sie unter 5.4.3.

5.2.3 Try-Finally Ein weiteres Konstrukt zur Fehlerbehandlung ist dann von Interesse, wenn das "Kind schon in den Brunnen gefallen ist". Nach dem Motto "Retten, was zu retten ist" geht es darum, Systemressourcen etc. auch im Fehlerfall sicher wieder freizugeben. Die Rede ist von den Try-Finally-Blöcken.

Try Programmcode, der einen Fehler auslösen kann Fehler

Finally

Normaler Ablauf

Routine, die unbedingt ausgeführt werden muß

End

Normaler Ablauf

5.2 Fehlerbehandlung

255

Sollte ein Fehler den gewohnten Ablauf stören, wird die Programmausführung im geschützten Block unterbrochen und nach Finally fortgesetzt. HINWEIS: Dieser Teil wird auch beim "normalen" Programmablauf ausgeführt.

Diese Art der Fehlerbehandlung sollten Sie für das Reservieren/Freigeben von Ressourcen verwenden (Speicher, Objekte und dergleichen). BEISPIEL: Try-Finally var bitmap : TBitmap; begin bitmap := TBitmap.Create; try bitmap.width := Form.width div teiler; // dies kann einen Fehler erzeugen ... finally bitmap.free; // die Ausführung wird trotz des Fehlers hier fortgesetzt end end;

5.2.4 Das OnException-Ereignis Ansatzpunkt für eine weitere Form der Fehlerbehandlung ist das OnException-Ereignis des Application-Objekts. Weisen Sie diesem Ereignis beim Start der Anwendung eine eigene Fehlerbehandlungsroutine zu, entscheiden Sie, ob und welche Fehlermeldungen angezeigt werden. Ein derartiger Error-Handler ist für die gesamte Anwendung verantwortlich. BEISPIEL: Eine neue Ereignisroutine (vergessen Sie nicht, die Methode in die Klassendeklaration des Fensters

aufzunehmen): procedure TForm1.Fehlerhandler(Sender: TObject; E: Exception); begin MessageDlg('Hilfe, ein Fehler!', mtError, [mbOk], 0) end;

Die Zuweisung der Ereignisroutine im FormCreate-Ereignis: procedure TForm1.FormCreate(Sender: TObject); begin Application.OnException := Fehlerhandler end;

Die fehlerauslösende Funktion: procedure TForm1.Button1Click(Sender: TObject); var f : file; begin AssignFile(f,'c:\dddd');

256

Kapitel 5

Reset(f); ... end;

Techniken der Softwarentwicklung

// hier tritt evtl. ein Fehler auf

Da Ihnen in der Fehlerbehandlungsroutine auch der jeweilige Fehlertyp zur Verfügung steht (E: Exception), können Sie den Fehler natürlich auch gezielt auswerten. if E is EDivByZero then MessageDlg('Division durch NULL', mtError, [mbOk], 0) else MessageDlg(e.message, mtError, [mbOk], 0)

Im Programm selbst können Sie auf eine Fehlerbehandlung z.B. mit Try-Except verzichten, diese Aufgabe wird voll vom zentralen Error-Handler übernommen.

5.2.5 Erzeugen eigener Fehlerklassen In den bisherigen Beispielen sind wir davon ausgegangen, dass ein vordefinierter Fehler aufgetreten ist. Delphi bietet Ihnen aber auch die Möglichkeit, eigene Fehlerklassen zu definieren.

Die Klasse Exception Als Vorfahren für Ihre neue Fehlerklasse wählen Sie Exception. Exception = class(TObject) private FMessage: string; FHelpContext: Integer; public constructor Create(const Msg: string); constructor CreateFmt(const Msg: string; const Args: array of const); constructor CreateRes(Ident: Integer); constructor CreateResFmt(Ident: Integer; const Args: array of const); constructor CreateHelp(const Msg: string; AHelpContext: Integer); constructor CreateFmtHelp(const Msg: string; const Args: array of const; AHelpContext: Integer); constructor CreateResHelp(Ident: Integer; AHelpContext: Integer); constructor CreateResFmtHelp(Ident: Integer; const Args: array of const; AHelpContext: Integer); destructor Destroy; override; property HelpContext: Integer property Message: string; end;

Nach der Definition Type MeinNeuerFehler = class(Exception)

können Sie im Programmcode den Fehler mit der Anweisung Raise auslösen: raise MeinNeuerFehler.Create('Wassereinbruch in Laufwerk A: !!!');

5.2 Fehlerbehandlung

257

Der selbst definierte Fehler kann natürlich genauso wie die bereits vordefinierten Fehler behandelt werden: try raise MeinNeuerFehler.Create('Wassereinbruch in Laufwerk A: !!!'); except on e: MeinNeuerFehler do showmessage(e.message) end;

Vielleicht haben Sie sich schon gewundert, dass die Klasse Exception über acht verschiedene Konstruktoren verfügt? Die Begründung für diese Vielfalt: Statt der einfachen Create-Methode können Sie zum Beispiel auch einen etwas komplexeren Konstruktor verwenden, der in der Lage ist, die Fehlermeldung aus einer Ressource zu laden oder eine formatierte Meldung auszugeben. raise MeinNeuerFehler.CreateFmt('%s in Laufwerk %s',['Wassereinbruch','A:']);

Mehrsprachige Fehlermeldungen Wer mehrsprachige Anwendungen entwickelt, sollte sich auf jeden Fall die Methode CreateResFmt näher ansehen. BEISPIEL: In der Ressourcen-Stringtabelle legen Sie String "Datei %s nicht gefunden!" unter der ID 1001

bzw. "File %s not found!" unter der ID 2001 ab. Im Programm genügt dann der Aufruf raise MeinNeuerFehler.CreateResFmt(1001,['daten.dat']);

bzw. raise MeinNeuerFehler.CreateResFmt(1001,['daten.dat']);

um die deutsche bzw. die englische Variante der Fehlermeldung anzuzeigen.

Zusätzliche Eigenschaften Genügen Ihnen die Eigenschaften der Klasse Exception nicht, können Sie (wie bei jedem anderen Objekt) weitere Eigenschaften und Methoden hinzufügen. BEISPIEL: Neue Fehlerklasse Type MeinNeuerFehler = class(Exception) private FFehlernummer : Integer; public property Fehlernummer:Integer read FFehlernummer; constructor Create(const Msg: string; nr: Integer); end;

Die Methode Create können Sie gegebenenfalls überschreiben, um die zusätzliche Eigenschaft zu setzen:

258

Kapitel 5

Techniken der Softwarentwicklung

constructor MeinNeuerFehler.Create(const Msg: string; nr : Integer); begin inherited Create(msg); FFehlernummer := nr; end;

Der spätere Ernstfall: try raise MeinNeuerFehler.Create('Die Festplatte brennt !',14); except on e: MeinNeuerFehler do Showmessage(format('Fehlernummer: %d',[e.Fehlernummer])) end;

HINWEIS: Anstatt sich zu sehr mit der Definition neuer Fehlerklassen zu beschäftigen, sollten

Sie lieber gleich fehlertoleranten Quellcode schreiben.

5.3 Dialogfenster Für Standardein-/-ausgaben lässt sich ein Dialog am einfachsten mit den Windows-typischen MessageBox- bzw. InputBox-Funktionen realisieren (Unit Dialogs). Allerdings handelt es sich hierbei um keine von TForm abgeleiteten Objekte, sondern um ein direktes Anzapfen der Windows-API. Dadurch ist es ohne großen Programmieraufwand möglich, Zwischenergebnisse oder Warnungen anzuzeigen oder auch Werte einzugeben. Aus diesem Grund können diese Dialogfenster-Funktionen auch sehr gut für Testzwecke bzw. zur Fehlersuche eingesetzt werden.

5.3.1 ShowMessage Mit dieser Prozedur kann eine Meldung ohne viel Federlesens auf den Bildschirm ausgegeben werden. Ein Dialog ist nicht möglich. SYNTAX:

procedure ShowMessage(const Msg: string); ShowMessage('Das ist eine Demonstration über die Funktion eines einfachen' + 'Meldungsfensters!');

5.3 Dialogfenster

259

Um die Titelleiste brauchen Sie sich hier nicht zu kümmern, sie entspricht dem Namen der Projektdatei. Das Meldungsfenster erscheint exakt in Bildschirmmitte positioniert und ist so breit, wie es der Text erfordert. HINWEIS: Soll ein Zeilenumbruch realisiert werden, so ist das Zeichen #13 einzufügen. BEISPIEL: Schreiben Sie folgenden Code für das OnClick-Event eines Buttons. procedure TForm1.Button1Click(Sender: TObject); var i: Integer; begin for i:= 1 to 5 do ShowMessage(IntToStr(i)+ ' Das ist eine Demonstration über die Funktion' + #13 + 'eines einfachen Meldungsfensters!') end;

Sie müssen insgesamt fünfmal den OK-Button des Meldungsfensters klicken, bis das Programm beendet ist. Am Textanfang steht die Nummer des jeweiligen Durchlaufs.

Sie erkennen an diesem Beispiel auch, wie man zu Testzwecken Zahlenwerte anzeigt. Übrigens könnten Sie mit #9 auch einen Tabulator einfügen.

ShowMessagePos Hier handelt es sich lediglich um eine Erweiterung der ShowMessage-Prozedur, mit der man zusätzlich die genaue Position des Meldungsfensters festlegen kann. ShowMessagePos('Hallo',10,20);

platziert die linke obere Ecke des Meldungsfensters 10 Pixel vom linken bzw. 20 Pixel vom oberen Bildschirmrand entfernt.

5.3.2 MessageBox Diese Routine erlaubt ebenfalls vielgestaltige Dialogfenster und kapselt die gleichnamige APIFunktion MessageBox (Unit Windows), was man schon an dem für Text und Caption erforderlichen PChar-Datentyp erkennen kann. SYNTAX:

function MessageBox(Text,Caption:PChar; Flags:Word): Integer;

260

Kapitel 5

Techniken der Softwarentwicklung

Diese Funktion ist eine Methode von TApplication, was beim Aufruf beachtet werden muss. var button: Integer; // Rückgabewert ... button := Application.MessageBox('Klick auf die OK Schaltfläche!', 'Meldungsfenster', 49);

Wie leicht zu ersehen ist, bezeichnet Text den Inhalt und Caption die Titelleiste des Meldungsfensters. Wenn Sie hier statt der geforderten PChar-Datentypen Variablen vom string-Datentyp übergeben wollen, erhalten Sie eine Fehlermeldung "Inkompatible Typen PChar und String". Erforderlich ist in diesem Fall ein Konvertieren des Strings mit Hilfe der PChar-Funktion. s := 'Klick auf die OK-Schaltfläche!'; button := Application.MessageBox(s, 'Meldungsfenster', 49);

// falsch

... erzeugt einen Compilerfehler. Richtig ist für die zweite Zeile: button := Application.MessageBox(PChar(s), 'Meldungsfenster', 49);

// richtig

Nicht so einfach zu durchschauen ist der Wert von Flags, welcher das Aussehen (Schaltflächen, Symbol, Standardvorgabe) bestimmt und sich aus der Summe von mehreren Konstanten ergibt: Flag : = Symbol + Schaltfläche + Standardvorgabe Die Werte der Konstanten sind in den folgenden Tabellen zusammengefasst, wobei wir uns allerdings nur auf die wichtigsten beschränken wollen. BEISPIEL: Für das Vorgängerbeispiel gilt 49 = 48 + 1 + 0.

Symbol: Schaltfläche: Standardvorgabe:

48 1 0

MB_ICONWARNING MB_OKCANCEL MB_DEFBUTTON1

Symbol Konstante

Wert

Symbol

0

ohne

MB_ICONSTOP

16

MB_ICONQUESTION

32

261

5.3 Dialogfenster

Konstante

Wert

MB_ICONWARNING

48

MB_ICONINFORMATION

64

Symbol

Schaltflächen Konstante

Wert

MB_OK

0

MB_OKCANCEL

1

MB_ABORTRETRYIGNORE

2

MB_YESNOCANCEL

3

MB_YESNO

4

MB_RETRYCANCEL

5

MB_HELP

16384

Schaltfläche(n)

Standardvorgabe Diese Konstanten legen fest, welche Schaltfläche beim Erscheinen des Meldungsfensters den Fokus besitzt bzw. welche Wirkung bei Betätigen der Enter-Taste erzielt wird. Konstante

Wert

Standardvorgabe

MB_DEFBUTTON1

0

erste Schaltfläche

MB_DEFBUTTON2

256

zweite Schaltfläche

MB_DEFBUTTON3

512

dritte Schaltfläche

BEISPIEL: Einfaches Meldungsfenster ohne Prüfen des Rückgabewertes Application.MessageBox('Dateizugriff verweigert','Problem',16);

262

Kapitel 5

Techniken der Softwarentwicklung

Rückgabewerte Hier die möglichen Rückgabewerte der MessageBox-Funktion: Konstante

Wert

Bedeutung

0

Fehler (zu wenig Speicher)

IDOK

1

Schaltfläche OK gedrückt

IDCANCEL

2

Schaltfläche Abbrechen gedrückt

IDABORT

3

Schaltfläche Abbrechen gedrückt

IDRETRY

4

Schaltfläche Wiederholen gedrückt

IDIGNORE

5

Schaltfläche Ignorieren gedrückt

IDYES

6

Schaltfläche Ja gedrückt

IDNO

7

Schaltfläche Nein gedrückt

BEISPIEL: Für eine Ja-/Nein-Abfrage genügt der folgende Code: if Application.MessageBox('Programm beenden?','Frage',36) = 6 then Close;

// 32 + 4

BEISPIEL: Ahnungslose Kollegen können Sie mit folgender "Meldung" in Angst und Schrecken versetzen: var button: Integer; ... button := Application.MessageBox('Achtung Ihre Festplatte wird formatiert!', 'Hinweis', 66); // 64 + 2 case button of 3: ShowMessage('Abbruch'); 4: ShowMessage('Wiederholen'); 5: ShowMessage('Ignorieren') end;

263

5.3 Dialogfenster

5.3.3 MessageDlg Dies ist eine ähnliche Funktion wie MessageBox, hat aber einen grundsätzlich anderen Aufbau (keine Methode von TApplication, string anstatt PChar) und stammt (genauso wie ShowMessage) aus der Unit Dialogs. SYNTAX:

function MessageDlg(const Msg: string; aType: TMsgDlgType; aButtons: TMsgDlgButtons; HelpCtx: LongInt): Word;

Wie Sie sehen, werden andere Konstanten1 als bei der MessageBox-Funktion verwendet. Zusätzlich kann eine Hilfeseite aufgerufen werden. BEISPIEL: Der Code if MessageDlg('Wollen Sie das Programm beenden?', mtInformation,[mbYes, mbNo], 0) = mrYes then begin MessageDlg('Programm wird beendet!', mtWarning,[mbOk], 0); Close end;

erzeugt nacheinander folgende zwei Meldungsfenster:

Parameter Der Parameter aType legt den Typ des angezeigten Meldungsfensters fest. Daran ist die Beschriftung der Titelleiste automatisch gekoppelt (im Unterschied zu MessageBox haben Sie hier also keine individuellen Gestaltungsmöglichkeiten!):

1

Konstante

Symbol

Titelleiste

mtCustom

ohne

Name der Programmdatei

mtWarning

'Warnung'

mtError

'Fehler'

mtConfirmation

'Bestätigung'

mtInformation

'Information'

aus der VCL

264

Kapitel 5

Techniken der Softwarentwicklung

aButtons legt fest, welche Schaltflächen im Meldungsfenster angezeigt werden. Das können auch mehrere sein, da aButtons vom Mengentyp TMsgDlgBtns ist. Die entsprechenden Konstanten sind eigentlich selbst erklärend und sollen deshalb hier (zusammen mit den zugehörigen Beschriftungen) nur aufgezählt werden: mbYes ('Ja'), mbNo ('Nein'), mbOK ('OK'), mbCancel ('Abbruch'), mbHelp (Hilfe), mbAbort (Abbruch), mbRetry (Wiederholen), mbIgnore (Ignorieren), mbAll (Alle). Weiterhin gibt es die drei Konstanten mbYesNoCancel, mbOkCancel, mbAbortRetryIgnore, die vordefinierte Mengen für gebräuchlichen Schalterkombinationen darstellen. Da es sich bei diesen Konstanten um bereits vordefinierte Mengen handelt, sind die eckigen Klammern [ ] wegzulassen. MessageDlg('Fehler beim Lesen der Datei!', mtError, mbAbortRetryIgnore, 0)

HelpCtx zeigt eine kontextsensitive Hilfeseite an (F1) und entspricht der Eigenschaft HelpContext.

Rückgabewerte Die von der MessageDlg-Funktion gelieferten Werte dürften ebenfalls selbst erklärend sein: mrNone, mrAbort, mrYes, mrOk, mrRetry, mrNo, mrCancel, mrIgnore, mrAll, so dass auf eine gesonderte Beschreibung verzichtet werden kann (siehe Online-Hilfe).

MessageDlgPos Während die Funktion MessageDlg das Meldungsfenster zentriert auf dem Bildschirm ausgibt, kann man mit MessageDlgPos zusätzlich auch noch die Position festlegen (vergleiche ShowMessagePos). MessageDlgPos('Programm wird beendet!', mtWarning,[mbOk], 0, 100, 200);

erzeugt ein Meldungsfenster, dessen linke obere Ecke sich 100 Pixel vom linken bzw. 200 Pixel vom oberen Bildschirmrand entfernt befindet. Ein umfangreiches Beispiel zum "Erzeugen von Meldungsfenstern" finden Sie im Praxisteil.

5.3.4 InputBox und InputQuery Wer ohne großen Aufwand etwas eingeben möchte und auf Schönheit keinen gesteigerten Wert legt, kann sich dieser beiden schlichten Dialogbox-Funktionen bedienen.

InputBox In den meisten Fällen dürfte diese Funktion genügen. SYNTAX:

function InputBox(const aCaption, aPrompt, aDefault: string): string;

Parameter sind die Titelleiste (aCaption), eine Eingabeaufforderung (aPrompt) und der Anfangsinhalt (aDefault). Rückgabewert ist ein String (die Eingabezeile).

5.3 Dialogfenster

265

BEISPIEL: Nach OK wird der Inhalt der Eingabezeile dem Label1 zugewiesen. Label1.Caption:= InputBox('Input Box', 'Geben Sie etwas ein!', 'Anfangswert');

InputQuery Diese etwas kompliziertere Funktion liefert keinen String, sondern einen Boole'schen Wert zurück, mit dem Sie überprüfen können, mit welcher Schaltfläche die Box verlassen wurde. SYNTAX:

function InputQuery(const aCaption, aPrompt: string; var value: string): Boolean;

Die ersten beiden Parameter (aCaption und aPrompt) entsprechen denen der InputBox-Funktion. Der Eingabestring wird nicht direkt zurückgegeben, sondern mit value geliefert. Der Rückgabewert ist True, wenn OK geklickt wurde, ansonsten False (bei "Abbrechen" oder bei Schließen der InputBox über das Systemmenü). BEISPIEL: Es erscheint exakt die gleiche InputBox wie im Vorgängerbeispiel. Wenn Sie aber auf "Abbrechen"

klicken, wird dem Label der Inhalt 'Es wurde nichts eingegeben!' zugewiesen. var s: String;

... s := 'Anfangswert'; if InputQuery('Input Box','Geben Sie etwas ein!', s) then Label1.Caption := s else Label1.Caption := 'Es wurde nichts eingegeben!';

Häufig wollen Sie mit einer InputBox nicht Strings, sondern numerische Werte eingeben. Dann müssen Sie entsprechende Konvertierungsfunktionen (siehe Kapitel 2) einsetzen. Während dies bei Integer-Werten mittels IntToStr- bzw. StrToInt-Funktionen noch relativ einfach ist, müssen bei Gleitkommawerten noch spezielle Formatierungsangaben bzw. Fehlercodeprüfungen hinzukommen. var wert: Double; // einzugebende Gleitkommazahl code: Integer; // Fehlercode ... Str(wert:3:2, s); // Wert => String (3 Stellen, davon 2 Nachkommastellen) s := InputBox('Personal-Eingabe','Körpergröße?', s); // Anzeige/Eingabe Val (s, wert, code); // String => Wert (fehlerfrei: code = 0)

266

Kapitel 5

Techniken der Softwarentwicklung

5.4 Praxisbeispiele 5.4.1 Erzeugen von Meldungsfenstern Zur Darstellung eines Meldungsfensters gibt es überraschend viele Möglichkeiten, und Sie haben die Qual der Wahl. Das folgende kleine Testprogramm soll Ihnen die Entscheidung erleichtern, indem es für jede Variante ein mehr oder weniger sinnvolles Beispiel liefert.

Oberfläche Welche Komponenten benötigt werden, entnehmen Sie bitte der folgenden Abbildung (GroupBox, RadioButton, Image, Button):

Insgesamt stehen sechs Alternativen (Schaltflächen) in Form unterschiedlicher Funktionen/Prozeduren für die Anzeige von Meldungsfenstern zur Auswahl. Die in einer GroupBox zusammengefassten fünf RadioButtons dienen der Symbolauswahl. Die entsprechenden Ikonen wurden der Picture-Eigenschaft von Image-Komponenten zugewiesen (als *.BMP-Dateien auf der Buch-CD enthalten).

Quelltext Da der Interface-Abschnitt der Formular-Unit keine Besonderheiten bietet, wollen wir hier nur den Implementation-Abschnitt abdrucken: var mb_S: Word; mtS: TMsgDlgType;

// für Symbolauswahl von MessageBox // für Symbolauswahl von MessageDlg

Alle fünf RadioButtons teilen sich eine Ereignisprozedur, in welcher den Variablen mb_S und mtS diverse Konstanten für die Symbolauswahl zugewiesen werden: procedure TForm1.RadioButtonClick(Sender: TObject); // Symbol einstellen begin

267

5.4 Praxisbeispiele

if Sender if Sender if Sender if Sender if Sender end;

= = = = =

RadioButton1 RadioButton2 RadioButton3 RadioButton4 RadioButton5

then then then then then

begin begin begin begin begin

mb_S mb_S mb_S mb_S mb_S

:= := := := :=

0; mtS := mtCustom end; 16; mtS := mtError end; 32; mtS := mtConfirmation end; 48; mtS := mtWarning end; 64; mtS := mtInformation end

Die ShowMessage-Prozedur wird an einem nicht ganz simplen Codebeispiel demonstriert. Hier soll gezeigt werden, wie man Object-Pascal-Sprachkonstrukte (For-Schleife) ausprobieren, Zahlenwerte ausgeben (IntToStr...) und einen Zeilenumbruch (#13) realisieren kann: procedure TForm1.Button1Click(Sender: TObject); // ShowMessage-Prozedur var i: Integer; begin for i:= 1 to 5 do ShowMessage(IntToStr(i)+ ' Das ist eine Demonstration der Funktion' + #13 + 'eines einfachen Meldungsfensters!') end;

Wem obige Demo zu kompliziert war, der sollte sich zunächst den folgenden Code zu ShowMessagePos ansehen, bei dem Sie Ihre Aufmerksamkeit voll auf die Positionskoordinaten (x=10, y=20) richten können: procedure TForm1.Button2Click(Sender: TObject); // ShowMessagePos-Prozedur begin ShowMessagePos('Einfaches Meldungsfenster mit Position!', 10,20) end;

Bei der folgenden MessageBox-Prozedur wird das Formular-Handle benötigt. Mit der Variablen mb_S wird das ausgewählte Symbol eingestellt: procedure TForm1.Button3Click(Sender: TObject); // MessageBox-Prozedur begin MessageBox(Self.Handle,'Klick auf den Button!','Meldungsfenster', mb_S) end;

Die folgende MessageBox-Funktion ist eine Methode von TApplication. Im Beispiel soll gezeigt werden, wie Symbol (mb_S), Art und Anzahl der Schaltflächen (mb_okCancel) und der Fokus (mb_defButton2) durch Addition von Konstanten eingestellt werden: procedure TForm1.Button4Click(Sender: TObject); // MessageBox-Funktion var button: Integer; begin button := Application.MessageBox('Klick auf die OK-Schaltfläche!', 'Meldungsfenster', mb_S + mb_okcancel + mb_defbutton2); if button = idOK then Application.MessageBox('Danke!', 'Meldungsfenster', mb_S + mb_ok) end;

Die MessageDlg-Funktion hat eine Syntax, die relativ einfach zu durchschauen ist: procedure TForm1.Button5Click(Sender: TObject); // MessageDlg-Funktion begin

268

Kapitel 5

Techniken der Softwarentwicklung

if MessageDlg('Wollen Sie das Programm beenden?', mtS, [mbNo,mbYes,mbCancel], 0) = mrYes then begin MessageDlg('Sie wurden gerade veralbert!', mtS, [mbOk], 0); end; end;

Mit der Schwesterfunktion MessageDlgPos wollen wir endlich etwas Sinnvolles anstellen, indem wir eine Möglichkeit zum Verlassen des Programms anbieten: procedure TForm1.Button6Click(Sender: TObject); // MessageDlgPos begin if MessageDlgPos('Wollen Sie das Programm beenden?', mtS, [mbYes,mbNo], 0, 200, 100) = mrYes then begin MessageDlgPos('Das Programm wird beendet!', mtS, [mbOk], 0, 500, 400); Close // Programmende end end;

Test Starten Sie das Programm (F9) und experimentieren Sie mit den einzelnen Varianten, wie z.B. hier mit der MessageBox-Funktion:

5.4.2 Werteingabe mit der InputBox Um dieses Beispiel nicht gar zu trivial zu gestalten, soll ein Record-Array über eine InputBox gefüllt und gelesen werden. Dass wir dazu einen selbst definierten Record TPerson nehmen, hat einen praktischen Hintergrund: Die einzelnen Recordfelder repräsentieren jeweils einen unterschiedlichen Datentyp (String, Boolean, Integer, Single). Da deren Konvertierung jeweils unterschiedlich ist, schlagen wir gleich mehrere Fliegen mit einer Klappe.

Oberfläche Das Startformular hat fünf Labels und zwei Befehlsschaltflächen:

269

5.4 Praxisbeispiele

Da man mit der InputBox nicht nur Werte eingeben, sondern auch anzeigen kann, wären die Labels eigentlich überflüssig. Sie sollen aber als zusätzliche Kontrollanzeige dienen.

Quelltext Vom Interface-Abschnitt der Formular-Unit zeigen wir Ihnen hier nur den interessanten Teil: Wir konstruieren einen Record ... type TPerson = record name: string[20]; geschlecht: Boolean; geburtsjahr: Integer; groesse: Single end;

und einen Array-Typ aus diesem Record: const nmax = 5;

// maximal 2 Personen

type TPersArray = array[1..nmax] of TPerson; var Form1: TForm1;

Jetzt muss noch eine Variable dieses Typs definiert werden: persArray1: TPersArray;

Nun zur Implementierung: implementation {$R *.DFM} procedure TForm1.Button1Click(Sender: TObject); var s : String; i, code : Integer; w : Single; begin for i:=1 to nmax do begin

// "Start"-Schaltfläche

270

Kapitel 5

Techniken der Softwarentwicklung

Keinerlei Probleme gibt es bei Strings: s := InputBox('Personal-Eingabe','Geben Sie den '+IntToStr(i)+ '. Namen ein!', persArray1[i].name); // Anzeige/Eingabe persArray1[i].name := s; // in Array speichern Label2.Caption := s; // im Label anzeigen

Boole'sche Werte müssen wir "per Hand" konvertieren: if persArray1[i].geschlecht = True then s := 'ja' else s := 'nein'; s := InputBox('Personal-Eingabe','männlich? (ja/nein)', s); if s = 'ja' then persArray1[i].geschlecht := True else persArray1[i].geschlecht := False; Label3.Caption := s; // im Label anzeigen

Ganzzahlige Werte sind einfach zu behandeln: s := IntToStr(persArray1[i].geburtsjahr); s := InputBox('Personal-Eingabe','Geburtsjahr?',s); persArray1[i].geburtsjahr := StrToInt(s); Label4.Caption := s;

// // // //

aus Array lesen Anzeige/Eingabe in Array speichern im Label anzeigen

Besonderes Fingerspitzengefühl verlangt die Hin- und Rückkonvertierung von Gleitkommawerten (Str- und Val-Funktion): Str(persArray1[i].groesse:3:2, s); // 3 Stellen, davon 2 nach dem Komma s := InputBox('Personal-Eingabe','Körpergröße?', s); Val (s, persArray1[i].groesse, code); // fehlerfrei, wenn code = 0 Label5.Caption := s end end;

Test Nach Programmstart (F9) und Klicken der "Start"-Befehlsschaltfläche müssen Sie zunächst die Geduld für die Eingabe der Daten von zwei Personen aufbringen (ansonsten vor dem Compilieren die Konstante nmax verändern!). Fehlerhafte Eingaben können Sie mit der "Abbrechen"-Taste verwerfen. Anschließend lassen Sie sich durch aufeinander folgendes Klicken von "OK" alle Datenfelder der Reihe nach anzeigen.

5.4 Praxisbeispiele

271

5.4.3 Zahleneingaben überprüfen Dieses Beispiel zeigt eine komfortable Möglichkeit, wie man mittels try-except-Anweisungen eine detaillierte Prüfung des Zahlentyps und seines Wertebereichs gewährleistet. Damit ein praktischer Sinn erkennbar ist, soll das Prinzip anhand der simplen Addition zweier Gleitkommazahlen erläutert werden.

Oberfläche Auf dem Formular platzieren Sie drei Editierfelder und zwei Buttons.

Da Edit3 nur zur Ergebnisanzeige dient, sollten Sie hier ReadOnly auf True setzen.

Quelltext Die folgenden Anweisungen werden beim Verlassen eines Editierfeldes ausgeführt: procedure testSingle(e: TEdit); // Übergabeparameter ist ein Editierfeld! var n : Single; code : Integer; s : string; begin s := e.text; try Val(s,n,code); // Versuch, den String s in die Zahl n zu verwandeln except MessageBox(0,'Wertebereich überschritten','Problem',16); e.SetFocus end; if code <> 0 then begin MessageBox(0,'Fehler im Ausdruck','Problem', 16); e.SetFocus end; end;

272

Kapitel 5

Techniken der Softwarentwicklung

Die Fehlerbehandlung mit Try-Except ist unbedingt notwendig, da die Anweisung Val eine Wertebereichsverletzung nicht "verkraftet" und das Programm zum Absturz bringt. Der Aufruf von testSingle erfolgt in einem OnExit-Event-Handler, der von Edit1 und Edit2 gemeinsam benutzt wird: procedure TForm1.EditExit(Sender: TObject); begin testSingle((Sender as TEdit)) end;

Test Sobald Sie ein Editierfeld verlassen wollen, in dem keine gültige Single-Zahl steht, werden Sie durch ein Meldungsfenster gezwungen, die Eingabe zu korrigieren. Ein Schließen des Formulars über den "Beenden"-Button ist erst dann möglich, wenn in den beiden Eingabefeldern keine fehlerhaften Werte stehen.

5.4.4 Fehlersuche mit dem Debugger In diesem Beispiel sollen Sie lernen, wie Laufzeit- und logische Fehler mit Hilfe des Debuggers aufgespürt und beseitigt werden. Grundlage ist ein fehlerbehaftetes Programm, welches Maximum, Minimum und Durchschnittswert einer Reihe von Integer-Zahlen ermitteln soll.

Oberfläche Die folgende Abbildung dürfte für Klarheit sorgen (links in der Mitte, das ist eine ListBox).

5.4 Praxisbeispiele

273

Quellcode Der im Folgenden angegebene Quelltext ist die vereinfachte Version des Beispiels 2.8.6 (auf das Array zum Zwischenspeichern wurde verzichtet, was sich in einem vereinfachten Quelltext auszahlt). Eintrag in Listbox übertragen: procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char); begin if Key = #13 then begin ListBox1.Items.Add(Edit1.Text); Edit1.Text := '' end end;

Berechnen: procedure TForm1.Button1Click(Sender: TObject); var i, n, wert, max, min, sum: Integer; av: Double; s: string; begin n := ListBox1.Items.Count; for i := 1 to n do begin wert := StrToInt(ListBox1.Items[i]); if (wert > max) then max := wert else if (wert < min) then min := wert; sum := sum + wert end; av := sum / n; Panel1.Caption := IntToStr(max); Panel2.Caption := IntToStr(min); Str(av:5:2, s); Panel3.Caption := s end;

Löschen: procedure TForm1.Button2Click(Sender: TObject); begin ListBox1.Items.Clear; Panel1.Caption := ''; Panel2.Caption := ''; Panel3.Caption := '' end;

274

Kapitel 5

Techniken der Softwarentwicklung

Test Starten Sie das Programm. Das Compilieren geht anstandslos, aber das "dicke Ende" kommt noch. Nachdem Sie eine Zahlenkolonne (z.B. die Ziffern 2, 3 und 4) eingegeben haben und auf "Berechne" klicken, erscheint eine Fehlermeldung:

HINWEIS: Die folgenden Hinweise zur Fehlersuche sind nur eine von vielen möglichen Strate-

gien. Auf jeden Fall sollten Sie versuchen, auch ohne diese Hinweise das Programm in einen funktionsfähigen Zustand zu versetzen!

Hinweise zur Fehlersuche Beenden Sie das Programm mit Start|Programm zurücksetzen (Strg+F2) und setzen Sie einen Haltepunkt auf die erste Anweisung im Event-Handler "Berechne" (doppelt auf breiten linken Rand klicken). Starten Sie das Programm erneut (F9) und wiederholen Sie die Eingaben. Nach Klick auf "Berechne" stoppt das Programm am Haltepunkt und Sie können sich mit der F7-Taste schrittweise vorwärts bewegen. Stutzig werden müssen Sie, nachdem Sie mit der Maus auf die Variable wert zeigen. Auf dem gelben Hinweisschildchen erscheint "wert = 3" (siehe Abbildung), obwohl Sie als ersten Wert der Zahlenkolonne eine "2" eingegeben hatten. Nachdem Sie der Debugger quasi "mit der Nase draufgestoßen hat", müsste Ihnen dämmern, dass das erste Element einer Listbox nicht den Index 1, sondern den Index 0 hat. Korrigieren Sie also die Schleifenanweisung wie folgt: for i := 0 to n-1 do

5.4 Praxisbeispiele

275

Beim folgenden Test werden Sie feststellen, dass die Zahlen richtig aus der ListBox ausgelesen werden. Nachdem Sie sich mittels F7-Taste dreimal durch die Schleife gearbeitet haben, folgt allerdings wieder die Ernüchterung. Zwar ist das Minimum richtig ermittelt, Maximum und Durchschnitt sind jedoch der blanke Unsinn:

Mmmm, spätestens jetzt sollten Sie einen Blick auf den untersten Abschnitt des Codefensters werfen, wo vom Compiler drei verdächtige "Warnungen" präsentiert werden:

276

Kapitel 5

Techniken der Softwarentwicklung

Richtig, wir haben die drei Variablen zwar deklariert, ihnen aber keine Anfangswerte zugewiesen – es ist ein Trugschluss zu glauben, dass Delphi die Variablen mit 0 initialisiert! Das holen wir jetzt schnell nach und fügen gleich nach begin die folgende Anweisung ein: max := 0; min:=0; sum:=0;

Unsere Hoffnung auf ein fehlerfreies Programm wird aber zum wiederholten Mal enttäuscht, zwar scheinen Maximum (4) und Durchschnitt (3) nun richtig zu sein, das Minimum (0) ist aber eindeutig falsch. Wiederholen Sie den Test aber mit einer anderen Zahlenkolonne, in der auch negative Werte vorkommen, so sind alle drei Ergebnisse richtig. HINWEIS: Sie haben es also hier mit einem der übelsten und hinterlistigsten Fehler zu tun, die es

überhaupt gibt, nämlich solchen, die nur unter bestimmten Bedingungen auftreten! Um die Ursache zu ergründen, können Sie sich die Variablen max, min und sum innerhalb eines bestimmten Schleifendurchlaufs (z.B. i=2) anschauen. Dazu verknüpfen Sie den Haltepunkt mit einer Bedingung (Strg+Alt+B, "Eigenschaften"):

Der Debugger bietet Ihnen weitere vielfältige Möglichkeiten zum Eingrenzen des Fehlers (siehe 5.1), und die Autoren würden Ihnen einen schlechten Dienst erweisen, wenn Sie Ihnen hier das komplett fehlerbereinigte Programm präsentieren würden – der Lerneffekt ginge gegen null. Aus diesem Grund sind Sie jetzt an der Reihe. Wer es nicht schafft, den Fehlerteufel aus seinem Versteck herauszulocken, dem bleibt immer noch ein Blick in die Buch-CD, wo beide Varianten (fehlerhaft und fehlerbereinigt) enthalten sind.

Bemerkungen ■ Ein Debugger kann keine Wunder vollbringen, aus einem schwachsinnigen Algorithmus kann er Ihnen kein funktionsfähiges Programm zaubern. ■ Sehr viel wichtiger ist, dass Sie Ihren eigenen klaren Kopf und Ihre Fähigkeit zum logischen Denken bereits beim Programmentwurf einsetzen. Der Debugger kann Ihnen nur dabei helfen, die unvermeidlichen kleinen, aber heimtückischen Fehler schneller zu finden.

6

Units und Objekte

Kapitel

6

Units und Objekte Pascal war von Anfang an eine streng strukturierte Sprache, die in den 80er-Jahren systematisch als Turbo Pascal (TP) weiterentwickelt wurde. Einen wesentlichen Sprung gab es beim Übergang der TP-Version 3 zu 4 mit der Einführung des Unit-Konzepts. Noch gravierender war der Übergang von Version 5 zu 5.5, wo mit der Weiterführung zur Objektorientierten Programmierung (OOP) die Grundlagen von Object Pascal gelegt wurden. Da in Delphi das Unit- und das OOP-Konzept aufs Engste miteinander verknüpft sind, werden wir beides in diesem Kapitel gemeinsam behandeln.

6.1 Programmieren in Units Units sind die komplexen Bausteine Ihres Delphi-Programms und können gewissermaßen als Vorläufer der OOP betrachtet werden. Jede Unit enthält eine eigene Bibliothek von Variablen, Konstanten, Prozeduren, Funktionen und Datentypen, die (in compilierter Form) in verschiedene andere Units eingebunden werden kann. Auch unter OOP verwenden Sie weiterhin Units, diese enthalten dann aber vor allem Klassendeklarationen. HINWEIS: Wer sich in OOP einarbeiten will, sollte vorher das Unit-Konzept von Delphi gründ-

lich studiert und verstanden haben.

6.1.1 Das Unit-Konzept In der Regel besteht jedes Delphi-Programm aus mindestens einer Unit (z.B. aus der zu Form1 gehörenden Unit1).

Unit-Bezeichner Speziell für das Programmieren von Units sind in Object Pascal folgende Wörter reserviert (die unbedingt notwendigen sind fett hervorgehoben): Bezeichner

Erklärung

finalization

finaler Abschnitt einer Unit

implementation

Beginn des Rumpfs (lokaler Teil) einer Unit

278

Kapitel 6

Bezeichner

Erklärung

initialization

Initialisierungsabschnitt einer Unit

interface

Schnittstelle (globaler Deklarationsteil) einer Unit

unit

einleitender Bezeichner (Deklaration) einer Unit

uses

Liste der verwendeten Units

Units und Objekte

Unit-Struktur Eine Unit setzt sich aus verschiedenen Abschnitten zusammen, die in streng vorgeschriebener Reihenfolge aufgeführt werden müssen: unit interface uses // optional // öffentliche Deklarationen implementation uses // optional // private Deklarationen // Implementierung von Prozeduren und Funktionen initialization // Initialisierungscode optional finalization // Schlusscode optional end.

HINWEIS: Jede Unit wird in einer .pas-Datei gespeichert und in eine .dcu-Datei compiliert.

Unit-Beispiel Obwohl wir zu den Details erst später übergehen, soll bereits jetzt ein erster Eindruck vermittelt werden. BEISPIEL: Eine einfache Unit mit dem Namen zylinder stellt Routinen zur Berechnung von Volumen und

Oberfläche eines Zylinders bereit. unit zylinder; interface var zr, zh: Double; // Radius und Höhe sind öffentliche Variablen! function zVolumen: Double; // öffentliche Routine zur Volumenberechnung procedure zOberflaeche(var o: Double); // dto. zur Oberflächenberechnung implementation var gF: Double; // Grundfläche (private Variable) procedure zGFlaeche; // Berechnen der Grundfläche (private Prozedur) begin gf := Pi * zr * zr end;

279

6.1 Programmieren in Units

// Schnittstellenroutinen: function zVolumen; begin zGFlaeche; Result := gf * zh end;

// verkürzte Kopfzeile!

// Volumen = Grundfläche mal Höhe

procedure zOberflaeche; begin zGFlaeche; o := 2 * gf + Pi * 2 * zr * zh end; end.

// verkürzte Kopfzeile!

Die Programmierung dieser trivialen Unit wurde bewusst etwas umständlich realisiert, um wesentliche strukturelle Merkmale zu verdeutlichen: ■ Der Aufbau des interface-Abschnitts zeigt, dass die Unit zwei Variablen (zr und zh) sowie zwei Routinen (Funktion zVolumen und Prozedur zOberflaeche) exportiert. Für beide Routinen wird lediglich die Kopfzeile angegeben. ■ Im implementation-Abschnitt werden die beiden Routinen programmiert. Typbezeichner und Parameterliste können dann (müssen aber nicht) in der Kopfzeile weggelassen werden. ■ Die privaten Variablen und Routinen des implementation-Abschnitts (gF, zGFlaeche) haben nur lokale Bedeutung und werden von der Unit nicht exportiert. HINWEIS: Das Einbinden der Unit in eine andere Unit wird mittels uses-Klausel veranlasst. BEISPIEL: Obige Unit zylinder wird in die Unit1 (von Form1) eingebunden. Die benutzten Elemente der Unit

sind durch Fettdruck hervorgehoben:. implementation uses zylinder; // Einbinden der Unit procedure TForm1.Button1Click(Sender: TObject); var x: Double; s: string; // lokale Zwischenvariablen begin zr := 23.7; zh:= 50; // Radius und Höhe zuweisen x:= zVolumen; // Volumen berechnen Str(x:6:2,s); Label1.Caption := s; // Ergebnisanzeige = 88 230.06 zOberflaeche(x); // Oberfläche berechnen Str(x:6:2, s); Label2.Caption := s // Ergebnisanzeige = 10974.78 end;

HINWEIS: Um sich einen Überblick darüber zu verschaffen, welche Units zu einem Projekt ge-

hören, wählen Sie den Menüpunkt Ansicht|Projektverwaltung.

280

Kapitel 6

Units und Objekte

BEISPIEL: Unser obiges kleines Beispielprojekt besteht aus der von uns selbst erstellten Unit zylinder.pas und

der von Delphi "vorgefertigten" Formular-Unit Unit1.pas:

Das komplette Programm (mit variabler Eingabe) finden Sie auf der Buch-CD:

6.1.2 Eine Unit im Detail Es folgen nun nähere Erläuterungen zu den verschiedenen Abschnitten einer Unit.

Interface-Abschnitt Dieser Teil ist von den reservierten Wörtern interface und implementation eingeschlossen. Dazwischen wird die nach außen "sichtbare" Schnittstelle der Unit definiert, d.h., es werden öffentliche (public) Konstanten, Typen, Variablen, Prozeduren und Funktionen deklariert. Von Prozeduren und Funktionen werden nur die Kopfzeilen aufgeführt, während sich der eigentliche Code im Implementationsteil befindet.

Implementation-Abschnitt Der Implementationsteil beginnt mit dem reservierten Wort implementation und enthält den Programmcode aller öffentlichen Prozeduren und Funktionen. Außerdem werden hier auch Konstanten, Typen, Variablen, Prozeduren und Funktionen für den internen Gebrauch (private) deklariert.

6.1 Programmieren in Units

281

Die Reihenfolge, in der Sie Prozeduren und Funktionen im implementation-Abschnitt definieren bzw. referenzieren, muss nicht der Deklarationsreihenfolge im interface-Abschnitt entsprechen. Die Kopfzeilen von Prozeduren und Funktionen können, müssen aber nicht, vom interfaceAbschnitt dupliziert werden, da auch ein Verzicht auf die formale Parameterliste möglich ist (so genannte Kurzform). Wenn Sie trotzdem die Parameterliste mit angeben, erzeugt der Compiler dann eine Fehlermeldung, wenn die Deklarationen im Interface- von denen im Implementationsteil abweichen. BEISPIEL: Im Interface-Teil steht der Prozedurkopf: procedure berechneVolumen(a, b, c: Single; var vol: Double);

Im Implementation-Teil kann die verkürzte Form stehen: procedure berechneVolumen; begin v := a * b * c end;

HINWEIS: Bei der Deklaration privater Funktionen und Prozeduren muss die formale Para-

meterliste immer angegeben werden (Kurzform ist verboten!).

Initialization-Abschnitt Dieser optionale Teil der Unit umfasst das reservierte Wort initialization, gefolgt von einer oder mehreren Anweisungen zum Initialisieren der Unit nach Programmstart. Um die Kompatibilität zu älteren Versionen von Turbo Pascal zu erhalten, könnte man auch das reservierte Wort begin anstatt initialization verwenden. Davon ist allerdings abzuraten, da dem Compiler dadurch das Nachvollziehen von sog. Blockverschachtelungsfehlern erschwert wird. HINWEIS: Innerhalb eines Programms werden die Initialisierungsteile in der gleichen Reihen-

folge ausgeführt, wie die entsprechenden Units in der uses-Klausel des Hauptprogramms aufgelistet sind.

Finalization-Abschnitt Dieser optionale Abschnitt kann nur in solchen Units enthalten sein, die auch einen initializationAbschnitt besitzen. Die ablaufenden Vorgänge bewirken das Gegenteil der Initialisierung: Sämtliche von der Unit im initialization-Abschnitt belegten Ressourcen sollten wieder freigegeben werden. HINWEIS: Setzen Sie den Cursor im interface-Abschnitt auf den Kopf der Methode oder Public-

Prozedur. Um die Implementierung der Methode/Prozedur anzuzeigen, drücken Sie danach Strg+Umschalt+Pfeil nach oben bzw. Strg+Umschalt+Pfeil nach unten.

282

Kapitel 6

Units und Objekte

Uses-Klausel Ebenso wie ein Programm kann auch eine Unit auf andere Units zugreifen. Letztere müssen, durch Kommas getrennt, nach dem reservierten Wort uses aufgelistet werden. Wie der Basisstruktur zu entnehmen ist, gibt es dafür zwei Möglichkeiten: ■ Öffentliche (public) Deklaration In diesem Fall erscheint die uses-Klausel unmittelbar nach dem Wort interface. Programme bzw. andere Units, die die aktuelle Unit benutzen, können also auch zusätzlich auf die hier angeführten Units zugreifen. Allerdings sind im Interface-Teil so genannte "zirkulare" Deklarationen verboten (siehe unten). Wenn z.B. Unit A die Unit B öffentlich benutzt, darf das andererseits die Unit B nicht mit der Unit A tun (und umgekehrt). ■ Interne (private) DeklarationWenn nur die aktuelle Unit Gebrauch von zusätzlichen Units machen will, so sind letztere in der zweiten uses-Klausel (also unmittelbar nach dem reservierten Wort implementation) anzuführen. Andere Programme bzw. Units, die die aktuelle Unit nutzen, haben keinen Zugriff! Allerdings sind hier zirkulare Deklarationen erlaubt, d.h., Unit A kann Unit B benutzen und umgekehrt (siehe unten). BEISPIEL: Die uses-Klausel im interface-Abschnitt eines neu eröffneten Formulars: uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;

Zur Bedeutung siehe Abschnitt 6.3.4.

Abhängige Unit-Referenzen In einer uses-Klausel müssen nur die Units enthalten sein, die direkt von dem Programm bzw. von der Unit verwendet werden, wo die uses-Klausel steht. Referenziert beispielsweise Unit A Konstanten, Typen, Variablen, Prozeduren oder Funktionen, die in Unit B deklariert sind, muss die Unit B explizit in der uses-Klausel von Unit A angegeben werden. Referenziert B wiederum Bezeichner aus Unit C, ist Unit A indirekt von Unit C abhängig. In diesem Fall muss Unit C nicht in einer usesKlausel in Unit A angegeben werden. Der Compiler benötigt jedoch Zugriff auf die Units B und C, während Unit A verarbeitet wird. BEISPIEL: Hier hängt Unit3 direkt von Unit2 ab, die wiederum direkt von Unit1 abhängig ist. Unit3 ist also

indirekt von Unit1 abhängig. Da aber UnitA nicht in der uses-Klausel von Unit3 angegeben ist, kann auf die in Unit1 deklarierten Bezeichner (c) von Unit3 aus nicht direkt zugegriffen werden. unit Unit3; interface uses Unit2; const a = b; ... unit Unit2; interface uses Unit1; const b = c; ... unit Unit1; interface

6.1 Programmieren in Units

283

const c = 1; ...

Zirkuläre Unit-Referenzen Gegenseitige Abhängigkeiten von Units (d.h. direktes oder indirektes gegenseitiges Referenzieren) sind zulässig, solange keine zirkulären Pfade auftreten, die eine uses-Klausel im interfaceAbschnitt einer Unit mit der uses-Klausel im interface-Abschnitt einer anderen Unit verbinden. Damit gegenseitige Abhängigkeiten gültig sind, muss der Pfad jeder zirkulären Referenz über die uses-Klausel mindestens eines implementation-Abschnitts führen. Im einfachsten Fall (zwei gegenseitig voneinander abhängige Units) bedeutet dies, dass sich die Units nicht gegenseitig in den uses-Klauseln der entsprechenden interface-Abschnitte referenzieren dürfen. BEISPIEL: Unerlaubte zirkuläre Referenz führt zu einem Compilerfehler. unit Unit1; interface uses Unit2; ... unit Unit2; interface uses Unit1; ...

Erlaubt ist eine gegenseitige Referenzierung jedoch, wenn zumindest eine der Referenzen in den implementation-Abschnitt verlagert wird: BEISPIEL: Erlaubte zirkuläre Referenz unit Unit1; interface uses Unit2; ... unit Unit2; interface ... implementation uses Unit1; ...

HINWEIS: Zwecks Vermeidung unzulässiger zirkulärer Referenzen sollten Sie Ihre selbst ent-

wickelten Units möglichst in der uses-Klausel des implementation- und nicht des interface-Abschnitts aufführen. Falls aber Bezeichner einer Unit im interface-Abschnitt vorkommen, muss die Unit in der uses-Klausel des interface-Abschnitts enthalten sein.

284

Kapitel 6

Units und Objekte

6.2 Object Pascal Im Unterschied zu den prozeduralen Sprachen bedeutet "objektorientiert", dass Daten und Algorithmen nicht mehr nebeneinander existieren, sondern in Objekten gekapselt sind. Object Pascal unterscheidet sich deshalb grundsätzlich von seinen Turbo Pascal-Vorfahren, wo man es lediglich mit Daten und Algorithmen zu tun hatte. Object Pascal ist leicht erlernbar, denn die visuelle Entwicklungsumgebung von Delphi erlaubt objektorientiertes Programmieren bereits mit einem Minimum an Vorkenntnissen.

6.2.1 OOP-spezifische Sprachelemente Bereits im Kapitel 1 (Abschnitte 1.2.2) haben Sie gelernt, dass Objekte durch Eigenschaften, Methoden und Ereignisse charakterisiert sind. Die folgenden reservierten Wörter und Standardanweisungen beziehen sich unmittelbar auf die objektorientierte Programmierung unter Delphi. Bezeichner

Erklärung

abstract

... deklariert virtuelle bzw. dynamische Methode ohne Implementation

class

... deklariert Objekttyp (oder Klassenmethode)

constructor

... initialisiert Objekt

default

... gibt Array-Standardeigenschaft eines Objekts an

destructor

... gibt Objekt wieder frei

dynamic

... wie virtual, nur mit anderer Bearbeitung des Methodenaufrufs zur Laufzeit

inherited

... benennt den Vorfahren des Objekttyps der umschließenden Methode

is

... dynamische Typüberprüfung bei Objekten

Message

... ruft eine botschaftsverarbeitende Methode auf

object

... Einheit aus Daten und Methoden (durch class abgelöst!)

overload

... kennzeichnet eine überladene Methode

property

... Eigenschaftsdeklaration

protected

... kombiniert Vorteile von public- und private-Komponenten

override

... definiert erneut (überschreibt) eine virtuelle (oder dynamische) Methode

private

... objektbezogener Teil innerhalb einer Objekttypdeklaration

public

... allgemein gültiger Teil innerhalb einer Objekttypdeklaration

published

... wie public, nur mit zusätzlichen Laufzeit-Typinformationen

read

... für Lesen des Wertes von Objekteigenschaften

stored

... steuert, ob eine Eigenschaft in einer Datei abgelegt wird oder nicht

virtual

... deklariert eine virtuelle Methode

write

... für Schreiben des Wertes von Objekteigenschaften

6.2 Object Pascal

285

Sie ergänzen die entsprechenden Zusammenstellungen im Sprach-Kapitel (2.2.2 "Reservierte Wörter und Standardbezeichner") sowie die auf das Unit-Konzept bezogenen Bezeichner (6.2.1). Wie Sie die Bezeichner verwenden, wird später anhand konkreter Beispiele erläutert. Eine Schlüsselrolle kommt dem reservierten Wort class zu, mit dem Sie eigene Objekttypen (Klassen) deklarieren können (siehe nachfolgender Abschnitt).

6.2.2 Objekte deklarieren Es ist scharf zu trennen zwischen Begriffen wie "Objekttyp" bzw. "Klasse" und deren "Instanzen", den so genannten "Objektvariablen". Nur Letztere sind die eigentlichen Objekte! Aber langsam, lassen Sie uns gemeinsam Schritt für Schritt diese abstrakte Begriffswelt in einen Zusammenhang mit dem Delphi-Objektmodell bringen. Das reservierte Wort class (ehemals object) ist von fundamentaler Bedeutung für die Objektorientierte Programmierung in Delphi. Es dient der Deklaration von Objekttypen. Halten Sie sich bei der Namensvergabe für nutzerdefinierte Klassen an die Konvention, diese mit dem Großbuchstaben T einzuleiten. BEISPIEL: Eine Klasse TStudent wird deklariert. type TStudent = class(TMensch) name: String[20]; geschlecht: Boolean; alter: Integer; augenFarbe: TColor; ... end;

Am Beispiel erkennen Sie deutlich die Verwandtschaft zum strukturierten Datentyp (record).

Objekttyp und Klasse sind ein und dasselbe! Die Begriffe Objektklasse und Objekttyp sind austauschbar, bezeichnen also ein und dasselbe. Eine Klasse wird vom übergeordneten Objekttyp abgeleitet und ist selbst wieder ein neuer Objekttyp. Also ist eine Klasse eine Datenstruktur, die folgende Bestandteile enthält: ■

Felder (die Daten eines bestimmten Typs enthalten)

■

Methoden (die Operationen für das Objekt durchführen)

■

Eigenschaften (die mit internen Methoden auf Felder zugreifen)

Die Deklaration eines Feldes enthält einen Bezeichner, der das Feld benennt und dessen Datentyp angibt. Für den Kenner des alten Pascal dürfte das Verständnis leichter fallen, da er mit den Strukturvariablen des Record-Datentyps bereits bestens vertraut ist. Auch diese bestehen aus mehreren Feldern unterschiedlichen Datentyps. Der Object-Datentyp hat ebenfalls solche Felder, umfasst aber zusätzlich Funktionen und Prozeduren (so genannte Methoden) und weiterhin noch Eigenschaften, die voreingestellte Werte besitzen, die zur Laufzeit erneut zugewiesen werden können.

286

Kapitel 6

Units und Objekte

Die Deklaration einer Methode enthält eine Kopfzeile für eine Prozedur oder Funktion bzw. für einen Konstruktor oder Destruktor. Die Definition einer Eigenschaft beinhaltet deren Zugriffsmethoden auf Objektfelder.

Vererbung Eine Klasse kann Komponenten von einer anderen Klasse erben, das erbende Objekt ist ein Nachkomme und das vererbende Objekt ein Vorfahre. Der Geltungsbereich eines Objekttyps umfasst sich selbst und alle seine Nachkommen. type TAuto = class(TFahrzeug) private va: Single; public procedure gasgeben; end;

// Nachkomme von TFahrzeug // Feld: aktuelle Geschwindigkeit // Methode, die auf va zugreift

6.2.3 Objekte erzeugen Wenn wir ein Objekt mittels seiner Klassendefinition deklariert haben, so existiert zwar seine "Konstruktionsvorschrift", aber noch lange kein Objekt! Um mit Objekten arbeiten zu können, müssen eine (odere auch mehrere) Objektvariable(n) als so genannte Instanz(en) der Klasse gebildet werden. Im Unterschied zur normalen Variablendeklaration geschieht dies in drei Schritten: ■ Mit var wird zunächst eine Referenz auf ein Objekt des gewünschten Typs deklariert. Dies ist ein Zeiger, der momentan noch den Wert nil hat, also gewissermaßen "in die Luft" zeigt. ■ Durch Aufruf eines so genannten Konstruktors (meist ist dies die Create-Methode) wird eine Instanz gebildet. Erst jetzt entsteht das eigentliche Objekt, und der im ersten Schritt deklarierte Zeiger (Referenz) verweist auf einen konkreten Speicherbereich. ■ Wenn das Objekt nicht mehr benötigt wird, sollte der von ihm belegte Speicherplatz wieder freigegeben werden. Dies geschieht durch Aufruf eines Destruktors (im Allgemeinen ist dies die Free-Methode). Danach verweist der Zeiger (die Objektreferenz) wieder auf nil. var auto1: TAuto; ... auto1 := TAuto.Create; ..... auto1.Free;

// Objektreferenz deklarieren // Objekt wird als Instanz der Klasse TAuto gebildet // Arbeiten mit dem Objekt // Objekt wieder freigeben

Und weil dies alles so "einfach" ist, soll es nochmals mit anderen Worten wiederholt werden: Die Instanz einer Klasse ist ein dynamisch reservierter Speicherbereich mit einer internen Struktur, die vom Objekttyp abhängt. Jedes Objekt besitzt eine mit eigenen Werten gefüllte Kopie der in der Klasse deklarierten Felder, benutzt aber die Methoden unverändert mit anderen Objekten zusammen. Eine Objektvariable ist lediglich eine Referenz auf ein bestimmtes Objekt. Sie enthält also nicht das Objekt selbst, sondern stellt einen Zeiger (bzw. Pointer) auf den Speicherbereich des Objekts

287

6.2 Object Pascal

bereit. Es können sich so mehrere Objektvariablen auf ein und dasselbe Objekt beziehen. Wenn eine Objektvariable den Wert nil enthält, bedeutet dies, dass sie momentan kein Objekt referenziert. BEISPIEL: Zwei Objektvariablen zeigen auf ein- und dasselbe Objekt. var auto1, auto2: TAuto; ... auto1 := TAuto.Create; auto2 := auto1; ... auto2:= nil;

// zweites Objekt zeigt auf erstes Objekt // zweites Objekt dereferenzieren

Attribut, Feld oder Eigenschaft? Eigenschaften (Properties) und Felder eines Objekts werden gemeinsam auch als dessen Attribute bezeichnet. Felder belegen "normale" Speicherplätze (siehe Recordfelder) und können demnach direkt gelesen bzw. geändert werden. Eigenschaften werden mit dem Schlüsselwort property deklariert und erscheinen für den Endbenutzer wie Objektfelder, allerdings kapseln sie intern nur Methoden zum Lesen (read) bzw. Schreiben (write) des Wertes eines oder mehrerer Felder und speichern selbst keine Werte. Innerhalb der mit read bzw. write spezifizierten so genannten Zugriffsmethoden können z.B. auch Berechnungen ausgeführt werden. Durch Weglassen von write lässt sich beispielsweise der Schreibzugriff verwehren. HINWEIS: Beachten Sie, dass der Lesezugriff immer über eine Funktion, der Schreibzugriff hin-

gegen über eine Prozedur implementiert wird. Felder und Zugriffsmethoden bringt man zweckmäßigerweise im private-Abschnitt der Typdeklaration unter, die property-Prozeduren hingegen im public-Abschnitt. Ein benutzerdefinierter Objekttyp TCircle hat ein Feld (F_Radius) und drei Eigenschaften (radius, umfang, flaeche). Nur der Wert von F_Radius braucht gespeichert zu werden! Die Eigenschaften werden entweder direkt zugewiesen oder über die Ihnen aus der Mathematik bekannten Formeln berechnet: radius = F_Radius umfang = 2 * Pi * F_Radius flaeche = 2 * Pi * (F_Radius)2

Da wir für unsere Klasse TCircle keinen geeigneten Vorfahren kennen, von dem etwas "geerbt" werden könnte, nehmen wir dafür kurzerhand den allgemeinsten Objekttyp TObject, der an der Spitze der Delphi-Objekthierarchie steht. Verpacken wir unsere Klasse TCircle in eine eigene Unit kreis, so hat diese folgenden Aufbau:

288

Kapitel 6

Units und Objekte

Unit kreis; interface type TCircle = class(TObject) // unser neuer Objekttyp erbt von TObject private F_Radius: Single; // das einzige Feld speichert den Radius! function getPeriph: Single; // Lese-Zugriffsmethode für umfang procedure setPeriph(periph: Single); // Schreib-Zugriffsmethode für umfang function getArea: Single; // Lese-Zugriffsmethode für flaeche procedure setArea(area: Single); // Schreib-Zugriffsmethode für flaeche public property radius: Single read F_Radius write F_Radius; //Eigenschaftenprozedur radius property umfang: Single read getPeriph write setPeriph; // dto. für umfang property flaeche: Single read getArea write setArea; // dto. für flaeche end; implementation function TCircle.getPeriph; begin result := 2 * Pi * F_Radius end; procedure TCircle.setPeriph(periph: Single); begin F_Radius := periph/2/Pi end; function TCircle.getArea; begin result := Pi*F_Radius*F_Radius end; procedure TCircle.setArea(area: Single); begin F_Radius := Sqrt(area/Pi) end;

Die Unit kreis können Sie nun beispielsweise in ein Formular mit zwei Editierfeldern, zwei Buttons und einigen Labels einbinden. Um die Demo anschaulich zu gestalten, werden wir zwei Objekte, d.h. zwei Instanzen, von TCircle bilden. Hier der implementation-Abschnitt der Formular-Unit: uses kreis; // Einbinden der Klassen-Unit var meinKreis1, meinKreis2: TCircle; // zwei Objektreferenzen procedure TForm1.FormCreate(Sender: TObject); // beide Instanzen werden beim Laden // des Formulars erzeugt begin // ererbten Konstruktor aufrufen meinKreis1 := TCircle.Create; meinKreis2 := TCircle.Create end;

6.2 Object Pascal

289

procedure TForm1.Button1Click(Sender: TObject); // Berechnen var s: string; code:Integer; wert:Single; begin // für den ersten Kreis: Val(Edit1.Text, wert, code); meinKreis1.radius := wert; // Schreibzugriff Str(meinKreis1.umfang:6:2, s); // Lesezugriff Label1.Caption := s; Str(meinKreis1.flaeche:6:2, s); // Lesezugriff Label2.Caption := s; // für den zweiten Kreis: Val(Edit2.Text, wert, code); meinKreis2.radius := wert; Str(meinKreis2.umfang:6:2, s); Label3.Caption := s; Str(meinKreis2.flaeche:6:2, s); Label4.Caption := s end; procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin meinKreis1.Free; meinKreis2.Free // Destruktor aufrufen end;

// Objekte freigeben

Nach dem Programmstart können Sie sich davon überzeugen, dass tatsächlich zwei voneinander unabhängige Kreis-Objekte existieren und dass der Lese-/Schreibzugriff auf deren Eigenschaften ordnungsgemäß funktioniert:

Natürlich könnten Sie nicht nur den Radius, sondern auch den Umfang oder die Fläche direkt eingeben. Die jeweils anderen Eigenschaften würden sich automatisch anpassen. Um das Beispiel überschaubar zu halten, wurde auf eine Demonstration dieser Möglichkeiten verzichtet.

290

Kapitel 6

Units und Objekte

6.3 OOP-Werkzeuge unter Delphi In diesem Abschnitt wollen wir die von der Delphi-Entwicklungsumgebung automatisch angelegten Units, Klassen, Objekte und Methoden näher beleuchten, einen kleinen Abstecher in die Delphi-Objekthierarchie unternehmen und einen Blick auf die Werkzeuge der Entwicklungsumgebung (IDE) werfen, die speziell einer objektorientierten Arbeitsweise gewidmet sind.

6.3.1 Der visuelle Oberflächenentwurf Haben Sie erst einmal das Prinzip der unter Delphi praktizierten objekt- und ereignisorientierten Programmierung verstanden, so werden Ihnen bald auch all die Aktivitäten vertraut vorkommen, die Delphi für Sie automatisch erledigt, ohne dass Sie eine einzige Zeile Code eintippen müssen. Beim Start eines neuen Projektes wird automatisch eine neue Unit (Unit1) angelegt, in der Delphi eine neue Fensterklasse (TForm1) von der Klasse TForm ableitet. Alle Komponenten, die Sie auf dem Formular platzieren, erscheinen als Mitglieder in der Typdeklaration von TForm1. Auch das Anlegen einer Fenstervariablen Form1 und deren Instanzenbildung (TForm1.Create) nimmt uns Delphi ab. Das Gleiche gilt für den Rahmencode der Event-Handler. Sie erkennen, dass dies spezielle Methoden der Fensterklasse sind, die jeweils auf ein bestimmtes Windows-Ereignis reagieren können.

Das Hauptprogramm schreibt Delphi für Sie! Nach dem Eröffnen einer neuen Anwendung besteht der gesamte Quelltext (Rahmencode) aus dem Hauptprogramm (Projekt1) und einer Unit (Unit1). Der Entwickler steht vor der Aufgabe, den Rahmencode auszufüllen bzw. zu ergänzen. Am Hauptprogramm brauchen Sie im Allgemeinen überhaupt nicht mehr herumzudoktern, das ist bereits fix und fertig. Delphi hat es auch gar nicht gerne, wenn man ihm da ins Handwerk pfuscht. Wir wollen trotzdem einen Blick riskieren (Menüpunkt Projekt|Quelltext anzeigen):

6.3 OOP-Werkzeuge unter Delphi

291

Beim Start von Delphi steht automatisch eine Instanz des Application-Objekts zur Verfügung, und es wird eine neue Objektklasse TForm1 abgeleitet und davon eine Instanz, also ein neues Formular (Form1), erzeugt.

Ressourcen Mitten im Hauptprogramm tummelt sich die Compileranweisung {$R *.RES}

um die Sie sich aber nicht weiter zu kümmern brauchen. Damit wird eine Ressourcendatei in das Programm eingebunden, die alle Angaben über den Aufbau der Fenstergrafik enthält. Die Extension für den Dateinamen ist .RES. Es muss sich hierbei um eine Windows-Ressourcendatei handeln. Wird im Dateinamen kein Verzeichnis angegeben, sucht der Compiler die Datei zuerst im aktuellen Verzeichnis und dann im Suchpfad. Beim Linken eines Programms oder einer Bibliothek werden die .RES-Dateien aller Units und des Programms bearbeitet, jede Ressource wird in die erzeugte .EXE- oder .DLL-Datei kopiert.

Bemerkungen ■ Der $R- Befehl erlaubt mehrere .RES-Dateien pro Unit. Es gibt während der Compilierung keine Bestätigung des Inhalts oder der Gültigkeit einer .RES-Datei (ob diese auch wirklich existiert). ■ Auch die in die Formular-Unit eingebundene .DFM-Bild-Datei ist eine Ressource, für die im Prinzip die gleichen Konventionen wie für .RES-Dateien gelten.

6.3.2 Ereignisbehandlungen müssen Sie selbst programmieren! Ihre Tätigkeit als Delphi-Programmierer wird sich zunächst schwerpunktmäßig auf das Schreiben von Ereignisbehandlungsroutinen (Event-Handler) konzentrieren. Wie Sie gesehen haben, werden die Methodenköpfe von Delphi automatisch in die Typdeklaration des Formulars eingefügt (Interface-Teil). Im Implementations-Teil erscheint nur der Rahmencode, den Sie vervollständigen müssen.

Ereignisbehandlungen (Event-Handler) Da es sich bei Event-Handlern gewissermaßen um spezielle Methoden handelt, erscheinen beim Zugriff der Name der Objektklasse und der Name der Methode, beide durch einen Punkt getrennt. Bei der Notation der Kopfzeile kann man auch von einer Kurzform Gebrauch machen, indem man die Parameterliste einfach weglässt. BEISPIEL: Wenn das Ereignis "Taste loslassen" für ein Editierfeld ausgewertet werden soll, erscheint im inter-

face-Abschnitt, in der Objekttypdeklaration von TForm1, folgende Definition: procedure EditKeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);

Im implementation-Teil genügt die Kurzform:

292

Kapitel 6

Units und Objekte

procedure TForm1.EditKeyUp; begin // hier wird von Ihnen Quelltext eingefügt end;

Der Sender-Parameter Dieser ist Ihnen sicher bereits im obigen Beispiel aufgefallen. Sender ist vom allgemeinen Typ TObjekt und informiert darüber, welche Komponente das Ereignis ausgelöst und infolgedessen den Event-Handler aufgerufen hat. Dies kann sehr praktisch sein, denn Sie brauchen für die Ereignisse mehrerer Komponenten nur eine einzige Ereignisbehandlungsroutine zu schreiben. BEISPIEL: Hier wird in der Kopfzeile auf die Kurzform verzichtet. In Abhängigkeit davon, ob auf Edit3 ge-

klickt wurde oder nicht, werden unterschiedliche Prozeduren aufgerufen. procedure TForm1.EditKeyUp(Sender: TObject; var Key:Word; Shift:TShiftState); begin if Sender = Edit3 then dollar_dm else dm_dollar end;

Man kann unter Verwendung von As auch direkt auf das aufrufende Objekt zugreifen. TEdit(Sender).Color:= clYellow

oder (Sender As TEdit).Color:= clYellow

färben das Editierfeld im vorherigen Beispiel gelb. Wenn nur auf bestimmte Objekttypen (also keine bestimmten Objekte) reagiert werden soll, kann der Is-Operator zum Einsatz kommen. if Source is TEdit then ...

Eine konkrete Anwendung finden Sie z.B. in 4.7.1 ("Arbeiten mit Drag & Drop").

Self-Parameter Self liefert einen Zeiger auf die aufrufende Instanz. Sie können Self nicht für den Zugriff auf Felder, Eigenschaften und normale (Objekt-)Methoden verwenden, sondern nur für Aufrufe von Konstruktoren und anderen Klassenmethoden (siehe Kapitel 11, Komponentenentwicklung). BEISPIEL: Mit der Anweisung Form1.Button1Click(Self);

// ruft die Button1Click-Methode von TForm1 auf

können Sie den folgenden Event-Handler statt per Buttonclick per Code auslösen: procedure TForm1.Button1Click(Sender: TObject); begin .... // auszuführender Code end;

6.3 OOP-Werkzeuge unter Delphi

293

Als Referenz für den zu übergebenden Sender-Parameter dient Self.

Klassenmethoden Eine Klassenmethode arbeitet nicht mit Objekten, sondern mit Klassen. Für den Aufruf einer Klassenmethode ist deshalb keine Objektvariable notwendig. Deklaration und Implementierung müssen mit dem reservierten Wort class eingeleitet werden. type TAuto = class(TObject) public class function getInfo: string; ... end;

Implementierung: class function TAuto.getInfo:string; begin result := 'Das ist eine Auto-Klasse!' end;

Der Aufruf: Label1.Caption := TAuto.getInfo;

Zuweisen von Methoden Auch Objektmethoden können per Quelltext zugewiesen werden. Edit1.OnClick := Edit1.OnKeyUp;

veranlasst, dass das Editierfeld auf einen Mausklick genauso reagiert wie beim Loslassen einer (Tastatur-)Taste.

6.3.3 Unterstützung beim Definieren eigener Klassen Die Delphi-IDE versucht nach Kräften, Ihnen beim Erstellen eigener Klassen hilfreich unter die Arme zu greifen.

Klassenvervollständigung Setzen Sie den Cursor an eine beliebige Stelle innerhalb einer Klassendeklaration im interfaceAbschnitt einer Unit und drücken Sie Strg+Umschalt+C1. Nun werden automatisch read- und write-Angaben zu den entsprechenden Eigenschaftsdeklarationen hinzugefügt. Außerdem wird der Rahmencode aller Methoden zum implementation-Abschnitt hinzugefügt. Geben Sie die folgende (unvollständige) Klassendeklaration in den interface-Abschnitt einer Unit ein.

1

... oder Sie klicken mit der rechten Maustaste und wählen im PopUp-Menü "Klasse beim Cursor vervollständigen".

294

Kapitel 6

Units und Objekte

type TMyEdit = class(TEdit) property MyColor: TColor; procedure clearMe; end;

Setzen Sie die Einfügemarke in die Klassendeklaration und drücken Sie Strg+Umschalt+C. Delphi fügt Folgendes (fettgedruckt) zur Klassendeklaration hinzu: type TMyEdit = class(TEdit) property myColor: TColor read FMyColor write SetMyColor; // Lese-/Schreibzugriff procedure clearMe; private FMyColor: TColor; // Feld für Lesezugriff wird hinzugefügt procedure SetMyColor(const Value: TColor); // Methode für Schreibzugriff end;

Außerdem wird der implementation-Abschnitt wie folgt ergänzt: { TMyEdit } procedure TMyEdit.clearMe; begin end; procedure TMyEdit.SetMyColor(const Value: TColor); begin FMyColor := Value end;

Umgekehrt können Sie diese Funktion auch einsetzen, um interface-Deklarationen für Methoden erzeugen zu lassen, die im implementation-Abschnitt definiert sind. Setzen Sie dazu den Cursor in die Methodendefinition und drücken Sie Strg+Umschalt+C. Falls diese Methode im interfaceAbschnitt der Klasse nicht deklariert ist, wird das von Delphi nachgeholt. Wenn Sie die oben beschriebenen Delphi-Dienste in Anspruch nehmen möchten, müssen Sie vorher über das Menü Tools|Umgebungsoptionen die Seite "Explorer" öffnen und das Häkchen bei "Unvollständige Eigenschaften vervollständigen" setzen.

Navigieren innerhalb einer Unit Drücken Sie Strg+Umschalt und gleichzeitig die jeweilige Pfeiltaste, so können Sie schnell zwischen interface- und implementation-Abschnitt einer Unit hin- und herspringen. Setzen Sie vorher die Schreibmarke im interface-Abschnitt auf die entsprechende Methodendeklaration oder globale Prozedur. Auch eigene Positionsmarken (Lesezeichen) können Sie definieren. Klicken Sie hierzu mit der rechten Maustaste in den Quelltext-Editor, und wählen Sie "Positionsmarken umschalten". Um zu einer von Ihnen gesetzten Positionsmarke zu springen, wählen Sie "Zu Positionsmarken gehen".

295

6.3 OOP-Werkzeuge unter Delphi

6.3.4 Die Form-Unit Die Form-Unit beinhaltet die so genannte Klassendeklaration des Formulars. Diese wird im Allgemeinen automatisch von Delphi erzeugt, kann aber auch von Ihnen mit zusätzlichen Klassenmitgliedern angereichert werden.

Standard-Units Damit Sie wenigstens grob informiert sind, welche Units Delphi automatisch bei der Eröffnung eines neuen Formulars standardmäßig der uses-Klausel hinzufügt (in der folgenden Tabelle mit "x" gekennzeichnet) und mit welchen Units Sie es sonst noch häufig zu tun haben, soll die folgende (keinesfalls vollständige) Tabelle für etwas mehr Übersicht sorgen. Die meisten dieser Units exportieren neben Funktionen/Prozeduren, Variablen/Konstanten auch Datentypen und Klassen mit deren Eigenschaften und Methoden. Name der Unit F Erläuterung

System

... die wichtigste, wird automatisch in jede andere Unit eingebunden, enthält z.B. auch arithmetische Funktionen.

Windows

x ... Deklaration der wichtigsten API- und GDI-Funktionen.

Messages

x ... Konstanten und Typen für die Windows-Botschaften.

SysUtils

x ... Stringfunktionen, Datums-/Zeit-Funktionen etc.

Classes

x ... wichtige Basis-Klassen (TPoint, TStrings,TStream, etc.).

Graphics

x ... wichtige Klassen für die Grafikverarbeitung (z.B. TCanvas, TFont).

Controls

x ... Konstanten, TControl, TCustomControl etc.

Forms

x ... wird von allen Delphi-Projekten benötigt, die Formulare enthalten, z.B. Application-Objekt.

Dialogs

x ... Windows-typische Dialogfenster (z.B. MessageBox).

StdCtrls

x ... Label, Edit, Combo- und Listboxen etc.

Math

... zusätzliche mathematische Funktionen.

DB

... Datentypen und Klassen rund um die Datenbankprogrammierung.

Printers

... exportiert das Printer-Objekt für die Druckausgabe unter Delphi.

Beim Entwurf der Benutzerschnittstelle fügt Delphi dann weitere Units zur uses-Klausel der Fenster-Unit hinzu, falls diese von der der Palette entnommenen Komponente benötigt werden.

Datenfelder und Methoden von TForm Klassen wie z.B. TForm1 können andere Objekte (wie z.B. Button1) als Datenfelder enthalten. Immer wenn Sie eine neue Komponente in ein Formular platzieren, erscheint ein neues Feld mit dem Namen der Komponente in der Typdeklaration des Formulars. Fügen Sie einen Event-Handler hinzu, so erscheint dessen Deklaration ebenfalls in der Typdeklaration, er ist damit zu einer so genannten Methode von TForm1 geworden. Der Rahmencode

296

Kapitel 6

Units und Objekte

für das Standardereignis der entsprechenden Komponente (z.B. OnClick für einen Button, OnCreate für ein Formular) wird von Delphi automatisch generiert, wenn Sie auf die Komponente bzw. das Formular doppelklicken. Setzen Sie einen Button und zwei Editierfelder auf das Formular und fügen Sie verschiedene Event-Handler hinzu, so erweitert sich die Typdeklaration von TForm1. type TForm1 = class(TForm) Button1: TButton; Edit1: TEdit; Edit2: TEdit; procedure FormCreate(Sender: TObject); procedure Button1Click(Sender: TObject); procedure Edit1Change(Sender: TObject); procedure Edit1KeyPress(Sender: TObject; var Key: Char); procedure Edit2KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState); private public end;

Private und öffentliche Deklarationen Der Rahmencode für einen neuen Objekttyp enthält auch die Abschnitte für die privaten und öffentlichen Deklarationen, die durch die Standardbezeichner private und public eingeleitet werden. Hier kann der Anwender das Formularobjekt um eigene Datenfelder (Variablen) und Methoden erweitern. Das sind solche, die nicht vom Delphi-Editor automatisch eingefügt werden, sich also nicht unmittelbar auf die Komponenten der VCL (Visual Component Library) und deren Event-Handler beziehen. Die Unterteilung in private und public hat etwas mit der Verfügbarkeit bzw. Zugänglichkeit zu tun. Sollen sie nur innerhalb des Objekts (der Unit) zugänglich sein, gehören sie in den private-, ansonsten in den public-Abschnitt. type TForm1 = class(TForm) // hier haben Sie nichts verloren, denn hier kümmert sich Delphi! ... private // hier Ihre privaten Deklarationen einfügen! ... public // hier Ihre öffentlichen Deklarationen einfügen! ... end;

Falls es sich nicht um Variablen-, sondern um Methodendeklarationen handelt, müssen diese noch im implementation-Abschnitt spezifiziert werden.

6.3 OOP-Werkzeuge unter Delphi

297

BEISPIEL: Unsere Formularklasse TForm1 soll um eine Methode bereichert werden, die einen Textstring

exakt in der Mitte des Formulars anzeigt. Zu Testzwecken erhält das Formular noch ein Editierfeld und einen Button. Im Folgenden wird der komplette Quelltext der Form-Unit angegeben. Die von Ihnen vorzunehmenden Ergänzungen sind fett hervorgehoben: unit Unit1; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type TForm1 = class(TForm) Button1: TButton; Edit1: TEdit; procedure Button1Click(Sender: TObject); private { Private-Deklarationen } procedure zentriereText(txt: string); public { Public-Deklarationen } end; var Form1: TForm1; implementation {$R *.DFM} procedure TForm1.zentriereText(txt: string); var x,y: Integer; begin x := Trunc((ClientWidth - Canvas.TextWidth(txt))/2); y := Trunc((ClientHeight - Canvas.TextHeight(txt))/2); Canvas.TextOut(x, y, txt) end; procedure TForm1.Button1Click(Sender: TObject); begin zentriereText(Edit1.Text) end;

Wie Sie sehen, funktioniert unsere selbst gebastelte Methode wunderbar (zu Details der Textausgabe informieren Sie sich bitte im Grafikkapitel 7):

298

Kapitel 6

Units und Objekte

Schreibweise verkürzen Es ist Ihnen sicher schon aufgefallen, dass sich die Prozedurköpfe der Methoden im interface- und im implementation-Abschnitt exakt wiederholen. Ein so intelligentes Werkzeug wie Delphi gibt sich aber auch mit einer einmaligen vollständigen Deklaration im interface-Abschnitt zufrieden. Im implementation-Abschnitt kann die Parameterleiste einfach weggelassen werden. Wir sprechen dann von einem verkürzten Prozedurkopf. Die Implementierung der nutzerdefinierten Methode aus obigem Beispiel könnte auch wie folgt aussehen: procedure TForm1.zentriereText; // Parameterliste kann wegfallen! var x,y: Integer; begin x := Trunc((ClientWidth - Canvas.TextWidth(txt))/2); y := Trunc((ClientHeight - Canvas.TextHeight(txt))/2); Canvas.TextOut(x, y, txt) end;

Insbesondere bei Methoden mit langen Parameterlisten kann man sich so einiges an Schreibarbeit ersparen. Der Anfänger sollte jedoch vorerst keinen Gebrauch von dieser Vereinfachung machen. Wenn Sie auch bei der Implementierung die vollständigen Methodenköpfe verwenden, haben Sie stets einen exakten Überblick über die Namen und Typ der Parameter.

6.3.5 Formulare und Komponenten zur Laufzeit erzeugen Normalerweise kümmert sich Delphi bei Programmstart um das Erzeugen der visuellen Komponenten. Sie können das aber auch selbst in die Hand nehmen.

Formulare Wie die zum Projekt gehörenden Formulare erzeugt werden, zeigt Ihnen das Fenster "Projektoptionen", das Sie über das Menü Projekt|Optionen... öffnen und wo Sie die Seite "Formulare" aufschlagen. Alle Formulare, die Sie von links (Liste "Autom. Formularerstellung") nach rechts (Liste "Verfügbare Formulare") verschieben, werden von Delphi zwar referenziert, aber nicht automatisch erstellt (siehe Menü Projekt|Quelltext anzeigen). Sie selbst müssen den Create-Konstruktor aufrufen.

299

6.3 OOP-Werkzeuge unter Delphi

var Form2.TForm2; ... TForm2.Create(Self);

// Referenz (von Delphi) // Erzeugen (von Ihnen hinzuzufügen)

Weitere Einzelheiten können Sie dem Beispiel 3.8.2 entnehmen (einfache MDI-Applikation).

Komponenten Beliebige Komponenten lassen sich zur Laufzeit generieren, indem zunächst ein Objekt referenziert und anschließend sein Konstruktor aufgerufen wird. Auf die folgende Weise entsteht quasi "aus dem Nichts" ein neues Editierfeld. var edField: TEdit; ... edField := TEdit.Create(Self); edField.Parent := Self; edField.Name := 'edField1'; edField.SetBounds(20,20,40,20); edField.Free

// Referenz // // // // //

neues Editierfeld wird erzeugt ... und dem Formular untergeordnet Eigenschaften werden zugewiesen ... Position und Abmessungen Editierfeld wird wieder entfernt

Das komplette Programm entnehmen Sie bitte dem Praxisteil dieses Kapitels (6.4.3, "Erzeugen visueller Komponenten zur Laufzeit").

6.3.6 VCL und Komponentenentwicklung Die VCL (Visual Components Library) enthält die in Delphi vordefinierten Objekttypen bzw. Komponenten. Das schließt deren Eigenschaften, Methoden und Ereignisse ein. Die folgende Abbildung zeigt die Objekthierarchie, wobei die für die Komponentenentwicklung maßgebenden Klassen fett hervorgehoben sind. Gewissermaßen als "Übervater" thront TObject über seiner zahlreichen Nachkommenschaft. Die Objekttypen der VCL sind häufig lediglich Basisklassen, die als Vorfahren von Komponentengruppen dienen und diesen zahlreiche Eigenschaften, Methoden und Ereignisse vererben. Einige Objekte werden selbst nur zur Laufzeit verwendet, um unsichtbare Aktionen im Hintergrund durchzuführen. Zum Beispiel kapselt die Klasse TPrinterObject die Druckerschnittstelle für Windows ein, oder TBitmap dient als Pufferspeicher für Grafiken. Es gibt in der VCL kaum Objekte, die nicht auch Komponenten sind. Eine Komponente ist ein Objekt mit zusätzlichen Eigenschaften, Methoden und Ereignissen, die für die spezielle Verwendung benötigt werden. Von TControl abgeleitete Komponenten sind Dialogelemente, d.h. Komponenten, die zur Laufzeit sichtbar sind. Einige dieser Dialogelemente wiederum verfügen über Fenstereigenschaften (d.h., sie können den Eingabefokus erhalten), und andere verfügen nicht über Fenstereigenschaften (d.h., sie können, während sie angezeigt werden, nicht den Eingabefokus erhalten). Alle Dialogelemente mit Fenstereigenschaften sind von TWinControl abgeleitet; die Dialogelemente, die nicht über Fenstereigenschaften verfügen, von TGraphicControl.

300

Kapitel 6

Units und Objekte

TObject

Exception

TGraphicsObject

TTimer

TScreen

TStream

TPersistent

TPrinter

TList

TGraphic

TComponent

TCanvas

TPicture

TMenuItem

TControl

TGraphicControl

TCustomComboBox TCustomControl TCustomEdit

TMenu

TCommon Dialog

TStrings

TGlobal Component

TApplication

TWinControl

TButtonControl TScrollBar TScrollingWinControl

TCustomListBox TForm

Der oben abgebildete "Stammbaum" bildet die Grundlage für die Entwicklung nutzerdefinierter Komponenten, wie sie im Kapitel 11 detailliert behandelt werden.

6.3.7 Der Objektbrowser Der Objektbrowser ist ein universelles Hilfsmittel für die objektorientierte Programmierung unter Delphi. Insbesondere können Sie ihn für folgende Aufgabenstellungen einsetzen: ■ grafische Anzeige der Objekthierarchien der Applikation ■ Auflisten der verwendeten Units, Anzeige der Komponenten (Symbole), die im Interface- oder Implementationsteil der Unit deklariert sind ■ Auflisten aller globalen Komponenten (Symbole), Auflistung aller Deklarationen, direktes Verzweigen zu Symbolreferenzen im Quelltext Der Objektbrowser lässt sich über das Menü Ansicht|Browser (Shift+Strg+B) direkt öffnen, es erscheint die komplette Delphi-Objekthierarchie. Hier können Sie sich darüber informieren, welches Objekt Ihrer Applikation von welchem abstammt. Die oberste Hierarchieebene ist TObject.

6.3 OOP-Werkzeuge unter Delphi

301

BEISPIEL: Die folgende Abbildung zeigt Ihnen die Klassenmitglieder von TForm1 für das Einsteigerbeispiel

in 1.3.2 ("Umrechnung Euro in Dollar"):

BEISPIEL: Die Mitglieder der im Abschnitt 6.2.2 von uns deklarierten Klasse TCircle.

6.3.8 Die Objektablage Bei der Objektablage handelt es sich gewissermaßen um eine Art von "Zwischenablage", allerdings auf beachtlich höherem Niveau, denn hier können komplette Objekte (bis hin zu Projekten bzw. Projektschablonen) abgespeichert und anderen Anwendungen zugänglich gemacht werden. Die

302

Kapitel 6

Units und Objekte

Objektablage ist eine editierbare (.INI-Format) Textdatei, die eine Liste von Formularen und Projekten enthält. Das Dialogfeld "Objektablage" erscheint nach Klick auf das Menü Tools|Objektablage...

Optionen Unter Beachtung der seitenorientierten Struktur der Objektablage (eine Seite kann mehrere Objekte aufnehmen) stehen folgende Optionen zur Verfügung: Option

Beschreibung

Seiten

... zeigt die Seiten in der Objektablage an.

Objekte

... zeigt die Elemente auf der aktuellen Seite der Objektablage an.

Seite hinzufügen

... fügt der Objektablage eine neue, leere Seite hinzu.

Seite löschen

... entfernt eine markierte Seite aus Objektablage (Seite muss leer sein).

Seite umbenennen

... benennt eine Seite in der Objektablage um.

Objekt bearbeiten

... verändert die Eigenschaften des markierten Elements.

Objekt löschen

... löscht ein markiertes Objekt aus der Objektablage.

Auf- und Abwärtspfeil ... ändert Position der ausgewählten Seite (auch durch Ziehen).

Hinzufügen von Objekten Wenn Sie ein Objekt zu einer Seite hinzufügen wollen, haben Sie die Wahl zwischen drei Möglichkeiten:

303

6.4 Lernbeispiele für Einsteiger

■ Im Fenster der Objektablage ziehen Sie ein Objekt aus der Spalte Objekte in die Spalte Seiten. ■ Im PopUp-Menü eines Formulars wählen Sie Der Objektablage hinzufügen. ■ Benutzen Sie das Menü Projekt|Der Objektablage hinzufügen. Weitere detailliertere Informationen über den praktischen Einsatz der Objektablage entnehmen Sie der Online-Hilfe.

6.4 Lernbeispiele für Einsteiger OOP unter Delphi kann man grob in zwei Hauptgebiete aufteilen: ■ Arbeit mit den von Delphi zur Verfügung gestellten Klassen bzw. Objekten ■ Entwickeln eigener Klassen/Objekte Für den Einsteiger empfiehlt es sich aber, vorher auf einem dritten Gebiet die notwendige Sicherheit zu erwerben: ■ Programmieren eigener Units Zu allen drei Schwerpunkten finden Sie in diesem Abschnitt je ein grundlegendes Übungsbeispiel.

6.4.1 Eine Unit für Hilfsfunktionen erstellen und einbinden Der Aufwand für eine eigene Unit lohnt sich bereits dann, wenn man bestimmte Datentypen, Prozeduren und Funktionen wiederholt in verschiedenen Programmen benötigt und eventuell den entsprechenden Quelltext für andere Entwickler "unsichtbar" machen möchte. Im folgenden Beispiel wollen wir uns eine Unit schaffen, die für Aufgaben wie ■ Testen auf bestimmte Datentypen, ■ Herausschneiden einzelner Zeichen, ■ Testen auf Groß- oder Kleinbuchstaben zu verwenden ist. Gleichzeitig lernen Sie den Umgang mit Stringfunktionen und, gewissermaßen als Vorgriff auf die folgenden Kapitel, einiges über die Fehlerbehandlung.

Quelltext für Unit Öffnen Sie das Menü Datei|Neu|Unit und füllen Sie das leere Skelett wie folgt aus: unit hFunc; interface

// Hilfsfunktionen

Die Kopfzeilen der sieben Hilfsfunktionen unserer Unit müssen im Interface-Abschnitt deklariert werden: function delChar(value:string; c:char):string; function isUpper(c:Char): Boolean;

304

Kapitel 6

function function function function function

Units und Objekte

isLower(c:Char): Boolean; isGerade(value: Integer): Boolean; isDigit(c: Char): Boolean; isInteger(value: string): Boolean; isFloat(value: string): Boolean;

Nun zum Implementation-Abschnitt. Dieser benötigt die Standard-Unit SysUtils, um grundlegende Operationen (Stringfunktionen etc.) ausführen zu können: implementation uses SysUtils;

Die isUpper-Funktion überprüft, ob das übergebene Zeichen in der Menge der Großbuchstaben vorkommt: function isUpper(c:Char): Boolean; begin result := c in ['A'..'Z','Ä','Ö','Ü'] end;

Analog arbeitet isLower für Kleinbuchstaben: function isLower(c:Char): Boolean; begin result := c in ['a'..'z','ä','ö','ü','ß'] end;

Ähnlich funktioniert isDigit für Ziffern: function isDigit(c: Char): Boolean; begin result := c in ['0'..'9'] end;

Die delChar-Funktion erlaubt das Entfernen eines einzelnen Zeichens aus einem übergebenen String: function delChar(value:string; c:Char):string; begin while Pos(c,value)<> 0 do Delete(value,Pos(c,value),1); result := value end;

Die beiden Funktionen zum Testen auf Integer- und Gleitkomma-Datentypen lassen sich am besten mit Hilfe von try-except-Blöcken realisieren: function isInteger(value: string): Boolean; begin result := True; try StrToInt(value) except result := False

6.4 Lernbeispiele für Einsteiger

305

end end; function isFloat(value: string): Boolean; begin result := True; try StrToFloat(value) except result := False end end;

Hintergrund dieser und ähnlicher Funktionen ist eine explizite Typumwandlung (z.B. StrToInt, StrToFloat, StrToBoolean, StrToCurr, StrToDateTime), die im Fehlerfall zu einem negativen Funktionsergebnis führt (mehr zur Fehlerbehandlung erfahren Sie im Kapitel 5). Die isGerade-Funktion stellt fest, ob es sich um eine gerade oder ungerade Integer-Zahl handelt: function isGerade(value: Integer): Boolean; begin result := (value mod 2) = 0 end; .... end.

Hier wollen wir erst einmal Schluss machen, Sie können jederzeit weitere Funktionen für den "Hausgebrauch" ergänzen (die Deklaration im Interface-Abschnitt nicht vergessen!).

Oberfläche Um unsere Unit zu testen, bietet sich die im Folgenden abgebildete Oberfläche an. Neben einem Editierfeld benötigen wir einen Wippregler (TUpDown), zwei Panels und zwei Buttons. Den Wippregler finden Sie auf der "Win32"-Seite der Komponentenpalette.

306

Kapitel 6

Units und Objekte

Quelltext für Form1 Wir beschränken uns auf die Wiedergabe des implementation-Abschnitts: implementation

Zu Beginn ist natürlich unsere Unit einzubinden: uses hFunc; {$R *.DFM} var c: Char;

// Hilfsvariable

Bei Programmstart: procedure TForm1.FormCreate(Sender: TObject); begin UpDown1.Max := Length(Edit1.Text) // Maximalwert für Wippregler ermitteln end;

Beim Bewegen zum nächsten Zeichen mit dem Wippregler: procedure TForm1.UpDown1Changing(Sender: TObject; var AllowChange: Boolean); begin Edit1.SetFocus; Edit1.SelStart := UpDown1.Position-1; Edit1.SelLength := 1; c := Edit1.SelText[1]; // Zeichen selektieren Button1.Caption := 'Alle ' + c + ' entfernen'; Panel1.Caption := '';

Test auf Groß-/Kleinschreibung: if isUpper(c) then Panel1.Caption := c + ' ist ein Großbuchstabe!' else if isLower(c) then Panel1.Caption := c + ' ist ein Kleinbuchstabe!'

Test auf einzelne Ziffer: else if isDigit(c) then Panel1.Caption := c + ' ist eine Ziffer!' end;

Das Entfernen des selektierten Zeichens: procedure TForm1.Button1Click(Sender: TObject); // Zeichen entfernen begin Edit1.Text := delChar(Edit1.Text, c); Button1.Caption := ''; Panel1.Caption := ''; Panel2.Caption := '' end;

Beim Ändern des Inhalts des Editierfeldes: procedure TForm1.Edit1Change(Sender: TObject); // Text ändern begin Beep;

6.4 Lernbeispiele für Einsteiger

307

if Edit1.Text = '' then Exit; UpDown1.Max := Length(Edit1.Text); UpDown1.Position :=UpDown1.Max; Panel2.Caption := '';

Der Test auf gerade/ungerade Integerzahl und auf Fließkommazahl: if IsInteger(Edit1.Text) then begin if isGerade(StrToInt(Edit1.Text)) then Panel2.Caption := Edit1.Text + ' ist eine gerade Zahl!' else Panel2.Caption := Edit1.Text + ' ist eine ungerade Zahl!' end else if isFloat(Edit1.Text) then Panel2.Caption := Edit1.Text + ' ist eine Gleitkommazahl!' end;

Test HINWEIS: Damit die try-except-Blöcke in der Entwicklungsumgebung keine Fehlermeldungen

produzieren, sollten Sie vor Programmstart die Option "Bei Delphi-Exceptions stoppen" deaktivieren (Menü Tools|Debugger-Optionen, Seite "Sprach-Exceptions"). Nach Programmstart geben Sie in das Editierfeld eine Zeichenkette oder auch eine Zahl ein und lassen sich von den Ergebnissen überraschen.

Mit dem UpDown-Button können Sie einzelne Zeichen selektieren, um sie anschließend mit dem "Entfernen"-Button aus dem String "herauszuschneiden".

308

Kapitel 6

Units und Objekte

6.4.2 Von der Unit zur Klasse Dem Anwender Ihres Delphi-Programms dürfte es so ziemlich egal sein, ob es chaotisch oder objektorientiert aufgebaut ist – Hauptsache es funktioniert! Die Vorteile von OOP liegen allein auf der Ebene des Entwicklers, denn ein objektorientiertes Programm ist nicht nur übersichtlicher (und deshalb wartungsfreundlicher), sondern auch die Chancen zur Wiederverwendbarkeit von Codebausteinen (Units/Klassen) sind erheblich größer. Langfristig gesehen spart der Entwickler durch konsequente Anwendung von OOP also erheblich an Zeit und Kosten! Folgende Vorgehensweise ist zweckmäßig, um ein "chaotisches" Programm, das meist in einer einzigen Unit abläuft, in ein "objektorientiertes" Programm zu verwandeln. ■ Lagern Sie allgemeine Funktionalität unter dem Aspekt der Wiederverwendbarkeit in eine oder mehrere Units aus. ■ Fügen Sie diesen Units Klassendeklarationen hinzu und verwandeln Sie die öffentlichen Variablen in Eigenschaften und die öffentlichen Funktionen/Prozeduren in Methoden. ■ Erzeugen Sie im Hauptprogramm aus den Klassen Objekte und arbeiten Sie mit deren Eigenschaften und Methoden. Ausgangsbeispiel dieser Übung ist die "chaotisch" programmierte Applikation 7.6.2 ("2-D-Vektorgrafik") aus dem Grafik-Kapitel, die wir in mehreren Etappen in eine den OOP-Regeln entsprechende Applikation umwandeln wollen. Laden Sie das Beispiel "2-D-Vektorgrafik" (Kap07\PB_02) von der Buch-CD und schauen Sie es sich genau an. Auf die Wirkungsweise der Grafikoperationen kann im Folgenden nicht eingegangen werden.

Eine Unit abspalten Das Programm realisiert die Darstellung einer Vektorgrafik zum Zeichnen eines Hauses in einer einzigen Unit (Unit1). Nach sorgfältiger Sichtung des Quellcodes stellen wir fest, dass einige Variablen, Funktionen und Prozeduren allgemeinen Charakter tragen, also zum Zeichnen beliebiger Figuren verwendet werden könnten. Aus diesem Grund verschieben wir den allgemeinen Code in eine neue Unit. Mit dem Menüpunkt Datei|Neu|Unit fügen Sie Ihrem Projekt eine Unit mit dem Namen grafik2D zu. unit grafik2D; interface uses Graphics; // Standard-Unit für Grafikfunktionen var cvs: TCanvas; // Zeichenfläche alf, // Drehwinkel si, co, // Sinus und Kosinus mf, // Maßstabsfaktor x0,y0 : Single; // absolute Bezugskoordinaten sf : Integer; // Spiegelungsfaktor dirFlg : Boolean; // Richtungsflag

309

6.4 Lernbeispiele für Einsteiger

procedure dwc (dx1, dy1, r : Single); // zeichnet relativen Kreis mit Radius r procedure dwl (dx1, dy1 : Single); // zeichnet relative Linie procedure dwp (dx1, dy1: Single); // zeichnet relativen Punkt implementation

Diese Prozedur zeichnet einen relativen Kreis: procedure dwc; var x1,y1 : Single; begin dx1 := mf * dx1; dy1 := mf * dy1; R := mf * R; x1 := x0 + dx1 * co - sf * dy1 * si; y1 := y0 - sf * dy1 * co - dx1 * si; cvs.Ellipse(Round(x1-r), Round(y1-r), Round(x1+r), Round(y1+r)) end;

Relative Linie: procedure dwl; var x1,y1 : Single; begin dx1 := mf * dx1; dy1 := mf * dy1; x1 := x0 + dx1 * co - sf * dy1 * si; y1 := y0 - sf * dy1 * co - dx1 * si; cvs.LineTo(Round(x1), Round(y1)) end;

Verschieben der Stiftposition: procedure dwp; var x1,y1 : Single; begin dx1 := mf * dx1; dy1 := mf * dy1; x1 := x0 + dx1 * co - sf * dy1 * si; y1 := y0 - sf * dy1 * co - dx1 * si; cvs.MoveTo(Round(x1), Round(y1)) end; end.

Die Unit im Hauptprogramm benutzen Da wir die Unit grafik2D nur innerhalb der Formular-Unit verwenden wollen, wird sie erst im implementation-Abschnitt von Unit1 eingebunden: implementation {$R *.DFM} uses grafik2D;

// Einbinden der Unit

310

Kapitel 6

Beim Laden des Formulars werden die Anfangswerte initialisiert: procedure TForm1.FormCreate(Sender: TObject); begin x0 := ClientWidth / 2; y0 := ClientHeight / 2; alf := 0; sf := 1; mf := 20; cvs := Form1.Canvas end;

Diese Prozedur benutzt die von der Unit grafik2D exportierten Routinen: procedure drawHouse; // zeichnet Haus begin dwp(0, 10); // Frontseite dwl(10, 10); dwl(10, 0); dwl(0, 0); dwl(0, 10); dwp(1, 8); // Fenster dwl(4, 8); dwl(4, 4); dwl(1, 4); dwl(1, 8); dwp(6, 0); // Tür dwl(6, 8); dwl(9, 8); dwl(9, 0); dwl(6, 0); dwp(-1, 9); // Dachgiebel dwl(5, 15); dwl(11, 9); dwc(5, 12, 1); // Giebelfenster dwp(7, 13); // Schornstein dwl(7, 16); dwl(9, 16); dwl(9, 11) end;

Nun zu den Bedienfunktionen: procedure TForm1.Button1Click(Sender: begin mf := mf + 1 end; procedure TForm1.Button2Click(Sender: begin mf := mf – 1 end; procedure TForm1.Button4Click(Sender: begin sf := -sf end; procedure TForm1.Button3Click(Sender: begin dirFlg := not dirFlg end;

TObject);

// Vergrößern

TObject);

// Verkleinern

TObject);

// Spiegelung

TObject);

// Drehrichtung

Periodisches Anzeigen nach dem Prinzip "Flimmerkiste": procedure TForm1.Timer1Timer(Sender: TObject); begin Form1.Refresh; // Hintergrund löschen if dirFlg then alf := alf + Pi / 100 // rotiert im Uhrzeigersinn else alf := alf - Pi / 100; // ... entgegen Uhrzeigersinn si := Sin(alf); co := Cos(alf); drawHouse end;

Units und Objekte

311

6.4 Lernbeispiele für Einsteiger

Die Unit in eine Klassen-Unit verwandeln Sie brauchen in der Unit grafik2D nur zwei Änderungen vorzunehmen, die kaum Mehrarbeit bedeuten, und schon haben Sie den Sprung von der einfachen Unit zur Klassen-Unit geschafft! unit grafik2D; interface uses Graphics;

Alle im interface-Abschnitt enthaltenen Variablen und Funktionen/Prozeduren werden in den Körper einer Klassendeklaration T2DGrafik verschoben: type T2DGrafik = class(TObject) // Felder: cvs: TCanvas; alf, // Drehwinkel si, co, // Sinus und Kosinus mf, // Maßstabsfaktor x0,y0 : Single; // absolute Bezugskoordinaten sf : Integer; // Spiegelungsfaktor dirFlg : Boolean; // Richtungsflag // Methoden: procedure dwc (dx1, dy1, r : Single); // zeichnet relativen Kreis mit Radius r procedure dwl (dx1, dy1 : Single); // zeichnet relative Linie procedure dwp (dx1, dy1: Single); // zeichnet relativen Punkt end;

Im implementation-Abschnitt brauchen Sie vor die Methodenbezeichner eigentlich nur noch den Namen der Klasse (T2DGrafik) zu setzen – das war's schon! implementation procedure T2DGrafik.dwc; ... end;

// zeichnet relativen Kreis

procedure T2DGrafik.dwl; ... end;

// zeichnet relative Linie

procedure T2DGrafik.dwp; ... end.

// zeichnet relativen Punkt

Die Klassen-Unit im Hauptprogramm benutzen Die Änderungen im Hauptprogramm (Unit1) sind ebenfalls nicht gravierend, setzen aber bereits ein Grundverständnis für den Lebenszyklus eines Objekts voraus: 1. Objekt deklarieren (Objektvariable referenzieren) 2. Objekt erzeugen (Instanz der Klasse bilden)

312

Kapitel 6

Units und Objekte

3. Objekt initialisieren (Anfangswerte zuweisen) 4. Objekt entfernen (Speicherplatz freigeben) Vergleichen Sie diesen Quellcode sorgfältig mit dem des Vorgänger-Hauptprogramms, und es werden sich Ihnen die Augen öffnen! implementation uses grafik2D;

Beim Deklarieren des Objekts wird lediglich ein Zeiger (das ist die Objektvariable!) eingerichtet: var haus1: T2DGrafik;

// Objekt deklarieren

Erzeugen und Initialisieren des Objekts erfolgt im OnCreate-Event-Handler: procedure TForm1.FormCreate(Sender: TObject); begin haus1 := T2DGrafik.Create; // Objekt erzeugen with haus1 do begin // Objekt initialisieren (Ersatz für Konstruktor) x0 := ClientWidth / 2; y0 := ClientHeight / 2; alf := 0; sf := 1; mf := 20; cvs := Form1.Canvas end end;

Das Haus wird gezeichnet: procedure drawHouse(haus: T2DGrafik); begin with haus do begin dwp(0, 10); // Frontseite dwl(10, 10); dwl(10, 0); dwl(0, 0); dwl(0, 10); dwp(1, 8); // Fenster dwl(4, 8); dwl(4, 4); dwl(1, 4); dwl(1, 8); dwp(6, 0); // Tür dwl(6, 8); dwl(9, 8); dwl(9, 0); dwl(6, 0); dwp(-1, 9); // Dachgiebel dwl(5, 15); dwl(11, 9); dwc(5, 12, 1); // Giebelfenster dwp(7, 13); // Schornstein dwl(7, 16); dwl(9, 16); dwl(9, 11) end end;

Verschiedene Event-Handler manipulieren das Objekt: procedure TForm1.Button1Click(Sender: TObject); begin haus1.mf := haus1.mf + 1 end;

// Vergrößern

313

6.4 Lernbeispiele für Einsteiger

procedure TForm1.Button2Click(Sender: TObject); // Verkleinern begin haus1.mf := haus1.mf – 1 end; procedure TForm1.Button4Click(Sender: TObject); begin haus1.sf := -haus1.sf end;

// Spiegeln

procedure TForm1.Button3Click(Sender: TObject); begin haus1.dirFlg := not haus1.dirFlg end;

// Richtungsänderung

procedure TForm1.Timer1Timer(Sender: TObject); begin Form1.Refresh; // Hintergrund löschen with haus1 do begin if dirFlg then alf := alf + Pi / 100 // im Uhrzeigersinn else alf := alf - Pi / 100; // entgegen Uhrzeigersinn si := Sin(alf); co := Cos(alf) end; drawHouse(haus1) end; procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin haus1.Free // Objekt entfernen end;

Bemerkung ■ In diesem Lernbeispiel wurde bewusst nicht das gesamte OOP-Instrumentarium benutzt, um Sie nicht unnötig abzulenken. So wurde z.B. auf einen Konstruktor sowie auf Property-Prozeduren verzichtet. Ausführlich werden Sie in diese und andere wichtige OOP-Features im "Kleinen OOP-Crashkurs" (6.5) eingeführt. ■ Da die Vorzüge von OOP umso deutlicher zutage treten, je mehr Instanzen von einer Klasse abgeleitet werden, finden Sie auf der Buch-CD ein geringfügig erweitertes Beispiel mit drei Objekten (Abbildung).

314

Kapitel 6

Units und Objekte

6.4.3 Delphi-Komponenten erst zur Laufzeit erzeugen Normalerweise sind Sie es gewöhnt, die Bedienoberfläche eines Programms bereits im Entwurfsmodus "zusammenzuschieben". Aber es gibt eine Reihe von Anwendungsfällen, wo die Anzahl der Komponenten variabel ist, zur Laufzeit müssen also welche hinzugefügt bzw. wieder entfernt werden. Aber auch dann, wenn eine große Anzahl gleichartiger Komponenten (z.B. in Matrixform) nebeneinander bzw. untereinander anzuordnen ist, können Sie sich viel Zeit und millimetergenaue Filigranarbeit mit der Maus sparen, wenn Sie diese Angelegenheit dem Programm überlassen. Für das Erzeugen bzw. Entfernen von Komponenten werden von Delphi die Methoden Create und Destroy (bzw. Free) zur Verfügung gestellt, aber allein damit ist es nicht getan. Im folgenden Demonstrationsbeispiel werden wir den kompletten Rahmencode erörtern und dabei unter anderem auch noch die Erkenntnis gewinnen, dass sich mit Objektvariablen eine ganze Menge anstellen lässt.

Oberfläche Auf einem Formular (Form1) platzieren wir ein Anzeigefeld (Label1) und vier Schaltflächen (Button1 ... Button4). Im oberen Abschnitt des Formulars lassen Sie etwas Platz für die zur Laufzeit hinzukommenden Editierfelder (siehe Abbildung am Schluss).

315

6.4 Lernbeispiele für Einsteiger

Quelltext unit Unit1; // Komponenten zur Laufzeit erzeugen/entfernen interface ... var Form1: TForm1; edField: TEdit; // Objektvariable für Editierfeld i: Integer; // Zähler implementation procedure TForm1.Button1Click(Sender: TObject); var links, oben, breit, hoch: Integer; begin

// Erzeuge 10 Editierfelder ! // lokale Variablen

Position und Abmessungen des ersten Editierfeldes (Schablone) festlegen: links:=20; oben:=20; breit:=40; hoch:=20; for i:=1 to 10 do

Nur ausführen, wenn i-tes Editierfeld nicht da ist: if TEdit(FindComponent('ed_'+IntToStr(i)))= nil then begin edField:=TEdit.Create(Self); // neues Editierfeld wird erzeugt, edField.Parent:=Self; // ... dem Formular zugeordnet edField.Name:='ed_'+IntToStr(i); //... und erhält Namen:ed_1, ed_2, ... // Position und Abmessungen neu setzen: edField.SetBounds(links+(i-1) * breit, oben, breit, hoch); edField.Text := IntToStr(i); // Beschriftung mit Index edField.OnClick := EditClick // gemeinsamer Event-Handler end; end;

Alle Komponenten wieder entfernen: procedure TForm1.Button2Click(Sender: TObject); begin for i:=1 to 10 do begin edField:=TEdit(FindComponent('ed_'+IntToStr(i))); // sucht den Namen edField.Free // ... und entfernt Komponente end end;

Ein gemeinsamer Event-Handler für alle Editierfelder: procedure TForm1.EditClick(Sender: TObject); edField:=TEdit(Sender); // auf dieses Feld wurde geklickt! edField.Color:=clYellow // gelbe Markierung end;

316

Kapitel 6

Units und Objekte

Löschen des markierten Felds: procedure TForm1.Button4Click(Sender: TObject); begin if edField.ComponentIndex > 4 then edField.Free end;

Test Nach Klick auf den linken oberen Button erscheinen wie "von Geisterhand" die zehn Editierfelder. Da im Quelltext alle möglichen Fehler (Laden eines bereits vorhandenen bzw. Löschen eines nicht mehr vorhandenen Editierfeldes) abgefangen wurden, können Sie hemmungslos die einzelnen Buttons betätigen und versuchen, deren Wirkung am Quelltext nachzuvollziehen bzw. durch eigene Änderungen das Programm zum Absturz zu bringen.

Bemerkungen ■ Die Create-Methode weist Speicher für das Erzeugen einer Komponente zu und initialisiert deren Daten. Als Argument benötigt sie den Besitzer der Komponente. Der entfernt die Komponente, wenn er selbst entfernt wird. ■ Die ComponentIndex-Eigenschaft bezieht sich auf alle Komponenten des Formulars. Falls also mehr oder weniger als die hier vorhandenen vier "festinstallierten" Komponenten (Label1, Button1 ... Button4) vorhanden sein sollten, so ist die entsprechende Anweisung im Buttton4ClickEreignis anzupassen. ■ Die SetBounds-Methode ist schneller als das einzelne Setzen der Eigenschaften Left, Top, Width und Height.

Ergänzungen Im Zusammenhang mit der ComponentIndex-Eigenschaft dürften die Eigenschaften Components und ComponentCount Anlass zu Verwechslungen geben. Klarheit schafft eine kleine Programmerweiterung. Platzieren Sie eine zusätzliche Schaltfläche (Button5) auf dem Formular und ergänzen Sie folgenden Ereigniscode:

6.5 Kleiner OOP-Crashkurs

317

procedure TForm1.Button5Click(Sender: TObject); begin for i := 0 to ComponentCount -1 do if Components[i] is TEdit then TEdit(Components[i]).Color := clGreen end;

Die Farbe aller vorhandenen Editierfelder ändert sich nach Betätigen dieses Buttons in Grün.

6.5 Kleiner OOP-Crashkurs Diese Beispielserie beinhaltet fünf Demoprogramme, die systematisch aufeinander aufbauen. Ziel ist eine verständliche Einführung in die Entwicklung eigener (benutzerdefinierter) Klassen unter Delphi: ■ Klassen und Objekte ■ Konstruktor und Destruktor ■ Read-Only-Eigenschaften ■ Property-Prozeduren ■ Vererbung Damit bei dieser trockenen Materie der Spaß nicht zu kurz kommt, soll das Ganze dann als Formel1-Rennen in Szene gesetzt werden. Zur Vorbereitung empfiehlt sich ein Blick in das Beispiel 6.4.2 ("Von der Unit zur Klasse"). Weitere anspruchsvollere Beispiele für objektorientierte Lösungen finden Sie unter 14.4.2. ("Dynamisches Array auf dem Heap") oder im Applikationsbeispiel 16.4 ("Mathematikprogramm GAUSS2").

6.5.1 Klassen und Objekte verstehen Wir wollen zunächst eine Klasse TAuto (das ist die "Konstruktionsvorschrift") definieren, von der wir dann drei verschiedene Objekte (Auto1, Auto2, Auto3) ableiten werden.

Oberfläche Öffnen Sie eine neue Anwendung. Etwa in der Mitte von Form1 platzieren Sie die Start-/Ziellinie als breiten senkrechten Strich (TShape-Komponente mit Shape-Eigenschaft = stRectangle, Pen.Style = psClear). Auf Form1 richten Sie drei "Cockpits" für die noch zu erzeugenden Auto-Objekte ein 1. Unterhalb platzieren Sie in drei Rahmen (GroupBox1, GroupBox2, GroupBox3) jeweils zwei Schaltflächen (Button1 ... Button6). Auch ein Zeitgeber-Control (Timer1) ist erforderlich:

1

In unserem Fall gehört das Cockpit nicht mit zum Auto-Objekt, es ist als separates Bedienpult zu verstehen, ähnlich wie bei einem ferngesteuerten Modell.

318

Kapitel 6

Units und Objekte

Weisen Sie der Interval-Eigenschaft des Timers einen Wert von ca. 10 bis 30 zu1.

Shape1

GroupBox2

GroupBox3

GroupBox1 Button2

Button4 Button6

Button5 Button1

Button3

Timer1

Button7

Klassendefinition "TAuto" Jetzt müssen wir definieren, wie unsere Auto-Objekte aussehen sollen (Eigenschaften) und wie sie funktionieren (Methoden). Die entsprechende Klassendeklaration könnten wir zwar auch noch mit in Unit1 unterbringen, da wir aber wollen, dass die TAuto-Klasse zur allgemeinen Verfügung stehen soll, also später auch von beliebigen anderen Programmen benutzt werden kann, werden wir sie in einer separaten Unit unterbringen. Fügen Sie also über Datei|Neu... eine neue Unit hinzu. Sie heißt zwar standardmäßig Unit2, wir werden Sie aber aus nahe liegenden Gründen auf den Namen Auto umtaufen. unit Auto; interface uses Graphics;

// stellt die TAuto-Klasse zur Verfügung

Unsere neu zu definierende Klasse TAuto hat vier Eigenschaften (x, y, va, farbe) und drei Methoden (Gasgeben, Bremsen, Zeichnen): type TAuto = class(TObject) // Klassendeklaration von TAuto // Felder: x:Integer; // x-Position

1

Das muss später gegebenenfalls noch korrigiert werden.

6.5 Kleiner OOP-Crashkurs

319

y: Integer; // y-Position va: Single; // aktuelle Geschwindigkeit farbe: LongInt; // Lackierung // Methoden: procedure Gasgeben(dv:Single); // erhöht va um dv procedure Bremsen(dv:Single); // verringert va um dv procedure Zeichnen(canv: TCanvas; colr: LongInt); // zeichnet Auto in Farbe colr end;

Im implementation-Abschnitt müssen die drei Methoden definiert werden: implementation procedure TAuto.Gasgeben(dv:Single); begin va := va + dv; if va > 100 then va := 100 // Geschwindigkeitsbegrenzung end; procedure TAuto.Bremsen(dv:Single); begin va := va - dv; if va <= 0 then va := 0 // Rückwärtsrollen verhindern end; procedure TAuto.Zeichnen(canv:TCanvas; colr: LongInt); begin with canv do begin Pen.Color := colr; // Stiftfarbe zuweisen Rectangle(x+10, y+5, x+30, y+20); // linkes Hinterrad Rectangle(x+10,y+70,x+30,y+85); // rechtes Hinterrad Rectangle(x+80,y+10,x+100,y+20); // linkes Vorderrad Rectangle(x+80,y+70,x+100,y+80); // rechtes Vorderrad MoveTo(x+20, y+20); LineTo(x+20,y+30); // linke Hinterachse MoveTo(x+20, y+60); LineTo(x+20,y+70); // rechte Hinterachse MoveTo(x+90, y+20); LineTo(x+90,y+35); // linke Vorderachse MoveTo(x+90, y+55); LineTo(x+90,y+70); // rechte Vorderachse MoveTo(x, y+30); LineTo(x+70,y+30); // linke Karosserieseite LineTo(x+110, y+40); LineTo(x+110,y+50); LineTo(x+70, y+60); LineTo(x,y+60); // rechte Karosserieseite LineTo(x,y+30); Ellipse(x+45,y+35,x+65,y+55) // Cockpit end end; end.

Speichern Sie die fertige Unit unter dem neuen Namen Auto.pas ab.

Formular-Unit Nun wenden wir uns der Programmierung von Unit1 zu, für die bereits die Oberfläche (Form1) existiert. Der interface-Abschnitt wurde von Delphi automatisch generiert und bedarf unsererseits keiner weiteren Ergänzungen. Widmen wir uns also dem implementation-Abschnitt:

320

Kapitel 6

Units und Objekte

implementation

Die Auto-Unit muss hier eingebunden werden: uses Auto;

// Einbinden der TAuto-Unit

Nun zu den Objektvariablen (den Autos), die zunächst deklariert werden müssen, bevor sie mittels Create tatsächlich erzeugt werden können (siehe weiter unten): var Auto1, Auto2, Auto3: TAuto;

// drei Auto-Objekte deklarieren

Auch einen Parameter der Rennstrecke legen wir hier fest: xb: Integer;

// außerhalb des Sichtbereichs liegender Streckenabschnitt

Beim Laden von Form1 werden die drei neuen Instanzen (Objekte) der TAuto-Klasse erzeugt: procedure begin Auto1 := Auto2 := Auto3 :=

TForm1.FormCreate(Sender: TObject); TAuto.Create; TAuto.Create; TAuto.Create;

Anschließend werden die Eigenschaften jedes einzelnen Objekts auf die Anfangswerte eingestellt: with Auto1 do begin x := Shape1.Left -100; y := 10; farbe := clRed end; with Auto2 do begin x := Shape1.Left -100; y := end; with Auto3 do begin x := Shape1.Left -100; y := end;

// der rote Ferrari // an Startlinie ausrichten // obere Fahrbahn // rot // der blaue Williams Renault 110; farbe := clBlue // der grüne Exote 210; farbe := clGreen

Und schließlich ist noch ein programmtechnischer Parameter zuzuweisen: Form1.Canvas.Brush.Style := bsClear end;

// Füllmuster ist transparent

Nun programmieren wir die einzelnen Gas- und Bremspedale. Damit das Rennen interessant wird, erhalten alle drei Autos jeweils unterschiedliche Motorstärken bzw. Bremsverzögerungen als Übergabeparameter. Gas und Bremse für den roten Ferrari: procedure TForm1.Button2Click(Sender: TObject); begin Auto1.Gasgeben(0.5) end;

321

6.5 Kleiner OOP-Crashkurs

procedure TForm1.Button1Click(Sender: TObject); begin Auto1.Bremsen(1) end;

Gas und Bremse für den blauen Williams-Renault: procedure TForm1.Button4Click(Sender: TObject); begin Auto2.Gasgeben(1.8) end; procedure TForm1.Button3Click(Sender: TObject); begin Auto2.Bremsen(1.5) end;

Gas und Bremse für den grünen Exoten: procedure TForm1.Button6Click(Sender: TObject); begin Auto3.Gasgeben(5) end; procedure TForm1.Button5Click(Sender: TObject); begin Auto3.Bremsen(4) end;

Nun müssen wir uns noch um die Anzeige der drei Autos kümmern: procedure anzeigen(auto:TAuto); // Anzeigeroutine für ein TAuto-Objekt begin auto.Zeichnen(Form1.Canvas, Form1.Color); // alte Position übermalen auto.x := auto.x + Trunc(auto.va); // Verschieben der x-Position if auto.x >= Form1.ClientWidth then auto.x := -xb; // Rand erreicht auto.Zeichnen(Form1.Canvas, auto.farbe) // an neuer Position zeichnen end;

Übergabeparameter für obige Prozedur ist ein komplettes Auto-Objekt! Für den periodischen Aufruf obiger Prozedur nach dem Prinzip "Flimmerkiste" ist der Timer zuständig: procedure TForm1.Timer1Timer(Sender: TObject); // periodisches Anzeigen begin anzeigen(auto1); anzeigen(auto2); anzeigen(auto3) end;

Durch Auseinanderziehen des Fensters können wir auch den unsichtbaren Abschnitt der Rennstrecke ändern: procedure TForm1.FormResize(Sender: TObject); begin xb := 3 * Form1.ClientWidth; // unsichtbare Strecke ist 3 Mal so lang wie sichtbare Timer1Timer(Self) // Anzeige durch Aufruf von TForm1.Timer1Timer end;

Das Ende des Autorennens: procedure TForm1.Button7Click(Sender: TObject); begin

// Beenden

322

Kapitel 6

Units und Objekte

Form1.Close end;

Dann sollte man den von den Objekten belegten Speicherplatz auch wieder freigeben1: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin Auto1.Free; Auto2.Free; Auto3.Free end;

Test Nach Programmstart stehen die drei bunten Flitzer exakt ausgerichtet an der Start-/Ziellinie:

Stören Sie sich nicht am fehlenden Lenkrad, wagen Sie trotzdem ein kleines Rennen. Sie müssen dazu jedes Auto einzeln beschleunigen.

1

Das geschieht zwar automatisch beim Schließen des Projekts, aber man sollte es sich trotzdem zur Gewohnheit werden lassen, da ein Projekt ja auch aus mehreren Formularen bestehen kann.

6.5 Kleiner OOP-Crashkurs

323

Klicken Sie immer mehrmals hintereinander auf das Gaspedal1. Ebenso verhält es sich mit dem Bremsen, was ähnlich einer "Stotterbremsung" funktioniert2:

Bemerkungen ■ Sie werden feststellen, dass entsprechend der den Methoden Gasgeben und Bremsen übergebenen Parameter alle Autos unterschiedlich auf Gas bzw. Bremse reagieren. ■ Ein leichtes Flackern der Fahrzeuge ist aufgrund der verwendeten ungepufferten Vektorgrafiken normal. Eventuell ist durch Ändern der Interval-Eigenschaft des Timers eine bessere Darstellung zu erreichen. ■ Verlängern Sie den sichtbaren Bereich der Rennstrecke, indem Sie das Fenster während der Programmausführung einfach auseinander ziehen!

6.5.2 Konstruktor und Destruktor Eine objektorientierte Sprache wie Delphi realisiert das Erzeugen und Entfernen von Objekten mit so genannten Konstruktoren und Destruktoren. Beides sind spezielle Methoden innerhalb der Klassendeklaration. "Welchen Konstruktor und welchen Destruktor haben wir denn beim Vorgängerbeispiel eingesetzt?", werden Sie nun zu Recht fragen. Hier die Antwort: "Es war der von TObject ererbte Create-Konstruktor bzw. der Free-Destruktor!" Grund unserer Unzufriedenheit ist vor allem der Create-Konstruktor, der alle Eigenschaften auf Nullwerte bzw. Leerstrings initialisiert. Anschließend mussten die Werte mühsam über einzelne Befehle zugewiesen werden. (aus dem Quelltext von Unit1 des Vorgängerbeispiels) Auto1 := TAuto.Create; with Auto1 do begin x := Shape1.Left -100; y := 10; farbe := clRed end; ...

Lassen Sie es uns diesmal besser machen! Wir wollen unsere TAuto-Klasse mit einem "selbst gestrickten" Konstruktor nachrüsten und auch auf einen extra Destruktor nicht verzichten!

1

Nicht die Schaltfläche dauerhaft niederdrücken, denn dann passiert ... nichts.

2

Denken Sie an Glatteisgefahr!

324

Kapitel 6

Units und Objekte

Erweiterung der Klassendefinition "TAuto" Wir öffnen die Unit Auto.pas des Vorgängerbeispiels und doktern ein wenig an der Klassendeklaration herum. Die beiden neu einzufügenden Methodenköpfe sind unterstrichen hervorgehoben: type TAuto = class(TObject) // Eigenschaften: x:Integer; // x-Position y: Integer; // y-Position va: Single; // aktuelle Geschwindigkeit farbe: LongInt; // Lackierung // Methoden: constructor Erzeugen(xpos,ypos: Integer; colr: LongInt); destructor Entfernen; procedure Gasgeben(dv:Single); procedure Bremsen(dv:Single); procedure Zeichnen(canv:TCanvas; colr: LongInt); end;

Den implementation-Abschnitt ergänzen Sie wie folgt: constructor TAuto.Erzeugen(xpos,ypos: Integer; colr: LongInt); begin x := xpos; y := ypos; farbe := colr end; destructor TAuto.Entfernen; begin // bleibt leer! end;

Vereinfachen der Formular-Unit Öffnen Sie nun Unit1.pas und vereinfachen Sie den FormCreate-Event-Handler wie folgt: procedure TForm1.FormCreate(Sender: TObject); begin Auto1 := TAuto.Erzeugen(Shape1.Left-100, 10, clRed); Auto2 := TAuto.Erzeugen(Shape1.Left-100, 110, clBlue); Auto3 := TAuto.Erzeugen(Shape1.Left-100, 210, clGreen); Form1.Canvas.Brush.Style := bsClear end;

Dieser Quelltext ist doch wesentlich kürzer und übersichtlicher, oder? Wie im obigen Code sind auch im folgenden FormClose-Event-Handler die geänderten Anweisungen unterstrichen hervorgehoben: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin Auto1.Entfernen;

6.5 Kleiner OOP-Crashkurs

325

Auto2.Entfernen; Auto3.Entfernen end;

Test Wenn Sie das Programm starten, werden Sie keinerlei Unterschied zum Vorgängerbeispiel feststellen.

6.5.3 Read-Only-Eigenschaften programmieren? Mit den Eigenschaften x, y, va und farbe unserer TAuto-Klasse haben wir im Vorgängerbeispiel bereits erfolgreich gearbeitet, wozu also dann noch Eulen nach Athen tragen? Die Antwort: Mit dem Deklarieren von Eigenschaften als öffentliche Felder von TAuto haben wir das Brett an der dünnsten Stelle gebohrt, denn dies ist nicht der sauberste und oft auch nicht der effektivste Weg. Warum? Die "hohe Kunst" der OOP verbietet das direkte Herumdoktern an Variablen und verlangt, dass diese durch Methoden zu kapseln sind, um sich dadurch einem kontrollierten Lese-/Schreibzugriff zu unterwerfen. Delphi stellt dazu so genannte "Eigenschaftsprozeduren" (Property-Procedures) zur Verfügung, die wir im vorliegenden Beispiel anwenden wollen. Ziel der folgenden Demo ist das Ergänzen der Fahrzeug-Cockpits aus dem Vorgängerbeispiel um eine Tachometeranzeige. "Nichts einfacher als das!", werden Sie denken, denn man kann ja auf die Eigenschaft va (aktuelle Geschwindigkeit) auch direkt zugreifen. Doch gerade das macht die Sache so gefährlich. Warum? Jeder Fahrschulanfänger weiß, dass man bei einem realen Auto-Objekt die Eigenschaft "Geschwindigkeit" nicht direkt, sondern nur über die Methoden "Gasgeben" und "Bremsen" beeinflussen kann. Es gilt also, den Zugriff auf die Eigenschaft va als Read-Only zu deklarieren, um damit ein Schreiben ein für allemal zu verhindern. Dies aber erreicht man nur durch "Verstecken" von va in den private-Abschnitt von TAuto und durch Einfügen einer speziellen property-get-Zugriffsmethode, die wir tacho nennen wollen.

Änderungen in der Klassendeklaration "TAuto" Die Änderungen gegenüber dem Vorgängerbeispiel sind durch Unterstreichung hervorgehoben: type TAuto = class(TObject) // privater Bereich private va: Single; // speichert aktuelle Geschwindigkeit public // öffentlicher Bereich x: Integer; // x-Position y: Integer; // y-Position farbe: LongInt; // Lackierung

Objektmethoden: constructor Erzeugen(xpos,ypos: Integer; colr: LongInt); procedure Gasgeben(dv:Single); procedure Bremsen(dv:Single); procedure Zeichnen(canv:TCanvas; colr:LongInt);

326

Kapitel 6

property tacho:Single read va; end;

Units und Objekte

// ReadOnly-Objekteigenschaft!

Auf einen Destruktor haben wir diesmal verzichtet, da der ererbte (Free) genügt. Im implementation-Abschnitt sind, bis auf die fehlende destructor-Methode, keine Änderungen erforderlich.

Geänderte Oberfläche Aus Übersichtlichkeitsgründen brauchen wir diesmal nur Platz für zwei Autos. Beide Cockpits ergänzen wir durch Bezeichnungsfelder für die Tachoanzeige (Label1 und Label2), so dass sich zur Laufzeit etwa der folgende Anblick bieten sollte:

Modifizieren der Formular-Unit Modifizieren Sie den implementation-Abschnitt, so dass nur noch zwei Autos angezeigt werden. Weiterhin ist die neue Eigenschaft tacho anstatt va zu verwenden. Auch in den folgenden Codeauszügen wird auf die entsprechenden Änderungen durch Unterstreichung hingewiesen: var Auto1, Auto2: TAuto; procedure TForm1.FormCreate(Sender: TObject); begin Auto1 := TAuto.Erzeugen(Shape1.Left-100, 10, clRed); Auto2 := TAuto.Erzeugen(Shape1.Left-100, 110, clBlue); Form1.Canvas.Brush.Style := bsClear end;

6.5 Kleiner OOP-Crashkurs

327

procedure anzeigen(Auto:TAuto); begin Auto.Zeichnen(Form1.Canvas, Form1.Color); Auto.x := Auto.x + Trunc(Auto.tacho); If Auto.x >= xb then Auto.x := -xb; Auto.Zeichnen(Form1.Canvas, Auto.farbe) end; procedure TForm1.Timer1Timer(Sender: TObject); var s: string; begin anzeigen(Auto1); anzeigen(Auto2); // Tachometer für Auto1 Str(Auto1.tacho:5:1,s); Label1.Caption := s + 'km/h'; Str(Auto2.tacho:5:1,s); Label2.Caption := s + 'km/h' // dto. für Auto2 end; procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin Auto1.Free; Auto2.Free // Speicherplatz freigeben end;

Test Das fehlende grüne Auto werden Sie leicht verschmerzen, dafür haben das rote und das blaue Auto jetzt eine Geschwindigkeitsanzeige. Ansonsten werden Sie bei der Bedienung keinerlei Unterschiede zum Vorgängerbeispiel feststellen.

Bemerkung Wenn Sie in Unit1 an irgendeiner Stelle eine Anweisung wie z.B. Auto1.tacho := 85;

verwenden wollen, werden Sie durch eine Fehlermeldung darauf hingewiesen, dass es sich bei tacho um eine Readonly-Eigenschaft handelt.

6.5.4 Eigenschaften mit Zugriffsmethoden kapseln Im Vorgängerbeispiel hatten wir demonstriert, wie mit einer property-get-Prozedur der Zugriff auf die private Mitgliedsvariable va der TAuto-Klasse kontrolliert werden kann. Jetzt wollen wir noch eins draufsetzen und zeigen, wie man property-Prozeduren durch so genannte Zugriffsmethoden ergänzen kann. Als Beispiel dient uns diesmal eine neue Eigenschaft Alter, die aus der neuen privaten Mitgliedsvariablen bj (Baujahr) mit Hilfe von Zugriffsmethoden berechnet wird. Im Unterschied zum Vorgängerbeispiel soll diesmal sowohl Lese- als auch Schreibzugriff erlaubt sein.

Änderungen in der Klassendeklaration "TAuto" Diesmal wird der interface-Abschnitt komplett wiedergegeben, die Änderungen sind unterstrichen. Wichtig ist das Einbinden der Unit sysUtils, welche die Date-Funktion zwecks Ermittlung des aktuellen Systemdatums bereitstellt:

328

Kapitel 6

Units und Objekte

interface // notwendig wegen Date-Funktion uses Graphics, sysUtils; type TAuto = class(TObject) private va: Single; // speichert Baujahr bj: Integer; function liesAlter: Integer; // Lese-Zugriffsmethode für Alter-Prop // Schreib-Zugriffsmethode ... procedure schreibAlter(a: Integer); public x: Integer; y: Integer; farbe: LongInt; constructor Erzeugen(xpos,ypos: Integer; colr: LongInt; bauj: Integer); procedure Gasgeben(dv:Single); procedure Bremsen(dv:Single); procedure Zeichnen(canv:TCanvas; colr:LongInt); property Tacho: Single read va; property Alter: Integer read liesAlter write schreibAlter; // neue Prop-Prozedur end;

Im implementation-Abschnitt müssen wir zunächst eine geringfügige Änderung am Konstruktor vornehmen: implementation constructor TAuto.Erzeugen(xpos,ypos: Integer; colr: LongInt; bauj: Integer); begin x := xpos; y := ypos; farbe := colr; bj := bauj end;

Neu kommen die Definitionen der beiden Zugriffsprozeduren hinzu. Wie Sie sehen, muss Alter aus der Differenz des aktuellen Jahrs (Formatierung 'yyyy') und des Baujahrs bj berechnet werden. Der Lesezugriff ist dabei stets als Funktion, der Schreibzugriff hingegen als Prozedur zu realisieren: function TAuto.liesAlter: Integer; begin result := StrToInt(FormatDateTime('yyyy', Date)) - bj end; procedure TAuto.schreibAlter(a: Integer); begin bj := StrToInt(FormatDateTime('yyyy', Date)) - a end;

Die übrigen Methodendefinitionen bleiben unverändert.

Änderungen der Bedienoberfläche In die beiden Cockpits fügen wir jeweils noch ein Label ein (Label3 und Label4). Beide dienen uns zur Anzeige der neuen Eigenschaft Alter.

6.5 Kleiner OOP-Crashkurs

329

Änderungen der Formular-Unit Beim Laden des Formulars wird jedem Auto per Konstruktoraufruf ein Baujahr zugewiesen (in unserem Beispielcode 1985 bzw. 1992). Anschließend erfolgt die Anzeige des Alters: procedure TForm1.FormCreate(Sender: TObject); begin Auto1 := TAuto.Erzeugen(Shape1.Left-100, 10, clRed, 1985); Auto2 := TAuto.Erzeugen(Shape1.Left-100, 110, clBlue, 1992); Label3.Caption := 'Ich bin ' + IntToStr(Auto1.Alter) + ' Jahre alt!'; Label4.Caption := 'Ich bin ' + IntToStr(Auto2.Alter) + ' Jahre alt!'; Form1.Canvas.Brush.Style := bsClear end;

Test Beim Programmstart erscheint in beiden Labels die Selbstauskunft der Autos, z.B. "Ich bin 12 Jahre alt!" bzw. "Ich bin 5 Jahre alt!" (in Abhängigkeit von baujahr und aktuellem Systemdatum).

Bemerkungen ■ Obwohl im Beispielcode nur das Lesen der Eigenschaft Alter demonstriert wurde, funktioniert natürlich das Schreiben ebenfalls, z.B.: Auto1.Alter := 15;

■ Beachten Sie, dass Alter in der Klassendeklaration von TAuto nicht direkt gespeichert wird. Stattdessen sorgen die beiden (privaten!) Zugriffsmethoden liesAlter und schreibAlter dafür, dass der Wert (in Abhängigkeit vom Systemdatum) auf die private Mitgliedsvariable bj (Baujahr) zurückgeführt wird. ■ Obwohl der Direktzugriff auf die private Mitgliedsvariable bj unmöglich ist, lässt sie sich durch Aufruf des Konstruktors trotzdem manipulieren.

6.5.5 Vererbung Die Objektorientierte Programmierung unter Delphi gibt dem Programmierer noch weitaus mehr Trümpfe in die Hand, als wir sie bisher kennen gelernt haben. Nehmen wir spaßeshalber einmal an, dass auf unserer Rennstrecke nicht nur Autos, sondern auch Fahrräder unterwegs sein sollen. Sicher wäre es möglich, eine neue Klasse TFahrrad zu definieren und dabei genauso vorzugehen, wie wir es bisher mit TAuto praktiziert haben. Sehr schnell werden Sie aber feststellen, dass sowohl Autos als auch Fahrräder gleich lautende Eigenschaften farbe, alter, tacho haben oder eine gleich lautende Methode Bremsen. Kar ist, dass trotz gleichen Namens diese Eigenschaften/Methoden für jede Klasse unterschiedlich zu implementieren sind. Das nennt man dann Polymorphie. Ganz deutlich wird die Polymorphie, wenn Sie sich die Methode Zeichnen der TAuto-Klasse aus den Vorgängerbeispielen betrachten. Auch für eine TFahrrad-Klasse hätte diese Methode den gleichen Namen, müsste aber intern völlig anders programmiert (sprich implementiert) werden. Aber es gibt auch Unterschiede. So wäre z.B. eine

330

Kapitel 6

Units und Objekte

Methode Gasgeben bei einer TFahrrad-Klasse völlig fehl am Platze. Wir müssten ihr einen anderen Namen geben, beispielsweise Strampeln. All diese Probleme können wir mit Vererbung elegant, übersichtlich und zeitsparend programmieren, d.h., wir bilden eine abstrakte Klasse TFahrzeug1, in die wir all die Eigenschaften und Methoden hinein packen, die für die Nachkommen TAuto und TFahrrad gleichermaßen von Interesse sind. Der Rest kann später in den Unterklassen hinzugefügt werden. Für das folgende Demoprogramm brauchen wir außer der Formular-Unit Unit1 noch drei weitere Units: Fahrzeug, Auto und Fahrrad. Im Unterschied zu den Vorgängerbeispielen werden wir in diesem abschließenden Beispiel die Listings vollständig drucken. Versuchen Sie insbesondere, am Quelltext die Bedeutung der OOP-spezifischen Schlüsselwörter virtual, override und inherited zu verstehen!

Oberfläche Wir brauchen Bedienpulte für zwei Autos und zwei Fahrräder. Nur die beiden Autos sollen über Geschwindigkeitsanzeigen verfügen.

Klassendefinition "TFahrzeug" Auf besonders wichtige Stellen im Quelltext wird durch Unterstreichung hingewiesen. unit Fahrzeug; interface uses Graphics;

Eine abstrakte Klasse TFahrzeug: type TFahrzeug = class(TObject) private va: Single; // Feld public // die öffentlichen Klassenmitglieder: x: Integer; // Feld y: Integer; // dto. farbe: LongInt; // dto.

Die Methoden: constructor Erzeugen(xpos,ypos: Integer; colr: LongInt); procedure Schneller(dv:Single); procedure Bremsen(dv:Single); procedure Zeichnen(canv:TCanvas; colr: LongInt); virtual; // wird vom Nachkommen // überschrieben property tacho:Single read va; // ReadOnly- Eigenschaft end; implementation 1

Sie entsinnen sich: Von abstrakten Klassen werden keine Instanzen gebildet, sie sind nur dazu da, ihre Eigenschaften/ Methoden an die Nachkommen weiterzugeben.

6.5 Kleiner OOP-Crashkurs

constructor TFahrzeug.Erzeugen; begin x := xpos; y := ypos; farbe := colr end; procedure TFahrzeug.Schneller; // abstrakte Methode begin va := va + dv end; procedure TFahrzeug.Bremsen; begin va := va - dv; if va < 0 then va := 0 // verhindert Rückwärtsrollen des Fahrzeugs end; procedure TFahrzeug.Zeichnen; // virtuelle Methode (Polymorphie!) begin canv.Pen.Color := colr; // Rest bleibt leer, wird von Nachkommen ergänzt end; end.

Klassendefinition "TAuto" unit Auto; interface uses Graphics, Fahrzeug;

Eine eigene Klasse TAuto als Nachkomme von TFahrzeug: type TAuto = class(TFahrzeug) // zusätzliche eigene Methoden: procedure Gasgeben(dv:Single); // polymorphe Methoden: procedure Zeichnen(canv:TCanvas; colr: LongInt); override; end;

Methoden implementieren: implementation procedure TAuto.Gasgeben; begin if tacho < 100 then Schneller(dv) // abstrakte Methode von TFahrzeug verwenden end; procedure TAuto.Zeichnen; begin inherited Zeichnen(canv, colr); // gleichnamige Methode des Vorfahren aufrufen with canv do begin Rectangle(x+10, y+5, x+30, y+20); // linkes Hinterrad Rectangle(x+10,y+70,x+30,y+85); // rechtes Hinterrad Rectangle(x+80,y+10,x+100,y+20); // linkes Vorderrad Rectangle(x+80,y+70,x+100,y+80); // rechtes Vorderrad

331

332

Kapitel 6

MoveTo(x+20, y+20); LineTo(x+20,y+30); // MoveTo(x+20, y+60); LineTo(x+20,y+70); // MoveTo(x+90, y+20); LineTo(x+90,y+35); // MoveTo(x+90, y+55); LineTo(x+90,y+70); // MoveTo(x, y+30); LineTo(x+70,y+30); // LineTo(x+110, y+40); LineTo(x+110,y+50); LineTo(x+70, y+60); LineTo(x,y+60); // LineTo(x,y+30); Ellipse(x+45,y+35,x+65,y+55) // end end; end.

Units und Objekte

linke Hinterachse rechte Hinterachse linke Vorderachse rechte Vorderachse linke Karosserieseite rechte Karosserieseite Cockpit

Klassendefinition "TFahrrad" In der Unit Fahrrad wird eine eigene Klasse TFahrrad als Nachkomme von TFahrzeug definiert: unit Fahrrad; interface uses Graphics, Fahrzeug; type TFahrrad = class(TFahrzeug) public

Hier eigene Methoden deklarieren: procedure Strampeln(dv:Single); procedure Zeichnen(canv:TCanvas; colr:LongInt); override; end;

Methoden implementieren: implementation procedure TFahrrad.Strampeln; begin if tacho < 10 then Schneller(dv) // eine Methode des Vorfahren verwenden end; procedure TFahrrad.Zeichnen; // virtuelle Methode (Polymorphie!) begin // gleichnamige Methode des Vorfahren inherited Zeichnen(canv, colr); with canv do begin MoveTo(x, y+20); LineTo(x+20,y+20); // Hinterrad Rectangle(x+20, y+11, x+40,y+29); // Oberkörper Ellipse(x+36,y+16,x+44,y+24); // Kopf mit Helm MoveTo(x+40, y+10); LineTo(x+50,y+10); // linker Arm MoveTo(x+40, y+30); LineTo(x+50,y+30); // rechter Arm MoveTo(x+50, y+5); LineTo(x+50,y+35); // Lenker MoveTo(x+45, y+20); LineTo(x+70,y+20) // Vorderrad end end; end.

6.5 Kleiner OOP-Crashkurs

333

Formular-Unit Wie immer genügt es, wenn wir uns auch diesmal auf den Implementation-Abschnitt beschränken: implementation

Nicht nur die Klassen TAuto und TFahrrad werden benötigt, sondern auch die abstrakte Klasse TFahrzeug; Letztere wegen der Prozedur anzeigen (siehe weiter unten). Deshalb sind alle drei Units einzubinden: uses Fahrzeug, Auto, Fahrrad; var Auto1, Auto2: TAuto; Fahrrad1, Fahrrad2: TFahrrad; xb: Integer; // nicht einsehbarer Streckenbereich procedure TForm1.FormCreate(Sender: TObject); begin Auto1 := TAuto.Erzeugen(Shape1.Left-100, 10, clRed); Auto2 := TAuto.Erzeugen(Shape1.Left-100, 110, clBlue); Fahrrad1 := TFahrrad.Erzeugen(Shape1.Left-100, 200, clGreen); Fahrrad2 := TFahrrad.Erzeugen(Shape1.Left-100, 240, clBlack); Form1.Canvas.Brush.Style := bsClear end;

Die folgenden Methodenaufrufe spiegeln die einzelnen Bedienfunktionen der Fahrzeuge wider und erfolgen mit unterschiedlichen Werten der Übergabeparameter, weil natürlich ein Auto eine andere Beschleunigung und Bremsverzögerung hat als ein Fahrrad: procedure TForm1.Button2Click(Sender: TObject); begin Auto1.Gasgeben(0.5) end; procedure TForm1.Button1Click(Sender: TObject); begin Auto1.Bremsen(1) end; procedure TForm1.Button4Click(Sender: TObject); begin Auto2.Gasgeben(1.8) end; procedure TForm1.Button3Click(Sender: TObject); begin Auto2.Bremsen(1.5) end; procedure TForm1.Button5Click(Sender: TObject); begin

334

Kapitel 6

Units und Objekte

Fahrrad1.Bremsen(0.5) end; procedure TForm1.Button6Click(Sender: TObject); begin Fahrrad1.Strampeln(0.3) end; procedure TForm1.Button8Click(Sender: TObject); begin Fahrrad2.Bremsen(0.5) end; procedure TForm1.Button9Click(Sender: TObject); begin Fahrrad2.Strampeln(0.7) end;

Was jetzt kommt, ist keine Methode von TForm1, sondern eine ganz normale Prozedur, die es allerdings in sich hat. Sie zeigt ein Fahrzeug auf dem Bildschirm an, egal ob ihr Übergabeparameter ein Fahrrad oder ein Auto ist. procedure anzeigen(fhzg:TFahrzeug); // zeigt Autos und Fahrräder an! begin fhzg.Zeichnen(Form1.Canvas, Form1.Color); fhzg.x := fhzg.x + Trunc(fhzg.tacho); if fhzg.x >= Form1.ClientWidth then fhzg.x := -xb; fhzg.Zeichnen(Form1.Canvas, fhzg.farbe) end;

Der Rest dürfte Ihnen aus den Vorgängerbeispielen bekannt vorkommen: procedure TForm1.Timer1Timer(Sender: TObject); var s:string; begin anzeigen(Auto1); anzeigen(Auto2); anzeigen(Fahrrad1); anzeigen(Fahrrad2);

Tachometeranzeige nur für die Autos: Str(Auto1.tacho:5:1,s); Label1.Caption := s + 'km/h'; Str(Auto2.tacho:5:1,s); Label2.Caption := s + 'km/h' end;

Während der Laufzeit können Sie die Fensterbreite verändern: procedure TForm1.FormResize(Sender: TObject); begin

335

6.5 Kleiner OOP-Crashkurs

xb := 3 * ClientWidth; Timer1Timer(Self) end;

// Länge der Rennstrecke anpassen // Aufruf der Anzeige (im Timer-Event)

Beim Beenden des Programms müssen die von unseren Objekten belegten Ressourcen wieder freigegeben werden: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin Auto1.Free; Auto2.Free; Fahrrad1.Free; Fahrrad2.Free end;

Test Endlich ist es geschafft, und das ungleiche Rennen kann beginnen:

Bemerkung Wer keinen Bock auf derlei Spielereien hat, kann sich auch anhand einer total seriösen Anwendung im Wissenschaftskapitel in die Geheimnisse der OOP einführen lassen (13.7.2, "Kreuzprodukt von Vektoren").

7

Grafikprogrammierung

Kapitel

7

Grafikprogrammierung Windows ist Grafik pur. Einen Unterschied zwischen Text- und Grafikmodus, wie unter DOS, gibt es nicht mehr, da auch Text als eine spezielle Form von Grafik aufgefasst wird. Delphi bietet für die Grafikprogrammierung vier grundsätzliche Varianten: ■ Zeichnen von Grafiken mit z.B. LineTo, Ellipse, Draw, ... auf dem Canvas (Leinwand) einer Komponente (Form, Image, Bitmap, Printer, ...) ■ Anzeige von Grafikdateien (z.B. *.BMP, *.WMF) in speziellen Container-Komponenten (z.B. Image, PaintBox, ...) ■ Verwendung von Shape-Komponenten (z.B. als Rechteck, Ellipse, ...) ■ Direkter Zugriff auf die Grafikschnittstelle von Windows über GDI-Funktionen Das folgende Kapitel wird sich schwerpunktmäßig mit den ersten vier Varianten beschäftigen. Die letzte Variante ist dem Kapitel 15 ("Fortgeschrittene Grafikprogrammierung") vorbehalten.

7.1 Das Canvas-Objekt Der von DOS kommende Umsteiger ist es gewohnt, dass sich Grafikanweisungen stets auf den gesamten Bildschirm beziehen. Von dieser Vorstellung müssen Sie sich trennen! Unter Delphi haben wir es mit Grafikmethoden zu tun, die sich immer nur auf die Zeichenfläche (Canvas) eines bestimmten Objekts1 beziehen, z.B.: ■ Formulare ■ Image-Komponenten ■ Paintbox-Komponenten ■ Drucker (Printer) Dies hat unter anderem zur Folge, dass ein und dieselbe Grafikanweisung, auf unterschiedlichen Objekten ausgeführt, zu unterschiedlichen Ergebnissen führen kann. 1

Diese Objekte können auch unsichtbar sein, z.B. TBitmap.

338

Kapitel 7

Grafikprogrammierung

Ein Canvas-Objekt kann weitere untergeordnete Objekte enthalten. Dazu zählen unter anderem Pen-, Brush- und Font-Objekte, die wiederum Eigenschaften haben. Die folgende Abbildung soll diesen Sachverhalt am Beispiel des Canvas eines Image-Objekts verdeutlichen: Image.Canvas.Pixels

Image

Image.Canvas.Brush

Image.Canvas.Font Image.Canvas.Pen

B

Pen.Width Pen.Color Pen.Style Pen.Mode

Brush.Color Brush.Style

Font.Name Font.Color Font.Style Font.Size

Während Pen Ihr "Stift" ist, mit dem Sie auf dem Canvas zeichnen und für den Sie die Eigenschaften Width (Linienstärke), Color (Farbe) und Style (Linienart) einstellen können, versteht man unter Brush die "Bürste", mit der man geschlossene Flächen mit Farbe und Muster ausfüllt. Hierfür und auch um z.B. eine andere Schriftfarbe einzustellen, müssen Sie wissen, für welches Objekt (Form, Image, Printer) diese Änderungen vorgenommen werden sollen. BEISPIEL: So weisen Sie dem Canvas eines Formulars das "Malerwerkzeug" zu, d.h. einen roten Stift und

eine gelbe Bürste. Form1.Canvas.Pen.Color := clRed; Form1.Canvas.Brush.Color := clYellow;

oder auch einfacher Canvas.Pen.Color := clRed; Canvas.Brush.Color := clYellow;

wenn sich der Quellcode in einem Event-Handler von Form1 befindet.

339

7.1 Das Canvas-Objekt

BEISPIEL: Die Zuweisung einiger Eigenschaften für ein Bildfeld: Form1.Image1.Canvas.Font.Color Form1.Image1.Canvas.Font.Size Form1.Image1.Canvas.Pen.Color Form1.Image1.Canvas.Brush.Style

:= := := :=

clRed; 12; clBlack; bsClear;

// // // //

rote Schrift 12 dpI schwarzer Zeichenstift transparente Füllung

Ziemlich aufwändig, nicht wahr? Wenn Sie mehrere Properties festlegen wollen, ist mit diesen "Bandwurmeigenschaften" schon eine ganze Menge an Tipparbeit verbunden. Aber vielleicht erinnern Sie sich noch an die with-Anweisung aus dem Sprachkapitel 2. BEISPIEL: Obiges Beispiel kann kürzer so formuliert werden: with Form1.Image1.Canvas do begin Font.Color := clRed; Font.Size := 12; Pen.Color := clBlack; Brush.Style := bsClear end;

Das sieht doch schon etwas freundlicher aus, aber nun der Reihe nach.

7.1.1 Koordinatensystem In einem Delphi-Programm beziehen sich Koordinaten stets auf ein bestimmtes Objekt, d.h. auf ein Formular, auf eine Komponente oder auf den Drucker. Maßeinheit ist immer Pixel, was allerdings beim Drucker etwas sinnlos erscheint. Wer möchte schon, dass ein Bild auf einem 150-dpi-Drucker viermal so groß wie auf einem 600-dpi-Drucker ist? Wie Sie dieses Problem elegant umgehen, lesen Sie im Beispiel 8.10.1 ("Drucken einer Textdatei"). Ein weiteres Problem bereitet dann Kopfzerbrechen, wenn ein Programm auf Bildschirmen mit unterschiedlicher Grafikauflösung laufen soll, z.B. 640 x 480, 800 x 600 und 1024 x 768 Pixel. Zwar gibt es die Eigenschaften PixelsPerInch und Scaled (letztere muss True gesetzt werden, damit PixelsPerInch wirksam wird), und man kann durch diverse Umrechnungen für eine leidliche Anpassung sorgen, doch erfahrungsgemäß ist man erst dann auf der absolut sicheren Seite, wenn man das Brett an der dünnsten Stelle bohrt und seine Fenster nicht größer als die niedrigstmögliche Auflösung (640 x 480) entwirft bzw. unterschiedliche Versionen herausgibt1. HINWEIS: Eine Koordinatenumwandlung ist auch mit den Methoden ScreenToClient und

ClientToScreen möglich. Es gibt noch eine Reihe weiterer Vorsorgemaßnahmen, die der Programmierer treffen kann, um seine Applikation weniger anfällig gegenüber unterschiedlichen Grafikauflösungen zu machen, beispielsweise das Zentrieren der Fenster.

1

Eine plattformunabhängige Sprache wie Java löst dieses Problem durch so genannte Layout-Manager.

340

Kapitel 7

Grafikprogrammierung

Form1.Width 0,0

Image1.Top

Form1.Height

Image1.Left Image1.ClientHeight

Form1.ClientHeight

0,0

Image1.ClientWidth

Form1.ClientWidth

Obige Abbildung verdeutlicht die Bedeutung verschiedener Eigenschaften. Left und Top bezeichnen den Abstand der linken bzw. oberen Kante des Objekts zur linken bzw. oberen Kante des umgebenden Objekts (Clientbereich). Width und Height bezeichnen die äußeren Abmessungen eines Objekts. Beachten Sie, dass im vorliegenden Koordinatensystem die y-Achse gekippt ist, d.h., positive y-Werte werden nach unten abgetragen. Wenn auch in obiger Abbildung ClientWidth und Width nahezu identisch erscheinen, so wird der Unterschied dann deutlich, wenn z.B. ein dickerer Rahmen oder eine vertikale Bildlaufleiste hinzukommen. Wesentlich wird diese Unterscheidung bei vielen GDI-Funktionen, denen Sie eine Variable vom Typ TRect übergeben müssen (siehe Kapitel 15). Verwenden Sie in diesen Fällen immer die Innenabmessungen der Komponenten (z.B. Image).

7.1.2 Grundlegende Zeichenfunktionen Die Zeichenfunktionen unter Delphi sind meist Methoden und nur ausnahmsweise Eigenschaften des Canvas-Objekts. Die zu übergebenden Koordinaten sind im Allgemeinen vom Integer-Typ.

7.1 Das Canvas-Objekt

341

Punkt Auf einen Punkt greifen Sie über die Pixels-Eigenschaft zu. Canvas.Pixels[x,y:Integer]

Beachten Sie die eckigen Klammern!

BEISPIEL: Eine waagerechte blaue Linie auf Form1 zeichnen var i: Word; ... for i := 0 to Form1.ClientWidth do Form1.Canvas.Pixels[i,100] := clBlue

Der Vorteil einer Eigenschaft anstatt einer Methode ist, dass Sie damit die Farbe eines Punktes nicht nur setzen, sondern auch lesen können. var farbe: TColor; ... farbe := Canvas.Pixels[300,50];

Aktuelle Stiftposition Die Eigenschaft PenPos spiegelt die gegenwärtige Position des Stifts wider. SYNTAX:

Canvas.PenPos: TPoint

Der (von Delphi bereitgestellte) Datentyp TPoint hat folgende Struktur: SYNTAX:

TPoint = record X,Y: LongInt; end; var ecke: TPoint; links: LongInt; ... links := Canvas.PenPos.X; ecke := Canvas.PenPos;

342

Kapitel 7

Grafikprogrammierung

Linie Linien können Sie nicht mit einem einzigen Befehl zeichnen. Legen Sie zuerst den Startpunkt mit der Methode MoveTo fest. Gezeichnet wird von dieser Position aus mit der Methode LineTo, die den Endpunkt bestimmt: SYNTAX:

Canvas.MoveTo(x1,y1:Integer); Canvas.LineTo(x2,y2:Integer)

x2,y2

x1,y1 Image1.Canvas.MoveTo(10,10); Image1.Canvas.LineTo(100,100);

Auch über diese Absonderlichkeit von Delphi sollte man Bescheid wissen: HINWEIS: Der Endpunkt gehört nicht mehr mit zur Linie!

Kreis, Ellipse Eine direkte Funktion zum Zeichnen eines Kreises gibt es nicht. Der Kreis wird als Spezialfall der Ellipse angesehen. Als Koordinatenangaben dienen die linke obere und die rechte untere Ecke des umrahmenden Rechtecks. SYNTAX:

Canvas.Ellipse(x1,y1,x2,y2:Integer) x1,y1

x2,y2

Canvas.Ellipse(25,67,143,231);

... zeichnet eine Ellipse. Canvas.Ellipse(25,25,100,100);

... zeichnet einen Kreis mit einem Durchmesser von 75 Pixeln. Canvas.Ellipse(x0-r,y0-r,x0+r,y0+r);

... zeichnet einen Kreis mit dem Mittelpunkt x0,y0 und dem Radius r.

343

7.1 Das Canvas-Objekt

Rechteck Das Zeichnen von Rechtecken bedarf wohl keiner besonderen Erläuterung. SYNTAX:

Canvas.Rectangle(x1,y1,x2,y2:Integer)

x1,y1

x2,y2 Image1.Canvas.Rectangle(10,10,100,100);

Abgerundetes Rechteck Diese Figur wird wie ein Rechteck gezeichnet, die Ecken werden jedoch als Ellipsenviertel der Breite X3 und der Höhe Y3 dargestellt. Ist Brush.Style <> bsClear, wird das Rechteck mit dem aktuellen Pinsel gefüllt. SYNTAX:

Canvas.RoundRect(X1, Y1, X2, Y2, X3, Y3: Integer)

x3 x1,y1 y3

x2,y2 Canvas.RoundRect(10,10,100,100,10,5);

Tortenstück Die Methode Pie zeichnet ein Segment, das durch eine Ellipse und zwei Linien begrenzt ist. Für Brush.Style <> bsClear wird das Segment mit dem aktuellen Pinsel gefüllt. SYNTAX:

Canvas.Pie(X1, Y1, X2, Y2, X3, Y3, X4, Y4: LongInt)

344

Kapitel 7

Grafikprogrammierung

x3,y3 x1,y1

x2,y2 x4,y4

Canvas.Pie(0,0,500,400, 500, 0, 250, 400);

Bogenstück Die Methode Arc zeichnet im Gegensatz zur Methode Pie nur den Bogen, nicht die Verbindungen zum Ellipsenmittelpunkt. Aus diesem Grund kann die Figur auch nicht gefüllt werden. SYNTAX:

Canvas.Arc(x1,y1,x2,y2,x3,y3,x4,y4:Integer) x3,y3 x1,y1

x2,y2 x4,y4

Canvas.Pie(0,0,500,400, 500, 0, 250, 400);

Kreisstück Mit Hilfe der Methode Chord können Sie den Teil eines Kreises zeichnen, der durch eine Sehne abgeteilt ist. SYNTAX:

Canvas.Chord(x1,y1,x2,y2,x3,y3,x4,y4:Integer) x3,y3 x1,y1

x2,y2 x4,y4

Canvas.Chord(0,0,500,400, 500, 0, 250, 400);

345

7.1 Das Canvas-Objekt

Mehrfachlinie Die PolyLine-Methode arbeitet ähnlich wie MoveTo und LineTo, Sie können jedoch mehrere Punkte auf einmal übergeben. SYNTAX:

Canvas.PolyLine([Point(x1,y1),Point(x2,y2),Point(x3,y3), ...]) x4,y4

x6,y6 x7,y7

x2,y2 x5,y5 x1,y1 x3,y3

Canvas.PolyLine([Point(10,15),Point(100,200),Point(300,150)]);

oder etwas umständlicher: var punkte: array[1..3] of TPoint; ... punkte[1].x := 10; punkte[1].y := 15; punkte[2].x := 100; punkte[2].y := 200; punkte[3].x := 300; punkte[3].y := 150; Canvas.PolyLine(punkte);

Polygon Möchten Sie ein gefülltes n-Eck zeichnen, müssen Sie auf die Polygon-Methode zurückgreifen. SYNTAX:

Canvas.Polygon([Point(x1,y1),Point(x2,y2),Point(x3,y3), ...]) x2,y2 x5,y5

x4,y4

x1,y1 x3,y3

Füllfarbe und -muster entsprechen der aktuellen Brush-Eigenschaft des Canvas. Canvas.Polygon([Point(10,10),Point(100,200),Point(300,150)]);

HINWEIS: Die Linie vom letzten Punkt zum ersten wird automatisch gezogen und schließt den

Umriss.

346

Kapitel 7

Grafikprogrammierung

7.1.3 Farben Farben setzen sich unter Windows aus der additiven Überlagerung der drei Grundfarben Rot, Grün und Blau zusammen (RGB). Da jeder Farbanteil in 256 Farbstufen unterteilt ist, ergibt sich eine maximale Anzahl von ca. 16 Mio. Farben. Bei dieser Auflösung ist das menschliche Auge nicht mehr in der Lage, einzelne Abstufungen wahrzunehmen, man spricht von Echtfarben.

HINWEIS: Beachten Sie, dass eine additive Farbmischung auf einem Drucker nicht sinnvoll ist.

Rot + Blau + Grün ergeben Schwarz und nicht Weiß, aber dies nur nebenbei, da Windows uns weitergehende Überlegungen dieser Art abnimmt. Unter Delphi werden Farbwerte als Datentyp TColor abgespeichert. var hColor : TColor; ... hColor := Canvas.Brush.Color;

HINWEIS: Brauchen Sie eine Variable zum Zwischenspeichern von Farbwerten, kann diese vom

Typ TColor oder LongInt sein. Für das Zuweisen von Farbwerten gibt es zwei prinzipielle Möglichkeiten: ■ Benutzen der in der Unit Graphics definierten Farbkonstanten ■ Verwenden einer 4-Byte-Hexadezimalzahl BEISPIEL: Zwei Möglichkeiten, um die Farbe Rot zuzuweisen: Canvas.Brush.Color := clRed;

oder Canvas.Brush.Color := $000000FF;

Im Folgenden wollen wir uns jede der beiden Varianten näher anschauen.

RGB-Farben Um zu verstehen, wie Farbwerte als 4-Byte-Hexadezimalzahl gespeichert werden können, müssen wir wissen, dass zur Darstellung eines Bytes zwei Hexziffern benötigt werden. Eine einzelne Hex-

347

7.1 Das Canvas-Objekt

ziffer wird durch eines der 16 Zeichen 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F dargestellt. Die drei niederwertigen Bytes geben die RGB-Farbintensität für Blau, Grün und Rot an. Pro Byte können demnach 256 Werte gespeichert werden. Der Wert $00FF0000 entspricht einem reinen Blau mit voller Intensität, der Wert $0000FF00 einem reinen Grün und der Wert $000000FF einem reinen Rot. $00000000 gibt Schwarz und $00FFFFFF Weiß an. BEISPIEL: In der Abbildung wird eine graublaue Farbe definiert. $

00

BF

7F

3F

1.Byte Farbpalette 2.Byte Blau

3.Byte Grün

4.Byte Rot

191

127

63

Wenn das höchstwertige Byte den Wert null ($00) hat, sind die Farben denen in der Systempalette am ähnlichsten. Ist es eins ($01), entspricht die Farbe etwa derjenigen in der aktuell realisierten Palette. Zwei ($02) bedeutet, der Wert wird an die ähnlichste Farbe in der logischen Palette des aktuellen Gerätekontexts angepasst. Um sich die lästige Umrechnerei in Hexadezimalzahlen zu ersparen, kann man auch eine Funktion schreiben, der die einzelnen Farbanteile als Prozentwerte zwischen 0 und 100 übergeben werden: function RGB(rot, gruen, blau: Byte): TColor; begin result := StrToInt('$00' + IntToHex(blau * 255 div 100, 2) + IntToHex(gruen * 255 div 100,2) + IntToHex(rot * 255 div 100, 2)) end;

BEISPIEL: Kreis mit graublauer Mixfarbe (75 % Blau-, 50 % Grün- und 25 % Rotanteil) Canvas.Brush.Color := RGB(25,50,75); Canvas.Ellipse(100,100,300,300);

HINWEIS: Ein Beispielprogramm "Farben mischen" finden Sie im Praxisteil des Kapitels.

Farbkonstanten In der Unit Graphics sind zahlreiche Konstanten für TColor definiert. Diese Konstanten unterteilen sich in zwei Gruppen: ■ Die Farbkonstanten werden direkt der ähnlichsten Farbe in der Systempalette zugeordnet (z.B. clRed für die Farbe Rot).

348

Kapitel 7

Grafikprogrammierung

■ Die Farbkonstanten werden der entsprechenden Systemfarbe für Desktop-Elemente zugeordnet, die im Dialogfeld "Farben" der Windows-Systemsteuerung definiert ist (z.B. clBtnFace für Schaltflächen). Hier eine Zusammenstellung: Konstanten für ähnlichste Systemfarben

Konstanten für Desktop-Farben

clAqua, clBlack, clBlue, clDkGray, clFuchsia, clGray, clGreen, clLime, clLtGray, clMaroon, clNavy, clOlive, clPurple, clRed, clSilver, clTeal, clWhite, clYellow.

clActiveBorder, clActiveCaption, clAppWorkSpace, clBackground, clBtnFace, clBtnHighlight, clBtnShadow, clBtnText, clCaptionText, clGrayText, clHighlight, clHighlightText, clInactiveBorder, clInactiveCaption, clInactiveCaptionText, clMenu, clMenuText, clScrollBar, clWindow, clWindowFrame, clWindowText

7.1.4 Linienfarbe, Muster und Pinsel Farbeigenschaften Für die Ausgabe von Linien, Mustern und Texten sind für uns vor allem folgende Eigenschaften und Objekte interessant: Eigenschaft

Objekt

Bemerkungen

Linienfarbe

Pen.Color

... ist gleichzeitig Rahmenfarbe für Kreise, Rechtecke etc.

Füllfarbe

Brush.Color

... wird nur berücksichtigt, wenn Brush.Style <> bsClear.

Füllmuster

Brush.Style

Die Farbe des Füllmusters hängt von Brush.Color ab. Die möglichen Füllmuster finden Sie in der folgenden Abbildung.

Textfarbe

Font.Color

Abhängig von der Farbauflösung kann nicht jede Farbe zugewiesen werden.

Füllmuster Beachten Sie in der folgenden Zusammenstellung, dass die Konstante bsClear die Füllfarbe Brush.Color außer Kraft setzt und quasi den Hintergrund "durchscheinen" lässt (transparente Füllung). Der Standardwert ist bsSolid. HINWEIS: Die folgenden Füllmuster sind nicht vom gesetzten Abbildungsmodus abhängig, d.h.,

auf einem hochauflösenden Ausgabegerät (z.B. Laserdrucker) kann sich der Linienabstand sehr stark verringern. Für das DIN-gerechte Schraffieren von Flächen müssen Sie gegebenenfalls mit einem eigenen Algorithmus sorgen (siehe Regions).

349

7.1 Das Canvas-Objekt

7.1.5 Linien und Stifte Linieneigenschaften Im Wesentlichen bietet Delphi nur drei Eigenschaften, um Linienart und -form zu beeinflussen: Eigenschaft

Objekt

Beschreibung

Linienbreite

Pen.Width

... in Pixeln, die Linienenden werden abgerundet.

Linientyp

Pen.Style

... nur wenn Pen.Width = 1, siehe nächste Abbildung.

Zeichenmodus Pen.Mode

... Farbverknüpfung mit dem Hintergrund.

Linientypen Der Pen.Style-Eigenschaft des Canvas-Objekts können Sie die folgenden Konstanten zuweisen:

Zeichenmodus Mit Pen.Mode legen Sie fest, in welcher Farbe eine Linie bzw. ein Pixel erscheint. "Wird dies nicht bereits mit der Eigenschaft Pen.Color entschieden?", werden Sie erstaunt fragen. Die Antwort ist ein klares Jein, denn die resultierende Linienfarbe entspricht nur dann der Stiftfarbe, wenn Pen.-

350

Kapitel 7

Grafikprogrammierung

Mode auf seinen Standardwert pmCopy gesetzt ist. In allen anderen Fällen kann eine völlig neue Farbe als Resultat einer bestimmten Verknüpfung mit dem Hintergrund entstehen. Im folgenden Beispiel wird der verzweifelte, weil farblose, Versuch unternommen, die insgesamt 16 verschiedenen Werte der Eigenschaft Pen.Mode zu erläutern. BEISPIEL: Ein Farbgitter laut folgender Abbildung wird erzeugt. Die senkrechten Balken sind in den 16 Stan-

dardfarben (2 = clRed), die waagerechten Balken hingegen immer mit Pen.Color = clRed gezeichnet. Nur bei Pen.Mode = pmCopy entsteht aber tatsächlich ein roter waagerechter Balken.

pmBlack pmWhite pmNop pmNot pmCopy pmNotCopy pmMergePenNot pmMaskPenNot pmMergeNotPen pmMaskNotPen pmMerge pmNotMerge pmMask pmNotMask

pmXor pmNotXor

1

2

3

4

5

6

7

8

9

10

11

Die folgende Funktion liefert die 16 Farbkonstanten: function qbColor(i:Integer):TColor; begin case i of 0: result:=clBlack; 1: result:=clMaroon; 2: result:=clGreen; 3: result:=clOlive; 4: result:=clNavy; 5: result:=clPurple;

12

13

14

15

351

7.1 Das Canvas-Objekt

6: result:=clTeal; 7: result:=clGray; 8: result:=clSilver; 9 :result:=clRed; 10: result:=clLime; 11: result:=clBlue; 12: result:=clFuchsia; 13: result:=clAqua; 14: result:=clYellow; 15: result:=clWhite end end;

Das Farbgitter wird erzeugt: procedure TForm1.FormPaint(Sender: TObject); var i:Integer; begin with Canvas do begin Pen.Width := 25;

// Balkenbreite

Vertikale Farbbalken zeichnen: for i := 0 to 15 do begin MoveTo((i+1)*40,0); Pen.Color := qbColor(i); LineTo((i+1)*40,ClientHeight) end;

// neue Zeichenfarbe

Horizontale Farbbalken zeichnen: Pen.Color := clRed; for i := 0 to 15 do begin Pen.Mode := TPenMode(i); MoveTo(0,(i+1)*40); LineTo(ClientWidth,(i+1)*40) end

// neuer Zeichenmodus

end end;

Es wird empfohlen, sich dieses Beispiel live anzusehen, denn nur so erhalten Sie einen informativen (weil farbigen) Eindruck!

Animationen In der Praxis haben neben pmCopy vor allem pmXOR und pmNotXOR als Werte für die Eigenschaft Pen.Mode Bedeutung. Damit lassen sich auf einfachste Weise Animationen erzeugen, da eine zweifache Anwendung der XOR-Verknüpfung die Originalfarbe wiederherstellt und damit der Hintergrund quasi restauriert wird.

352

Kapitel 7

Grafikprogrammierung

BEISPIEL: Auf einem Formular mit einem Timer (Interval = 100) wird ein sich langsam von links nach rechts

bewegender Kreis erzeugt. Dieser wandert durch ein gefülltes Rechteck, ohne es zu verletzen. var x1:Integer = 10; y1:Integer = 100; // Anfangsposition x2:Integer = 60; y2:Integer = 150; procedure TForm1.Timer1Timer(Sender: TObject); begin Canvas.Ellipse(x1,y1,x2,y2); // Löschen der alten Position durch Überzeichnen Inc(x1,2); Inc(x2,2); // neue Position einstellen Canvas.Ellipse(x1,y1,x2,y2) // auf neuer Position zeichnen end; procedure TForm1.FormPaint(Sender: TObject); begin Canvas.Pen.Mode := pmCopy; // Standardeinstellung Canvas.Brush.Color := clRed; // rote Füllfarbe Canvas.Rectangle(200,50,400,200); // ein rot gefülltes Rechteck Canvas.Pen.Mode := pmXOR; // XOR-Verknüpfung der Pixel Canvas.Ellipse(x1,y1,x2,y2); // Anfangsposition zeichnen Timer1.Enabled := True // Animation starten end;

Nach Programmstart sehen Sie, dass die Füllfarbe des Kreises nicht Brush.Color = clRed entspricht, sondern in Abhängigkeit von der Farbe des Untergrunds zwischen Türkis und Schwarz wechselt. Wen das stört, der sollte es einmal mit Pen.Mode := pmNotXOR oder Brush.Style := bsClear versuchen.

Bemerkungen ■ Keine Frage, dass Sie auf diese Weise auch Männchen quer über den Canvas sprinten lassen oder gar ein richtiges Autorennen programmieren können. Siehe dazu auch die Beispiele im Kapitel 6 (OOP). ■ Eine weitere Anwendung finden Sie im Praxisteil dieses Kapitels (7.5.2, Erzeugen eines Markierungsrahmens).

353

7.1 Das Canvas-Objekt

7.1.6 Textausgabe Auch die Ausgabe von Text wird in Delphi mit Grafikmethoden realisiert.

TextOut Diese Methode ist die einfachste Möglichkeit, einen Text auf den Bildschirm bzw. auf Papier zu bringen. Als Schriftart wird dabei der aktuelle Wert von Font verwendet. SYNTAX:

Canvas.TextOut(X,Y:Integer,Text:String);

X und Y bezeichnen die linke obere Ecke des Ausgaberechtecks. Canvas.TextOut(100,100,'Äquator');

Y X

TextRect Wenn Sie nur denjenigen Teil eines Textes ausgeben wollen, der innerhalb eines Clipping-Rechtecks liegt, verwenden Sie diese Methode. SYNTAX:

Canvas.TextRect(Rect: TRect; X, Y: Integer; Text: string)

Die Maße des begrenzenden Rechtecks müssen Sie in einer Variablen vom Typ TRect übergeben: SYNTAX:

TRect = record case Integer of 0: (Left, Top, Right, Bottom: Integer); 1: (TopLeft, BottomRight: TPoint); end;

HINWEIS: Typen wie TRect oder TPoint brauchen Sie nicht zu deklarieren, sie werden von Del-

phi bereitgestellt! Sie können die Zuweisung der Einzelwerte für das Rechteck vereinfachen, wenn Sie die Funktion Bounds verwenden.

354

Kapitel 7

Grafikprogrammierung

var rec: TRect; ... rec := Bounds(40,40,100,100); Canvas.TextRect(Rec,10,10,'Hallo');

Top Left

Y

X Height

Width

TextWidth und TextHeight Beide Methoden erlauben das Feststellen von Breite und Höhe eines auszugebenden Strings. SYNTAX:

Canvas.TextWidth(text:String):Integer

BEISPIEL: Folgende nutzerdefinierte Methode, die Sie der Typdeklaration des Formulars hinzufügen, erlaubt

das exakte Positionieren eines auszugebenden Textstrings in Formularmitte. procedure TForm1.zentriereText(txt: String); var x,y: Integer; begin x := (ClientWidth - Canvas.TextWidth(txt)) div 2; y := (ClientHeight - Canvas.TextHeight(txt)) div 2; Canvas.TextOut(x, y, txt) end;

HINWEIS: TextWidth liefert denselben Wert zurück wie der Aufruf von TextExtent(Text).cx.

Analoges gilt für TextHeight und TextExtend(Text).cy.

Fontabmessungen Die Texthöhe in Pixeln können Sie auch mit Font.Height ermitteln:

Font.Height

7.2 Standarddialoge

355

In einigen Fällen ist es allerdings günstiger, die Texthöhe in Punkten anzugeben. Verwenden Sie dazu die Eigenschaft Font.Size.

Zuweisen der Schriftkonstanten Möchten Sie gezielt Schriftoptionen wie fett, kursiv etc. setzen, hilft Ihnen die Eigenschaft Style weiter: BEISPIEL: Schriftart auf fett und kursiv festlegen Canvas.Font.Style := [fsBold, fsItalic];

7.2 Standarddialoge Jeder, der mit der Bedienung von Windows-Programmen vertraut ist, kennt diese modalen Dialogboxen. Auch Delphi stellt sie zur Verfügung, indem einfach die entsprechenden Ressourcen der Windows-Bibliothek (API) angezapft werden. Die entsprechenden Steuerelemente finden Sie auf der "Dialoge"-Seite der Komponentenpalette. Es ist typisch, dass diese Komponenten zur Laufzeit ein völlig anderes Aussehen annehmen. Für Grafikanwendungen sind vor allem der Font-Dialog und der Farbauswahl-Dialog von Interesse.

7.2.1 Standarddialog zur Schriftauswahl Für die Auswahl einer Schriftart kann zur Laufzeit der Standarddialog "Schriftauswahl" verwendet werden. Dazu ist die Komponente Fontdialog auf dem Formular zu platzieren.

Programmierung Die Aktivierung erfolgt erst zur Laufzeit mittels Execute-Methode: procedure TForm1.Button1Click(Sender: TObject); begin fontDialog1.Execute end;

Nach der Ausführung können Sie über die Font-Eigenschaft (Type TFont) alle Schriftparameter abfragen: var schriftfarbe : TColor; schriftfarbe := Fontdialog1.Font.Color;

bzw. Sie weisen diese Schriftart einem Ausgabegerät zu. Image1.Canvas.Font := FontDialog1.Font;

356

Kapitel 7

Grafikprogrammierung

Der Schriftarten-Dialog:

Weitere Eigenschaften Außer der Font-Eigenschaft sind noch folgende Properties von Bedeutung: Eigenschaft

Beschreibung

Device

Anzeige der Schriftarten für: Drucker, Bildschirm, Drucker/Bildschirm

MaxFontSize

Ist die Option fdLimitSize gesetzt, werden nur Schriftarten angezeigt, die in diesem Bereich liegen.

MinFontSize

Optionen Die wichtigsten Werte für die Eigenschaft Options finden Sie in der Tabelle: Option

Beschreibung

fdAnsiOnly

nur ANSI-Schriftarten

fdEffects

Anzeige der Optionen für: ■ Unterstrichen ■ Durchgestrichen ■ Farbe

fdFixedPitchOnly

nur Bitmap-Fonts

fdForceFontExist

Fehlermeldung aktivieren, wenn Schriftattribut nicht existiert

fdLimitSize

nur Schriften größer Min und kleiner Max

357

7.2 Standarddialoge

Option

Beschreibung

fdNoVektorfonts

keine Vektorschriften

fdNoOEMFonts

nur skalierbare Schriftarten

fdShowHelp

Help-Button anzeigen

fdTrueTypeOnly

nur True Type-Fonts

fdWysiwyg

nur Schriften, die auf Drucker und Bildschirm gleichzeitig verfügbar sind

7.2.2 Standarddialog zur Farbauswahl Für die Auswahl von Farben können Sie während der Laufzeit den Standarddialog "Farben" verwenden. Platzieren Sie dazu die Komponente ColorDialog auf dem Fenster. Der Standard-Farbdialog in Aktion:

Auch dieser Dialog wird zur Laufzeit über die Execute-Methode aktiviert: procedure TForm1.Button1Click(Sender: TObject); begin ColorDialog1.Execute end;

Den Rückgabewert können Sie mit der Eigenschaft Color auswerten: Image1.Canvas.Brush.Color := ColorDialog1.Color;

Möchten Sie die Farbdefinition verhindern, müssen Sie die Eigenschaft Options wie folgt festlegen: [cdPreventFullOpen]

358

Kapitel 7

Grafikprogrammierung

7.3 Grafik-Komponenten Die wichtigsten grafischen Ausgabeobjekte sind das Form-Objekt, die Paintbox- und die ImageKomponente. Alle verfügen natürlich als wichtigstes gemeinsames Merkmal über die CanvasEigenschaft1, d.h., zur Laufzeit können Bilder (Zeichnungen) mittels Grafikmethoden erzeugt und angezeigt werden. Außerdem sollen in diesem Abschnitt auch noch das quasi "unsichtbare" Bitmap-Objekt sowie die Shape-Komponente betrachtet werden.

7.3.1 Form und PaintBox Man kann die PaintBox-Komponente ohne Übertreibung als die "kleine Schwester" des Formulars bezeichnen, zumindest was die Grafikfähigkeiten betrifft. Die folgenden Ausführungen beziehen sich zwar auf das Form-Objekt, lassen sich aber auch ohne weiteres auf die PaintBox übertragen (auf Besonderheiten wird zum Schluss eingegangen).

Grafik zeichnen Es ist ein Windows-typisches Merkmal, dass diese Objekte (vor allem Fenster) durch den Benutzer oder das Programm ständig manipuliert werden (verschieben, verdecken, vergrößern, verkleinern). Sehr häufig muss deshalb der Inhalt des Canvas auf dem Bildschirm neu aufgebaut werden, z.B. nach dem Freilegen eines vorher verdeckten Fensters. procedure TForm1.Button1Click(Sender: TObject); begin Canvas.Ellipse(50,20,400,200) end;

// Zeichnen

Überdecken Sie die Ellipse vorübergehend mit einem anderen Fenster, so kann Ihr Werk sehr schnell beschädigt werden und ist nur durch erneutes Klicken des Buttons "Zeichnen" wieder zu reparieren:

1

Diese Eigenschaft ist wiederum ein Objekt.

7.3 Grafik-Komponenten

359

Um einen automatischen Wiederaufbau der Fenstergrafik zu gewährleisten, nutzen Sie das OnPaint-Ereignis. Es wird immer dann ausgelöst, wenn die Grafik oder Teile davon neu gezeichnet werden müssen. In den zugehörigen Event-Handler schreiben Sie einfach die Anweisungen zum Neuzeichnen der Grafik hinein. procedure TForm1.FormPaint(Sender: TObject); begin Canvas.Ellipse(50,20,400,200) end;

Auf einen Button "Zeichnen" können Sie verzichten, die Grafik ist bereits bei Programmstart präsent und durch kein anderes Fenster mehr zu beschädigen.

Grafik löschen Durch einen Aufruf der Refresh-Methode wird ein Formular (und auch jedes andere Steuerelement) sofort von Windows neu gezeichnet. Damit verschwindet auch die Fenstergrafik (Buttons etc. bleiben). procedure TForm1.Button2Click(Sender: TObject); begin Refresh end;

Allerdings funktioniert das Löschen nicht, wenn Sie (wie oben beschrieben) den Aufbau der Fenstergrafik im OnPaint-Event-Handler erledigen. Ein Aufruf von Refresh löst nämlich ebenfalls OnPaint aus, und die Grafik ist sofort wieder da. Doch durch Einführen eines Zustandsflags bekommen wir dieses Problem in den Griff. Wir erreichen damit, dass ein Neuzeichnen der Grafik nur dann stattfindet, wenn wir dies auch wünschen. BEISPIEL: Unser Testbeispiel hat jetzt zwei Buttons ("Zeichnen" und "Löschen"). var flag: Boolean = False; // initialisierte Zustandsvariable procedure TForm1.FormPaint(Sender: TObject); begin if flag then Canvas.Ellipse(50,20,400,200) // bedingtes Neuzeichnen end; procedure TForm1.Button1Click(Sender: TObject); // Grafik zeichnen begin flag := True; Refresh end; procedure TForm1.Button2Click(Sender: TObject); // Grafik löschen begin flag := False; Refresh; end;

Zeichnen und Löschen der Grafik können jetzt gezielt gesteuert werden:

360

Kapitel 7

Grafikprogrammierung

Besonderheiten der PaintBox Diese "Miniaturausgabe" eines Formulars finden Sie auf der "System"-Seite der Komponentenpalette. Verwenden Sie die PaintBox dann, wenn Sie die Grafikausgaben auf einen bestimmten Bereich des Formulars begrenzen möchten, anstatt den gesamten Clientbereich dafür zu verwenden. Auch bei der PaintBox müssen Sie das OnPaint-Ereignis nutzen, um die angezeigte Grafik nach einem Verdecken durch andere Fenster neu aufzubauen. procedure TForm1.PaintBox1Paint(Sender: TObject); begin PaintBox1.Canvas.Ellipse(10,10,100,100) end;

HINWEIS: Ein Refresh des Formulars löscht auch den Inhalt der PaintBox!

7.3.2 Image Die Image-Komponente, die Sie auf der Seite "Zusätzlich" der Komponentenpalette finden, ist um einiges komfortabler als die PaintBox.

Grafik zeichnen Bezüglich der Ausführung von Zeichenoperationen scheint es keinerlei Unterschiede zu geben. procedure TForm1.FormClick(Sender: TObject); begin Image1.Canvas.Ellipse(10,10,100,100) end;

Der entscheidende Unterschied offenbart sich im Bildaufbau: Die Image-Komponente regeneriert die Grafik mit Hilfe einer Hintergrund-Bitmap (Speicher-Bitmap). Wird ein verdeckter Ausschnitt freigelegt, kopiert die Komponente diesen automatisch aus der Speicher-Bitmap in den Vordergrund. Ein OnPaint-Ereignis werden Sie deshalb hier vergeblich suchen, man braucht es einfach nicht!

361

7.3 Grafik-Komponenten

Dieser Komfort wird allerdings teuer erkauft: Image-Komponenten sind teilweise langsamer als eine PaintBox und verbrauchen in jedem Fall auch deutlich mehr Ressourcen.

Grafiken aus Datei laden bzw. in Datei abspeichern Sie sollten ein Image immer dann verwenden, wenn es darum geht, Bilder (WMF, BMP, ICO) aus Dateien zu laden bzw. in Dateien zu speichern. Verantwortlich dafür ist die Picture-Eigenschaft (eigentlich auch ein Objekt), die Sie bei Form und PaintBox vergeblich suchen. Bereits zur Entwurfszeit können Sie der Picture-Property per Objektinspektor ein Bild zuordnen. Mit der Methode LoadFromFile lassen sich Grafikdateien aber auch erst zur Laufzeit laden. Image1.Picture.LoadFromFile('c:\test.bmp');

Auch das Abspeichern des Bildinhalts ist dank SaveToFile-Methode kein Problem. Image1.Picture.SaveToFile('c:\test.bmp');

Grafik in eine andere Grafik kopieren Die Inhalte von Image-Komponenten (Picture.Bitmap-Eigenschaft) können Sie bequem über die Canvas.Draw-Methode zuweisen, wobei auch noch die Koordinaten der linken oberen Ecke übergeben werden. BEISPIEL: Der Inhalt des linken Bildes (Image1) wird mit einem Versatz von x = 30 und y = 50 in das rechte

Bild (Image2) kopiert. Image2.Canvas.Draw(30,50,Image1.Picture.Bitmap)

Einfügen und Kopieren aus/in Zwischenablage Der Arbeit mit der Zwischenablage sind jetzt (dank Assign-Methode) Tür und Tor geöffnet. Image1.Picture.Assign(Clipboard); Clipboard.Assign(Image1.Picture);

// Bild aus Zwischenablage einfügen // Bild in Zwischenablage kopieren

362

Kapitel 7

Grafikprogrammierung

7.3.3 Bitmap Alle bisherigen Ausführungen bezogen sich auf sichtbare Komponenten. Delphi unterstützt jedoch auch Grafik-Objekte, die nicht sichtbar sind. Dazu zählen Objekte vom Typ: ■ TBitmap ■ TMetafile ■ TIcon Am interessantesten dürfte das Objekt Bitmap sein. Dieses können Sie z.B. als Pufferspeicher bzw. als Speicher-Bitmap für eine PaintBox-Komponente einsetzen, um damit einige Nachteile gegenüber der aufgemotzten Image-Schwester wettzumachen. Eine Verwendung für Animationen wäre ebenfalls denkbar, Sie kopieren dazu einfach in eine PaintBox-Komponente Ausschnitte der Hintergrund-Bitmap.

Objekt erzeugen Beim Erzeugen eines Bitmap-Objekts sollten Sie sich auf Ihr OOP-Handwerkszeug besinnen und dabei beachten, dass Sie sich um die Erzeugung von Objekten, die nicht in der visuellen Entwicklungsumgebung (Komponentenpalette) von Delphi enthalten sind, komplett selbst kümmern müssen. Allein mit der Definition einer Variablen vom Typ TBitmap ist es aber nicht getan. Die Variable muss auch mit der Methode Create initialisiert werden! Erst danach können Sie die Abmessungen der Bitmap festlegen, Grafikmethoden auf dem Canvas ausführen, in die Zwischenablage oder in Dateien speichern. BEISPIEL: Eine Bitmap wird erzeugt, ein Rechteck darauf gezeichnet und als Datei bild1.bmp abgespeichert. uses Clipbrd; var bild : TBitmap; // definieren begin bild := TBitmap.Create; // initialisieren bild.Width := 200; // Größe festlegen bild.Height := 250; bild.Canvas.Rectangle(10,10,30,30); // Grafik zeichnen Clipboard.Assign(bild); // in Zwischenablage speichern bild.SaveToFile('c:\bild1.bmp'); // in Datei abspeichern bild.Free // zum Schluss Objekt freigeben end;

Bitmap in Canvas kopieren Es dürfte jetzt auch kein Problem mehr sein, was vorher unlösbar erschien: eine Pixelgrafik in den Canvas eines Formulars kopieren. BEISPIEL: Im folgenden Event-Handler wollen wir es ausnahmsweise einmal wie die Profis machen und das

Laden der Bilddatei in einem try-finally-Block erledigen.

363

7.3 Grafik-Komponenten

procedure TForm1.Button1Click(Sender: TObject); var bild1: TBitmap; i : Integer; begin bild1 := TBitmap.Create; try // der Versuch, die Bilddatei zuzuweisen und anzuzeigen with bild1 do begin LoadFromFile('Haus.bmp'); // Bilddatei befindet sich im Projektverzeichnis Transparent := True; // Hintergrundfarbe (Weiß) ist transparent for i := 1 to 4 do Form1.Canvas.Draw(i * 60, i* 10, bild1); // viermal kopieren end; finally bild1.Free // am Ende und wenn Bilddatei nicht gefunden wurde end end; end.

7.3.4 Shape-Komponenten Mit der Shape-Komponente (Seite "Zusätzlich" der Komponentenpalette) können Sie Linien, Ellipsen und Kreise sowie normale und abgerundete Rechtecke erstellen. Eigentlich handelt es sich hierbei mehr um ein "gewöhnliches" Steuerelement mit Ereignissen (Drag&Drop sowie MouseDown, MouseMove, MouseUp), das seinen Platz wohl besser im Komponenten-Kapitel 4 gefunden hätte. Da aber diese Komponente den (falschen) Eindruck erweckt, dass sie eine gängige Alternative zu den Grafikmethoden des Canvas-Objekts bietet, soll sie an dieser Stelle kurz vorgestellt werden. Die folgende Abbildung zeigt die Auswirkungen verschiedener Werte der Shape-Eigenschaft sowie verschiedener Füllmuster (Brush.Style). stRectangle

bsDiagCross

bsClear

stRoundRect

stSquare

stEllipse

bsBDiagonal

bsVertical

bsHorizontal

bsSolid

stRoundSquare

stCircle

364

Kapitel 7

Grafikprogrammierung

Wie alle Komponenten können auch Shape-Komponenten mit Refresh nicht gelöscht werden. Sie zeigen prinzipiell das gleiche Verhalten wie z.B. ein Button, der unbeeindruckt an seinem Platz stehen bleibt, wenn sich der Hintergrund ändert. Eine Shape-Komponente verbraucht natürlich mehr Ressourcen, als wenn Sie die gleiche Grafik z.B. mit den Canvas-Methoden Rectangle, Ellipse usw. erzeugen würden. Setzen Sie diese Komponenten deshalb nur für kleinere Grafiken bzw. Hervorhebungen ein. Eine nützliche Anwendung: Durch geschickte Wahl von Pen und Brush können Sie die Komponente quasi "unsichtbar" machen (entspricht nicht Visible = False). Die Komponente reagiert aber weiterhin auf Nutzereingaben (Maus). Diese Möglichkeit können Sie z.B. in Grafikprogrammen nutzen.

7.4 2-D-Vektorgrafik In einer vektororientierten Zeichnung wird die Grafik nicht pixelweise abgespeichert, sondern in geometrische Grundelemente (Punkt, Kreis, Linie, ...) so zerlegt, dass lediglich die zur eindeutigen Definition dieser Grundelemente benötigten Daten (Vektoren) zu speichern sind, z.B. nur die Koordinaten für den Anfangs- und den Endpunkt einer Linie. Für den angehenden Spieleprogrammierer dürfte die 2-D-Vektorgrafik genau das Richtige sein. Zählen Sie sich allerdings nicht mehr zu den Einsteigern, können Sie sich gleich der 3-D-Vektorgrafik zuwenden (siehe Kapitel 15).

7.4.1 Verschieben und Verdrehen von Symbolen Die verschiedenen Symbole einer Vektorgrafik müssen nicht nur verschoben, sondern, je nach Bedarf, auch in unterschiedliche Richtungen gedreht werden. Während das bloße Verschieben kein Thema ist (es genügen simple Additionen), ist beim Verdrehen ein kleiner Ausflug in die Mathematik unumgänglich.

Koordinatentransformation Unter Berücksichtigung der folgenden Beziehungen ist eine einfache Koordinatentransformation eines Punktes P nach P' in Abhängigkeit vom Drehwinkel α möglich. Beziehungen bei Drehung eines Punktes P nach P':

365

7.4 2-D-Vektorgrafik

P'

dy'

α

P

dy

α0 x0 y0

dx'

dx

Bezeichnet man mit r die Länge der Strecke vom Koordinatenursprung x0, y0 nach P bzw. P', so gelten die folgenden trigonometrischen Beziehungen: dx = r . cosα0 dy = r . sinα0 Unter Anwendung der Additionstheoreme erhalten wir: dx' = r cos(α+α0) = r cosα cosα0 - r sinα sinα0 dy' = r sin(α+α0) = r sinα cosα0 + r cosα sinα0 Daraus ergeben sich schließlich die relativen Koordinaten von P' zu dx' = dx cosα - dy sinα dy' = dx sinα + dy cosα Die absoluten Koordinaten des verschobenen und gedrehten Punktes ergeben sich damit zu x = x0 + dx cosα - dy sinα y = y0 + dx sinα + dy cosα wobei x0, y0 die Koordinaten des Bezugspunktes (quasi identisch mit Verschiebung) sind.

Programmierung Um nicht alle Parameter bei jeder Transformation übergeben zu müssen, hat sich als zweckmäßig erwiesen, die folgende Variablen global zu vereinbaren:

366

Kapitel 7

var x0, y0, alpha, x, y: Single;

Grafikprogrammierung

// Bezugskoordinaten // Drehwinkel // die transformierten Koordinaten (Rückgabewert!)

Die Zielkoordinaten x, y werden von der Prozedur trans2D gesetzt, deren Übergabeparameter die relativen Abstände dx, dy (bezogen auf die Normalposition) sind. Vor dem Aufruf müssen die Bezugskoordinaten x0, y0 und der gewünschte Drehwinkel alpha zugewiesen werden. Bei der programmtechnischen Umsetzung ist die Vorzeichenumkehr der y-Achse zu beachten: procedure trans2D(dx, dy: Single); var si, co: Single; begin si := Sin(alpha); co := Cos(alpha); x := x0 + dx * co - dy * si; y := y0 - dy * co - dx * si end;

Obige Prozedur ist universell für die unterschiedlichsten 2-D-Vektorgrafiken einsetzbar. BEISPIEL: Es soll ein Pfeilsymbol gemäß folgender Vorlage gezeichnet werden.

Die Abbildung zeigt den Pfeil in Normalposition. Die relativen Koordinaten der Linienendpunkte können deshalb leicht abgelesen und in der folgenden Routine als Parameter an die Prozedur tr2D übergeben werden. procedure pfeilZeichnen; begin tr2D(0,0); Form1.Canvas.MoveTo(Round(x),Round(y)); tr2D(100,0); Form1.Canvas.LineTo(Round(x),Round(y)); tr2D(80,10); Form1.Canvas.LineTo(Round(x),Round(y)); tr2D(100,0); Form1.Canvas.MoveTo(Round(x),Round(y)); tr2D(80,-10); Form1.Canvas.LineTo(Round(x),Round(y)) end;

// auf Anfangspunkt setzen // Linie zum Endpunkt zeichnen // Pfeilspitze zeichnen (obere Hälfte) // auf Endpunkt setzen // Pfeilspitze zeichnen (untere Hälfte)

367

7.4 2-D-Vektorgrafik

HINWEIS: Beachten Sie, dass der Drehwinkel an die Delphi-Funktionen Sin und Cos nicht in

Grad, sondern im Bogenmaß (Rad) übergeben werden muss. Eine volle Drehung (360 Grad) entspricht dem Wert 2π. BEISPIEL: Für einen Winkel von 45 Grad gilt alpha = π/4 (Abbildung).

Bemerkungen ■ Übrigens funktionieren alle CAD-Programme nach ähnlichen Prinzipien. Aufgrund der rechenzeit- bzw. speicherplatzintensiven Auswertung trigonometrischer Funktionen (durch Reihenentwicklung oder Tabellen) ist das Manipulieren komplexer Objekte (insbesondere bei dreidimensionalen Gebilden) ein bekannter Gradmesser für die Leistungsfähigkeit von Hard- und Software. ■ Bei einigen technischen Zeichnungen, z.B. bei Schaltbildern elektrischer Netzwerke, bestehen diesbezüglich weitaus geringere Anforderungen. Hier ist ein kontinuierliches Drehen einzelner Bauelementesymbole im Allgemeinen nicht erforderlich, es genügen die vier Hauptrichtungen (α = 0°, 90°, 180°, 270° bzw. "Ost", "Nord", "West", "Süd"). Eine extra Berechnung von Sinus und Cosinus entfällt, da diese entweder 0, 1 oder -1 sind. ■ Natürlich sind die Gesetze der Koordinatentransformation auch auf Pixelgrafiken anwendbar. Es leuchtet aber ein, dass der dazu benötigte Rechenaufwand erheblich größer ist, da nicht nur die Anfangs- und Endpunkte von Linien, sondern jeder einzelne Bildpunkt nach der Drehung neu zu berechnen ist. ■ Auf der Buch-CD finden Sie das obige Pfeil-Beispiel in zwei Versionen (konventionell und als Klasse programmiert). Eine umfangreichere Anwendung finden Sie in 13.7.2.

7.4.2 Spiegeln und Maßstabsänderung von Symbolen Bis jetzt können wir Symbole zwar verschieben und drehen, aber damit sind noch längst nicht alle denkbaren Raumlagen erreichbar. Es fehlt die Möglichkeit der Spiegelung. Dies ist durch einfache Erweiterung der Koordinatentransformation zu realisieren. Dafür muss ein zusätzlicher "Spiegelungsfaktor" sf eingeführt werden, der entweder 1 (normale Lage) oder -1 (gespiegelte Lage) ist: dx' = dx . cosα - sf . dy . sinα dy' = dx . sinα + sf . dy . cosα

368

Kapitel 7

Grafikprogrammierung

Auch das Vergrößern bzw. Verkleinern von Symbolen ist dank Vektorgrafik problemlos machbar, da die relativen Koordinaten lediglich mit einem "Maßstabsfaktor" mf zu multiplizieren sind. Die kompletten Transformationsformeln (inklusive Verschieben und Verdrehen) sind demnach: x = x0 + mf . (dx cosα - sf . dy . sinα) y = y0 + mf . (dx sinα + sf . dy . cosα) Ein Anwendungsbeispiel finden Sie unter 7.6.2 im Praxisteil des vorliegenden Kapitels.

7.5 Lernbeispiele für Einsteiger 7.5.1 Linien und Textausgabe testen Schreiben Sie ein Testprogramm, mit dem Sie eine kleine Strichgrafik erzeugen können. Jede Mausbewegung mit gedrückter linker Maustaste soll dazu führen, dass eine Linie zur aktuellen Mausposition gezeichnet wird. Drücken Sie die rechte Maustaste, sollen die Koordinaten angezeigt werden.

Oberfläche Fügen Sie eine Image-Komponente in ein Formular ein und setzen Sie deren Align-Eigenschaft auf alClient.

Quelltext Wir beschränken uns auch hier auf den Implementation-Abschnitt von Unit1: Eine der beiden Maustasten wird gedrückt (über den Button-Parameter können Sie zwischen den beiden Maustasten unterscheiden): procedure TForm1.Image1MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin if button = mbleft then Image1.Canvas.MoveTo(x,y) else begin Image1.Canvas.Ellipse(x-2,y-2,x+2,y+2); Image1.Canvas.TextOut(x,y,Format('(%d:%d)',[x,y])) end end;

Jede Bewegung der Maus führt zur Ausführung der folgenden Ereignisroutine: procedure TForm1.Image1MouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer); begin if ssLeft in Shift then Image1.Canvas.LineTo(x,y) end;

7.5 Lernbeispiele für Einsteiger

369

Test

7.5.2 Animierten Markierungsrahmen erzeugen In fast jedem Zeichenprogramm ist folgendes praktische Problem anzutreffen: Durch Klick auf die Maustaste und anschließendes Bewegen der Maus öffnet sich ein Rechteck, das man bei gedrückt gehaltener Maustaste auf die gewünschte Größe zoomt, um damit irgendein Objekt einzurahmen oder zu kennzeichnen. Besonderen Eindruck schinden Sie, wenn der Rahmen animiert wird (scheinbare Bewegung).

Oberfläche Zur Oberfläche gibt es nicht viel zu sagen: Ein Panel zur Anzeige der aktuellen Mauskoordinaten (Align = alBottom) und ein Timer für den Animationseffekt (Interval = 50) genügen.

370

Kapitel 7

Grafikprogrammierung

Quelltext Grundlage des Verfahrens ist die Erkenntnis, dass die zweimalige XOR-Verknüpfung zweier Werte (in diesem Fall handelt es sich um Farben) den ursprünglichen Zustand wiederherstellt. Den XOR-Zeichenmodus erreichen Sie über die Mode-Eigenschaft des Pen-Objekts. Dies kann zum Beispiel beim Erzeugen des Fensters geschehen: procedure TForm1.FormCreate(Sender: TObject); begin Canvas.Pen.Mode := pmNotXor; Canvas.Pen.Style := psDot end;

Innerhalb der Unit deklarieren Sie die folgenden Variablen: var x1,y1,x2,y2 :Integer;

Wird die linke Maustaste gedrückt, können wir die Anfangskoordinaten speichern und das Rechteck zum ersten Mal zeichnen: procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; x, y: Integer); begin if Shift = [ssLeft] then begin Timer1.Enabled:= False; Canvas.Brush.Style := bsClear; x1 := X; y1 := Y; x2 := X; y2 := Y; Canvas.Rectangle (x1, y1,x2, y2) end end;

Jede weitere Bewegung der Maus löst das Ereignis MouseMove aus, in dem wir zum einen die Koordinatenanzeige aktualisieren, zum anderen das bisherige Rechteck löschen und neu zeichnen. procedure TForm1.FormMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer); begin Panel1.Caption := IntToStr(x)+ ':' + IntToStr(Y); If shift = [ssLeft] then begin Canvas.Rectangle (x1, y1,x2, y2); x2 := X; y2 := Y; Canvas.Rectangle (x1, y1,x2, y2) end end;

Mit dem Loslassen der Maustaste ist die Zeichenaktion abgeschlossen, es geht jetzt nur noch darum, mit den gespeicherten Koordinaten das Rechteck zyklisch neu zu zeichnen. Dazu wird der Timer eingeschaltet:

7.5 Lernbeispiele für Einsteiger

371

procedure TForm1.FormMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin Timer1.Enabled := True end;

Durch den Wechsel zwischen psSolid und psDot für die Eigenschaft Pen.Style entsteht eine scheinbare Bewegung der einzelnen Rahmenpunkte: procedure TForm1.Timer1Timer(Sender: TObject); begin Canvas.pen.Style := psSolid; Canvas.Rectangle(x1, y1,x2, y2); Canvas.Pen.Style := psDot end;

Test Zeichnen Sie hintereinander mehrere Rahmen. Unten links sehen Sie die Pixel-Koordinaten der oberen linken Ecke des aktuellen (flimmernden) Rahmens.

7.5.3 Bitmaps laden Die LoadFromFile-Methode verwenden Sie, um verschiedenen Objekten eine Bilddatei zuzuweisen. Das folgende Beispiel erläutert dies für zwei Objekte (PaintBox und BitBtn) und liefert gleichzeitig noch eine Demo für den Einsatz des (unsichtbaren!) Bitmap-Objekts.

Oberfläche Auf dem Startformular platzieren Sie eine Paintbox (Seite "System") und einen BitBtn (Seite "Zusätzlich"). Zoomen Sie den Rahmen der Paintbox genügend weit auf, so dass die komplette Bitmap später darin Platz finden kann, ansonsten wird nur ein Ausschnitt angezeigt. Auch der BitmapSchalter sollte genügend Platz für eine kleine Grafik bieten.

372

Kapitel 7

Grafikprogrammierung

Quelltext Voraussetzung für die Funktion dieses Programms ist das Vorhandensein der beiden BitmapDateien Bild1.BMP und Bild2.BMP im Projektverzeichnis. Zunächst wird gezeigt, wie Sie den Button mit einer netten kleinen Grafik aufmöbeln können: procedure TForm1.FormCreate(Sender: TObject); begin BitBtn1.Glyph.LoadFromFile('bild2.bmp') end;

Nicht ganz so einfach geht es mit der PaintBox. Im OnPaint-Event erzeugen Sie zunächst ein Bitmap-Objekt (quasi ein "Zwischenspeicher"), in das bild1.bmp geladen wird. procedure TForm1.PaintBox1Paint(Sender: TObject); var Bitmap1: TBitmap; begin Bitmap1 := TBitmap.Create; Bitmap1.LoadFromFile('bild1.bmp');

Mittels Draw-Methode des Canvas wird die Bitmap in die PaintBox transportiert, anschließend hat das Bitmap-Objekt seine Mission erfüllt und kann freigegeben werden: PaintBox1.Canvas.Draw(0, 0, Bitmap1); Bitmap1.Free end;

Test Das Ergebnis ohne viele Worte:

373

7.6 Praxisbeispiele für Fortgeschrittene

Bemerkungen ■ Statt in den Canvas der Paintbox könnte man nach dem gleichen Prinzip natürlich auch direkt in den Canvas des Formulars zeichnen. Die Paintbox bietet allerdings den Vorteil, dass der Zeichenbereich begrenzt ist. ■ Verwenden Sie statt der Paintbox- eine Image-Komponente (Achtung, Ressourcenfresser!), ist die Syntax etwas einfacher (es geht ohne Canvas und TBitmap): Image1.Picture.LoadFile('bild1.bmp');

7.6 Praxisbeispiele für Fortgeschrittene 7.6.1 Farben mischen Farbwerte haben den Datentyp TColor, dahinter verbirgt sich eine vier Byte lange LongInt-Zahl, von der die drei niederwertigen Bytes die Farbintensität für Blau, Grün und Rot angeben. Damit sind ca. 16 Mio. Farben möglich! Die Demo zeigt, wie man beliebige Farben aus der additiven Überlagerung der drei Grundfarben gewinnen kann.

Vorbereitungen Wir wollen jede der drei Grundfarben in einem Quadrat anstatt wie üblich in einem Farbkreis anzeigen. Alle drei Quadrate überlappen sich und zeigen die daraus resultierenden Mischfarben. Das lässt sich programmtechnisch wesentlich einfacher realisieren als drei sich überlappende Kreise. Um ein ausgewogenes Verhältnis zwischen den einzelnen Flächen zu erhalten, wird eine Aufteilung wie in folgender Abbildung vorgenommen: a 1/2

1/2

x0, y0

1 Rot 2/3 a

5 Rot+Blau

1/3

4 Rot+Grün

7 Rot+ Grün+Blau

6 Grün+Blau

2 Grün

3 Blau

374

Kapitel 7

Grafikprogrammierung

Jedes der drei Farbquadrate hat die Kantenlänge a. Bei der Überlappung entstehen insgesamt sieben Bereiche. Obwohl 1, 2 und 3 keine "richtigen" Rechtecke sind, werden sie als solche gezeichnet und später teilweise durch die anderen Rechtecke überdeckt (Reihenfolge beachten!). Die folgende Tabelle dient als Grundlage für die spätere Programmierung (x0, y0 = Bezugspunkt = linke obere Ecke des roten Farbquadrats; x1, y1 = linke obere Ecke des Rechtecks): Rechteck Farbe

x1

y1

Höhe

Breite

1

Rot

x0

y0

a

a

2

Grün

x0

y0+2a/3

a

a

3

Blau

x0+a/2

y0+a/3

a

a

4

Rot + Grün

x0

y0+2a/3

a/3

a/2

5

Rot + Blau

x0+a/2

y0+a/3

a/3

a/2

6

Grün + Blau

x0+a/2

y0+a

a/3

a/2

7

Rot + Grün + Blau

x0+a/2

y0+2a/3

a/3

a/2

Die vorgenommene Raumaufteilung kann als ausgewogen gelten, da die Regionen 1 bis 3 gleich groß sind (jeweils 3/6 der Fläche eines Farbquadrats), ebenso wie die Regionen 4 bis 7 (jeweils 1/6 eines Farbquadrats).

Oberfläche Auf dem Startformular platzieren Sie drei ScrollBar- und drei Panel-Komponenten. Letztere dienen zur Anzeige der Reglerstellungen. Ändern Sie die Kind-Eigenschaft aller ScrollBars in sbVertical und Max in 255. Lassen Sie rechts genug Platz, damit zur Laufzeit die drei Farbquadrate angezeigt werden können. Die Abbildung zeigt die Laufzeitansicht.

375

7.6 Praxisbeispiele für Fortgeschrittene

Quelltext Wir beschränken uns wie immer auf den implementation-Abschnitt. Drei globale Variablen sind notwendig, um sich die aktuellen Einstellungen zu "merken": var rot, gruen, blau: Byte;

Das Programm ist in einem einzigen Event-Handler untergebracht. Dieser reagiert auf das OnChange-Ereignis aller drei Scrollbars. Sie müssen deshalb auf der "Ereignis"-Seite des Objektinspektors allen drei Scrollbars diesen gemeinsamen Event-Handler zuweisen! procedure TForm1.ScrollBarChange(Sender: TObject);

Diese Konstanten können von Ihnen bei Bedarf abgeändert werden: const x0 = 200; y0 = 50; a = 210;

// linke obere Ecke des roten Farbquadrats // Kantenlänge eines Farbquadrats

Die folgende RGB-Hilfsfunktion ist von zentraler Bedeutung für unser Programm. Ihr werden die drei Farbanteile (Byte) übergeben. Rückgabewert ist ein LongInt (identisch mit TColor). Die IntToHex-Standardfunktion (liefert einen String!) verwandelt jeden der drei Farbanteile in eine zweistellige Hexzahl. Das erste Byte bezeichnet die Farbpalette ($00 = Standard). function RGB(rot, gruen, blau: Byte): TColor; begin Result := StrToInt('$00' + IntToHex(blau, 2) + IntToHex(gruen, 2) + IntToHex(rot, 2)) end;

Eine weitere notwendige Hilfsprozedur zeichnet ein farbiges Rechteck (x1, y1 = linke obere Ecke): procedure fuellRechteck(x1,y1, hoch, breit: Integer; frb: TColor); begin with Form1.Canvas do begin Pen.Style := psClear; // kein Rand Brush.Color := frb; Rectangle(x1, y1, x1+breit, y1+hoch) end end;

Nach diesen Vorbereitungen beginnt nun endlich die Hauptroutine: begin

Anhand des im Prozedurkopf übermittelten Sender-Parameters kann unterschieden werden, welche Scrollbar das OnChange-Ereignis ausgelöst hat. Rotes Farbquadrat zeichnen: if Sender = ScrollBar1 then begin rot := ScrollBar1.Position; Panel1.Caption := IntToStr(rot); fuellRechteck(x0, y0, a, a, RGB(rot, 0, 0)) end else

376

Kapitel 7

Grafikprogrammierung

Grünes Farbquadrat zeichnen: if Sender = ScrollBar2 then begin gruen := ScrollBar2.Position; Panel2.Caption := IntToStr(gruen); fuellRechteck(x0, y0 + (2 * a) div 3, a, a, RGB(0, gruen, 0)) end else

Blaues Farbquadrat zeichnen: if Sender = ScrollBar3 then begin blau := ScrollBar3.Position; Panel3.Caption := IntToStr(blau); fuellRechteck(x0 + a div 2, y0 + a div 3, a, a, RGB(0, 0, blau)) end;

Die Rechtecke der Mischfarben werden in jedem Fall gezeichnet: Überdeckung rot + grün: fuellRechteck(x0, y0 + (2 * a) div 3, a div 3, a div 2, RGB(rot, gruen, 0));

Überdeckung rot + blau: fuellRechteck(x0 + a div 2, y0 + a div 3, a div 3, a div 2, RGB(rot, 0, blau));

Überdeckung grün + blau: fuellRechteck(x0 + a div 2, y0 + a, a div 3, a div 2, RGB(0, gruen, blau));

Überdeckung rot + grün + blau: fuellRechteck(x0 + a div 2, y0 + (2 * a) div 3, a div 3, a div 2, RGB(rot, gruen, blau)) end;

Um bereits beim Start des Programms etwas anzuzeigen sowie nach vorübergehendem Abdecken des Fensters die Grafik zu regenerieren, muss das OnPaint-Event wie folgt besetzt werden: procedure TForm1.FormPaint(Sender: TObject); begin ScrollBarChange(ScrollBar1); ScrollBarChange(ScrollBar2); ScrollBarChange(ScrollBar3) end;

Test Zu Beginn sehen alle drei Farbquadrate schwarz und hässlich aus. Aber nach Betätigen der Regler kommt mit den Farben auch die Freude am Experiment. Sind alle drei Regler auf Maximalstellung, so muss das mittlere Feld ein reines Weiß anzeigen (siehe obige Laufzeitansicht).

377

7.6 Praxisbeispiele für Fortgeschrittene

Bemerkung Das Beispiel eignet sich gut zum Beurteilen von Farbwerten, die man in anderen Programmen verwenden möchte. Dabei sollte natürlich Ihre Grafikkarte auf die hohe Farbauflösung eingestellt sein.

7.6.2 2-D-Vektorgrafik Vektorgrafiken brauchen weniger Speicherplatz und sind schneller im Bildaufbau als Pixelgrafiken. Ein einzelnes Grafiksymbol braucht nur einmal in "Normalposition" definiert zu werden, um dann für alle nur möglichen gedrehten bzw. gespiegelten Raumlagen gleichermaßen gültig zu sein. Als Vorlage für unser Beispiel dient die folgende "anspruchsvolle" Zeichnung1. 15

10

5

0 0

5

10

Oberfläche Auf dem Startformular (Form1) werden ein Timer und vier Befehlsschaltflächen(Button1 bis Button4) platziert (siehe Abbildung am Ende). Die Interval-Eigenschaft des Timers stellen Sie auf ca. 10 ein (= 10 ms).

Quellcode Der implementation-Abschnitt beginnt mit einer Reihe von Variablendeklarationen: var alf, si,co, mf, x0,y0 : single; sf : integer; dirFlg : boolean;

{ { { { { {

Drehwinkel } Sinus und Kosinus } Maßstabsfaktor } absolute Bezugskoordinaten } Spiegelungsfaktor } Richtungsflag }

Die nachfolgenden Prozeduren haben ganz bewusst kurze Bezeichner, da sie häufig aufgerufen werden und der Quelltext möglichst nicht zu lang sein soll:

1

Leider wurde in der Zeichnung das kreisförmige Giebelfenster vergessen.

378

Kapitel 7

Grafikprogrammierung

procedure dwc (dx1,dy1,R : single); { zeichnet relativen Kreis } var x1,y1 : single; begin dx1 := mf * dx1; dy1 := mf * dy1; R := mf * R; x1 := x0 + dx1 * co - sf * dy1 * si; y1 := y0 - sf * dy1 * co - dx1 * si; form1.canvas.ellipse(round(x1-r),round(y1-r),round(x1+r),round(y1+r)) end; procedure dwl (dx1,dy1 : single); { zeichnet relative Linie } var x1,y1 : single; begin dx1 := mf * dx1; dy1 := mf * dy1; x1 := x0 + dx1 * co - sf * dy1 * si; y1 := y0 - sf * dy1 * co - dx1 * si; form1.canvas.Lineto(round(x1),round(y1)) end; procedure dwp (dx1,dy1:single); { zeichnet relativen Punkt } var x1,y1 : single; begin dx1 := mf * dx1; dy1 := mf * dy1; x1 := x0 + dx1 * co - sf * dy1 * si; y1 := y0 - sf * dy1 * co - dx1 * si; form1.canvas.moveto(round(x1),round(y1)); end;

Der Aufruf der obigen Prozeduren erfolgt entsprechend der gewünschten Grafik: procedure drawHouse; { zeichnet Haus } begin dwp(0, 10); { Frontseite } dwl(10, 10); dwl(10, 0); dwl(0, 0); dwl(0, 10); dwp(1, 8); { Fenster } dwl(4, 8); dwl(4, 4); dwl(1, 4); dwl(1, 8); dwp(6, 0); { Tür } dwl(6, 8); dwl(9, 8); dwl(9, 0); dwl(6, 0); dwp(-1, 9); { Dachgiebel } dwl(5, 15); dwl(11, 9); dwc(5, 12, 1); { Giebelfenster } dwp(7, 13); { Schornstein } dwl(7, 16); dwl(9, 16); dwl(9, 11) end;

Die Initialisierung: procedure TForm1.FormCreate(Sender: TObject); begin

379

7.6 Praxisbeispiele für Fortgeschrittene

x0 := clientWidth / 2; y0 := clientHeight / 2; alf := 0; sf := 1; mf := 20; canvas.brush.style:= bsclear end;

Die Manipulationen der Vektorgrafik: procedure TForm1.Button1Click(Sender: TObject); begin mf := mf + 1 end;

// Vergrößern

procedure TForm1.Button2Click(Sender: TObject); // Verkleinern begin mf := mf - 1 end; procedure TForm1.Button4Click(Sender: TObject); // Spiegeln begin sf := -sf end; procedure TForm1.Button3Click(Sender: TObject); // Richtungsänderung begin dirFlg := Not dirFlg end;

Die Anzeige erfolgt im Timer-Event: procedure TForm1.Timer1Timer(Sender: TObject); begin form1.refresh; If dirFlg Then alf := alf + Pi / 100 { im Uhrzeigersinn } Else alf := alf - Pi / 100; { entgegen Uhrzeigersinn } si := Sin(alf); co := Cos(alf); drawHouse end;

Test Nach Programmstart sollte die Grafik in 1/8-Grad-Schritten entgegen dem Uhrzeigersinn rotieren. Weitere Manipulationen können Sie über die Schaltflächen quasi online durchführen.

380

Kapitel 7

Grafikprogrammierung

Bemerkungen ■ Weitere Verbesserungen lassen sich erzielen, wenn für die Rechtecke eine eigene Prozedur (dwr) geschrieben wird, für die nur noch die Koordinaten der linken oberen und rechten unteren Ecke zu übergeben sind. ■ Natürlich wäre es auch möglich, die Geometrie nicht direkt im Quelltext, sondern z.B. in einem Array zu speichern, was allerdings zusätzliche Eingabeprozeduren erforderlich macht. ■ Die Darstellung von Rechtecken ist mit LineTo relativ langsam. Für häufig benötigte Rechtecke bzw. Polygone lohnen sich eigene Routinen, die intern auf der GDI-Funktion PolyLine aufbauen (siehe Kapitel 15). ■ Es sei nahe gelegt, das Progrämmchen auch einmal mit selbst definierten Symbolen in kleineren und größeren Winkelschritten auf einem bereits vorhandenen Hintergrundbild auszuprobieren. Um dieses nicht zu verletzen, müssen Sie auf Refresh verzichten und stattdessen mit einem XOR-Mode überschreiben. Gleichzeitig dürften Sie damit den lästigen Flackereffekt vermeiden. HINWEIS: Dieses Beispiel ist konventionell programmiert. Wie Sie es in eine zeitgemäße OOP-

Lösung überführen können, erfahren Sie im Beispiel 6.4.2 (OOP-Kapitel, "Von der Unit zur Klasse").

8

Dateien/Streams

Kapitel

8

Dateien/Streams Delphi, d.h. Objekt Pascal, bietet für den Zugriff auf Dateien eine ganze Palette von Befehlen und Möglichkeiten an. Um den Überblick nicht zu verlieren und um den Leser nicht mit irgendwelchen endlosen Parameter-Übersichten (die Sie sowieso in der Online-Hilfe finden) zu verwirren, haben wir die Dateioperationen nach Themen bzw. Schwerpunkten geordnet und auf die vollständige Darstellung aller Möglichkeiten verzichtet. Nach einigen grundsätzlichen Ausführungen zum Thema werden wir uns mit ■ Textdateien (sequenzielle Dateien) ■ typisierten Dateien (Random- oder Direktzugriffs-Dateien) ■ Binärdateien ■ INI-Dateien ■ Registrierdatenbank beschäftigen. Vielleicht vermissen Sie in obiger Aufzählung die Grafikdateien, wir waren jedoch der Meinung, dass diese in den Grafikkapiteln 7 und 15 weit besser aufgehoben sind.

8.1 Übersicht 8.1.1 Dateifunktionen Dem C- und Basic-Programmierer bzw. dem Umsteiger aus anderen Pascal-Dialekten werden die folgenden Befehle in dieser oder ähnlicher Form vertraut vorkommen: Befehl

Beschreibung

AssignFile

... verknüpft eine Dateivariable mit einer Datei. Diese Verbindung wird erst mit CloseFile aufgehoben.

CloseFile

... schließt eine geöffnete Datei.

Append

... öffnet eine Textdatei zum Anfügen weiterer Zeichen.

EoLn

... prüft auf Zeilenendezeichen.

382

Kapitel 8

Dateien/Streams

Befehl

Beschreibung

Flush

... erzwingt das Schreiben des Dateipuffers.

Read

... liest einen oder mehrere Werte aus der Datei.

Readln

... liest eine Zeile aus einer Textdatei.

SeekEof

... prüft das Vorhandensein von Zeichen zwischen der aktuellen Position und dem Textdateiende.

SeekEoln

... prüft das Vorhandensein von Zeichen zwischen der aktuellen Position und dem Zeilenende.

Write

... schreibt einen oder mehrere Werte in eine Datei.

Writln

... schreibt eine Zeile in die Textdatei.

Eof

... prüft auf das Dateiende.

Erase

... löscht die angegebene Datei (verwenden Sie besser DeleteFile).

FilePos

... liefert die Position des Dateizeigers.

FileSize

... liefert Dateigröße in Einheiten (bei Binär-Dateien die Anzahl der Bytes, bei typisierten Dateien die Satzzahl).

GetDir

... ermittelt das aktuelle Verzeichnis eines Laufwerks.

IOResult

... kennzeichnet den Fehlerstatus einer Dateioperation.

MkDir

... erstellt ein neues Unterverzeichnis.

Rename

... benennt eine Datei um (verwenden Sie besser RenameFile).

Reset

... öffnet eine vorhandene Datei.

Rewrite

... erzeugt und öffnet eine Datei. Sollte die Datei bereits existieren, wird diese überschrieben.

RmDir

... löscht ein leeres Unterverzeichnis.

Seek

... verändert die Position des Dateizeigers.

Truncat

... schneidet eine Datei an der aktuellen Position des Dateizeigers ab.

BlockRead

... liest Daten aus einer untypisierten Datei.

BlockWrite

... schreibt Daten in eine untypisierte Datei.

DeleteFile

... löscht die angegebene Datei.

DiskSize

... liefert die Laufwerksgröße in Bytes.

ChangeFileExt

... verändert die Dateiextension.

DiskFree

... liefert die Anzahl freier Bytes auf dem angegebenen Laufwerk.

ExpandFileName

... erweitert einen Dateinamen um Laufwerks- und Verzeichnisangaben.

ExtractFileExt

... liefert die Dateiextension.

ExtractFileName

... liefert den Dateinamen.

ExtractFilePath

... liefert die Pfadangaben.

FileExists

... prüft auf das Vorhandensein einer Datei.

FileGetAttr

... liefert die Attribute einer Datei.

383

8.1 Übersicht

Befehl

Beschreibung

FileGetDate

... liefert das Dateidatum.

FileSearch

... sucht eine Datei in vorgegebenen Verzeichnissen (ähnlich der PATHAnweisung in AUTOEXEC.BAT).

FileSetAttr

... verändert die Dateiattribute.

FileSetDate

... verändert das Dateidatum.

FindFirst

... durchsucht ein Verzeichnis nach dem ersten vorgegebenen Eintrag.

FindNext

... durchsucht das Verzeichnis nach weiteren Einträgen.

FindClose

... beendet eine FindFirst/FindNext-Sequenz.

RenameFile

... benennt eine Datei um.

In der Tabelle werden Sie einige Funktionen vermissen, die über die Unit SysUtils bereitgestellt werden, Näheres dazu in Abschnitt 8.1.2. Neben bereits oben genannten Funktionen/Anweisungen findet der Delphi-Programmierer weitere leistungsfähige Funktionen als Methoden in der Objekthierarchie wieder. Die folgende Tabelle enthält nur die wichtigsten Methoden, die Möglichkeiten im Zusammenhang mit Datenbanken sollen an dieser Stelle außer Acht gelassen werden. Methode

Beschreibung

Save

... sichert den aktuellen Inhalt in eine Datei (MediaPlayer).

SaveToFile

... speichert ein Objekt in die spezifizierte Datei. Dabei kann es sich um Grafiken (Bitmap, WMF), Texte (Memofeld) oder auch OLE-Objekte handeln.

SaveToStream

... speichert den Inhalt des Objekts in einen Stream.

LoadFromFile

... liest ein Objekt aus der spezifizierten Datei. Dabei kann es sich um Grafiken (Bitmap, WMF), Texte (Memofeld) oder auch OLE-Objekte handeln.

LoadFromStream

... liest den Inhalt eines Streams in ein Objekt.

HINWEIS: Anwendungsbeispiele für eine Vielzahl der oben genannten Funktionen finden Sie im

Praxisteil des vorliegenden Kapitels.

8.1.2 Dateizugriff unter Windows Wer nur unter DOS programmiert, brauchte sich um den Mehrfachzugriff auf eine Datei (fast) keine Sorgen zu machen. Während das eigene Programm mehr oder weniger gut lief, konnte eigentlich keine andere Anwendung "dazwischen funken". Dem ist leider nicht mehr so: ■ Erstens hält Windows eine ganze Reihe von Dateien geöffnet (der Zugriff auf diese Dateien ist meist nicht möglich). ■ Zweitens können auch mehrere andere Programme (oder auch dasselbe Programm) zeitgleich ausgeführt werden (Multitasking!).

384

Kapitel 8

Dateien/Streams

Beides führt dazu, dass eine Datei durchaus physisch vorhanden sein kann (die Funktion FileExists liefert True zurück), der Schreib-/Lesezugriff jedoch nicht erlaubt ist. Gegebenenfalls müssen Sie entsprechende Fehler abfangen, eine Fehlerbehandlungsroutine ist meist unumgänglich. Das Problem mit dem Mehrfachzugriff auf Dateien hat uns auch im Kapitel "Datenbanken" hinreichend beschäftigt. Leider hat Delphi bei den Standard-Datei-Befehlen nicht allzu viel zu bieten. Andere Sprachen, wie zum Beispiel Visual Basic, unterstützen den Programmierer durch entsprechende Parameter wesentlich besser. Optionen wie "Lock Read", "Shared" etc. wird man vergeblich suchen. Mit einer Ausnahme: Über die Unit SysUtils können Sie unter anderem einige Low-Level-Dateifunktionen importieren, die auch Share-Optionen unterstützen: Befehl

Beschreibung

FileCreate

... erzeugt eine neue Datei.

FileOpen

... öffnet eine Datei.

FileRead

... liest Daten in einen Puffer.

FileWrite

... schreibt Daten aus einem Puffer in eine Datei.

FileSeek

... positioniert den Dateizeiger.

FileClose

... schließt eine Datei.

HINWEIS: Mischen Sie die obigen Anweisungen nicht mit den anderen Dateifunktionen, der

Übergabeparameter ist in diesem Fall ein Datei-Handle, keine Dateivariable! Der kleine, aber feine Unterschied beginnt beim Öffnen der Datei. Neben dem Dateinamen übergeben Sie jeweils eine Konstante für den Dateimodus und eine für den Share-Mode: Dateimodus

Erläuterung

fmCreate

Neue Datei erzeugen

fmOpenRead

Nur Lesezugriff

fmOpenWrite

Nur Schreibzugriff

fmOpenReadWrite

Lese- und Schreibzugriff

Share-Modus

Erläuterung

fmShareExclusive

Kein Lese- und Schreibzugriff durch andere Anwendungen

fmShareDenyWrite

Kein Schreibzugriff

fmShareDenyRead

Kein Lesezugriff

fmShareDenyNone

Andere Anwendungen haben uneingeschränkten Zugriff auf die bereits geöffnete Datei.

HINWEIS: Beide Konstanten können Sie mit dem OR-Operator miteinander verknüpfen.

385

8.2 Textdateien

BEISPIEL: Starten Sie zwei Instanzen des folgenden Pascal-Programms, können beide auf die bereits geöff-

nete Datei zugreifen: var f : File; procedure TForm1.FormCreate(Sender: TObject); begin AssignFile(f,'c:\test.txt'); Reset(f) end; procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin CloseFile(f) end;

Ein anderes Programm kann sogar in die Datei schreiben, womit wir auch schon bei den eigentlichen Problemen angekommen wären. Stellen Sie sich vor, zwei Programme überschreiben gleichzeitig denselben Record, oder ein Programm löscht gerade den Record, an dem das andere Programm arbeitet. Etwas anders sieht die Sache aus, wenn Sie mit FileOpen arbeiten: var f : THandle; procedure TForm1.FormCreate(Sender: TObject); begin f1 := FileOpen('c:\test.txt',fmOpenReadWrite or fmShareExclusive) end; procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin FileClose(f) end;

Über die Share-Konstante können Sie beim Öffnen der Datei bestimmen, welchen Zugriff andere Anwendungen auf die Datei haben. Im obigen Beispiel wird es keiner Anwendung möglich sein, die Datei zum Lesen oder Schreiben zu öffnen. Sie können das Programm nur einmal starten, ohne dass es zu Zugriffsverletzungen kommt. HINWEIS: Verwenden Sie die oben genannten Funktionen nur, wenn es unbedingt notwendig ist

(z.B. wenn Sie ein neues Datenbanksystem schreiben wollen).

8.2 Textdateien Wofür sollten Sie eine Textdatei verwenden? Die Antwort kann bereits dem Namen entnommen werden: Textdateien eignen sich besonders gut zum Speichern von Texten mit unterschiedlicher Zeilenlänge. Für Texte mit konstanter Zeilenlänge ist die Verwendung einer typisierten Datei sinn-

386

Kapitel 8

Dateien/Streams

voller, da in diesem Modus bessere Zugriffsmöglichkeiten zur Verfügung stehen (wahlfreier Zugriff).

8.2.1 Aufbau Textdateien sind zeichen- und zeilenweise organisiert. Jede Zeile wird durch die ASCII-Zeichen 13 und 10 abgeschlossen (beide Zeichen stammen noch aus der Computer-Urzeit: 13 = Wagenrücklauf, 10 = Zeilenvorschub). Die Länge einer Zeile wird allein durch die Position dieser beiden Zeilenendzeichen bestimmt. Die Ansicht in einem HEX-Editor:

Da wir gerade bei ASCII sind: Windows (und damit auch Delphi) bevorzugt den ANSI-Zeichensatz, was uns die Arbeit mit DOS-Textdateien nicht gerade erleichtert. Werden ASCII-Texte unter Windows geladen, kann das wie folgt aussehen:

Glücklicherweise liefert uns Windows gleich zwei entsprechende Funktionen, um die eventuell nötige Umwandlung vorzunehmen: function CharToOem(lpszSrc: PChar; lpszDst: PChar): BOOL; stdcall; function OemToChar(lpszSrc: PChar; lpszDst: PChar): BOOL; stdcall;

Beide Funktionen erwarten als Übergabeparameter Zeichenketten (Strings). Sie können für beide Parameter auch ein und dieselbe Variable verwenden. BEISPIEL: Öffnen einer Textdatei und Konvertierung procedure TForm1.Button1Click(Sender: TObject); var s:String; l:TStringlist; begin

387

8.2 Textdateien

l := TStringlist.Create; // Stringliste zur Aufnahme der ASCII-Textdatei l.LoadFromFile('test.txt'); // laden der ASCII-Datei s := l.Text; // der Inhalt der Textdatei wird der Variablen s zugewiesen

Übergabe des Strings (Konvertierung ASCII ... ANSI), der zweite Parameter ist der Rückgabewert. Da dieser genauso groß wie der erste Parameter ist, können wir auf einen extra Puffer verzichten. OEMtoChar(PChar(s),PChar(s)); // Anzeige in einem Memo-Feld Memo1.Text := s end;

HINWEIS: Wenn Sie durch die obigen Deklarationen abgeschreckt werden: Kein Problem, Del-

phi hat in die wichtigsten Komponenten bereits eine entsprechende Eigenschaft integriert, die die nötigen Umwandlungen veranlasst: OEMConvert. Setzen Sie diese auf True, wird die ASCII/ANSI-Konvertierung automatisch vorgenommen.

8.2.2 Öffnen Um auf eine Datei zugreifen zu können, müssen wir diese erst einmal öffnen. Bei einer Textdatei gibt es drei verschiedene Möglichkeiten: ■ Reset (Lesen aus einer Textdatei) ■ Rewrite (Schreiben in eine Textdatei) ■ Append (Text an eine Textdatei anhängen) Die Trennung dieser drei Modi ist einer der größten Nachteile einer Textdatei. Die Ursachen liegen im Dateiaufbau begründet, Zeilen unterschiedlicher Länge lassen sich nun einmal nicht wie Records fester Länge behandeln. BEISPIEL: Einlesen der AUTOEXEC.BAT var f: TextFile; s : String; begin AssignFile(f,'c:\autoexec.bat'); // Fehlermeldungen ausschalten: {$i-} Reset(f) {$i+} if IOResult <> 0 then begin ShowMessage('Fehler ...'); Exit end; while not eof(f) do Readln(f,s); CloseFile(f) end;

388

Kapitel 8

Dateien/Streams

BEISPIEL: Eine Textdatei schreiben var f: TextFile; begin AssignFile(f,'c:\test.txt'); {$i-} Rewrite(f); {$i+} if IOResult <> 0 then begin ShowMessage('Fehler ...'); Exit end; Writeln(f,'Hallo User, das ist eine Textdatei'); Writeln(f,'Hallo User, das ist eine Textdatei'); Writeln(f,'Hallo User, das ist eine Textdatei'); CloseFile(f) end;

BEISPIEL: Text (eine Zeile) an die AUTOEXEC.BAT anhängen var f: TextFile; begin AssignFile(f,'c:\autoexec.bat'); {$i-} Append(f); {$i+} if IOResult <> 0 then begin ShowMessage('Fehler ...'); Exit end; Writeln(f,'REM zusätzliche Zeile'); CloseFile(f) end;

HINWEIS: Beachten Sie, dass statt Text der neue Typ TextFile verwendet wird. Delphi möchte

auf diese Weise vermeiden, dass es zu Überschneidungen mit der Property Text kommt. In allen Beispielen wird nach dem Initialisieren der Dateivariablen F mit AssignFile die Fehlerprüfung ausgeschaltet (Compilerschalter {$i-}). Über die Funktion IOResult kann auf Laufzeitfehler geprüft werden (siehe dazu auch Abschnitt 5.2, "Fehlerbehandlung").

8.2.3 Lesen Wie lesen wir nun die Daten aus der Textdatei ein? Auch hier müssen wir wieder zwischen verschiedenen Möglichkeiten unterscheiden:

Zeilenweises Einlesen Zeilenweises Einlesen brauchen Sie, um beispielsweise eine Tabelle zu füllen. i := 0; while not EOF(f) do begin ReadLn(f,s);

389

8.2 Textdateien

StringGrid1.Cells[1,i]:= s; Inc(i) end;

Solange das Dateiende nicht erreicht ist (While Not EOF(F)), wird die Datei zeilenweise eingelesen. Durch die ReadLn-Anweisung werden die beiden Zeilenendzeichen (13,10) entfernt, der String enthält nur den reinen Text.

Variablen einlesen Mit der Read-Anweisung können Sie aus einer Textdatei auch numerische Variablen einlesen, Sie sollten jedoch einige Besonderheiten beachten. In jeder Zeile darf nur eine einzige Variable stehen. Lesen Sie mit folgender Anweisung über das Dateiende hinaus, weil z.B. eine ungerade Anzahl von Zeilen vorhanden ist, tritt kein Laufzeitfehler auf. Die "überflüssige" Variable wird mit null initialisiert: var f n, n1 i

: TextFile; : Real; : Integer;

begin AssignFile(f,'c:\test.txt'); ... while not eof(f) do begin Read(f,x,y) end;

Bitte beachten Sie Folgendes: ■ Führende Leerzeichen und Tabulatoren werden ignoriert. ■ Im Gegensatz zum Einlesen von Strings rückt das Lesen von numerischen Variablen den Satzzeiger weiter.

8.2.4 Schreiben Beim Schreiben unterscheiden wir zwischen zwei Möglichkeiten: ■ Anhängen an eine bestehende Datei ■ Schreiben in ein leeres File Die Entscheidung für eine der beiden Möglichkeiten wurde bereits mit der Anweisung zum Öffnen getroffen. Die eigentlichen Ausgabefunktionen unterscheiden sich nicht voneinander (siehe Öffnen von Textdateien). Den Inhalt einer Textbox können Sie auf zwei verschiedene Arten speichern:

390

Kapitel 8

Dateien/Streams

Zeilenweise schreiben var f : TextFile; i : Integer; begin AssignFile(f,'c:\test.txt'); {$i-} Rewrite(f); {$i+} if IOResult <> 0 then Halt; for i := 0 to Memo1.Lines.Count do Writeln(f,Memo1.Lines[i]); CloseFile(f) end;

Diese Möglichkeit sollten Sie allerdings nur nutzen, wenn Sie bestimmte Zeilen auslassen wollen oder wenn Sie den Text an eine Datei anfügen möchten. Soll der gesamte Inhalt in einer neuen Datei gespeichert werden, ist die Verwendung der SaveToFile-Methode einfacher: Ohne if IOResult <>0 ... erfolgt keine Fehlermeldung, und es passiert nichts! Besser wäre deshalb if IOResult <> 0 then begin ShowMessage('Die Datei befindet sich nicht im akt. Verzeichnis!'); Exit end;

Schreiben mit der Methode SaveToFile Memo1.Lines.SaveToFile('SOMETEXT.TXT');

Beachten Sie jedoch, dass der Inhalt einer eventuell bestehenden Datei "gnadenlos" überschrieben wird. Gegebenenfalls müssen Sie eine entsprechende Prüfung vornehmen (FileExists).

8.3 Typisierte Dateien Für das Sichern von numerischen Daten und Nutzertypen bietet sich statt einer Textdatei eine so genannte typisierte Datei an. Bei typisierten Dateien handelt es sich eigentlich um keinen Dateityp, sondern eher um eine Zugriffsmöglichkeit. Sie können eine typisierte Datei auch als Textdatei öffnen und auslesen, ob dabei etwas Sinnvolles herauskommt, ist jedoch fraglich. Typisierte Dateien sind durch eine konstante Datensatzlänge gekennzeichnet, zwischen den einzelnen Datensätzen (Records) ist kein Trennzeichen vorhanden. Sie müssen also wissen, wie groß ein Datensatz ist. Nr

Name

Vorname Nr

Name

Vorname

Nr

Name

Vorname Nr

Name

Vorname

Bei typisierten Dateien müssen Sie keine Unterscheidung zwischen Schreib- und Lesezugriff treffen, Sie können also in einer Datei gleichzeitig lesen und schreiben.

8.3 Typisierte Dateien

391

8.3.1 Öffnen BEISPIEL: Vor dem Öffnen der Datei definieren Sie die Struktur des Datensatzes. type PunktType = record x: Integer; y: Integer; end; LinienType = record a: punktType; b: punktType; end;

Der definierte Typ (bzw. die Variable dieses Typs) hat eine bestimmte Länge, die aus der Anzahl und dem Typ der verwendeten Felder resultiert. Das Anlegen und Öffnen der Datei gestaltet sich ebenso einfach wie bei einer Textdatei: var f : file of LinienType; begin AssignFile(f,'c:\test.dat'); {$i-} Rewrite(f); // erstellt neue Datei und öffnet sie {$i+} if IOResult <> 0 then halt;

Ob Sie einmal mit einer Variablen vom LinienType oder zweimal mit einer Variablen vom PunktType zugreifen, ist nur von der Definition der File-Variablen abhängig. Sie können auch als PunktType schreiben und mit LinienType lesen.

8.3.2 Lesen/Schreiben Mit der Read-Anweisung können Sie den Inhalt der Datei lesen. Im Unterschied zur Textdatei benötigen Sie noch einige zusätzliche Befehle zur Positionierung des Datensatzzeigers sowie zur Bestimmung der Anzahl von Datensätzen. Die folgenden Beispiele sind sowohl für den Schreib- als auch für den Lesezugriff interessant:

Wie bestimmt man die Anzahl der Datensätze? AssignFile(f,'c:\test.dat'); {$i-} Reset(f); {$i+} if IOResult <> 0 then Halt; anzahl = FileSize(f); Close(f);

392

Kapitel 8

Dateien/Streams

Wie positioniert man den Satzzeiger? ... Reset(f) ... Seek(f, 25); CloseFile(f)

Die aktuelle Position des Datenzeigers bestimmen Sie mit FilePos: ... Reset(f) ... n := FilePos(f); CloseFile(f)

HINWEIS: Im Unterschied zu Visual Basic hat der erste Datensatz in einer typisierten Datei stets

die Satznummer 0!

Wie liest man einen Datensatz? ... Reset(f) ... Read(f, linie); ...

liest den aktuellen Datensatz, ... Reset(f) ... Seek(f,16); Read(f, linie); ...

liest den siebzehnten Datensatz in die Variable linie ein.

Wie schreibt man einen Datensatz? ... Reset(f) ... Write(f,linie); CloseFile(f) ...

schreibt die Werte der Variablen "linie" an der aktuellen Position, ... Reset(f) ... Seek(f,11); Write(f,linie); CloseFile(f) ...

schreibt die Werte in den Datensatz 12. Ist die angegebene Satznummer größer als die Anzahl der vorhandenen Datensätze, wird der Wert an die Datei angehängt, einen Append-Modus gibt es nicht. HINWEIS: Wie auch bei den Textdateien gilt: Vergessen Sie nie, die Datei nach dem letzten

Schreibzugriff zu schließen!

8.4 Binärdateien

393

8.3.3 Probleme mit Records Stellen Sie sich folgendes Szenarium vor: Leichtsinnig, wie Sie waren, hatten Sie ein 16-Bit-Pascal-Programm geschrieben, das eine typisierte Datei folgenden Aufbaus erzeugte: type Ttest = record i : Integer; b : Byte; s : String[10]; end;

Die Recordgröße war damit auf 16 Bytes (4+1+11) festgelegt. Doch jetzt folgt das böse Erwachen: Sie haben das Programm neu compiliert, wollen es ausprobieren, und was passiert? Natürlich wird nur der blanke Unsinn aus der Datei ausgelesen. Die Ursachenforschung beginnt und endet damit, dass sich die Recordgröße verändert hat. Ein Integer ist kein Integer mehr, sondern plötzlich vier statt zwei Byte groß. Als Lösung bieten sich zwei Wege an: ■ Sie verändern die Integer-Variable im Record in eine SmallInt-Variable. ■ Sie konvertieren gleich die ganze Datei, auf diese Weise vergrößert sich auch noch der zulässige Wertebereich, und Sie können auf das Umschreiben des Programms verzichten. Wem daran gelegen ist, nicht unnötig Platz auf der Festplatte zu verschwenden, sei daran erinnert, die packed-Option für den Record zu setzen. type TTest = packed record i : Integer; b : Byte; s : String[7]; end;

entspricht 13-Byte-Recordgröße, ohne die packed-Option wären es 16 Byte.

Fazit Für das Speichern von Zeichenketten (Strings) ist eine typisierte Datei weniger gut geeignet, da auch für einen Leerstring die einmal definierte Anzahl von Zeichen freigehalten wird. Möchten Sie aber zum Beispiel ein Array speichern, so dürfte eine typisierte Datei die erste Wahl sein. Für komplexere Anwendungen mit Such- und Sortierfunktionen sollten Sie jedoch auf jeden Fall einer Datenbank den Vorzug geben, auch wenn dies im ersten Augenblick komplizierter erscheint.

8.4 Binärdateien Wie auch für typisierte Dateien gilt: Unter einer Binärdatei versteht man kein Dateiformat, sondern eine Zugriffsart. Sie könnten also auch auf eine Textdatei im Binärmodus zugreifen.

394

Kapitel 8

Dateien/Streams

Eigentlich ist eine Binärdatei eine spezielle Form der typisierten Datei, die Datensatzlänge variiert und ist mindestens 1 Byte groß. Wie viele Bytes gelesen bzw. geschrieben werden, hängt vom verwendeten Variablentyp ab: 56

24

13

11

56 219 115 255 64

79 123 43

2

28

90 213 155 76

0

Zugriff Sie haben zwei verschiedene Möglichkeiten, um auf Binärdateien zuzugreifen. Entweder Sie deklarieren eine Dateivariable vom Type Byte oder Char: var f : File of Byte;

bzw. var f : File of Char;

oder Sie verwenden eine untypisierte Datei: var f : File;

Im letzteren Fall können Sie nur die Anweisungen BlockRead und BlockWrite verwenden. Die in älteren Delphi-Versionen gültige Beschränkung auf 64 KByte Lese- bzw. Schreibpuffer entfällt. Es ist günstig, wenn Sie den Schreib- bzw. Lesepuffer nicht statisch belegen, sondern dafür Speicher dynamisch reservieren: var p : Pointer ... GetMem(p,1000); // Speicher reservieren BlockRead(f,p^,1000,result); FreeMem(p,1000); // Speicher freigeben

Wichtige Hinweise: ■ Geben Sie nur so viel Speicher frei, wie Sie auch belegt haben! ■ Verwenden Sie eine Binärdatei zum Speichern von einzelnen Status-Variablen Ihres Programms oder zum Manipulieren anderer Dateien!

8.5 Streams Selten verwendet und schlecht dokumentiert fristen sie zu Unrecht ein Schattendasein: die Streams in all ihren möglichen Varianten. Ob als File- oder Memory-Stream, höchstens in Form einer Methode (SaveToStream) kommt man mit ihnen in Berührung. Wir wollen diesem Missstand abhelfen. Ein kleines Beispiel zur Einstimmung zeigt die Leistungsfähigkeit des Konzepts.

395

8.5 Streams

BEISPIEL: Eine kleine Routine zum Kopieren einer Datei // Deklarieren zweier FileStream-Objekte: var s1,s2 : TFileStream; begin // Erzeugen der Objektinstanzen (gleichzeitig werden die Dateien geöffnet bzw. erzeugt): s1 := TFileStream.Create('c:\test.dat',fmOpenRead); s2 := TFileStream.Create('d:\test.bak',fmCreate); // Der Kopiervorgang: s2.CopyFrom(s1, s1.Size) end;

Sieht doch gar nicht so schlecht aus! Mit drei Zeilen Code wurde eine ganze Datei kopiert, und diverse Fehlermeldungen wurden gleich mit integriert.

8.5.1 Was ist ein Stream? Ein Stream ist prinzipiell mit einer einfachen sequenziellen Datei vergleichbar. Es muss sich jedoch nicht unbedingt um eine physikalische Datei handeln, es kann auch ein Speicherbereich sein, der sich genau wie eine Datei bearbeiten lässt (lesen/schreiben). Delphi kapselt Streams entsprechend ihrer Funktionalität in verschiedenen Objektklassen, die alle von TStream abstammen. Sehen wir uns doch einmal den Stammbaum an:

Interessant dürften vor allem zwei Typen sein: TFileStream und TMemoryStream.

8.5.2 Öffnen, Schreiben und Lesen Wie Sie schon im Eingangsbeispiel gesehen haben, erzeugen bzw. öffnen Sie einen FileStream durch den Aufruf der Methode Create. Übergabewerte sind der Dateiname und der Dateimodus (die Konstanten finden Sie in Abschnitt 8.1.1). Wie eine normale Datei hat auch ein Stream eine Größe (Size) und einen Dateizeiger (Position). Gelesen wird mit der Methode Read, geschrieben mit Write. Alternativ können Sie auch die Methoden ReadBuffer und WriteBuffer verwenden. Lese- bzw. Schreibvorgänge verändern die Satzzeigerposition, ebenso ein Aufruf der Seek-Methode.

396

Kapitel 8

Dateien/Streams

BEISPIEL: Speichern von Variablen var fStream : TFileStream; datum : TDateTime; ... // Stream-Objekt erzeugen: fStream := TFileStream.Create('c:\test.dat', fmOpenReadWrite) // Auf das 20. Byte setzen: fStream.Position := 20; // die Variablen nacheinander in den Stream, d.h. die Datei, schreiben: fStream.WriteBuffer(datum, SizeOf(datum)); ... fStream.Free;

Möchten Sie Stringvariablen speichern, müssen Sie sich schon etwas mehr einfallen lassen. Zuerst speichern Sie die Größe des Strings, nachfolgend die eigentlichen Stringdaten. procedure TForm1.Button1Click(Sender: TObject); var s : String; len : LongInt; begin s := 'Hallo User'; // Erzeugen des Stream-Objekts: with TFileStream.Create('c:\test.dat',fmCreate) do begin // Bestimmen der Stringlänge: len := Length(s); // Schreiben der Stringlänge: Write(len, SizeOf(LongInt)); // Schreiben des Strings: Write(s[1], len); Free end end;

HINWEIS: Beachten Sie die Aufrufsyntax beim Schreiben des Strings. Übergeben wird nicht der

String, sondern das erste Zeichen des Strings. BEISPIEL: Einlesen einer Stringvariablen procedure TForm1.Button2Click(Sender: TObject); var s : String; len : LongInt; begin s := '?'; with TFileStream.Create('c:\test.dat',fmOpenRead) Read(len, SizeOf(len)); SetLength(s,len); Read(s[1],len); Free

do // // //

begin Bestimmen der Stringlänge String entsprechender Länge erzeugen String einlesen

397

8.5 Streams

end; Form1.Caption := s end;

8.5.3 Kopieren von Streams Mit CopyFrom kopieren Sie eine bestimmte Anzahl von Bytes aus einem Stream in den anderen. Dabei ist es völlig unerheblich, ob es sich um einen File- oder einen Memory-Stream handelt. Dies gilt auch für alle oben genannten Methoden und Eigenschaften. Intern setzt die Methode CopyFrom natürlich wieder auf der schon bekannten Read- bzw. Write-Methode auf. HINWEIS: Beachten Sie bei CopyFrom, dass Sie vorher mit Position den Satzzeiger des Quell-

und des Ziel-Streams entsprechend setzen. BEISPIEL: Speichern eines Memofeldes (mit Umweg über einen MemoryStream) var fStream : TFileStream; mStream : TMemoryStream; begin fStream := TFileStream.Create('c:\test.dat',fmCreate); mStream := TMemoryStream.Create; memo1.Lines.SaveToStream(mStream); fStream.CopyFrom(mStream, mStream.Size); fStream.Free; mStream.Free end;

Das obige Beispiel wird zu einem Laufzeitfehler führen, da sich der Positionszeiger des MemoryStreams bereits am Stream-Ende befindet. Mit Position setzen wir den Zeiger neu: Memo1.Lines.SaveToStream(mStream); mStream.Position := 0; fStream.CopyFrom(mStream,mStream.Size);

Je nach Objekttyp finden sich einige zusätzliche Eigenschaften und Methoden, die für die Arbeit mit dem entsprechenden Medium nötig sind. So bietet der TMemoryStream eine Eigenschaft Capacity, über die Sie die Größe des Speicherbereichs festlegen bzw. auslesen können. Verwechseln Sie die Capacity-Eigenschaft nicht mit der Eigenschaft Size, die lediglich die Größe des Streams angibt. Interessant ist auch noch die Eigenschaft Memory, die einen Pointer auf den Speicherbereich des Streams zurückgibt. Speicher-Streams (TMemoryStreams) können Sie mit SaveToFile bzw. LoadFromFile in eine Datei schreiben bzw. aus einer Datei lesen. Haben Sie einen Stream mit Create erzeugt, können Sie darin beispielsweise den Inhalt einer RTFKomponente, einer TreeView-Komponente usw. speichern (Methode SaveToStream). Auf diese Weise können Sie problemlos mit verschiedenartigen Daten umgehen, ohne sich um den Datentyp kümmern zu müssen. Ein komplettes Anwendungsbeispiel finden Sie im Praxisteil des Kapitels.

398

Kapitel 8

Dateien/Streams

8.6 Memory Mapped Files Wer mit den bisherigen Möglichkeiten des Dateizugriffs immer noch nicht zufrieden ist, düfte spätestens hier die Lösung für seine Probleme finden. Memory Mapped Files (kurz MMF) stellen eine Möglichkeit dar, physische Dateien in den Adressraum einer oder auch mehrerer Anwendungen einzublenden. Wozu das Ganze? Die Antwort findet sich im Zugriffsprinzip auf derartige "Dateien". Sie verwenden statt umständlicher Seek-, Read- und Write-Anweisungen einfach ganz normale Speicheroperationen (z.B. mit typisierten Pointern, siehe Kapitel 14). Da Satzzeiger zugunsten von Pointern entfallen, ist es kein Problem, auf unterschiedliche Abschnitte der Datei gleichzeitig zuzugreifen. Legen Sie dazu einfach mehrere Pointer an. Ein weiterer Pluspunkt für die Verwendung von MMFs resultiert aus der strikten Trennung der Anwendungsadressräume. MMFs stellen eine der wenigen Möglichkeiten dar, große Datenmengen gleichzeitig von unterschiedlichen Anwendungen zu nutzen. Obwohl Sie bei MMFs mit Pointern in einem "Speicherbereich" arbeiten, befindet sich die Datei prinzipiell auf der Festplatte, nur der aktuell bearbeitete Abschnitt befindet sich im Speicher. Je nach Prozessortyp haben diese Abschnitte eine unterschiedliche Größe, bei Intel-Prozessoren sind es 4 KByte, die mindestens in den Speicher geladen werden (so genannte Pages). Um nicht nach jedem Schreib-/Lesezugriff die Page sichern zu müssen, werden meist mehrere Pages im Speicher gehalten. Für Sie als Programmierer ist dieser Vorgang nicht weiter von Bedeutung. Lediglich wenn Sie sicherstellen wollen, dass Änderungen sofort an der physischen Datei ausgeführt werden, müssen Sie dies der Memory-Verwaltung mitteilen (wir kommen später darauf zurück).

8.6.1 Erzeugen eines MMF Wie bei jeder normalen Datei müssen auch MMFs vor der Bearbeitung geöffnet werden. Ausgangspunkt ist die API-Funktion CreateFile1, über die Sie einen im weiteren Verlauf benötigten Datei-Handle erhalten. SYNTAX:

function CreateFile(lpFileName: PChar; dwDesiredAccess, dwShareMode: Integer; lpSecurityAttributes: PSecurityAttributes; dwCreationDisposition, dwFlagsAndAttributes: DWORD; hTemplateFile: THandle): THandle; stdcall;

Möchten Sie Lese- und Schreibzugriff auf den MMF erhalten, müssen Sie den Parameter dwDesiredAccess mit GENERIC_READ+ GENERIC_WRITE festlegen. Ob und, wenn ja, wie andere Anwendungen auf die aktuelle Datei zugreifen können, legen Sie mit dwShareMode fest. Die Security-Attribute sind nur unter Windows NT von Bedeutung, übergeben Sie einfach NIL. HINWEIS: Über die weiteren Parameter informieren Sie sich bitte in der Online-Hilfe.

1

Es geht auch mit der Funktion OpenFile.

8.6 Memory Mapped Files

399

Mit dem von der Funktion CreateFile zurückgegebenen Handle können wir uns dem nächsten Schritt zuwenden: dem Aufruf der Funktion CreateFileMapping. SYNTAX:

function CreateFileMapping(hFile: THandle; lpFileMappingAttributes: PSecurityAttributes; flProtect, dwMaximumSizeHigh, dwMaximumSizeLow: DWORD;lpName: PChar): THandle; stdcall;

Übergeben Sie neben dem FileHandle wieder NIL für die Security-Attribute. Soll ein Schreib/Lesezugriff auf den Speicher möglich sein, müssen Sie flProtect mit PAGE_READWRITE festlegen. Die Parameter dwMaximumSizeHigh und dwMaximumSizeLow deuten schon an, was uns in den nächsten Jahren erwarten wird: unendliche Weiten bei der Größe der Dateien. Zwei Variablen von Typ DWORD ermöglichen Dateigrößen bis zu 1,844674407371 * 10 19 bzw. 264 Bytes. Vorläufig müssen Sie sich allerdings mit dem Parameter dwMaximumSizeLow begnügen, aber 4 GByte dürften für den Anfang schon reichen. Handelt es sich um eine bestehende Datei, die nicht vergrößert werden soll, können Sie für beide Parameter null angeben. In diesem Fall wird die Dateigröße verwendet, andernfalls lässt sich die Datei bis zur angegebenen Größe erweitern. Zum Schluss folgt noch ein eindeutiger Bezeichner, über den Sie später auf den MMF zugreifen können. Dieses Feature wird allerdings nur bei der Interprozess-Kommunikation verwendet, normalerweise übergeben Sie hier einfach NIL. Den Rückgabewert der Funktion CreateFileMapping sollten Sie sich merken, es handelt sich um das Handle des MMFs. Der letzte Schritt vor dem eigentlichen Speicherzugriff ist der Aufruf von MapViewOfFile. SYNTAX:

function MapViewOfFile(hFileMappingObject: THandle; dwDesiredAccess: DWORD; dwFileOffsetHigh,dwFileOffsetLow, dwNumberOfBytesToMap: DWORD): Pointer; stdcall;

Übergeben wird neben dem MMF-Handle eine Konstante, die beschreibt, welche Operationen (Lesen, Schreiben etc.) im Speicherbereich zulässig sind. Bei Schreib-/Lesezugriffen sollten Sie hier sinnvollerweise FILE_MAP_WRITE übergeben. Mit den restlichen Parametern können Sie bestimmen, welcher Bereich der Datei im Speicher abgebildet werden soll (Startadresse und Länge). Am einfachsten ist es, wenn Sie die komplette Datei auswählen (einfach für alle Parameter NULL angeben). Im Erfolgsfall wird Ihnen von der Funktion ein Pointer auf den Speicherbereich zurückgegeben. Alles Weitere bleibt Ihrer Kreativität überlassen, Kapitel 14 gibt einige Anregungen, was Sie mit dem Pointer anfangen können. BEISPIEL: Durchlaufen des gesamten Speicherbereichs var FData : Pointer; fileSize : LongInt; fileHandle, mapHandle : THandle; P : ^Byte; ... FData := MapViewOfFile(mapHandle,FILE_MAP_WRITE,0,0,0); P := FData;

400

Kapitel 8

Dateien/Streams

while fileSize > 0 do begin Dec(fileSize); Inc(P) end; UnmapViewOfFile(FData); CloseHandle(mapHandle); CloseHandle(fileHandle);

HINWEIS: Den Original-Pointer sollten Sie nicht verändern, den brauchen Sie noch beim Schlie-

ßen des MMFs mit UnMapViewofFile.

8.6.2 Datenaustausch über MMFs Die bisherigen Ausführungen waren im Wesentlichen darauf gerichtet, innerhalb einer Anwendung den Zugriff auf Dateien zu verbessern. Beispielsweise um Dateien auf Byte-Ebene zu manipulieren. Ein weiteres Einsatzgebiet findet sich bei der Interprozess-Kommunikation, d.h. dem Datenaustausch von 32-Bit-Anwendungen. Im Wesentlichen lässt sich alles bisher Gesagte auch auf dieses Einsatzgebiet verallgemeinern, einige Besonderheiten sind dennoch zu berücksichtigen. Beispielsweise brauchen Sie beim Erstellen des MMFs nicht unbedingt eine physische Datei anzugeben. Sie können auch die Auslagerungsdatei dazu missbrauchen. Übergeben Sie in diesem Fall statt eines File-Handles den Wert $FFFFFFFF an die Funktion CreateFileMapping. Natürlich ist es jetzt auch nötig, die Dateigröße zu bestimmen. Weiterhin sollten Sie sich jetzt auch für einen eindeutigen Namen entscheiden. Dieser kann dann von den weiteren Prozessen beim Aufruf der Funktion OpenFileMapping verwendet werden. Diese Funktion gibt nur dann ein gültiges Handle auf den MMF zurück, wenn er bereits existiert. BEISPIEL: Möglicher Ansatz für Datenaustausch über MMF (Server) Function CreateMMF(FileName: string; Size: Integer):Pointer; begin Result := nil; FHandle := CreateFileMapping($FFFFFFFF, nil, PAGE_READWRITE, 0, Size, PChar(FileName)); if FHandle = 0 then Exit; P := MapViewOfFile(FHandle, FILE_MAP_WRITE, 0, 0, Size); Result := P; ... p := CreateMMF('ABC_XYZ',1000);

BEISPIEL: Möglicher Ansatz für Datenaustausch über MMF (Client) var H : THandle; H := OpenFileMapping(FILE_MAP_WRITE, false, 'ABC_XYZ'); if h = NULL then //... MMF existiert noch nicht

HINWEIS: Ein komplettes Anwendungsbeispiel für den Datenaustausch finden Sie auch bei den

zu Delphi mitgelieferten Beispielprogrammen (\\IPCDemos).

401

8.7 INI-Dateien

8.7 INI-Dateien Fast jedes Programm braucht für die Sicherung von Optionen und Einstellungen eine INI-Datei. Sie können diese Datei als "normale" Textdatei speichern oder Sie nutzen eine der folgenden Möglichkeiten, die Windows bietet: ■ Speichern in der WIN.INI ■ Anlegen einer eigenen INI-Datei Die erste Methode ist die schnellste, aber auch die hässlichste. Programme "leben" nicht ewig, auch wenn mancher Programmierer zu dieser Meinung neigen sollte. Die "Reste" unserer Programme liegen als Datenmüll noch eine "halbe Ewigkeit" in der WIN.INI herum. Wer sich schon einmal der Mühe unterzogen hat, die WIN.INI von unnötigen Einträgen zu säubern, kann ein Lied davon singen. HINWEIS: 32-Bit-Programme sollten statt der WIN.INI besser die Systemdatenbank (Registry)

verwenden (siehe Abschnitt 8.8). Für alle Unverbesserlichen: Zum Arbeiten mit der WIN.INI ist man auf die Hilfe zweier API-Funktionen angewiesen. Mit function WriteProfileString(ApplicationName, KeyName, Str: PChar): Bool;

und function GetProfileString(AppName, KeyName, Default, ReturnedString: PChar; Size: Integer): Integer;

können Sie eigene Einträge in der WIN.INI erzeugen bzw. auslesen. var s :string; begin s := 'c:\test\grafik' + #0; WriteProfileString('Testabschnitt', 'Verzeichnis',@s[1]); end;

wird folgenden Eintrag in der WIN.INI hinterlassen: [Testabschnitt] Verzeichnis=c:\test\grafik

Dies entspricht dem grundsätzlichen Aufbau: [Abschnitt] Schlüssel1= Eintrag ...

Eigene INI-Datei anlegen Die Vorgehensweise mit function WritePrivateProfileString(ApplicationName, KeyName, Str, FileName: PChar): Bool;

402

Kapitel 8

Dateien/Streams

können Sie sich sparen, verwenden Sie besser das von Delphi zur Verfügung gestellte TIniFileObjekt. Mit den Methoden ■ ReadBool/WriteBool ■ ReadInteger/WriteInteger ■ ReadString/WriteString ■ EraseSection (Löschen eines Abschnitts) erstellen Sie auf einfache Weise eigene INI-Dateien: var Ini: TIniFile; begin Ini := TIniFile.Create('Test.INI'); Ini.WriteBool('Option', 'Logo', True); Ini.WriteInteger('Option', 'Pause', 3); Ini.WriteString('Passwortliste', 'Hans', 'Otto'); Ini.Free;

Das Beispiel erzeugt folgende Einträge in der Datei TEST.INI: [Option] Logo=1 Pause=3 [Passwortliste] Hans=otto

HINWEIS: Auch wenn die Datei bereits existiert, müssen Sie mit der Create-Methode die Varia-

ble initialisieren, andernfalls kommt es zu einer Schutzverletzung.

8.8 Die Registrierdatenbank Windows speichert alle Informationen über Hard- und Software in einer Datenbank mit Baumstruktur. Im Unterschied zu den früher üblichen INI-Dateien ist zum Einsehen der Datenbank ein Texteditor nicht geeignet, Sie müssen den Registrierungseditor verwenden, den Sie im Systemverzeichnis finden. Als frischgebackener 32-Bit-Programmierer ist Ihnen die Verwendung der Registrierungsdatenbank dringend anzuraten, überlassen Sie die INI-Dateien der 16-Bit-Welt.

8.8.1 Registrierungseditor Um den Registrierungseditor auszuführen, starten Sie REGEDIT.EXE vom Datei-Manager oder vom Programm-Manager. Wie Sie der folgenden Abbildung entnehmen können, sind die Informationen ähnlich einem Dateiverzeichnis in einer Baumstruktur gespeichert. Die einzelnen Einträge auf der linken Seite werden als Schlüssel bezeichnet, auf der rechten Seite werden gegebenenfalls die zugeordneten Werte angezeigt.

403

8.8 Die Registrierdatenbank

HINWEIS: Änderungen an der Registrierung sollten Sie nur vornehmen, wenn Sie wirklich wis-

sen, was Sie da tun. Im Allgemeinen werden die Einträge von den Programmen verwaltet, die sie benötigen, Änderungen durch den Anwender sind nicht vorgesehen.

8.8.2 Grundstruktur Die Registrierungsdatenbank gliedert sich in folgende vier Teile: Element

Beschreibung

HKEY_LOCAL_MACHINE

... enthält die Konfigurationsinformationen für den Computer (alle User).

HKEY_USERS

... die Root für alle Benutzerprofile.

HKEY_CURRENT_USER

... stellt die Root der Konfigurationsinformationen für den momentan angemeldeten Benutzer dar (z.B. Programmgruppen, Bildschirmfarben ...). HKEY_CURRENT_USER ist ein Teilschlüssel von HKEY_USERS.

HKEY_CLASSES_ROOT

... ist ein Teilschlüssel von HKEY_LOCAL _ MACHINE\SOFTWARE. Hier sind die Dateiverknüpfung und OLE-Objekte gespeichert.

404

Kapitel 8

Dateien/Streams

8.8.3 Speichern Bevor Sie einfach drauflosspeichern, sollten Sie sich darüber im Klaren sein, wo was gespeichert wird. Grundsätzlich sollten Sie nur Informationen speichern, die auch in eine Registrierdatei gehören, umfangreiche Daten gehören auch weiterhin in eine eigene Datei. Registrierungsdaten sollten Sie in ■ users-pezifische Daten und ■ computerspezifische Daten unterteilen. Allgemeine Computerdaten, wie zum Beispiel Hardware-Informationen, speichern Sie unter HKEY_LOCAL_MACHINE nach folgendem Muster: HKEY_LOCAL_MACHINE\SOFTWARE\Firmenname\Produkt\Version\...

Daten, die den einzelnen User betreffen (z.B. Farbeinstellungen, Fenstergrößen etc.), speichern Sie unter HKEY_CURRENT_USER wie folgt: HKEY_CURRENT_USER\SOFTWARE\Firmenname\Produkt\Version\...

Der Schlüssel SOFTWARE existiert bereits, Firmenname stellt eine eindeutige Firmenbezeichnung dar (z.B. Microsoft). Danach folgt die Produktbezeichnung (z.B. Corel Draw) und die Versionsnummer (z.B. 1.23). Auf diese Weise lassen sich alle Produkte einer Firma sinnvoll zusammenfassen:

Wichtig ist, dass in einer Baumebene alle Schlüssel eindeutig sein müssen1. Der Untereintrag eines Schlüssels kann dagegen den gleichen Namen wie der übergeordnete Schlüssel haben. Für das Speichern der Informationen sind folgende Wertetypen bzw. Klassen vordefiniert:

1

Typ

Beschreibung

REG_BINARY

... binärer Werteintrag

REG_SZ

... Zeichenkette (nullterminiert)

In einem Verzeichnis können Sie ja auch nicht zwei Dateien unter demselben Namen speichern.

405

8.8 Die Registrierdatenbank

Typ

Beschreibung

REG_DWORD

... DWORD-Eintrag

REG_MULTI_SZ

... mehrere Zeichenketten

REG_EXPAND_SZ

... erweiterbare Zeichenkette

8.8.4 Die Klasse TRegistry Als Alternative zum Registry-API bietet Ihnen Delphi mit TRegistry eine recht komfortable Klasse zum Zugriff auf die wichtigsten Registry-Funktionen. Nach dem Erstellen einer Instanz var regist : TRegistry; ... regist := TRegistry.Create;

stehen Ihnen alle Methoden und Eigenschaften zur Verfügung. HINWEIS: Delphi verwendet beim Erstellen der Instanz standardmäßig HKEY_CURRENT-

_USER als Root. Möchten Sie allgemeine Einstellungen in der Registry ablegen, müssen Sie den Teilbaum HKEY_LOCAL_MACHINE verwenden. Setzen Sie dazu die Eigenschaft RootKey. regist.RootKey := HKEY_LOCAL_MACHINE;

Konstanten für die Eigenschaft RootKey: Konstante

HKEY_CLASSES_ROOT HKEY_CURRENT_USER HKEY_LOCAL_MACHINE HKEY_USERS HKEY_PERFORMANCE_DATA HKEY_CURRENT_CONFIG HKEY_DYN_DATA

Schlüssel hinzufügen/löschen Geht es um das Einfügen neuer Schlüssel, bieten sich zwei Varianten an: ■ CreateKey ■ OpenKey

406

Kapitel 8

Dateien/Streams

Während Sie mit der Methode CreateKey lediglich einen neuen Schlüssel anlegen können, besteht bei OpenKey die Alternative, einen Schlüssel zu öffnen oder neu anzulegen. Gleichzeitig wird der Schlüssel als CurrentKey gesetzt, d.h., neue Schlüssel werden relativ zu diesem Schlüssel angelegt. Der zweite Parameter von OpenKey entscheidet darüber, ob ein Schlüssel erzeugt wird, falls er noch nicht existiert (True). BEISPIEL: Auswahl von HKEY_CLASSES_ROOT als Root und Anlegen eines Schlüssels ".aaa" mit weiteren

Untereinträgen: regist.RootKey := HKEY_CLASSES_ROOT; regist.OpenKey('.aaa',True); regist.CreateKey('test1\test2\test3');

Die folgende Abbildung zeigt das Resultat obiger Anweisungen:

Wie Sie sehen, ist es problemlos möglich, gleichzeitig mehrere Schlüssel anzulegen. Geht es darum, einen Schlüssel zu löschen, genügt ein Aufruf der Methode DeleteKey, um den gesamten Teilbaum, d.h. auch untergeordnete Schlüssel mit den zugehörigen Werten, zu eliminieren. regist.RootKey := HKEY_CLASSES_ROOT; regist.deletekey('.aaa')

Werte hinzufügen, auslesen Wie schon erwähnt, können Sie in der Registry Daten in verschiedenen Formaten speichern. Während die Verwendung von API-Funktionen in diesem Zusammenhang recht aufwändig ist, bietet Delphi folgende, recht einfach zu bedienende Methoden: ■ WriteCurrency ■ WriteBinaryData ■ WriteBool ■ WriteDate ■ WriteDateTime ■ WriteFloat ■ WriteInteger ■ WriteString ■ WriteTime

8.8 Die Registrierdatenbank

407

Übergabeparameter ist neben dem Namen der eigentliche Wert. regist.OpenKey('SOFTWARE\DOKO\Delphi-Buch\14.0',true); regist.WriteInteger('Test-Integer',294791524); regist.WriteString('Programm-ID','45-1246-31-2012');

Das Resultat:

8.8.5 Dateiverknüpfungen erzeugen Unterstützt Ihre Anwendung einen bestimmten Dateityp (.DB, .XLS etc.), ist es sinnvoll, wenn Sie dem Anwender ein entsprechendes Kontextmenü zur Verfügung stellen:

Unterstützen können Sie ■ Open (Öffnen) ■ Print (Drucken) ■ Print To indem Sie die Registry um entsprechende Einträge erweitern.

408

Kapitel 8

Dateien/Streams

Die Variante "Print To" haben Sie sicherlich noch in keinem Kontextmenü gefunden, handelt es sich doch um die Aktion, die ausgeführt wird, wenn ein Dokument mittels Drag & Drop auf ein Druckersymbol gezogen wird. Folgende Einträge müssen Sie in der Registry vornehmen (Beispiel Metafiles): 01: 02: 03: 04: 05: 06:

HKEY_CLASSES_ROOT\.wmf = metafile HKEY_CLASSES_ROOT\metafile = Windows Metafile HKEY_CLASSES_ROOT\metafile\DefaultIcon = c:\delphi\project1.exe,0 HKEY_CLASSES_ROOT\metafile\shell\open\command = project1.exe %1 HKEY_CLASSES_ROOT\metafile\shell\print\command = project1.exe /p %1 HKEY_CLASSES_ROOT\metafile\shell\printto\command = project1.exe /p %1

Zeile 1 definiert den Zusammenhang zwischen Extension und Registry-Einträgen. Zeile 2 stellt eine kurze Beschreibung des Eintrags dar. Die Angabe DefaultIcon ist optional, es handelt sich um den Index des Icons, das dem Dokument zugeordnet wird. Der Eintrag "...\shell\open\command" beschreibt die Aufrufkonventionen für die Anzeige des Dokuments. Analog dazu werden mit "...\print\command" bzw. "...\printto\command" die Aufrufparameter für den Druck des Dokuments festgelegt. HINWEIS: Bei allen Einträgen sind die Werte im Feld "Default" gespeichert, es gibt keine weite-

ren Feldeinträge. Die Umsetzung des oben genannten Beispiels als Delphi-Programm: regist := TRegistry.Create; regist.RootKey := HKEY_CLASSES_ROOT; regist.OpenKey('.wmf',True); regist.WriteString('','metafile'); regist.CloseKey; regist.OpenKey('metafile',True); regist.WriteString('','Windows Metafile'); regist.CloseKey; regist.OpenKey('metafile\DefaultIcon',True); regist.WriteString('','c:\delphi\project1.exe,0'); regist.CloseKey; regist.OpenKey('metafile\shell\open\command',True); regist.WriteString('','project1.exe %1'); regist.CloseKey; regist.OpenKey('metafile\shell\print\command',True); regist.WriteString('','project1.exe /p %1'); regist.CloseKey; regist.OpenKey('metafile\shell\printto\command',True); regist.WriteString('','project1.exe /p %1'); regist.CloseKey;

8.9 Dateidialoge

409

Das Resultat in der Registry:

Wenn Sie die Funktionen ausprobieren und die Ergebnisse mit dem Registrierungseditor kontrollieren wollen, müssen Sie die Anzeige nach jeder der oben genannten Funktionen aktualisieren (F5). PS: Für alle Unverbesserlichen bietet sich das Objekt TRegIniFile an, das zwar wie TInifile funktioniert, aber statt einer INI-Datei einen Schlüssel mit den entsprechenden Werten unter HKEY_CURRENT_USER in der Registry anlegt. Zum Thema "INI-Dateien" finden Sie in Abschnitt 8.7 weitere Informationen.

8.9 Dateidialoge Im Zusammenhang mit der Dateiarbeit bleibt es nicht aus, dass der Programmnutzer Dateinamen eingeben muss, Verzeichnisse wechselt etc. Unter Delphi bieten sich vier verschiedene Möglichkeiten an: ■ Verwenden der Standarddialoge, die Windows bereitstellt ■ Programmieren eigener Dialogboxen mit Komponenten ■ Programmieren eigener Komponenten basierend auf TTreeView ■ Verwendung von Dialogboxen der Windows-Shell Für "einfache" Aufgaben sollten Sie die Standarddialoge einsetzen. Der Vorteil: Diese Dialoge sind dem Anwender bereits von anderen Windows-Applikationen vertraut. Möchten Sie aber eine Dateivorschaufunktion integrieren, ist es sicher sinnvoller, eine eigene Dialogbox zu programmieren.

8.9.1 Eigene Dateidialoge erstellen Wollen Sie eigene Dateidialoge erstellen, brauchen Sie nicht bei null anzufangen. Alle Controls, die zu einer "richtigen" Dialogbox gehören, werden seit langem auch von Delphi unterstützt und finden sich auf der "Win 3.1"-Seite der Komponentenpalette inmitten anderer "Veteranen":

410

Kapitel 8

Dateien/Streams

Komponente

Beschreibung

FileListbox

... Anzeige von Dateien/Verzeichnissen, die Dateiattribute können frei gewählt werden.

DirectoryListbox ... Anzeige des Verzeichnisbaums. DriveCombobox ... Anzeige aller verfügbaren Laufwerke (inklusive Netz). FilterCombobox ... Vorgabe von Filterausdrücken (*.*, *.bmp ...). Die sinnvolle Auswahl von Eigenschaften macht fast jede Zeile Code überflüssig, mit wenigen Mausklicks ist die komplette Logik erstellt. HINWEIS: Sowohl Label, Edit als auch der Filter sind nicht unbedingt nötig, auf die anderen

Komponenten werden Sie aber kaum verzichten können. Für einen Dateibetrachter eignet sich das OnChange- oder das OnClick-Ereignis am besten. Soll eine Datei geladen werden, verwenden Sie das OnDblClick-Ereignis. DirList DriveComboBox

DirectoryListbox DirLabel

Label FileList

DirLabel

FileListBox FilterComboBox

FileList

Edit

8.9 Dateidialoge

411

8.9.2 Standard-Dialogboxen Noch einfacher als mit oben genannten Einzelkomponenten geht es mit den Standard-Dateidialogen, welche die Windows-Ressourcen direkt anzapfen und die Sie auf der Seite "Dialoge" der Komponentenpalette finden. Ihre eigenen Programmschöpfungen erhalten damit die gleichen Dateidialoge wie auch andere "professionelle" Windows-Applikationen. Die Bedienoberfläche bleibt konsistent, womit das angestrebte Prinzip der "einheitlichen Nutzerführung unter Windows" gemeint ist.

SaveDialog Haben Sie die Eigenschaften (siehe unten) festgelegt, genügt meist der folgende Aufruf, um eine Dialogbox zu erzeugen. Über die FileName-Eigenschaft können Sie den gewählten Dateinamen abfragen. var dateiName :string; begin if SaveDialog1.Execute then dateiName:= SaveDialog1.FileName else dateiName:= '' end;

412

Kapitel 8

Dateien/Streams

OpenDialog Das äußere Erscheinungsbild des Standarddialogs "Öffnen" entspricht fast 100%ig dem zum "Speichern unter", nur einige Beschriftungen haben sich geändert.

Optionen Folgende Einstellungen der Options-Eigenschaft sollten Sie beim Sichern-/Laden-Dialog berücksichtigen: Option

Beschreibung

OFAllowMultiSelect

Im Dateinamen-Listenfeld ist eine Mehrfachauswahl möglich (mittels Maus oder Shift+Cursortasten). Die FileName-Property enthält dann den Dateinamen.

OFCreatePrompt

Eine MessageBox erscheint, wenn der Benutzer einen nicht existierenden Dateinamen eingegeben hat.

OFFileMustExist

Der Benutzer kann nur die Namen von existierenden Dateien eingeben, andernfalls erfolgt eine Warnung.

OFHideReadOnly

...versteckt die "Schreibgeschützt"-CheckBox.

OFNoChangeDir

Das aktuelle Verzeichnis entspricht dem aktuellen Verzeichnis beim Öffnen der Dateibox.

OFNoReadOnlyReturn

Es werden keine schreibgeschützten Dateien angezeigt.

413

8.10 Lernbeispiele für Einsteiger

Option

Beschreibung

OFNoValidate

Unzulässige Zeichen im zurückgegebenen Dateinamen sind erlaubt.

OFOverwritePrompt

Die Dialogbox "Speichern unter" generiert eine Message-Box, wenn die selektierte Datei bereits existiert. Der Nutzer muss entscheiden, ob diese Datei überschrieben werden soll.

OFPathMustExist

Der Nutzer darf nur gültige Pfadnamen eingeben, andernfalls erscheint eine Warnung.

OFReadOnly

Die "Schreibgeschützt"-Checkbox erscheint mit Kreuzchen.

HINWEIS: Standardmäßig sind alle Optionen deaktiviert. BEISPIEL: Sinnvolle Optionen zum Laden: OpenDialog1.Options := [ofPathMustExist,ofFileMustExist]

BEISPIEL: Sinnvolle Optionen zum Sichern: SaveDialog1.Options := [ofOverwritePrompt,ofPathMustExist]

Ein weiteres Anwendungsbeispiel finden Sie unter 8.10.1. Wie man die Dialoge in eine etwas umfangreichere Applikation einbindet, erfahren Sie in 16.1 ("TEXTVERARBEITUNG").

8.10 Lernbeispiele für Einsteiger 8.10.1 Drucken einer Textdatei Geht es darum, lediglich ein paar Textzeilen zu Papier zu bringen, dürften Sie mit den QuickReport-Komponenten (siehe Kapitel 9) "mit Kanonen nach Spatzen schießen". Ein paar Methodenaufrufe genügen, um eine Textdatei auszudrucken (es könnte sich auch um eine Stringliste oder um ein Array handeln).

Oberfläche Außer den zwei Buttons brauchen wir die OpenDialog-Komponente (Seite "Dialoge" der Komponentenpalette):

414

Kapitel 8

Dateien/Streams

Quelltext Binden Sie zu Beginn des implementation-Abschnitts als Erstes die Unit Printers ein, sonst haben Sie keinen Zugriff auf das Printer-Objekt. uses Printers; {$R *.DFM} const maxZeilen = 60; // Zeilen pro Seite textHoehe = 40; // 4 mm linkerRand = 200; // 20 mm

Und los geht's: procedure var w,v : OUTDC f zeile txt

TForm1.Button1Click(Sender: TObject); TSize; : HDC; : Textfile; : Integer; : string;

Das folgende Listing fällt etwas umfangreicher aus, da wir uns die Mühe machen, das Druckerkoordinatensystem anzupassen (1/10 Millimeter). Doch bevor es so weit ist, wählen wir mit Hilfe der Datei-Dialogbox eine Datei aus: begin if OpenDialog1.Execute then begin AssignFile(f,OpenDialog1.Filename);

Öffnen der Datei: Reset(f);

Initialisieren des Druckers (Millimeter): Printer.BeginDoc; outDC := Printer.Canvas.Handle; SetMapMode(OutDC,mm_lometric); // 1/10 mm, aber Y geht nach oben GetWindowExtEx(OutDC,w); // Auflösung ermitteln GetViewportExtEx(OutDC,v); SetMapMode(OutDC,MM_ANISOTROPIC); // neuer Abb.-Modus SetWindowExtEX(OutDC,w.cx,w.cy,nil); // Skalierung ... SetViewPortExtEx(OutDC,v.cx,-v.cy,nil);

Einstellen der Schriftart, -farbe und -größe: Printer.Canvas.Font.Name := 'Courier New'; Printer.Canvas.Brush.Color := clWhite; // Hintergrundfarbe Printer.Canvas.Font.Height:= textHoehe; zeile := 0;

Für alle Zeilen in der Datei: while not Eof(f) do begin Inc(zeile); Readln(f,txt);

8.10 Lernbeispiele für Einsteiger

415

if zeile = maxZeilen then begin zeile := 1;

Eventuell Seitenvorschub auslösen, wenn die maximale Zeilenanzahl erreicht wurde: Printer.NewPage end;

Die Kopfzeile drucken: if zeile = 1 then begin // Kopfzeile erzeugen Printer.Canvas.Font.Style := [fsBold]; Printer.Canvas.TextOut(linkerRand,0,OpenDialog1.filename + ' / Seite: ' + IntToStr(Printer.PageNumber)); Printer.Canvas.Font.Style := [] end;

Die eigentliche Ausgabezeile: Printer.Canvas.TextOut(linkerRand, zeile * (textHoehe + 3), txt) end; CloseFile(f); Printer.EndDoc end end;

Test Starten Sie das Programm, öffnen Sie eine *.TXT-Datei, und schon wird Ihr Drucker loslegen!

Bemerkungen ■ Das Programm an andere Aufgabenstellungen anzupassen dürfte nicht allzu schwierig sein, zumal das neue Koordinatensystem eine vollständig systemunabhängige Ausgabe garantiert. ■ Um auch anderen Applikationen diese schnelle und bequeme Druckmöglichkeit zur Verfügung zu stellen, empfiehlt sich dafür das Anlegen einer eigenen Unit.

8.10.2 Ermitteln des freien Diskettenspeichers Für den Programmierer ist häufig auch der frei verfügbare Festplattenspeicher interessant. Das folgende kleine Beispielprogramm zeigt, wie Sie sowohl den gesamten verfügbaren als auch den freien Speicher bestimmen und anzeigen können.

Oberfläche Die Oberfläche besteht aus einer DriveComboBox zur Auswahl des aktuellen Laufwerks, zwei Labels zur Anzeige der Messwerte sowie einer Gauge-Komponente (siehe Laufzeitansicht).

416

Kapitel 8

Dateien/Streams

Quelltext Der einzige Quelltext, den Sie hinzufügen müssen, ist mit dem DriveComboBox-Click-Event verknüpft. Im Wesentlichen geht es darum, den ersten Buchstaben (den Laufwerksbuchstaben) aus dem zurückgegebenen String zu extrahieren. Diesen wandeln Sie mit der Funktion Ord in den ANSI-Wert um, da die Funktionen DiskFree und DiskSize als Übergabewert die Nummer des Laufwerks benötigen (0 = aktuelles Laufwerk, 1 = Lw. A:, 2 = Lw. B: ...). procedure TForm1.DriveComboBox1Click(Sender: TObject); var s : string[255]; frei, gesamt: Double; begin s := UpperCase(DriveCombobox1.Drive); frei := DiskFree(Ord(s[1])-64); gesamt:= DiskSize(Ord(s[1])-64); Label1.Caption := Format('Frei : %12.0n',[frei]); Label2.Caption := Format('Gesamt: %12.0n',[gesamt]); Gauge1.Progress :=Round((gesamt-frei)/gesamt*100) end;

Für die Ausgabe wurden die Werte in Prozent umgerechnet.

Test Starten Sie das Programm und probieren Sie die Funktion aus.

Testen Sie, was passiert, wenn Sie auf ein nicht verfügbares Laufwerk zugreifen.

8.10.3 Speichern von Records in einer typisierten Datei Im Beispiel 2.9.1 haben Sie gelernt, wie man Records in einem statischen Array speichern kann. Leider waren alle mühselig eingegebenen Personendaten nach dem Ausschalten des Rechners futsch.

417

8.10 Lernbeispiele für Einsteiger

In diesem Beispiel wird Ihnen gezeigt, wie man die Personendaten in einer typisierten Datei ablegt, so dass sie bei einem Neustart des Programms wieder zur Verfügung stehen.

Oberfläche Die Oberfläche entspricht 100%ig dem oben genannten Beispiel.

Quellcode Ergänzen Sie den Private-Abschnitt von TForm1 mit sechs neuen Methodendeklarationen: type TForm1 = class(TForm) ... private { Private-Deklarationen } procedure dsInit; procedure dsSpeichern; procedure dsAnzeigen; procedure dateiNeu; procedure dateiSchreiben; procedure dateiLesen; public { Public-Deklarationen } end; var Form1: TForm1;

// // // // // //

nutzerdef. Methode zum Initialisieren aller DS dto. zum Speichern eines Datensatzes dto. zum Anzeigen nutzerdef. Methode zum Anlegen einer typ. Datei dto. zum Abspeichern aller DS in die Datei dto. zum Lesen

Im implementation-Abschnitt gibt es allerhand zu tun: const pmax = 10; // max. Anzahl von Personen = Größe des Arrays type TPerson = record // Typ der Strukturvariablen name: string[20]; // max. 20 Buchstaben geburt: TDateTime; // Geburtsdatum geschlecht: Boolean; // männlich = True, weiblich = False nr: Integer // Telefonnummer end; var personen: array[1..pmax] of TPerson; // Array-Variable index: Byte = 1; // aktueller Feldindex (initialisierte Variable)

418

Kapitel 8

Dateien/Streams

var f: File of TPerson; verz: string;

Die Implementierung der speicherspezifischen Methoden: procedure TForm1.dsInit; // setzt alle Personen auf Standardwerte var i: Integer; begin for i := pmax downto 1 do with personen[i] do begin name := ''; geburt := StrToDate('31.12.99'); geschlecht := False; nr := 9999999 end end; procedure TForm1.dsSpeichern; // Anzeige => Speicher begin personen[index].name := Edit1.Text; if Edit2.Text <> '' then personen[index].geburt := StrToDate(Edit2.Text); personen[index].geschlecht := CheckBox1.Checked; personen[index].nr := StrToInt(Edit3.Text) end; procedure TForm1.dsAnzeigen; // Speicher => Anzeige begin Label1.Caption := IntToStr(index); // Index anzeigen Edit1.Text := personen[index].name; Edit2.Text := DateToStr(personen[index].geburt); CheckBox1.Checked := personen[index].geschlecht; Edit3.Text := IntToStr(personen[index].nr) end;

Die Bewegungsmethoden: procedure TForm1.Button3Click(Sender: TObject); // vorwärts (>) begin if index < pmax then begin dsSpeichern; Inc(index); dsAnzeigen end end; procedure TForm1.Button2Click(Sender: TObject); // rückwärts (<) begin if index > 1 then begin dsSpeichern; Dec(index); dsAnzeigen end end;

Die Implementierung der dateispezifischen Methoden: procedure TForm1.dateiNeu; begin {$I-} Rewrite(f); {$I+} // legt neue Datei an und öffnet sie if IOResult <> 0 then ShowMessage('Fehler beim Erzeugen der neuen Datei!');

419

8.10 Lernbeispiele für Einsteiger

dsInit

// alle Felder initialisieren

end;

Obige IOResult-Abfrage nach dem Reset ist erforderlich, da eine nicht vorhandene Datei sonst keinen Fehler verursachen würde (der Compilerschalter $I- ist deaktiviert, um einen Programmabsturz zu verhindern). procedure TForm1.dateiSchreiben; var i: Integer; begin {$I-} Reset(f); {SI+} if IOResult <> 0 then ShowMessage('Fehler beim Speichern!'); for i := pmax downto 1 do Write(f,personen[i]) end; procedure TForm1.dateiLesen; var i: Integer; begin {$I-} Reset(f); {SI+} if IOResult <> 0 then ShowMessage('Fehler beim Lesen!'); for i := pmax downto 1 do Read(f, personen[i]) // Datensätze einlesen end;

Der Programmstart gestaltet sich etwas aufwändig, da hier auch das Öffnen bzw. Neuanlegen einer Datei mit dem Namen Personen.dat erfolgt. Diese befindet sich im Anwendungsverzeichnis: procedure TForm1.FormCreate(Sender: TObject); var i: Integer; begin verz := ExtractFilePath(ParamStr(0)) + 'Personen.dat'; // aktuelles Verzeichnis AssignFile(f, verz); // Zuordnen des Dateiverzeichnisses zur Dateivariablen {$I-} Reset(f); {SI+} // Versuch, die Datei zu öffnen, if IOResult <> 0 then // wenn keine Datei da ist begin MessageBeep(0); i := Application.MessageBox('Die Personendatei befindet' + #10#13 + 'sich nicht im aktuellen Verzeichnis!' + #10#13 + 'Soll sie neu angelegt werden?','Datei nicht gefunden!', 52); if i = 6 then dateiNeu else Halt // Ja-Button oder Programmabbruch end else dateiLesen; // wenn Datei vorhanden ist // bei vorhandener oder neuer Datei: dsAnzeigen; // ersten Datensatz anzeigen Form1.Caption := verz // Anzeige Dateipfad in Titelleiste des Formulars end;

Die im statischen Array abgespeicherten Datensätze können bei Programmende in die Datei geschrieben werden:

420

Kapitel 8

Dateien/Streams

procedure TForm1.Button5Click(Sender: TObject); // Beenden var i: Integer; begin MessageBeep(0); i := Application.MessageBox('Soll die Personendatei gespeichert werden?','Frage', 36); if i = 6 then // Ja-Button gedrückt begin dsSpeichern; // aktuellen Datensatz sichern dateiSchreiben end; CloseFile(f); Close end;

Test Falls keine Datei Personen.dat im Anwendungsverzeichnis gefunden wird, so legt das Programm auf Wunsch eine neue Datei an. Sie können max. zehn Personen eingeben. Nach Beenden und erneutem Starten des Programms sollten alle Datensätze wieder angezeigt werden.

Bemerkungen ■ Wenn Sie das Formular nicht über den "Beenden"-Button schließen, gehen die vorgenommenen Änderungen verloren. Ein Ausweg bietet sich durch Verwendung des OnClose-Events. ■ Wenn Sie das Programm durch eine OpenDialog- und eine SaveDialog-Komponente ergänzen, können Sie beliebige Dateinamen und Verzeichnisse verwenden.

8.11 Praxisbeispiele für Fortgeschrittene

421

8.11 Praxisbeispiele für Fortgeschrittene 8.11.1 Speichern von Variablenwerten in einem FileStream Die Arbeit mit Filestreams ist gewöhnungsbedürftig, erfordert sie doch eine objektorientierte Vorgehensweise. Praktischer Hintergrund dieser Übung ist das Sichern der Werte einer Eingabemaske, so dass diese nach Programmstart wieder zur Verfügung stehen.

Oberfläche Die nachfolgende Laufzeitabbildung steht als Beispiel für eine beliebige Eingabemaske und dürfte selbst erklärend sein.

Quelltext In den implementation-Abschnitt von Unit1 kopieren Sie: type TFahrzeugdaten = record kennzeichen: string[10]; zulassung: TDateTime; verbrauch: Single; km: Word; bemerkung: string[80] end;

Halt, wir wollen nicht in eine typisierte Datei, sondern in ein FileStream-Objekt abspeichern!

422

Kapitel 8

Deshalb werden Sie im Folgenden nicht var f: File of TFahrzeugdaten;

vorfinden, sondern die datentypneutrale Deklaration einer Objektreferenz: var fStream: TFileStream;

Wir wollen drei unterschiedliche Datentypen nacheinander speichern und lesen: fDat: TFahrzeugdaten; fStrecke: string[40]; fZeit: TDateTime;

// Puffervariable // dto. // dto.

In den Stream abspeichern: procedure TForm1.Button1Click(Sender: TObject); var code: Integer; begin with fDat do begin kennzeichen := Edit1.Text; zulassung := StrToDate(Edit2.Text); Val(Edit3.Text, verbrauch, code); km := StrToInt(Edit4.Text); bemerkung := Edit5.Text end; fStrecke := Edit6.Text; fZeit := StrToTime(Edit7.Text);

Nachdem nun die verschiedenen Puffervariablen gefüllt sind, kann es losgehen: with fStream do begin Position := 0;

// zurücksetzen (immer erforderlich!)

Die Puffer nacheinander in den Stream schreiben: WriteBuffer(fDat, SizeOf(fDat)); WriteBuffer(fStrecke, SizeOf(fStrecke)); WriteBuffer(fZeit, SizeOf(TDateTime)) end end;

Der Button "Von Stream lesen": procedure TForm1.Button2Click(Sender: TObject); begin

Die Reihenfolge beim Schreib- und Lesezugriff muss übereinstimmen: with fStream do begin Position := 0;

// akt. Posit. im Stream zurücksetzen

Stream variablenweise in die Puffer einlesen: ReadBuffer(fDat,SizeOf(fDat)); ReadBuffer(fStrecke, SizeOf(fStrecke));

Dateien/Streams

8.11 Praxisbeispiele für Fortgeschrittene

423

ReadBuffer(fZeit, SizeOf(TDateTime)) end;

Die drei Datenpuffer sind gefüllt, jetzt kann ihr Inhalt angezeigt werden: with fDat do begin Edit1.Text := kennzeichen; Edit2.Text := DateToStr(zulassung); Edit3.Text := Format('%.1f',[verbrauch]); // nur eine Nachkommastelle anzeigen Edit4.Text := IntToStr(km); Edit5.Text := bemerkung end; Edit6.Text := fStrecke; Edit7.Text := TimeToStr(fZeit) end;

Der Rest ist Routine, zunächst der Button "Anzeige löschen", damit wir beim nachfolgenden Einlesen sicher sind, dass die Daten tatsächlich von der Festplatte kommen: procedure TForm1.Button4Click(Sender: TObject); begin Edit1.Text := ''; Edit2.Text:=''; Edit3.Text:=''; Edit4.Text := ''; Edit5.Text:=''; Edit6.Text:= ''; Edit7.Text:='' end;

Das Formular wird geladen: procedure TForm1.FormCreate(Sender: TObject); begin try fStream := TFileStream.Create('testStream', fmOpenReadWrite);

Obige Anweisung war ein "Versuch", die Datei testStream für den Lese-/Schreibzugriff zu öffnen und davon ein FileStream-Objekt zu bilden. Bei Fehlschlag wird im Folgenden eine Instanz mit neuer (leerer) Datei angelegt. except fStream := TFileStream.Create('testStream', fmCreate) end; Button4Click(Self) // zu Beginn Anzeige säubern end;

Der Kehraus beim Schließen der Anwendung: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin fStream.Free // zum Schluss Objekt freigeben end;

Test Nach Programmstart begrüßt Sie eine leere Eingabemaske. Füllen Sie diese und klicken Sie "In Stream speichern". Dann löschen Sie die Anzeige, und nach "Von Stream lesen" dürften die Werte wieder da sein.

424

Kapitel 8

Dateien/Streams

8.11.2 Arbeiten mit Memory Mapped Files Für unser Beispiel wollen wir eine Datei verschlüsseln1. Wie immer besteht natürlich die Forderung nach einer möglichst schnellen Variante, und die dürfte durch die Verwendung eines Memory Mapped Files erfüllt sein.

Oberfläche Außer einem Button benötigen wir noch eine OpenFileDialog-Komponente, mit deren Hilfe wir zur Laufzeit eine Datei auswählen können.

Quelltext Auf den verwendeten Chiffrieralgorithmus wollen wir an dieser Stelle nicht weiter eingehen, für uns steht die Dateiverwaltung im Vordergrund. Nur so viel: Ein aus dem ursprünglichen Schlüssel erzeugter Schlüsselbytestrom wird mit dem eigentlichen Datenstrom aus der Datei XOR verknüpft. Da der Schlüssel bis zu 256 Bytes umfassen kann, wird dieser in einer externen Datei gespeichert. Zum Laden dieser Datei verwenden wir die folgende Funktion, die mit einem FileStream den Zugriff auf die Datei key.dat ermöglicht: function KeyLaden : Boolean; var keyFile : TFileStream; i,j,n : Byte; begin try keyFile:= TFileStream.Create('key.dat',fmOpenRead); keyFile.Read(key,256); keyFile.Free; result := True; for i := 0 to 255 do sbox[i] := i; j := 0; for i := 0 to 255 do begin j := (j + sbox[i] + key[i]) MOD 256; n := sbox[i]; sbox[i] := sbox[j]; sbox[j] := n; end; except 1

Bitte benutzen Sie nicht gleich Ihre wichtigsten Dateien als Versuchsobjekte. Die Autoren übernehmen keinerlei Haftung für eventuell "dauerhaft" verschlüsselte Daten.

8.11 Praxisbeispiele für Fortgeschrittene

425

result := False end end;

Nachfolgend wird der geladene Schlüssel noch einmal verwürfelt1. Die eigentliche Funktion fällt unerwartet kurz aus: procedure TForm1.Button1Click(Sender: TObject); var FData : Pointer; fileSize : LongInt; FileHandle, MapHandle : THandle; p : ^Byte; i,j,n : Byte; begin if not OpenDialog1.Execute then Exit; if not keyladen then Exit;

Ein erster Versuch, die Datei exklusiv für den Schreib-/Lesezugriff zu öffnen (während der Verschlüsselung soll kein anderer Nutzer mit der Datei arbeiten): FileHandle := FileOpen(OpenDialog1.Filename, fmOpenReadWrite + fmShareDenyNone);

Falls ein Fehler auftritt, lösen wir eine Exception aus: if FileHandle = INVALID_HANDLE_VALUE then Raise Exception.Create('Datei kann nicht geöffnet werden');

Die Größe der Datei merken wir uns in der Variablen filesize: FileSize := GetFileSize (Filehandle, nil);

Mit CreateFileMapping erstellen wir ein FileMapping-Objekt (Schreib-/Lesezugriff wie bei FileOpen). MapHandle := CreateFileMapping(FileHandle,nil,PAGE_READWRITE,0,0,nil); if MapHandle = 0 then begin CloseHandle(FileHandle); Raise Exception.Create('Fehler beim Filemapping') end;

Das eigentliche Einblenden in den Adressraum der Anwendung: FData := MapViewOfFile(MapHandle,FILE_MAP_WRITE,0,0,0);

Rückgabewert ist im Erfolgsfall ein Pointer auf den Datenbereich. Wie groß dieser ist, bestimmt die zugrunde liegende Datei (Variable fileSize). if FData = nil then begin 1

Ist eigentlich nur nötig, wenn der Schlüssel kleiner als 256 Byte ist. In diesem Fall würde der Schlüssel mehrfach in die SBox übernommen werden.

426

Kapitel 8

Dateien/Streams

CloseHandle(MapHandle); Raise Exception.Create('Fehler beim Filemapping') end;

Alle weiteren Arbeitsschritte unterscheiden sich nicht mehr von der Arbeit mit einem ganz normalen Speicherbereich, mit dem kleinen Unterschied, dass jede Veränderung dieses Speichers sich auf die physische Datei auswirkt. p := FData; i := 0; j := 0;

Das Durchlaufen der einzelnen Datenbytes realisieren wir durch das Inkrementieren des Pointers: while FileSize > 0 do begin i := (i+1) MOD 256; j := (j + sbox[i]) MOD 256; n := sbox[i]; sbox[i] := sbox[j]; sbox[j] := n; p^ := p^ XOR (sbox[(sbox[i]+sbox[j]) MOD 256]); Dec(FileSize); Inc(P) end;

Zum Schluss sollte noch aufgeräumt werden: UnmapViewOfFile(FData); CloseHandle(MapHandle); CloseHandle(FileHandle) end;

Test Starten Sie das Programm und wählen Sie eine Datei zum Verschlüsseln. Mit einem Texteditor (Notepad.exe) können Sie das Ergebnis betrachten. Entschlüsseln können Sie die Datei auf dem gleichen Weg.

8.11.3 Dateien suchen und Attribute auswerten In der Unit SysUtils sind auch die Funktionen FindFirst und FindNext enthalten, mit denen man dem Problem der Dateisuche auf den Leib rücken kann.

Oberfläche Neben einer Edit-Komponente brauchen wir acht Panels und zwei Schaltflächen. Es erleichtert den späteren Programmtest, wenn Sie der Text-Eigenschaft von Edit1 einen gültigen Suchpfad zuweisen (siehe Laufzeitansicht am Schluss).

8.11 Praxisbeispiele für Fortgeschrittene

427

Quelltext Im interface-Abschnitt von Unit1 erweitern wir die Typdeklaration von TForm1 um eine private Methode, die sich um die Anzeige der Dateiattribute kümmert: private procedure display; ...

Wir hätten display natürlich auch als einfache lokale Prozedur implementieren können, aber mit der gewählten Variante können wir einfacher auf die Felder von TForm1 zugreifen (anstatt Form1.Panel1 braucht z.B. nur noch Panel1 geschrieben zu werden, s.u.). Nun zum implementation-Abschnitt: Die Funktionen FindFirst und FindNext verlangen einen strukturierten Übergabeparameter vom Typ TSearchRec: var searchRec: TSearchRec;

Die display-Methode: procedure TForm1.display; var dat: TDateTime; begin with searchRec do begin Panel1.Caption := Name; Panel2.Caption := IntToStr(Size) + ' Byte';

Bei weitem nicht so harmlos gestaltet sich das Auslesen des Datums-/Zeitstempels, der noch das alte DOS-Format (Integer) aufweist. Die Delphi-Hilfe zu TSearchRec schweigt sich galant zu diesem wahrscheinlich heiklen Thema aus, und erst nach längerem Suchen kommt man auf die rettende Funktion: dat := FileDateToDateTime(Time);

Auch das folgende FormatDateTime sollte man keinesfalls durch DateTimeToStr ersetzen, da man sonst höchst unangenehme Überraschungen mit dem Jahr 2000 erleben kann. Panel3.Caption := FormatDateTime('d/m/yyyy h:nn', dat);

Durch bitweise UND-Verknüpfung werden nun die einzelnen Dateiinformationen aus searchRec.Attr herausgefiltert und durch Hervorhebung angezeigt: if (Attr AND faReadOnly) = faReadOnly then Panel4.Font.Style := [fsUnderline, fsBold] else Panel4.Font.Style := []; if (Attr AND faHidden) = faHidden then Panel5.Font.Style := [fsUnderline, fsBold] else Panel5.Font.Style := []; if (Attr AND faSysFile) = faSysFile then Panel6.Font.Style := [fsUnderline, fsBold] else Panel6.Font.Style := []; if (Attr AND faArchive) = faArchive then

428

Kapitel 8

Dateien/Streams

Panel7.Font.Style := [fsUnderline, fsBold] else Panel7.Font.Style := []; if (Attr AND faDirectory) = faDirectory then Panel8.Font.Style := [fsUnderline, fsBold] else Panel8.Font.Style := []; end end;

Der Button "Suche starten": procedure TForm1.Button1Click(Sender: TObject); begin if FindFirst(Edit1.Text, faAnyFile, searchRec) = 0 then begin display; Button2.Enabled := True end else begin Beep; ShowMessage('Nichts gefunden!'); Button2.Enabled := False end end;

Der Button "Suche fortsetzen": procedure TForm1.Button2Click(Sender: TObject); begin if (FindNext(searchRec) = 0) then display end;

Test Starten Sie das Programm und geben Sie einen gültigen Pfadnamen und einen Platzhalter für Dateinamen und Dateiextension ein, z.B. D:\Programme\*.*. Klicken Sie dann "Suche beginnen" und anschließend "Suche fortsetzen". Die jeweils zutreffenden Dateiattribute werden rechts durch Unterstreichung und Fettschrift angezeigt:

Falls die Meldung "Nichts gefunden!" erscheint, existiert der von Ihnen eingegebene Pfadname nicht.

8.11 Praxisbeispiele für Fortgeschrittene

429

8.11.4 Kopieren von Dateien Leider haben die Borland-Entwickler Delphi keine Routine zum Kopieren von Dateien "spendiert". Die im Folgenden vorgestellten drei Funktionen erfüllen diese Aufgabe auf jeweils andere Weise.

Oberfläche Zum bequemen Vergleich der drei Methoden können Sie eine Testoberfläche entsprechend folgender Laufzeitabbildung verwenden. Zur Auswahl der Quelldatei dienen DriveComboBox1, DirectoryListBox1 und FileListBox1 (siehe Seite "Win 3.1" der Komponentenpalette), das Zielverzeichnis soll mit DriveComboBox2 und DirectoryListBox2 (rechts) eingestellt werden.

Quelltext (Variante 1: BlockRead/BlockWrite) Um den Arbeitsspeicher nicht unnötig zu strapazieren, reservieren wir diesen dynamisch. Übergeben Sie der Variablen bufferSize die Größe des Kopierpuffers. function KopiereDatei(von, nach: string): Boolean; var f1,f2 : File; buffer : Pointer; bufferSize : Integer; gel : Integer; ges : Integer; fehler : Word; i : Word; dateiName : string; begin

430

Kapitel 8

Dateien/Streams

bufferSize := 10000; // Kopierpuffer dateiName := UpperCase(von);

Ist die Datei schon vorhanden, beenden wir an dieser Stelle. Sie können diesen Teil auch abändern, so dass Dateien einfach überschrieben werden. if (FileExists(nach)) then begin result := True; Exit end;

Öffnen der Dateien: AssignFile(f1, von); AssignFile(f2, nach); {$i-} Reset(f1,1); Rewrite(f2,1); {$i+} if ioresult <> 0 then begin Result := False; Exit end; gel:=0; ges:=0;

Versuch, entsprechend viel Speicher zu reservieren: GetMem(buffer, bufferSize);

Kopieren bis zum letzten Byte: repeat; {$i-} BlockRead(f1, buffer^, bufferSize, gel); BlockWrite(f2, buffer^, gel, ges); {$i+} fehler := ioresult;

Systemzeit freigeben: Application.ProcessMessages; until (gel = 0) or (ges <> gel) or (fehler <> 0); if fehler <> 0 then begin FreeMem(buffer,buffersize); result := False; Exit end; CloseFile(f1); CloseFile(f2); FreeMem(buffer, bufferSize);

8.11 Praxisbeispiele für Fortgeschrittene

431

Nur wenn alles gut gegangen ist, liefert die Funktion den Status True zurück: result := True end;

Auf einen Test wird an dieser Stelle verzichtet.

Quelltext (Variante 2: OOP) Wem die obige Variante zu aufwändig ist, der sollte sich einmal mit den Möglichkeiten von OOP vertraut machen. Mit dem Objekt TFileStream bietet sich eine sinnvolle Alternative zur Arbeit mit BlockRead und BlockWrite. Mit Hilfe der Methode CopyFrom ist es relativ einfach möglich, eine Datei zu kopieren. function FileCopy(von,nach: String ): Boolean; var s, d: TFileStream; // Source & Destination begin Result := False; s := TFileStream.Create(von, fmOpenRead ); try d := TFileStream.Create( nach, fmOpenWrite or fmCreate ); except s.Free; Exit end; try d.CopyFrom(s, s.Size ) ; except d.Free; s.Free; Exit end; d.Free; s.Free; result := True end;

Der größte Teil des Codes betrifft noch die Fehlerbehandlung.

Quelltext (Variante 3: API) Zum Schluss wollen wir Ihnen die einfachste Variante nicht vorenthalten: Mit der API-Funktion CopyFile reduziert sich der Aufwand auf den einfachen Funktionsaufruf. Übergabeparameter ist der Name von Quell- und Zieldatei sowie ein boolescher Parameter, ob eine bestehende Datei überschrieben wird oder nicht (True = Nein, False = Ja). Allerdings können Sie während des Kopiervorgangs keinen Fortschrittsbalken ansteuern, da die gesamte Datei mit einem Funktionsaufruf kopiert wird. Nähere Einzelheiten entnehmen Sie dem Quellcode auf der Buch-CD.

Test Kopieren Sie die links ausgewählte Datei in das rechts eingestellte Zielverzeichnis und vergleichen Sie die Performance (Schnelligkeit) der drei Methoden.

9

Datenbankprogrammierung

Kapitel

9

Datenbankprogrammierung Delphi bietet seit seinem Erscheinen 1995 umfassende Möglichkeiten zur Programmierung von Datenbankanwendungen. Von Version zu Version sind neue datenbankspezifische Features hinzugekommen, so dass es unmöglich ist, alles mit der gebotenen Gründlichkeit in einem einzigen Buch zu berücksichtigen. Aus diesem Grunde haben wir den Komplex "Datenbank- und InternetProgrammierung" in einen eigenen Band ausgelagert Allerdings wäre es unfair gegenüber unseren Lesern, würden wir diese hochaktuelle Thematik im vorliegenden Grundlagenband rigoros ausklammern. Deshalb wollen wir hier nach dem Prinzip "so viel wie für den Einstieg nötig" die Grundlagen der Datenbankprogrammierung unter Borland Delphi vermitteln, so dass Sie in die Lage versetzt werden, bereits mit relativ einfachen Mitteln Anwendungen zu erstellen, die sich allerdings ausschließlich auf lokale Datenbanken unter Verwaltung der BDE1 beziehen. Wir beschränken uns dabei auf folgende Themen: ■ Aufbau relationaler Datenbanken ■ Datenbankzugriff mit Bound Controls ■ Datenbankberichte mit Rave Reports Alles, was darüber hinausgeht (SQL, Datenzugriffsobjekte, Client-Server-Netzwerke, Internet, ...), ist Sache der Spezialliteratur, wie z.B. unser Buch [Borland Delphi – Datenbankprogrammierung], das Sie ebenfalls auf der Buch-CD finden. Um Ihnen möglichst schnell Erfolgserlebnisse zu vermitteln, wurde der theoretische Teil dieses Kapitels drastisch zugunsten der Lern- und Praxisbeispiele gekürzt.

9.1 Relationale Datenbanken In diesem Abschnitt geht es lediglich darum, Sie mit den wichtigsten Grundbegriffen vertraut zu machen.

1

Borland Database Engine

434

Kapitel 9

Datenbankprogrammierung

9.1.1 Datenbankformate Durch Delphi werden fast alle gängigen Datenbankformate unterstützt (Paradox 7, Paradox 5.0 für Windows, Paradox 4, Paradox 3.5, Visual dBASE, dBASE für Windows, FOXPRO, MS ACCESS, MS SQL, INFORMIX, SYBASE, ORACLE, ODBC-Datenquellen und andere). Wir werden uns vorrangig auf das Paradox-Format beziehen, die gegenwärtig modernste Version der von Borland direkt unterstützten Datenbankformate. Paradox-Dateien (Tabellen) erkennen Sie an der Extension *.DB. Im Unterschied dazu haben dBASE-Tabellen die Extension *.DBF. Gegenüber den anderen Formaten, vor allem gegenüber dBASE, hat Paradox 7 entscheidende Vorzüge, z.B. können in einem Memofeld unterschiedliche Schriftarten vorkommen, Grafiken und OLEObjekte lassen sich in die Tabellen einbinden, auch eine Eingabekontrolle auf Tabellenebene ist vorgesehen. Außerdem ist die Sicherstellung der so genannten "Referenziellen Integrität" möglich.

9.1.2 Was sind relationale Datenbanken? Datenbanken lassen sich als Sammlung von Informationen bzw. Daten definieren. Ziel ist eine möglichst effiziente Verwaltung dieser Daten. Dies schließt die Aufnahme, Manipulation und Integritätssicherung sowie weitere Funktionen ein. Zu diesem Zweck wurden verschiedene Konzepte (Netzwerkmodell, hierarchisches, relationales Modell etc.) entwickelt, von denen sich in den letzten Jahren das relationale Modell durchgesetzt hat. Relationale Datenbank Datenbank Kunden Nr Name 1

Müller

Nr Maier 1 3 2 4 3 4 5 5 6 6 7 7 8 8 9 9 10 11 10 12 13 14 2

Vorname geb. Personal Heinz 12.3.47 Name Müller Maier Schulz Kohl Schmitt Krause Lindemann Böhm Lehmann Wetzel Becker Hofmann König Winkler

Vorname Heinz Viola Günter Astrid Ines Thomas Edith Ruth Steffi Ines Karin Kristina Jürgen Karin

Datensatz Kunden Müller, Heinz

Personal

Tabelle

In relationalen Datenbanken speichern Sie Ihre Daten in gleichartig aufgebauten Datensätzen, die wiederum in Tabellen organisiert sind. Zwischen mehreren derartigen Tabellen können Beziehungen bestehen (Relationen). Vergleichen Sie eine relationale Datenbank am besten mit einem Aktenschrank. Die einzelnen Fächer für die Kunden und die Mitarbeiter entsprechen den Tabellen, die Karteikarten den einzelnen Datensätzen einer Datenbank. Die Funktion des Registers wird in der Datenbank durch den Index übernommen. In der Literatur finden Sie für die oben genannten Begriffe auch andere Bezeichnungen. Die folgende Aufzählung listet alle verwandten bzw. gleichbedeutenden Begriffe auf:

435

9.1 Relationale Datenbanken

■ Tabelle, Relation, Datei, File ■ Datensatz, Tupel, Zeile, Record ■ Feld, Spalte, Attribut Lassen Sie sich durch die Vielzahl der verwendeten Begriffe nicht verwirren, im Folgenden werden einheitlich nur die fett gedruckten Bezeichnungen benutzt.

9.1.3 Beziehungen zwischen den Tabellen Will man eine "richtige" Datenbankapplikation entwerfen, so kommt es vor allem auf die genaue Kenntnis der Beziehungen (Relationen) zwischen den einzelnen Tabellen an. Wir wollen annehmen, dass wir in unserer Firma die Tabellen "Kunden" und "Rechnungen" haben. Die Beziehungen zwischen diesen beiden Tabellen könnten rein theoretisch wie folgt aussehen: ■ Jedem Kunden ist genau eine Rechnung zugeordnet (1:1-Relation). ■ Jedem Kunden ist keine, eine oder sind mehrere Rechnungen zugeordnet (1:n-Relation). Obwohl das ER-Modell noch weitere Typen kennt, verwenden wir unter Paradox in der Regel nur diese zwei Relationen. Davon ist die 1:n-Beziehung die eindeutig dominierende, da sich Tabellen mit 1:1-Relation auch zu einer einzigen zusammenfassen lassen und nur dann einen Sinn ergeben, wenn nebensächliche Informationen ausgelagert werden sollen. Tabelle A (Kunden)

1

Jedem Datensatz in Tabelle A ist kein, ein oder sind mehrere Datensätze in Tabelle B zugeordnet.

Tabelle B (Rechnungen) n Jeder Datensatz in Tabelle B verweist auf genau einen Datensatz in Tabelle A.

Schlüssel Da in jedem relationalen Modell nur die Daten, nicht aber die Beziehungen (Relationen) zwischen diesen Daten abgespeichert werden, sind zusätzliche Maßnahmen zur Herstellung der Verknüpfungen zwischen den Tabellen erforderlich. Eine zentrale Rolle spielt dabei der so genannte Identifikationsschlüssel oder kurz Schlüssel. Ein solcher Schlüssel (manchmal auch als Hauptschlüssel, Primärschlüssel oder Hauptindex bezeichnet) kann einer Tabelle als Attribut (Feld) zugeordnet sein und muss folgende Bedingungen erfüllen: ■ Jeder Datensatz muss durch den Schlüssel eindeutig identifizierbar sein. ■ Der Schlüssel darf durch Datenbankzugriffe nicht überschrieben werden. Exakt sind diese Forderungen nur mit einem so genannten Künstlichen Schlüssel erfüllbar, z.B. einer laufenden Nummer (Zähler). Warum?

436

Kapitel 9

Datenbankprogrammierung

Attribute (Felder) wie Name, Ort etc. in einer Kunden-Tabelle eignen sich z.B. nicht immer, da sie der ersten Forderung widersprechen, denn es gibt mit Sicherheit mehrere Kunden, die Müller heißen oder aus Berlin stammen. Allerdings sind auch zusammengesetzte Schlüssel möglich, die zwei oder noch mehr Attribute zusammenfassen. Aber leider ist auch hier die Eindeutigkeit nicht 100%ig gegeben, da die Wahrscheinlichkeit, dass es nur einen Müller aus Berlin gibt, alles andere als null ist.

9.1.4 Verknüpfen von Tabellen Indem wir die Tabellen miteinander verknüpfen, stellen wir die Beziehungen zwischen ihnen her. Die folgende Abbildung zeigt dafür als typisches Beispiel eine FIRMA-Datenbank: Kunden (Primärtabelle)

1:n - Beziehung (1 Kunde kann mehrere Rechnungen haben, 1 Rechnung kann nur zu einem Kunden gehören)

1 m:n - Beziehung (1 Rechnung kann mehrere Artikel haben, 1 Artikel kann in mehreren Rechnungen auftreten)

n

Artikel

Rechnungen (Primärtabelle)

m

n

(Primärtabelle)

1

1 1:n - Beziehung

1:n - Beziehung

(1 Artikel kann in mehreren Positionen auftreten, 1 Rechnungsposition kann sich nur auf 1 Artikel beziehen)

(1 Rechnung kann mehrere Positionen haben, 1 Rechnungsposition kann nur zu einer Rechnung gehören)

Rechnungsdaten n

(Interselektionstabelle)

n

Aus obigem Verknüpfungsdiagramm gewinnen wir folgende allgemein gültigen Erkenntnisse, die auch als Resultat der einzelnen Normalformen zu interpretieren sind: ■ Eine m:n-Beziehung, wie sie zwischen den Tabellen "Rechnungen" und "Artikel" besteht, kann so nicht nachgebildet werden. Sie muss mit Hilfe einer Interselektionstabelle ("Rechnungsdaten") in zwei 1:n-Beziehungen aufgelöst werden. ■ Nur Primärtabellen, wie "Kunden", "Artikel" und "Rechnungen", müssen einen (künstlichen) Schlüssel haben. ■ Fremdschlüssel verweisen auf den Primärschlüssel einer anderen Tabelle. In unserem Beispiel haben die Tabellen "Rechnungen" und "Rechnungsdaten" einen bzw. zwei Fremdschlüssel.

9.1 Relationale Datenbanken

437

Als Verknüpfungsziele dienen die Schlüsselfelder der Tabellen, in unserem Fall sind dies die künstlichen Schlüssel ReNr, KuNr und ArtNr. Alle Felder mit Fremdschlüsseln (ReNr und ArtNr in "Rechnungsdaten" und KuNr in "Rechnungen") sollten hingegen einen Sekundärindex (siehe nächster Abschnitt) zwecks Beschleunigung des Zugriffs erhalten. HINWEIS: Da in der Datenbank nur die Tabellen abgespeichert werden, erfolgt die konkrete

Umsetzung der Verknüpfungen erst in der Delphi-Applikation über Datenzugriffselemente bzw. SQL-Anweisungen.

9.1.5 Sekundärindex Normalerweise sind die Datensätze einer Tabelle ungeordnet, d.h., sie sind in der Reihenfolge so abgelegt, wie sie durch den Anwender eingegeben wurden. Das Suchen nach einer bestimmten Information erfordert deshalb das Durchlaufen des gesamten Datenbestandes. Werden nun einige Spalten der Tabelle indiziert, kann der Suchvorgang drastisch beschleunigt werden. BEISPIEL: Da sehr häufig nach dem Namen eines Kunden gesucht wird, ist das entsprechende Feld (KuName)

der Tabelle indiziert. Das Datenbanksystem legt dazu eine neue Indextabelle mit einer Liste der Namen an. Diese Tabelle ist alphabetisch geordnet und besitzt einen Querverweis auf den eigentlichen Datensatz in der Kundentabelle. Werden Daten über einen bestimmten Kunden benötigt, genügt die Suche in der geordneten Indextabelle, um über den Querverweis an die Information zu gelangen. HINWEIS: Ein Index lässt sich auch für das Sortieren von Tabellen verwenden. Alle Tabellen-

felder, nach denen häufig sortiert werden muss, sollten deshalb indiziert sein. Den Vorteilen einer Indizierung stehen auch mehrere Nachteile gegenüber: ■ Das Einfügen von Datensätzen erfordert nicht nur ein Ändern der Tabelle, sondern auch die Änderung aller enthaltenen Indizes. Dies kann unter Umständen die Bearbeitung verlangsamen. ■ Ist ein Schlüssel festgelegt, muss das Datenbanksystem beim Einfügen alle vorhandenen Datensätze auf Eindeutigkeit überprüfen. ■ Jeder Index stellt eine redundante (überflüssige) Information dar, d.h., es wird zusätzlicher Plattenspeicher benötigt. Paradox unterscheidet zwischen folgenden Indextypen: ■ Primärindex (Schlüssel, Hauptindex) einer Tabelle ■ Sekundärindex (auch zusammengesetzt möglich) Jeder Schlüssel ist automatisch indiziert, während Sekundärindizes vom Nutzer selbst anzulegen sind. Folgende Indexoptionen können Sie unter Paradox einstellen:

438

Kapitel 9

Datenbankprogrammierung

■ Eindeutig: Diese Einstellung verbietet, dass mehrere Datensätze den gleichen Wert in einem Sekundärindexfeld aufweisen dürfen. Ist ein Wert doppelt vorhanden, wird das Feld nicht indiziert und eine Warnung angezeigt. Nach Entfernen der Duplikate können Sie das Feld erneut indizieren lassen. ■ Gewartet (Standard): Diese (nur für Tabellen mit Schlüssel verfügbare) Einstellung bestimmt, ob der Sekundärindex nach jeder Veränderung der Tabelle automatisch aktualisiert wird. Das bedeutet eine Beschleunigung bestimmter Operationen, wie z.B. Abfragen. Ist die Option deaktiviert, so aktualisiert die Datenbankoberfläche den Index nur, wenn er verwendet wird, etwa beim Verknüpfen von Tabellen oder Ausführen von Abfragen. Ungewartete Indizes sollten vorzugsweise bei schreibgeschützten Tabellen zum Einsatz kommen. ■ Groß-/Kleinschreibung beachten: Normalerweise ist diese Option deaktiviert, so dass in der Sortierreihenfolge kein Unterschied z.B. zwischen den Einträgen "Borland Delphi" und "BORLAND DELPHI" festzustellen ist (die Reihenfolge entspricht dann der Stellung in der Tabelle). Einfachen Indizes mit aktivierter Groß-/Kleinschreibung wird automatisch der Feldnamen zugewiesen. Andererseits müssen Sie Indizes, bei denen die Schreibweise nicht berücksichtigt wird, beim Speichern selbst mit einem Namen benennen. ■ Absteigend: Auch diese Option ist im Normalfall deaktiviert, so dass Einträge in alphabetischer Reihenfolge (beginnend mit A) sortiert werden. Andernfalls würde, beginnend mit Z, abwärts sortiert. Praktische Erfahrungen zu dieser grundlegenden Thematik sammeln Sie in den Übungsbeispielen 9.3.2 und 9.3.3.

9.2 Datenbankzugriff mit Bound Controls Delphi verfolgt das Konzept der visuellen Programmierung nicht nur konsequent bei den Komponenten der Bedienoberfläche, sondern auch bei den Komponenten für den Datenbankzugriff. Diese werden wie "normale" Komponenten auf der Fensteroberfläche abgelegt und lassen sich über Eigenschaften und Methoden steuern. Auf Änderungen kann über Ereignisse reagiert werden. Ausgehend von einer Übersicht der vorhandenen Komponenten werden Sie mit den wichtigsten Einsatzmöglichkeiten vertraut gemacht.

9.2.1 Komponenten für Datenzugriff Komponenten dieses Typs sind zur Laufzeit unsichtbar. Sie stellen die Verbindung zur Datenbank her.

Übersicht Die für uns interessanten Table- und Query-Komponenten entnehmen Sie der Seite "BDE" der Komponentenpalette (siehe auch Abschnitte 3.4.5 bis 3.4.7 in Kapitel 3):

9.2 Datenbankzugriff mit Bound Controls

Table

439

Query

Weiterhin wird die TDataSource-Komponente von der Seite "Datenzugriff" benötigt (warum erfahren Sie später):

DataSource

Datenbankanbindung Die grundsätzliche Vorgehensweise bei der Herstellung einer Datenbankanbindung ist immer die gleiche: ■ Über eine Table- oder eine Query-Komponente schaffen Sie sich das virtuelle Abbild einer oder mehrerer Tabellen. Legen Sie dazu die Eigenschaften DatabaseName und TableName bzw. DatabaseName und SQL fest. Eine Query-Komponente liefert das Ergebnis einer SQLAbfrage, während eine Table-Komponente immer eine Tabelle darstellt. ■ Verbinden Sie eine DataSource-Komponente über die DataSet-Eigenschaft mit einer Tableoder Query-Komponente. ■ Setzen Sie die Active-Eigenschaft von Table bzw. Query auf True, um die Verbindung zur Datenbank zu aktivieren.

9.2.2 Komponenten für Datensteuerung Die Komponenten dieser zweiten wichtigen Kategorie bleiben auch zur Laufzeit sichtbar. Sie fallen unter verschiedene gleichwertige Bezeichnungen, wie Bound Components, Bound Controls, datensensitive Komponenten, visuelle Dialogelemente, Datendialogelemente, und lassen sich über Eigenschaften (DataSource, DataField etc.) an bestimmte Datenquellen (Tabelle, Abfrage) anbinden, wobei eine DataSource-Komponente als Verbindungsglied dient. Veränderungen der Satzzeigerposition wirken sich auch auf den Inhalt des Steuerelements aus.

Übersicht Welche Datendialog-Komponenten Delphi bietet, sehen Sie auf der Seite "Datensteuerung" der Komponentenpalette. Auf die für unsere Experimente besonders interessanten wird extra hingewiesen:

440

Kapitel 9

DBNavigator

DBLookupListBox

DBEdit

DBText DBGrid

Datenbankprogrammierung

DBCheckBox DBMemo

DBLookupComboBox

Was Sie damit anfangen können, können Sie sich eigentlich denken: ■ DBNavigator Anzeige und Bearbeitungsmöglichkeit von Datensätzen in einem Tabellengitter. ■ DBGridSteuertasten für Datensatzzeiger (Vor, Zurück, Löschen, Neu, Abbrechen etc.). ■ DBEditAnzeige- und Eingabefeld für eine Textzeile. ■ DBMemo Anzeige und Eingabefeld für Mehrfachzeilen oder BLOB-Text. ■ DBTextAnzeige eines Feldes als Label. ■ DBCheckBoxAnzeige/Eingabe True/False in Abhängigkeit eines Tabellenfeldes. ■ DBLookupListBoxListenfeld, der gewählte Eintrag (ItemIndex) wird in der Tabelle gespeichert, die Listeneinträge werden aus einer zweiten Tabelle geladen! ■ DBLookupComboBoxComboBox, sonst wie DBLookupListBox.

Verbinden mit den Datenzugriffskomponenten Die folgende Abbildung verdeutlicht das Grundprinzip: Wenn Sie die Datensteuerungskomponenten mit den Datenzugriffskomponenten verbinden wollen, schiebt sich die DataSource-Komponente quasi als "Mittler" dazwischen.

zur Laufzeit sichtbar!

Datenbank

zur Laufzeit unsichtbar! Table

DBEdit

DataSource DBMemo

DBNavigator

9.2 Datenbankzugriff mit Bound Controls

441

Vorgehensweise: ■ Binden Sie eine oder mehrere Bound Controls (DBText, DBEdit, DBMemo ...) über die DataSource-Eigenschaft an die DataSource-Komponente. Legen Sie anschließend den Feldinhalt über die DataField-Eigenschaft fest. Haben Sie diese Bearbeitungsreihenfolge eingehalten, können Sie den Feldnamen in einer Drop-down-Liste auswählen. ■ Wenn die Active-Eigenschaft der Table- oder Query-Komponente True ist, wird im Erfolgsfall der erste Datensatz der eingebundenen Tabelle/Abfrage angezeigt. Ist die SQL-Abfrage fehlerhaft oder existiert die Tabelle nicht, erscheint eine Fehlermeldung. Damit hätten Sie bereits eine (fast) fertige Eingabemaske. Ein Problem bleibt allerdings: Das Hinzufügen und Löschen von Datensätzen sowie eine Möglichkeit, zwischen den Datensätzen zu wechseln, fehlen bisher. All diese Wünsche erfüllt eine DBNavigator-Komponente, die Sie einfach über die DataSource-Eigenschaft an die DataSource-Komponente binden. Das war's auch schon! Mit einem Dutzend Mausklicks haben Sie bereits eine Datenbankapplikation erstellt, die in der Lage ist, Daten anzuzeigen, neue Datensätze hinzuzufügen und zu löschen. Die Funktionalität zum "Bewegen" zwischen den Datensätzen ist ebenfalls vorhanden. Den praktischen Einsatz lernen Sie im Übungsbeispiel 9.3.3 ("Eingabemaske mit Bound Controls") kennen.

9.2.3 Rave Reports-Komponenten Ihre Datenbankanwendung ist erst dann komplett, wenn die Abfrageergebnisse in ansprechender Form zu Papier gebracht werden. Bisher wurden Ihnen dazu die QuickReport-Komponenten bereitgestellt. Doch in Delphi 7 hat mit Rave Reports ein neuer Reportgenerator Einzug gehalten, und Sie als Programmierer haben jetzt natürlich dienstbeflissen alle Ihre Reports umzustellen. Halt, halt, ganz so schlimm ist es nicht gekommen. Haben Sie bereits Reports mit QuickReport entwickelt, können Sie diese natürlich auch weiternutzen bzw. Sie können wie gewohnt mit den QuickReport-Komponenten arbeiten. Für alle Neueinsteiger und Umstiegswilligen stellen wir an dieser Stelle die Arbeit mit Rave Reports vor, mehr zum Thema "QuickReport" finden Sie in unserem Buch [Borland Delphi – Datenbankprogrammierung].

Übersicht Die "Rave"-Seite der Komponentenpalette besticht bereits durch ihre Vielfalt:

Der eigentliche Report-Designer ist hier jedoch noch nicht enthalten, Sie finden diesen im Verzeichnis \\Delphi7\Rave5\ als Rave.exe) als eigenständiges Programm. Über die Bedeutung der einzelnen Rave-Komponenten informiert Sie die folgende Tabelle:

442

Kapitel 9

Icon

Datenbankprogrammierung

Bezeichnung

Erläuterung

RvProject

Über diese Komponente binden Sie die mit dem RaveDesigner erzeugten *.rav-Dateien in Ihr Delphi-Projekt ein, um diese mittels Execute-Methode anzuzeigen.

RvSystem

… ermöglicht die Vorgabe diverser Optionen und die Ausgabe als Vorschau, Druckausgabe oder *.NDR-Datei.

RvNDRWriter

… bietet die Möglichkeiten zum Erzeugen einer Druckdatei (*.NDR).

RvCustomConnection

… bietet Unterstützung für die Ausgabe von Array- oder nutzerdefinierten Daten. Der Programmierer stellt über die Ereignisse OnNext, OnEOF, OnFirst etc. quasi eine MiniDatenbank/-Tabelle zur Verfügung.

RvDatasetConnection

… unterstützt die Anbindung beliebiger TDatasetKomponenten an einen Report.

RvTableConnection

… dient dem Bereitstellen von BDE-TTable-Daten für einen Report (Einbindung als Direct Data View).

RvQueryConnection

… dient dem Bereitstellen von BDE-TQuery-Daten für einen Report (Einbindung als Direct Data View).

RvRenderPreview

… ermöglicht die Anzeige von NDR-Daten in einer Scrollbox. Mit den bereitgestellten Methoden können Sie eine komplette Druckvorschau realisieren.

RvRenderPrinter

… Ausgabe von NDR-Daten auf einem Drucker.

RvRenderPDF

… durch das Einbinden dieser Komponente steht Ihnen zusätzlich das Adobe Acrobat-Format für die Dateiausgabe zur Verfügung.

RvRenderHTML

… Ausgabe der Reportdaten im HTML-Format.

RvRenderRTF

… Ausgabe der Reportdaten im Rich Text-Format.

RvRenderText

… Ausgabe der Reportdaten im Text-Format.

Wichtige Features Einige wesentliche Features des Rave Reports auf einen Blick: ■ Sowohl seiten- als auch bandorientierter Reportentwurf ■ Anbindung an TTable, TQuery, TDataset sowie nutzerdefinierte Datenmengen aus Ihrer Delphi-Anwendung ■ Direkte Anbindung an ADO-, BDE- oder DBX-Datenquellen ■ Externer Report-Designer1 1

Mit zusätzlicher Lizenz kann dieser auch eingebunden (DLL) und an den Enduser weitergegeben werden.

9.2 Datenbankzugriff mit Bound Controls

443

■ Integrierte Druckvorschau ■ Integrierter Query-Builder ■ Relativ einfache Handhabung ■ Export im PDF-, HTML-, RTF- und Text-Format möglich ■ Eigener Rave Reports-Server für die Distribution von Reports über das Internet/Intranet im HTML- oder PDF-Format

Der Designer Wie bereits erwähnt, handelt es sich um ein externes Programm, dessen Bedienung sich nicht wesentlich von Delphi unterscheidet:

Die Vorgehensweise ist recht simpel: Erstellen Sie eine neue Reportdatei, können Sie in dieser beliebig viele Reports unterbringen. Diese Einzelreports können wiederum aus mehreren Seiten bestehen (z.B. Deckblatt, Listendarstellung und Zusammenfassung). Auf der linken Seite finden Sie die jeweiligen Eigenschaften des gewählten Objekts, über die Toolbar haben Sie die Möglichkeit, Komponenten auf dem Report zu platzieren. Die Struktur der Report-Datei (*.RAV) wird in der Baumansicht auf der rechten Seite dargestellt. Neben den einzelnen Reports sowie deren Seiten werden hier auch alle Datenverbindungen aufgelistet. Zwei Varianten bieten sich an: ■ Sie binden die Reports an Komponenten, die Sie in Ihr Delphi-Programm eingebunden haben (Direct DataView)

444

Kapitel 9

Datenbankprogrammierung

■ oder Sie nutzen die Möglichkeit des direkten Datenzugriffs per ADO, BDE oder ODBC (Driver Data View). Wir werden uns im Weiteren auf die erste Variante beschränken, da Sie hier die besten Einflussmöglichkeiten (Filtern, Gruppieren etc.) aus dem Delphi-Programm heraus haben. Doch bevor Sie vor lauter Theorie das Handtuch werfen, wollen wir uns lieber mit ein paar praktischen Beispielen beschäftigen. Konkrete Beispiele zum Thema "Rave Report" finden Sie unter 9.3.4 und 9.4.3 im Praxisteil des Kapitels.

9.3 Lernbeispiele für Einsteiger 9.3.1 Anlegen einer "Kundentabelle" Sie haben, beginnend mit dem Stand null, mehrere Etappen zu bewältigen: ■ Problemanalyse und Entwurf der Datenbankstruktur ■ Tabellenentwurf (Datenbankoberfläche, Paradox, SQL ...) ■ Oberflächenentwurf für den Datenzugriff (Delphi) ■ Zusammenstellen und Ausdruck von Berichten (Delphi/Rave Reports) Sie werden mit der wohl primitivsten Form einer relationalen Datenbank, einer einzigen Tabelle, beginnen. Darin sollen alle Kunden der Firma erfasst werden.

Datenbankstruktur Da Sie es nur mit einer einzigen Tabelle zu tun haben, brauchen Sie sich keinen quälenden Überlegungen bezüglich der Datenbankstruktur hinzugeben. Wir einigen uns lediglich darüber, dass pro Person eine laufende Nummer, deren Namen, Anschrift (Straße, Ort, PLZ) und Telefonnummer abzuspeichern sind. Damit hätte unsere Tabelle folgenden Aufbau: Kunden Feldname

Datentyp

Größe

Nr

Zähler

Name

Alpha

50

Straße

Alpha

50

Ort

Alpha

50

PLZ

Alpha

5

Telefon

Alpha

30

Das Zählerfeld Nr ist kompatibel zum Datentyp Integer (lang), nur dass es sich immer automatisch um eins erhöht, wenn Sie einen neuen Kunden in die Tabelle aufnehmen. Wie Sie sehen, handelt es

9.3 Lernbeispiele für Einsteiger

445

sich bei den übrigen Feldern um Text (Datentyp Alpha). Hier ist es erforderlich, sich vorher über die Feldgröße zu einigen (die maximale Anzahl von Zeichen). Vielleicht wundern Sie sich jetzt, dass für PLZ und Telefon kein numerischer Datentyp (Integer) verwendet wurde. Der Grund liegt in den späteren Auswertungsmöglichkeiten für diese Felder unter Delphi. Um beispielsweise die ersten fünf Ziffern der Telefonnummer zu ermitteln, benötigt man für eine Alpha-Variable (in Delphi String-Datentyp) nur die Copy-Funktion. Die Zerlegung eines numerischen Wertes ist hingegen weitaus komplizierter. Ein weiterer Grund ist die Tatsache, dass innerhalb einer Telefonnummer Trennstriche auftreten können bzw. dass der Postleitzahl ein Buchstabe zur Länderkennung vorangestellt sein kann. HINWEIS: Bevor Sie mit dem Tabellenentwurf beginnen, legen Sie sich ein extra Verzeichnis

(Ordner) für die Datenbank an (in unseren Beispielen \FirmaDB).

Tabellenentwurf Das Gerüst unserer (vorerst leeren) Datenbank entwerfen Sie mit der zu Delphi mitgelieferten "Datenbankoberfläche" (DBD = DataBase Desktop). Dieses Hilfsprogramm entspricht etwa einer abgerüsteten Version des Paradox-Datenbanksystems. Sie starten es durch Doppelklick auf das entsprechende Icon in der Borland DelphiProgrammgruppe oder über Start|Programme|Borland Delphi 7. Wählen Sie anschließend den Menüpunkt Datei|Neu|Tabelle:

In dem sich dann öffnenden Dialogfenster sollten Sie sich für das modernste Format (Paradox 7) entscheiden:

Nun sind Sie schon mittendrin im Entwurfsfenster. Beginnen Sie mit der Eingabe des ersten Feldnamens (Nr) und der Zuweisung des entsprechenden Datentyps (Zähler). Das Auswahl-PopupMenü öffnet sich nach Klick mit der rechten Maustaste auf die Typ-Spalte:

446

Kapitel 9

Datenbankprogrammierung

Wenn Sie die Daten eines Kunden später löschen, wird die nun freigewordene Nummer nicht wieder für einen neuen Kunden verwendet, sondern bleibt für immer und ewig gesperrt. Wundern Sie sich also nicht, wenn dann Lücken in der Zählreihenfolge auftreten. HINWEIS: Beachten Sie, dass man ein Zählerfeld nur einmal pro Tabelle vergeben darf!

Fügen Sie nun auf analoge Weise die anderen Felder hinzu, schließen Sie die Definition eines jeden Feldes mit der Enter-Taste ab. Die Festlegung der Tabellenstruktur schließt nicht aus, dass ein späteres Umstrukturieren möglich ist, z.B. Typänderungen oder das Hinzufügen weiterer Felder. Dazu rufen Sie den Menüpunkt Tabelle|Umstrukturieren... auf. Weisen Sie dem Nr-Feld den Primärschlüssel zu. Klicken Sie dazu doppelt auf die SchlüsselSpalte, und es erscheint ein Sternchen. Um weitere Einstellmöglichkeiten im rechten Teil des Fensters (Indizes etc.) sollten Sie sich jetzt noch nicht kümmern. Lediglich das Optionskästchen "Eingabe erforderlich" dürfte bereits interessieren. Sie sollten diese Option bei den Feldern aktivieren, für die später unbedingt ein Wert einzugeben ist. Das könnte zum Beispiel beim Namen des Kunden sinnvoll sein, denn was nützen alle übrigen Adressangaben, wenn unklar ist, auf welche Person sie sich beziehen? Haben Sie alle Felder definiert, klicken Sie auf die Schaltfläche "Speichern unter". Geben Sie als Dateinamen den Namen der Tabelle (Kunden) ein und wählen Sie ganz oben das Zielverzeichnis \Firma. Nach Verlassen des Programms überprüfen Sie, ob sich im Datenbankverzeichnis die Datei Kunden.db befindet.

447

9.3 Lernbeispiele für Einsteiger

9.3.2 Definieren von Alias und Sekundärindizes Beide Begriffe gehören zum Standardvokabular eines jeden Paradox-Programmierers. Mit Hilfe des Dienstprogramms "Datenbankoberfläche", das Sie über das Menü Tools|Datenbankoberfläche aufrufen, sind Sie auch unter Delphi in der Lage, einen Alias bzw. Sekundärindex für die im Vorgängerbeispiel erstellte Datenbank einzurichten.

Alias festlegen Ein Alias ist nichts weiter als ein Synonym für das Datei-Verzeichnis, in dem sich die Datenbank befindet. Öffnen Sie das Dienstprogramm "Datenbankoberfläche" (siehe oben) und wählen Sie dort das Menü Tools|Alias-Manager... Klicken Sie dort zuerst die Schaltfläche "Neu". Tragen Sie in das Fenster "Datenbankalias:" einen schlüssigen Begriff für die Datenbank (Firma) ein. Wenn Sie den Pfadnamen nicht direkt eingeben wollen oder ihn gar vergessen haben, wählen Sie als Nächstes die "Durchsuchen"-Schaltfläche und selektieren dort das entsprechende Verzeichnis (siehe folgende Abbildung). 4.

3.

2. 1.

5.

Die BDE (Borland Database Engine) "kennt" jetzt eine Datenbank namens "Firma" und "weiß", in welchem Verzeichnis diese zu finden ist. BEISPIEL: Die DatabaseName-Eigenschaft einer Table-Komponente kann im Objektinspektor per Klappbox

zugewiesen werden. Alle der BDE bekannten Alias-Namen werden hier aufgelistet (Anwendung siehe z.B. 9.3.3). Auch eine spätere Weitergabe der Datenbankapplikation dürfte nun kein Problem mehr sein, wenn dem Endanwender der Aliasname bekannt ist und er über einen Alias-Manager verfügt.

448

Kapitel 9

Datenbankprogrammierung

Sekundärindex anlegen Da Sie die Kunden später nach ihren Namen sortieren wollen, sollten Sie jetzt schon einen Sekundärindex für den Kunden-Namen anlegen: Starten Sie das Hilfsprogramm "Datenbankoberfläche" und öffnen Sie über das Menü Datei|Öffnen|Tabelle die Tabelle Kunden.DB. Wählen Sie dort den Menüpunkt Tabelle|Umstrukturieren... In der Rollbox "Tabelleneigenschaften:" klicken Sie den Eintrag "Sekundärindizes" und anschließend die Schaltfläche "Definieren":

Sie befinden sich nun im Dialogfenster "Sekundärindex definieren".

9.3 Lernbeispiele für Einsteiger

449

Im linken Listenfeld selektieren Sie das Feld Name und kopieren es nach rechts in den Bereich "Indizierte Felder" (Doppelklick oder Pfeiltaste →). Stellen Sie die entsprechenden Indexoptionen ein (in unserem Fall belassen Sie es bei den Standardeinstellungen). Falls Sie noch andere Felder indizieren wollen (zusammengesetzter Index), fügen Sie auf die beschriebene Art weitere Felder hinzu bzw. machen Sie die Aktion rückgängig (Pfeiltaste ←).

Klicken Sie die OK-Schaltfläche und vergeben Sie im Dialogfenster einen Namen (kundenName). Eine praktische Anwendung finden Sie am Ende des nachfolgenden Beispiels.

9.3.3 Eingabemaske mit Bound Controls Die einfachste Möglichkeit, sofort zu einer anwendungsbereiten Datenbankapplikation zu kommen, wäre der Einsatz einer einzigen DBGrid-Komponente. Weitaus individuellere Bedienoberflächen lassen sich aber mit Einzelkomponenten gestalten.

Entwurf Bestücken Sie ein neues Formular mit den Datensteuerungskomponenten DBText1, DBEdit1... DBEdit5 und DBNavigator1 und mit den Datenzugriffskomponenten Table1 und DataSource1. Hinzu kommen einige Labels zur Beschriftung.

450

Kapitel 9

Datenbankprogrammierung

Table1 DataSource1

DBNavigator1

Die Anbindung an die Datenbank ist mit wenigen Mausklicks im Objektinspektor erledigt. Beginnen Sie mit der TTable-Komponente. Von der Vielzahl der Eigenschaften sind vorerst für Sie nur drei interessant (Active, DatabaseName, TableName), die übrigen belassen Sie auf den Standardwerten. Als Erstes sollten Sie die Active-Property auf False setzen, zu ihrer Bedeutung kommen wir erst am Schluss dieses Abschnitts.

DatabaseName und TableName Nun ist die Zuweisung der DatabaseName-Eigenschaft vorzunehmen. Geben Sie hier den Namen des Verzeichnisses ein, in dem die Tabelle Kunden.DB abgespeichert wurde. HINWEIS: In den Beispielen der Buch-CD wird der relative Verzeichnisname ..\.\FirmaDB als

DataBaseName verwendet. In diesem Fall befindet sich die Datenbank im Unterverzeichnis \FirmaDB oberhalb des Projektverzeichnisses. Professioneller ist es, statt eines Verzeichnisses den in Übung 9.3.2 zugewiesenen Alias (Firma) als DataBaseName zu verwenden. Der Alias wird (falls vorhanden) durch die Rollbox der DataBaseName-Eigenschaft angeboten. Anschließend weisen Sie die TableName-Property zu. Klicken Sie dazu auf das leere Feld in der rechten Spalte des Objektinspektors und öffnen Sie die kleine Rollbox. Es werden Ihnen alle im Datenbankverzeichnis befindlichen Tabellen-Namen angezeigt, in unserem Fall wählen Sie Kunden.DB.

451

9.3 Lernbeispiele für Einsteiger

1. 2.

! 3.

DataSet Als Nächstes müssen Sie die Komponente DataSource1 an Table1 ankoppeln. Das ist relativ einfach, denn das Zuweisen der DataSet-Property ist mit einem einzigen Mausklick erledigt:

!

DataSource und DataField Jede der Datensteuerungskomponenten (DBText1, DBEdit1 ... DBEdit5) lässt sich nun an das entsprechende Feld von Table1 anbinden, wobei DataSource1 eine Art "Brückenfunktion" übernimmt. Setzen Sie also die DataSource-Properties aller Komponenten auf DataSource1 und weisen Sie anschließend die entsprechende DataField-Eigenschaft zu:

452

Kapitel 9

Datenbankprogrammierung

2. 1.

!

Vergessen Sie nicht, zum Schluss auch noch die DataSource-Eigenschaft von DBNavigator1 auf gleiche Weise über DataSource1 an Table1 anzubinden.

Active Setzen Sie jetzt die Active-Property von Table1 wieder auf True. Obwohl das Programm noch nicht gestartet ist, sollte der erste Datensatz bereits angezeigt werden. Die Active-Property erlaubt es, bereits zur Entwurfszeit die Verbindung zur Datenbank herzustellen. Ist diese Eigenschaft False, so ist diese Verbindung geschlossen, andernfalls (True) geöffnet. HINWEIS: Immer wenn Sie später DatabaseName oder TableName ändern wollen, sollten Sie

vorher Active auf False setzen, da sonst eine Fehlermeldung erscheint. Ein Bewegen durch die Datenbank mit den Navigatorschaltflächen zur Entwurfszeit ist, trotz hergestellter Verbindung zur Datenbank, nicht möglich.

Test Starten Sie also das Programm durch Klick auf den -Button (oder F9-Taste). Mit dem Datensatznavigator können Sie sich nun durch die Datenbank bewegen. Es lassen sich auch Datensätze editieren (bearbeiten), löschen oder neu hinzufügen:

9.3 Lernbeispiele für Einsteiger

453

HINWEIS: Wenn Sie zur Entwurfszeit die ShowHint-Eigenschaft von DBNavigator1 auf True

gesetzt haben, erscheinen kleine gelbe Hinweisschildchen immer dann, wenn Sie mit dem Mauszeiger einen kleinen Moment auf der entsprechenden Schaltfläche verweilen. Sie werden feststellen, dass bestimmte Schaltflächen in Abhängigkeit vom momentanen Bearbeitungszustand aktiviert oder deaktiviert sind (der Navigator "denkt" mit). So werden z.B. die Schaltflächen "Übernehmen" und "Bearbeiten abbrechen" erst dann freigegeben, wenn Sie einen Eintrag editiert oder neu hinzugefügt haben. HINWEIS: Durch Ändern der VisibleButtons-Eigenschaft der DBNavigator-Komponente können

Sie nicht benötigte Buttons (z.B. "Daten aktualisieren") ausblenden.

Datensätze sortieren Bis jetzt erscheinen die Datensätze in der Reihenfolge, wie sie in die Datenbank eingegeben wurden. Wollen Sie eine sortierte Reihenfolge, so muss das entsprechende Feld über einen Sekundärindex verfügen. Im Beispiel 9.3.2 hatten Sie dem Name-Feld einen Sekundärindex zugewiesen. Öffnen Sie den Objektinspektor für Table1 und weisen Sie der IndexName-Eigenschaft den Sekundärindex kundenName zu. Nach erneutem Programmstart werden Sie feststellen, dass die Namen der Kunden in alphabetischer Reihenfolge erscheinen1.

9.3.4 Einfacher Bericht mit Rave Report In dieser Übung wollen wir ersten Kontakt mit Rave Reports aufnehmen. Es soll der Inhalt der Tabelle Kunden.db aus unserer FIRMA-Datenbank ausgedruckt werden. 1

Die Sortierung erfolgt nach dem Vornamen, was etwas ungewöhnlich ist, Sie aber nicht stören soll.

454

Kapitel 9

Datenbankprogrammierung

Oberfläche Eröffnen Sie ein neues Projekt und erstellen Sie ein Formular entsprechend folgender Abbildung.

Verbinden Sie die Table-Komponente über ihre DatabaseName- und TableName-Eigenschaft mit der Tabelle Kunden.DB und setzen Sie Active auf True. Die DataSource- sowie die DBGrid-Komponente nutzen wir lediglich für die Kontrolle. In einem zweiten Schritt platzieren Sie eine RvProject- und eine RvTableConnection-Komponente auf dem Formular. RvTableConnection binden Sie über die Eigenschaft Table direkt an die bereits geöffnete Table-Komponente.

Report-Entwurf Wechseln Sie nun zur RvProject-Komponente. Über das Popup-Menü (Rave Visual Designer) können Sie den eigentlichen Berichtsdesigner starten. Über die Oberfläche des Designers brauchen wir Ihnen sicher nicht allzu viel zu erzählen, lehnt sich die Oberfläche doch recht stark an die Delphi-IDE an. Das weitere Vorgehen möchten wir Ihnen deshalb nur stichpunktartig erläutern: ■ Der erste Schritt ist das Erzeugen eines neuen Reports (Datei|Neu). ■ Fügen Sie nun über den Menüpunkt Datei|Neues Datenobjekt eine Direct Data View in den Report ein. In der folgenden Dialogbox dürfte lediglich eine aktive Verbindung angezeigt werden:

9.3 Lernbeispiele für Einsteiger

455

■ Hierbei handelt es sich bereits um die RvTableConnection-Komponente aus Ihrem Delphi-Projekt. Nach dem Einfügen zeigt die Projekt-Übersicht bereits die Details unserer Datenverbindung an:

■ Im Folgenden ist es wichtig zu wissen, dass der Rave-Reportgenerator grundsätzlich erst einmal seitenorientiert arbeitet. Um eine Unterstützung für bandorientierte Ausgaben zu realisieren, müssen Sie zunächst eine Region-Komponente in das noch leere Formular einfügen. Innerhalb dieser Region-Komponente können Sie nun Band- und DataBand-Komponenten platzieren. ■ Für unseren Bericht benötigen wir zwei Band-Komponenten (Kopfzeile und Tabellenkopf) sowie ein DataBand, in dem die eigentlichen Tabellendaten später angezeigt werden.

456

Kapitel 9

Datenbankprogrammierung

■ Fügen Sie in die einzelnen Bänder entsprechend obiger Abbildung Text- bzw. DataText-Komponenten ein. Der Verknüpfung mit den zugrunde liegenden Daten erfolgt wie in Delphi. Verwenden Sie die Eigenschaft DataView, um die Datenquelle zuzuordnen und die Eigenschaft DataField, um die gewünschte Spalte zu selektieren. ■ Das DataBand selbst binden Sie über die Eigenschaft DataView an unsere erzeugte Connection. ■ Für den Reportgenerator müssen Sie nun noch den Zusammenhang zwischen den einzelnen Bändern festlegen. Dazu dient die Eigenschaft BandStyle, die Sie für die drei Bänder entsprechend den folgenden Abbildungen festlegen:

■ Das war es auch schon, mit F9 können Sie einen ersten Test starten:

9.3 Lernbeispiele für Einsteiger

457

■ Speichern Sie den Report im Projektverzeichnis Ihrer Delphi-Anwendung und beenden Sie den Report-Designer. ■ In Ihrem Delphi-Projekt muss nun der neue Report eingebunden werden. Nutzen Sie dazu die ProjectFile-Eigenschaft der RvProject-Komponente.

Quellcode In das OnClick-Ereignis des Buttons tragen Sie ein: procedure TForm1.Button1Click(Sender: TObject); begin RvProject1.Open; RvProject1.Execute; end;

Test Nach dem Programmstart (F9) und dem Klick auf den Button erscheint die Berichtsvorschau, die Sie nach Klick auf das Drucksymbol auch zu Papier bringen können. HINWEIS: Falls der Report nicht oder fehlerhaft angezeigt wird, überprüfen Sie nochmals, ob

die Active-Eigenschaft von Table1 tatsächlich True ist.

Bemerkungen ■ Wie bereits erwähnt, können Sie den Report jederzeit während der Entwurfsphase im RaveDesigner testen (F9). ■ Das Papierformat können Sie über die Orientation-Eigenschaft des Reports (Baumansicht: Report|MainPage) anpassen.

458

Kapitel 9

Datenbankprogrammierung

9.3.5 Verknüpfen von Tabellen Im Abschnitt 9.1.4 wurde anhand der Datenbankstruktur gezeigt, wie die Tabellen Rechnungen.DB, Kunden.DB, Rechnungsdaten.DB und Artikel.DB über Primär- und Fremdschlüsselbeziehungen miteinander verknüpft sind. Eine solche Verknüpfung (Relation) sollen Sie jetzt zwischen den Tabellen Rechnungen.db und Kunden.db mit Hilfe einer DBLookupComboBox realisieren.

Oberfläche Stellen Sie die abgebildete Oberfläche zusammen.

Zunächst ist nur der linke Teil wichtig. Verbinden Sie (vgl. Übung 9.3.3) die Table1/DataSource1Komponenten mit der Tabelle Rechnungen.db unserer FIRMA-Datenbank und verbinden Sie dann alle links befindlichen Datensteuerungskomponenten mit den entsprechenden Feldern der Tabelle. HINWEIS: Wenn Sie die Active-Eigenschaft von Table1 auf True setzen, muss sich bereits der

erste Datensatz zeigen, falls DataBaseName und TableName stimmen und Sie auch nicht vergessen haben, die DataSet-Eigenschaft von DataSource1 zuzuweisen.

Test 1 Jetzt können Sie das Programm bereits zu einem ersten Probedurchgang starten. Da die Verknüpfung mit der Tabelle Kunden.db noch fehlt, wird nur die KundenNr (das ist ein Fremdschlüssel) angezeigt, was wenig informativ ist.

Zuweisen der Eigenschaften für DBLookupComboBox Bevor Sie damit beginnen können, müssen Sie die Table2/DataSource2-Komponenten mit der Tabelle Kunden.db verbinden. Beim Zuweisen der Eigenschaften für die DBLookupComboBox gilt es, einen kühlen Kopf zu bewahren. HINWEIS: Halten Sie sich an folgende Übersicht und gehen Sie dabei streng in der angegebenen

Reihenfolge (von oben nach unten) vor.

459

9.3 Lernbeispiele für Einsteiger

Eigenschaft

Wert

Erklärung

DataSource

DataSource1

Von welcher Datenquelle kommt der Fremdschlüssel?

DataField

KundenNr

Wie heißt der Fremdschlüssel?

ListSource

DataSource2

Von welcher Datenquelle kommen die Detaildaten?

KeyField

Nr

Wie heißt der Primärschlüssel der Detaildaten-Tabelle?

ListField

Name

Welches Feld der Detaildaten-Tabelle soll angezeigt werden?

Die genauen Zusammenhänge werden in folgender Abbildung deutlich: Detailtabelle

Mastertabelle

DataSource

ListSource Rechnungen.db

Kunden.db 1

Nr Datum DataField

n

Nr

KeyField

Name

ListField

KundenNr

Ort

GesamtNetto

Straße

Bemerkung

Telefon

Test 2 Nachdem die Active-Eigenschaften beider Table-Komponenten True gesetzt sind, kann es losgehen. In der ComboBox werden jetzt die Namen der Kundschaft angezeigt, Sie können neue Rechnungen hinzufügen und Kunden aus dem vorhandenen Kundenstamm zuordnen.

460

Kapitel 9

Datenbankprogrammierung

Bemerkungen ■ Fügen Sie das Formular aus der Übung 9.3.3 zur Anwendung hinzu, so können Sie auch den Kundenstamm bearbeiten. ■ In dieser Übung haben Sie aus Übersichtlichkeitsgründen nur zwei Tabellen der Firma-Datenbank miteinander verknüpft. Die Verknüpfung aller Tabellen wird erläutert im Beispiel 9.4.2. ■ Die DBLookupListBox, die "Schwester" der DBLookupComboBox, ist auf exakt die gleiche Art und Weise zu verwenden.

9.4 Praxisbeispiele für Fortgeschrittene 9.4.1 Einsparen des DBNavigators Einige Gründe, die dafür sprechen, den DBNavigator durch eine Eigenproduktion zu ersetzen: ■ Die DBNavigator-Komponente bietet neben den Bewegungstasten noch mehrere andere Tasten, die teilweise für Verwirrung sorgen können (ohne ShowHints kaum verständlich). ■ Beim Öffnen der Tabelle kann man sofort editieren, also auch versehentlich löschen. Das vermeidet man, wenn man die Tabelle grundsätzlich schreibgeschützt öffnet. Im vorliegenden Rezept soll anhand der Tabelle Kunden.DB (aus der Firma-Datenbank) gezeigt werden, wie man einen "handgestrickten" Navigator programmieren kann.

Oberfläche Orientieren Sie sich an der folgenden Abbildung, und weitere Erklärungen dürften sich erübrigen: BtnNew

BtnStore

BtnCancel

BtnClear

BtnFirst

BtnPrior

CheckBox1

BtnNext

BtnLast

461

9.4 Praxisbeispiele für Fortgeschrittene

Den Platz des DBNavigators haben acht Buttons eingenommen, die wir im Objektinspektor entsprechend obiger Abbildung umbenannt haben. Eine CheckBox sorgt für das Ein- und Ausschalten des Schreibschutzes. Das Anbinden der diversen Datensteuerungskomponenten DBText und DBEdit an die Tabelle Kunden.DB mit Hilfe der Datenzugriffskomponenten Table1/DataSource1 wird als bekannt vorausgesetzt. Einzige Besonderheit: Setzen Sie ReadOnly von Table1 auf True!

Quelltext Zunächst kümmern Sie sich um die vier Bewegungstasten, die Sie mit den Methoden First, Prior, Next und Last des TTable-Objekts nachbilden: procedure TForm1.BtnFirstClick(Sender: TObject); // Erster begin Table1.First; BtnLast.Enabled := True; BtnNext.Enabled := True; BtnPrior.Enabled := False; BtnFirst.Enabled := False end; procedure TForm1.BtnPriorClick(Sender: TObject); begin Table1.Prior; BtnLast.Enabled := True; BtnNext.Enabled := True; if Table1.BOF then BtnFirstClick(Self) end; procedure TForm1.BtnNextClick(Sender: TObject); begin Table1.Next; BtnFirst.Enabled := True; BtnPrior.Enabled := True; if Table1.EOF then BtnLastClick(Self) end; procedure TForm1.BtnLastClick(Sender: TObject); begin Table1.Last; BtnFirst.Enabled := True; BtnPrior.Enabled := True; BtnLast.Enabled := False; BtnNext.Enabled := False end;

// Zurück

// Vorwärts

// Letzter

Bereits jetzt können Sie den Quelltext erstmals compilieren und die Funktionsfähigkeit der Bewegungstasten testen. Etwas komplizierter gestaltet sich die Programmierung der vier Bearbeitungstasten "Neuer Kunde", "Speichern", "Rückgängig" und "Löschen".

462

Kapitel 9

Datenbankprogrammierung

Zur Klassendeklaration von TForm1 fügen Sie zunächst eine neue Methode setButtons hinzu: type TForm1 = class(TForm) ... procedure FormClose(Sender: TObject; var Action: TCloseAction); private procedure setButtons(m: Byte); // neue Methode! public { Public-Deklarationen } end;

Diese neu hinzugefügte Methode muss von uns implementiert werden. Weiterhin wird eine Variable vom Typ TBookmark benötigt: var pos: TBookmark;

// Lesezeichen

procedure TForm1.setButtons(m: Byte); begin case m of 0: begin BtnNew.Enabled := False; BtnStore.Enabled := False; BtnCancel.Enabled := False; BtnDelete.Enabled := False end; 1: begin BtnNew.Enabled := True; BtnStore.Enabled := False; BtnCancel.Enabled := False; BtnDelete.Enabled := True end; 2: begin BtnNew.Enabled := False; BtnStore.Enabled := True; BtnCancel.Enabled := True; BtnDelete.Enabled := False end end end;

Das folgende Zustandsüberführungsdiagramm soll den Übergang zwischen den drei möglichen Aktivierungen der Buttons verdeutlichen:

463

De le

te

9.4 Praxisbeispiele für Fortgeschrittene

1

1

Post

Cancel

dit rE

Ed it

Append

e Aft

0

2

Der Zustand 0 (links unten) liegt beim Aufrufen des Formulars vor. Hier sind die vier Bewegungstasten gesperrt, da der Schreibschutz noch nicht aufgehoben ist: procedure TForm1.FormCreate(Sender: TObject); begin setButtons(0) end;

Nach Klick auf die CheckBox ist der Schreibzugriff erlaubt: rocedure TForm1.CheckBox1Click(Sender: TObject); // Lese-/Schreibzugriff begin pos := Table1.GetBookmark; // Position merken Table1.Active := False; if CheckBox1.Checked = True then // Schreibschutz begin Table1.ReadOnly := True; setButtons(0) end else // Lesen und Schreiben begin Table1.ReadOnly := False; setButtons(1) end; Table1.Active := True; Table1.GotoBookmark(pos) // Position wiederherstellen end;

464

Kapitel 9

Datenbankprogrammierung

Eine spezielle Bearbeitungstaste ist nicht mehr notwendig. Haben Sie in einer der DBEdit-Komponenten eine Änderung vorgenommen, so wird das OnAfterEdit-Ereignis ausgewertet, um zum Zustand 2 zu gelangen: procedure TForm1.Table1AfterEdit(DataSet: TDataSet); begin setButtons(2) end;

// irgendetwas eingegeben

Nach Post wird abgespeichert, sicherheitshalber stellen Sie mit Edit den Editiermodus wieder her: procedure TForm1.BtnStoreClick(Sender: TObject); begin Table1.Post; setButtons(1); Table1.Refresh end;

// Speichern

Das Löschen kann mit der Cancel-Methode leider nicht rückgängig gemacht werden, deshalb empfiehlt sich dringend das Zwischenschalten eines Meldungsfensters. procedure TForm1.BtnDeleteClick(Sender: TObject); // Löschen begin if MessageDlg('Wollen Sie den Kunden wirklich löschen?', mtWarning,[mbYes, mbNo], 0) = mrYes then begin Table1.Delete; Table1.Edit end end;

Die Taste "Neu": procedure TForm1.BtnNewClick(Sender: TObject); begin Table1.Append; setButtons(2) end;

// Neu

Die Taste "Rückgängig": procedure TForm1.BtnCancelClick(Sender: TObject); // Rückgängig begin Table1.Cancel; Table1.Edit; setButtons(1) end;

Test Nach Programmstart können Sie sich davon überzeugen, dass die Navigatortasten übersichtlich zu bedienen sind und zuverlässig funktionieren:

465

9.4 Praxisbeispiele für Fortgeschrittene

9.4.2 Rechnungs-Eingabemaske Bevor man überhaupt ein Rechnungsformular für einen Kunden ausdrucken kann, müssen die Daten natürlich erst einmal eingegeben werden. Leider lässt sich dieses Problem nicht in wenigen Worten bzw. Codezeilen abhandeln. Aus diesem Grund wird der Programmentwurf in drei Etappen aufgeteilt.

Datenbankstruktur

FIRMA-Datenbank Rechnungen.db

Rechnungsdaten.db

Artikel.db

Nr

RechnungsNr

Nr

Datum

ArtikelNr

Name

KundenNr

Artikelzahl

Einkaufspreis

GesamtNetto

Verkaufspreis Kunden.db

Bemerkung

Bestand

Nr Name PLZ Ort Straße Telefon

HINWEIS: Ausführliche Erläuterungen zu Entwurf bzw. Normalisierung dieser typischen rela-

tionalen Datenbankstruktur finden Sie in unserem [Borland Delphi – Datenbankprogrammierung], siehe Buch-CD.

466

Kapitel 9

Datenbankprogrammierung

Oberfläche 1 In der ersten Etappe soll die Benutzerschnittstelle zu den Tabellen Rechnungen.db und Kunden.db gestaltet werden. Um den Anblick optisch aufzuwerten, haben Sie alle Komponenten auf einen Panel (Panel1) gesetzt. Sie wollen gleich Nägel mit Köpfen machen und haben aus diesem Grund auf die triste DBNavigator-Komponente verzichtet und stattdessen eigene Buttons zum Bewegen durch die Datensätze und zum Bearbeiten derselben programmiert und auch einen Schreibschutz integriert. Der Einsteiger, der den damit verbundenen Aufwand scheut, kann aber durchaus auch den DBNavigator verwenden.

Binden Sie Table1 und Table2 auf gewohnte Weise an die FIRMA-Datenbank an. HINWEIS: Auf der Buch-CD finden Sie eine Kopie der Firma-Datenbank im Unterverzeichnis

\FirmaDB des vorliegenden Rezepts. Dadurch wird es möglich, das Rezept sofort von der CD zu laden und abzuspielen, ohne dass Sie vorher einen Alias einrichten bzw. zuweisen müssen. Die DatabaseName-Eigenschaft der Table-Komponenten ist auf den Wert ..\.\FirmaDB eingestellt. Dieser Eintrag kommt folgendermaßen zustande: Mit "..\ "wechseln wir in das unserem Projekt übergeordnete Verzeichnis. Von dort geht es mit ".\FirmaDB" in das Datenbankverzeichnis. Setzen Sie nun die TableName-Eigenschaften auf Rechnungen.DB bzw. Kunden.DB. Die DBTextbzw. DBEdit-Komponenten werden über ihre DataSource- bzw. DataField-Eigenschaften wie gewohnt an DataSource1 bzw. DataSource2 angekoppelt. Beim Anbinden der DBLookupComboBox müssen Sie sich schon etwas mehr konzentrieren: Eigenschaft DataSource DataField

ListSource

ListField

KeyField

Wert

DataSource2

Name

Nr

DataSource1

KundenNr

9.4 Praxisbeispiele für Fortgeschrittene

467

Siehe auch Übung 9.3.5 ("Verknüpfen von Tabellen").

Quelltext 1 Den für die acht Buttons erforderlichen Quellcode finden Sie in Übung 9.4.1 ("DBNavigator einsparen"). Um die Neueingabe von Datensätzen zu erleichtern, ergänzen Sie folgenden Event-Handler: procedure TForm1.Table1AfterInsert(DataSet: TDataSet); begin Table1['Datum']:= Date; // aktuelles Datum einsetzen Table2.Last; Table1['KundenNr']:= Table2['Nr'] // aktuellen Kunden einsetzen end;

Test 1 Starten Sie zur ersten Etappe der Applikation. Wenn Sie z.B. einen anderen Kunden zuweisen wollen, so markieren Sie einfach den entsprechenden Namen in der ComboBox. Vergessen Sie aber nicht, vorher den Schreibschutz aufzuheben. Änderungen an Datensätzen können Sie durch den "Rückgängig"-Button wieder verwerfen. Die endgültige Übernahme in die Datenbank erfolgt nach "Speichern" oder durch Bewegen zu einem anderen Datensatz.

Oberfläche 2 Ziel ist das Gestalten der Benutzerschnittstelle zur Tabelle Rechnungsdaten.db. Vergrößern Sie die Höhe von Form1 und bestücken Sie die neu hinzugekommene untere Hälfte gemäß folgender Abbildung mit Query1/DataSource3, einem DBGrid1 und den Buttons BtnNew1, BtnStore1, BtnCancel1, BtnDelete1. Die CheckBox1 brauchen Sie nicht neu hinzuzufügen, sie wird bloß vom oberen Teil von Form1 hierher verschoben.

468

Kapitel 9

Datenbankprogrammierung

Auf Bewegungstasten kann verzichtet werden, da man in einem DBGrid durch einfaches Zeilenklicken bzw. mittels Bildlaufleiste wesentlich bequemer weiterkommt. Setzen Sie für DBGrid1 die Eigenschaft ReadOnly = True. Legen Sie die SQL-Eigenschaft von Query1 wie folgt fest: SELECT * FROM Rechnungsdaten WHERE RechnungsNr = :Nr

Der mit vorangestellten Leerzeichen und Doppelpunkt gekennzeichnete Parameter Nr stammt aus Table1/DataSource1 (Rechnungen.DB). Um diesen Parameter innerhalb des SQL-Strings verfügbar zu machen, muss die DataSource-Eigenschaft von Query1 auf DataSource1 eingestellt werden. Sie verbinden danach DBGrid1 mit DataSource3 und setzen Query1.Active auf True. Nachdem die SQL-Eigenschaft von Query1 funktioniert, setzen Sie RequestLive = True.

Quelltext 2 Der zum Hinzufügen, Speichern, Löschen und Verwerfen der Rechnungsdaten erforderliche Code entspricht im Wesentlichen dem bereits erörterten Code zum Bearbeiten der Rechnungen (oberer Teil des Formulars), so dass auf eine vollständige Wiedergabe hier verzichtet werden kann (siehe Buch-CD). Lediglich beim Löschen einer Rechnung ist zu beachten, dass auch die in Rechnungsdaten.db gespeicherten Rechnungspositionen mit gelöscht werden: procedure TForm1.BtnDeleteClick(Sender: TObject); // Rechnung löschen begin if MessageDlg('Wollen Sie die Rechnung wirklich löschen?', mtWarning,[mbYes, mbNo], 0) = mrYes then begin while not Query1.Eof do Query1.Delete; // löscht Positionen Table1.Delete; Table1.Edit; BtnStoreClick(Self) end end;

Bemerkenswert ist auch der folgende Event-Handler, welcher den Fremdschlüssel RechnungsNr automatisch einträgt: procedure TForm1.Query1AfterInsert(DataSet: TDataSet); begin Query1['RechnungsNr']:= Table1['Nr'] end;

Wenn Sie für Table1 persistente Feldobjekte hinzugefügt haben (statt der standardmäßig vorhandenen dynamischen), kann die Anweisung auch wie folgt modifiziert werden: Query1['RechnungsNr']:= Table1Nr.Value

Test 2 In dieser Programmphase können Sie sich bereits am Zusammenspiel der drei Tabellen Kunden.db, Rechnungen.db und Rechnungsdaten.db erfreuen. Es werden nur die Rechnungsdaten angezeigt,

9.4 Praxisbeispiele für Fortgeschrittene

469

die der oben eingestellten Rechnung entsprechen. Beachten Sie, dass Sie bei Eingabe einer neuen Rechnung zunächst diese speichern müssen, ehe Sie Rechnungsdaten hinzufügen können:

Oberfläche 3 In dieser letzten Etappe werden Sie die bis jetzt noch offene Verbindung zur Tabelle Artikel.db herstellen. Ergänzen Sie in der unteren Hälfte von Form1 eine weitere Table-Komponente (Table3) und koppeln Sie diese an die Tabelle Artikel.DB an. Eine entsprechende DataSource-Komponente ist nicht erforderlich! Die Verbindung zwischen Rechnungsdaten.DB und Artikel.DB realisieren Sie diesmal durch Lookup-Felder, die zum Query1-Objekt hinzugefügt werden müssen. Gehen Sie dazu wie folgt vor: Doppelklicken Sie auf Query1 und wählen Sie im Popup-Menü des Feldeditors die Option "Felder hinzufügen..." (Strg+A). Anschließend ergänzen Sie über die Option "Neues Feld..." (Strg+N) ein Lookup-Feld, dem Sie z.B. den Namen ArtikelName verordnen. Im Dialogfenster "Neues Feld" stellen Sie Feldeigenschaften, Feldtyp und Lookup-Definition ein:

470

Kapitel 9

Datenbankprogrammierung

Im Objektinspektor erkennen Sie anhand der Eigenschaften des von Ihnen erzeugten Lookup-Feldes Query1ArtikelName: TStringField das Ergebnis Ihrer Bemühungen: Eigenschaft DisplayLabel

Wert

DisplayWidth

ArtikelName 40

KeyFields

LookupDataSet

LookupKeyFields

LookupResultField

ArtikelNr

Table3

Nr

Name

Auf analoge Weise fügen Sie ein weiteres Lookup-Feld für den Artikelpreis (Typ Currency) hinzu. Auch der Gesamtpreis pro Einzeleintrag, der sich aus Artikelanzahl mal Verkaufspreis berechnet, soll angezeigt werden. Dazu müssen wir statt eines "Lookup Feld" ein "Berechnetes Feld" zur Query1 hinzufügen:

471

9.4 Praxisbeispiele für Fortgeschrittene

Durch die neu hinzugekommenen Spalten wird der Platz im Anzeigegitter knapp, schaffen Sie also Luft durch Ausblenden überflüssiger Spalten! Da Sie den zukünftigen Nutzer des Programms nicht mehr mit dem Anblick von Fremdschlüsseln belästigen wollen, blenden Sie RechnungsNr und ArtikelNr einfach aus dem Anzeigegitter aus. Wählen Sie dazu die Columns-Eigenschaft von DBGrid1. Im Spalteneditor klicken Sie zunächst auf den Button "Alle Felder hinzufügen", anschließend löschen Sie die Spalten, die nicht angezeigt werden sollen.

Quelltext 3 Die Berechnung der Gesamtsumme führen Sie im OnCalcField-Event von Query1 durch: procedure TForm1.Query1CalcFields(DataSet: TDataSet); begin Query1Gesamtpreis.Value := Query1Artikelzahl.Value * Query1Artikelpreis.Value end;

Natürlich möchten Sie auch den Rechnungsendbetrag wissen, bevor die Rechnung ausgedruckt wird1. Zu diesem finden Sie in der Tabelle Rechnungen.db ein bisher unbeachtetes Feld GesamtNetto. Da wir in unserem Beispiel so gut wie ohne SQL auskommen wollen, gestaltet sich das Zuweisen von Werten für dieses Feld etwas aufwändiger. Der folgende Code zeigt eine Lösungsmöglichkeit (eine andere wäre das Hinzufügen eines "berechneten" Feldes zu Table1). Ergänzen Sie im implementation-Abschnitt von Form1 die folgende Prozedur: procedure gesamtSumme; // berechnet Gesamtsumme aus berechneten Feldern! var sum: Currency; begin with Form1 do begin Query1.DisableControls; // um Rechenzeit einzusparen sum := 0; Query1.First; while not Query1.EOF do begin sum := sum + Query1GesamtPreis.Value; Query1.Next end; Query1.EnableControls; Table1.Edit; Table1GesamtNetto.Value := sum; Table1.Post end end;

Die Übernahme des Endbetrags erfolgt jeweils beim Abspeichern neuer Rechnungsdaten. Ergänzen Sie also den entsprechenden Event-Handler wie folgt: procedure TForm1.BtnStore1Click(Sender: TObject); begin 1

// Eintrag speichern

Nur so können Sie Ihre Kunden vor unangenehmen Überraschungen bewahren!

472

Kapitel 9

Datenbankprogrammierung

Query1.Post; setButtons1(1); gesamtSumme end;

Test 3 Endlich ist es geschafft! Starten Sie das Programm und überzeugen Sie sich von der Funktionsfähigkeit, indem Sie bestehende Rechnungen manipulieren und neue hinzufügen:

Für die Eingabe des Artikelnamens hält unser Programm eine Überraschung parat: Klicken Sie zweimal auf das Feld, und Sie können über eine eingeblendete Rollbox den gewünschten Eintrag auswählen. Einfacher geht es wohl nicht mehr. Zu verdanken haben Sie dieses bemerkenswerte Feature den zu Query1 hinzugefügten Lookup-Feldern. Übrigens funktioniert das auch beim Artikelpreis. Hier ist das direkte Herumdoktern allerdings weniger sinnvoll, denn dazu verwenden Sie besser die separate Eingabemaske für Artikel.DB. Setzen Sie deshalb über die Columns-Eigenschaft von DBGrid1 diese Spalte vorsichtshalber auf ReadOnly = True.

9.4 Praxisbeispiele für Fortgeschrittene

473

Bemerkungen ■ Nach jedem Hinzufügen von Lookup-Feldern zu einem Table- bzw. Query-Objekt müssen Sie auch die Columns-Eigenschaft des mit dem Datenzugriffsobjekt verbundenen DBGrid aktualisieren ("Alle Felder hinzufügen" und vorher existierende Spalten löschen). Ansonsten bleiben die vorgenommenen Änderungen der Datenstruktur unsichtbar. ■ Im OnCalcField-Event einer Table bzw. Query haben Sie nur Zugriff auf persistente Datenfeld-Objekte, die Sie vorher (wie oben beschrieben) mit dem Feldeditor hinzufügen müssen.

9.4.3 Rechnung mit Rave Reports Eingabemasken können mit Rave Reports auf einfache Weise, unter Ausnutzung einer bereits vorhandenen Datenbankanbindung, ergänzt werden. Im Folgenden ergänzen wir das vorhergehende Beispiel um eine standesgemäße Druckausgabe.

Oberfläche Erweitern Sie zunächst das vorhandene Formular um eine zusätzliche TQuery-Komponente sowie eine Datasource, mit der wir die jeweiligen Summen (NettoGesamt, BruttoGesamt und Mehrwertsteuer) berechnen. Die Anbindung an die Datenbank erfolgt analog zur bereits eingefügten Query, auch hier handelt es sich um eine Master-Detail-Beziehung. Die zugehörige SQL-Anweisung: SELECT sum (artikelzahl*verkaufspreis*1.16) AS Brutto, sum (artikelzahl*verkaufspreis) AS Netto, sum (artikelzahl*verkaufspreis*1.16) - sum (artikelzahl*verkaufspreis) AS MWST FROM Rechnungsdaten, artikel WHERE (RechnungsNr = :Nr)AND(Rechnungsdaten.Artikelnr=artikel.nr)

Die drei Felder zeigen wir in DBLabel-Komponenten an:

Alle drei Werte werden wir direkt an den Report übergeben, so vermeiden wir Rundungsdifferenzen zwischen Programm und Report. Bevor wir den eigentlichen Report entwerfen, kümmern wir uns zunächst um unser Formular, das für die Reportausgabe vorbereitet werden muss. Dazu fügen Sie zunächst ein RvProjekt-Kompo-

474

Kapitel 9

Datenbankprogrammierung

nente ein (Anbindung des Reports). Zusätzlich werden den vorhandenen Table- und Query-Komponenten jeweils RvTableConnection- bzw. RvQueryConnection-Komponenten zugeordnet.

Wie Sie der Abbildung entnehmen können, haben wir auch eine RvRenderPDF-Komponente in das Formular eingefügt, so haben wir jederzeit die Möglichkeit, die Reportdaten auch im AcrobatPDF-Format auszugeben. Fügen Sie auch gleich noch einen Button ein, über den wir den Report später aufrufen werden.

Report Damit ist es so weit, wir können uns dem eigentlichen Reportentwurf zuwenden. Wie schon in den vorhergehenden Übungen müssen wir zunächst einen neuen Report erzeugen. Diesem ordnen wir die von unserem Delphi-Programm bereitgestellten Connections zu (Menü Datei| Neues Datenobjekt). Wählen Sie alle drei Verbindungen aus:

9.4 Praxisbeispiele für Fortgeschrittene

475

In der Baumansicht auf der linken Seite sollten jetzt die gewünschten Informationen erscheinen:

Im nächsten Schritt fügen Sie eine Region-Komponente sowie drei Band- und eine DataBandKomponente entsprechend folgender Abbildung ein. Platzieren Sie DataText- und Text-Komponenten auf den jeweiligen Bändern:

476

Kapitel 9

Datenbankprogrammierung

Binden Sie das DataBand an die Details-Connection (Eigenschaft DataView). Wie Sie die BandStyle-Eigenschaften der jeweiligen Bänder festlegen, zeigen die folgenden Abbildungen:

9.4 Praxisbeispiele für Fortgeschrittene

477

HINWEIS: Band2 und Band3 müssen über die Eigenschaft ControllerBand an DataBand1 ge-

bunden werden! Zum Berechnen der Gesamtsumme (Netto) verwenden wir die CalcText-Komponente. Weisen Sie dieser die folgenden Eigenschaften zu: ■ CalcType = ctSum ■ Controller = DataBand1 ■ DataField = Gesamtpreis ■ DataView = dvDetails ■ DisplayFormat = '0.00 €' Für die Anzeige der Mehrwertsteuer bzw. der Gesamt-Bruttosumme verwenden wir gleich die im Delphi-Programm berechneten Werte. Erzeugen Sie dazu zwei Report-Parameter, indem Sie in der Baumansicht den Report auswählen und über die Eigenschaft Parameters die folgende Dialogbox öffnen und die gewünschten Namen eingeben:

478

Kapitel 9

Datenbankprogrammierung

Für die Anzeige verwenden Sie DataText-Komponenten, deren Eigenschaft DataField Sie auf den jeweiligen Parameter festlegen:

Damit ist der Reportentwurf abgeschlossen, Sie können den Report im Delphi-Projektverzeichnis sichern.

9.4 Praxisbeispiele für Fortgeschrittene

479

HINWEIS: Bei einem Test im Report-Designer werden die Zeilensumme und damit auch die an-

deren Summen nicht berechnet, da es sich um Delphi-berechnete Felder handelt. In Ihrem Delphi-Projekt weisen Sie nun der RvProject-Komponente den Report zu. Was bleibt, ist das Übergeben der Reportparameter und die Anzeige der Druckvorschau: procedure TForm1.Button2Click(Sender: TObject); // Rechnung drucken begin rvproject1.Open; rvproject1.SetParam('Netto',dbtext5.Field.DisplayText); rvproject1.SetParam('Mwst',dbtext6.Field.DisplayText); rvproject1.SetParam('Brutto',dbtext7.Field.DisplayText); rvproject1.Execute; end;

Test Starten Sie das Programm. Wählen Sie eine Rechnung aus. Nach dem Klick auf "Druckvorschau" ist Rave Report einen kleinen Moment mit sich selbst beschäftigt und überrascht Sie anschließend mit einer fein säuberlich angefertigten Rechnung:

10

Programmschnittstellen/Peripherie

Kapitel

10

Programmschnittstellen/Peripherie In diesem Kapitel wollen wir wichtige Möglichkeiten vorstellen, mit denen Ihr Delphi-Programm mit der "Außenwelt" kommunizieren kann. Betrachtet werden ■ Datenaustausch mit der Zwischenablage (Clipboard) ■ DLL-Programmierung (Dynamic Link Library) ■ Druckeransteuerung (Printer) OLE/ActiveX als wohl wichtigste Programmschnittstelle wird nicht etwa unter den Tisch gekehrt, sondern in Kapitel 12 vorgestellt1.

10.1 Zwischenablage Die Zwischenablage dient der Übertragung von Datenobjekten zwischen verschiedenen Anwendungen, entweder auf Grund von Befehlseingaben des Benutzers (Einfügen, Kopieren) oder programmgesteuert. Zu diesem Zweck werden globale Speicherblöcke verwendet, auf die jede angemeldete Applikation zugreifen kann.

10.1.1 Das Clipboard-Objekt Delphi stellt für die Arbeit mit der Zwischenablage das Clipboard-Objekt zur Verfügung (Unit Clipbrd). Der grundsätzliche Ablauf: Programm 1 stellt in einer Image-Komponente eine Grafik dar. Um diese nach Programm 2 zu übertragen, wird die Windows-Zwischenablage verwendet. Mit der Clipboard-Methode Assign können die Grafikdaten zwischen beiden Anwendungen ausgetauscht werden. Die Methoden: ■ Assign (Austausch von Grafikdaten) ■ Clear (löscht die Zwischenablage) 1

Ganz am Rande: Für den schnellen Datenaustausch zwischen zwei Win 32-Anwendungen bieten sich auch Memory Mapped Files an (siehe Kapitel 8).

482

Kapitel 10

Programmschnittstellen/Peripherie

■ Close (schließt die Zwischenablage) ■ Open (öffnet die Zwischenablage, wenn mehrere Formate abgelegt werden sollen) ■ GetAsHandle (liefert ein Windows-Handle auf das Objekt in der Zwischenablage) ■ HasFormat (fragt den Datentyp in der Zwischenablage ab) ■ SetAsHandle (übergibt einen Handle an die Zwischenablage) ■ SetTextbuf (kopiert Text in die Zwischenablage) Die Eigenschaften: ■ AsText (Abfragen von Zwischenablagedaten im Textformat) ■ FormatCount (Anzahl der Zwischenablageformate) ■ Formats (Liste der Zwischenablageformate) Für die Methode HasFormat() brauchen Sie folgende Konstanten: Format

Beschreibung

CF_TEXT

Text, in dem jede Zeile mit einer Kombination CR-LF1 endet. Das Textende ist durch ein Nullzeichen markiert.

CF_BITMAP

Windows-Bitmap-Grafik.

CF_METAFILE

Windows-Metafile-Grafik (richtig: CF_METAFILEPICT).

CF_PICTURE

Ein Objekt vom Typ TPicture (ICO, WMF, BMP).

CF_OBJECT

Persistente Objekte.

Mit den Konstanten können Sie abfragen, ob eines der vordefinierten Zwischenablage-Formate vorhanden ist. Es ist auch möglich, neue Clipboard-Formate zu definieren, dieser Aspekt soll jedoch nicht weiter verfolgt werden, da man im Allgemeinen mit den vorhandenen Möglichkeiten auskommt. if Clipboard.HasFormat(CF_Bitmap) then Image1.Picture.Assign(Clipboard) else MessageBeep(0);

Das Gleiche nach der "Quick and Dirty"-Methode: try Image1.Picture.Assign(Clipboard) except MessageBeep(0); end

1

Wagenrücklauf und Zeilenschaltung

10.1 Zwischenablage

483

Die Windows-Zwischenablage kann mehrere Formate gleichzeitig speichern (zum Beispiel Text und Grafik), der Aufruf der Open-Methode entscheidet darüber, ob die gesamte Zwischenablage gelöscht (Standard) oder ob nur ein bestimmtes Format überschrieben wird (Aufruf von Open ... Close). BEISPIEL: Gleichzeitiges Speichern von Grafik und Text Clipboard.Open; Clipboard.Assign(Image1.picture); Clipboard.AsText := 'Hallo'; Clipboard.Close;

10.1.2 Umsetzung der Zwischenablage-Funktionen Im Zusammenhang mit der Zwischenablage finden Sie unter dem Menüpunkt Bearbeiten fast immer die folgenden Befehle: ■ Kopieren (Strg+C) ■ Ausschneiden (Strg+X) ■ Einfügen (Strg+V) Wie diese in Delphi zusammen mit einem Memo-Feld umzusetzen sind, entnehmen Sie bitte den folgenden Listings: BEISPIEL: Kopieren procedure TForm1.Button2Click(Sender: TObject); begin if Memo1.SelText <> '' then Clipboard.AsText:= Memo1.SelText; end;

BEISPIEL: Ausschneiden procedure TForm1.Button2Click(Sender: TObject); begin if Memo1.SelText <> '' then begin Clipboard.AsText:= Memo1.SelText; Memo1.SelText:= '' end end;

BEISPIEL: Einfügen procedure TForm1.Button2Click(Sender: TObject); begin try Memo1.SelText:= Clipboard.AsText except

484

Kapitel 10

Programmschnittstellen/Peripherie

end end;

Die Programmierung eines Zwischenablage-Betrachters, der auch auf den Wechsel des Inhalts reagiert, ist in Delphi relativ einfach. Definieren Sie einen protected-Abschnitt in der Typ-Deklaration des betreffenden Formulars und nehmen Sie folgende neue Botschaftsbehandlung auf: procedure WMDrawClipboard(var Message: TMessage); message WM_DrawClipboard;

Die Umsetzung der Botschaftsbehandlung: procedure TForm1.WMDrawClipboard(var Message: TMessage); begin ... Code zur Anzeige von Zwischenablagedaten ... inherited; { vererbte Behandlungsroutine aufrufen } end;

Damit Ihr Programm die Windows-Botschaft WM_DRAWCLIPBOARD überhaupt empfängt, muss Ihre Anwendung als Zwischenablagebetrachter registriert werden: var nextViewer : hwnd; { global deklarieren } procedure TForm1.FormCreate(Sender: TObject); begin nextViewer:= SetClipboardViewer(Form1.Handle) end;

Bei Programmende melden Sie sich natürlich ordentlich ab: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin ChangeClipboardChain(Form1.Handle, nextViewer) end;

Eventuell sollten Sie noch die Botschaft WM_CHANGECBCHAIN bearbeiten, mit der angezeigt wird, dass sich die Viewer-Kette verändert hat.

10.2 DLL-Programmierung Wir wollen Sie im Folgenden mit der DLL-Programmierung in Pascal und in C vertraut machen1. Sie werden sich vielleicht wundern, warum auch die DLL-Programmierung in C besprochen wird. Die Antwort ist schnell gefunden. Zum einen sind C-Programme teilweise schneller, zum anderen erlangen Sie auf diese Weise ein besseres Verständnis für die Aufrufsyntax vieler API-Funktionen (diese sind nun einmal in C geschrieben). Der Abschnitt 10.2.5 behandelt ausschließlich das Erstellen von DLLs für Visual Basic-Programme. Da diese Programmiersprache eine weite Verbreitung gefunden hat, jedoch wesentliche Einschränkungen besitzt (keine Pointer, keine DLLs2, keine systemnahe Programmierung), dürfte Delphi die ideale Ergänzung darstellen. Die Ausführungen

1

Es geht hier ausschließlich um "normale" DLLs, also nicht um ActiveX-DLLs.

2

Mal abgesehen von den OLE-DLLs, bei denen es sich nicht um echte DLLs handelt.

10.2 DLL-Programmierung

485

machen Sie mit den Besonderheiten vertraut, so dass Ihre mit Delphi produzierten DLLs problemlos in VB eingebunden werden können. Durch die Trennung nach Programmiersprachen können sich die Inhalte der folgenden Ausführungen in einigen Punkten überdecken, dies haben wir jedoch im Interesse einer übersichtlichen Darstellung in Kauf genommen.

10.2.1 Grundlagen DLLs (Dynamic Link Library) sind compilierte Modulbibliotheken mit offen gelegter Schnittstelle, die sich zur Laufzeit durch andere Programme mit DLL-Schnittstelle einbinden lassen. In der Applikation befindet sich lediglich ein Verweis auf die entsprechende DLL bzw. Funktion/ Prozedur. Nach dem Programmstart sorgt die Systemverwaltung von Windows dafür, dass die benötigten DLLs in den Arbeitsspeicher geladen werden. Für Ihre Anwendung ist es im Allgemeinen egal, ob sich die Funktion in einer DLL befindet oder ob sie direkt im Programm eingebunden ist. Der Vorteil der DLL ist eine effektivere Nutzung sowohl des Platten- als auch des Arbeitsspeichers. Haben Sie beispielsweise mehrere Delphi-Datenbank-Applikationen auf dem Rechner, nutzen alle Programme dieselben DLLs, die einzelne EXE-Datei bleibt deshalb relativ klein. Dieses leistungsfähige Konzept ermöglicht es dem Delphi-Programmierer, entweder auf vorhandene DLLs zuzugreifen (z.B. auf die Windows-API) oder aber eigene Routinen zu programmieren. Letzteres erfordert jedoch einige tiefgründigere Kenntnisse.

10.2.2 Umstellung von 16 auf 32 Bit Haben Sie vor langer, langer Zeit einmal 16-Bit-DLLs erstellt, mussten Sie sich seit Delphi 2 auf einige wesentliche Änderungen gefasst machen1. Das erneute Compilieren von Anwendungen lässt sich ja in den meisten Fällen ohne größere Probleme realisieren, DLLs hingegen bedürfen einer etwas aufwändigeren Überarbeitung.

Schreibweise Im Unterschied zur bisherigen Verfahrensweise wird bei einer 32-Bit-DLL die Groß-/Kleinschreibung unterschieden. Dies trifft sowohl auf den Import als auch auf den Export von Prozedurbzw. Funktionsnamen zu. BEISPIEL: Die API-Funktion WinExec können Sie nur wie folgt einbinden: function WinExec; external kernel32 name 'WinExec';

Der Aufruf function WinExec; external kernel32 name 'winexec';

führt zur Meldung, dass die Funktion nicht gefunden wurde. 1

Dieser Abschnitt ist nur für Leser gedacht, die bereits 16-Bit-DLLs entworfen haben und die über die dafür nötigen Grundkenntnisse verfügen.

486

Kapitel 10

Programmschnittstellen/Peripherie

Solange es sich um API- bzw. GDI-Funktionen handelt, dürften Sie kaum Probleme bekommen, da (fast) alle Aufrufe in den Schnittstellen-Units (windows, mapi ...) vordefiniert sind. Etwas anders sieht die Sache bei eigenen DLLs aus. In diesem Fall sollten Sie sowohl bei der Funktionsdeklaration als auch bei der Exports-Klausel die gleiche Schreibweise verwenden, um unnötige Probleme zu verhindern. procedure Definiere(s : PChar); stdcall; begin ... end; exports Definiere;

Damit sind wir auch schon beim nächsten Thema angelangt, den Aufrufkonventionen:

Aufrufkonvention Rufen Sie Funktionen aus DLLs auf, die in anderen Programmiersprachen geschrieben wurden, müssen Sie die stdcall-Konvention für den Export der Funktion verwenden. Das Gleiche trifft zu, wenn Sie eine DLL beispielsweise für Visual Basic schreiben. Auch hier gilt für die Übergabe der Parameter die stdcall-Konvention. Beim einfachen Neucompilieren der DLL oder Anwendung wird von Delphi automatisch die Aufrufkonvention register verwendet. HINWEIS: Alle API- und GDI-Funktionen sind mit stdcall aufzurufen, auch wenn Sie in einigen

C-Programmen die Konventionen PASCAL, WINAPI oder CALLBACK finden. Diese werden ebenfalls als stdcall übersetzt. BEISPIEL: Export einer Funktion mit stdcall procedure Definiere(s : PChar);stdcall;

BEISPIEL: Einbinden einer Funktion mit stdcall procedure Definiere(s:string); stdcall; external 'FParse32.dll';

Die Unterschiede der einzelnen Aufrufkonventionen resultieren aus ■ Reihenfolge der Parameterübergabe (Stack/Register) ■ Zuständigkeit für das Löschen von Parametern aus dem Stack (Aufrufer oder Funktion) ■ Verwendung von Registern zur Parameterübergabe (nur register) Dass eine falsche Aufrufkonvention zu Problemen führt, dürfte aus obigen Unterschieden schnell ersichtlich sein. Selbst wenn die Funktion noch aufgerufen wird, sind die Parameter im Allgemeinen nicht mehr zu gebrauchen, von der Unordnung auf dem Stack einmal ganz abgesehen.

10.2 DLL-Programmierung

487

Der Grund für die neue Konvention ist die Kompatibilität mit C, wo einer Funktion auch eine variable Anzahl von Parametern übergeben werden kann. Dies bedingt eine Ablage der Parameter von rechts nach links auf dem Stack.

Verwenden von Strings als Übergabeparameter Auch bei der Übergabe von Strings hat sich einiges verändert. Zum einen müssen Sie zwischen ANSI- und UNICODE-Strings unterscheiden, zum anderen bringt die Verwendung der neuen Strings einige Besonderheiten mit sich. Grundsätzlich gilt: Exportiert Ihre DLL Strings (Lange Strings), müssen Sie sowohl in die DLL als auch in die aufrufende Anwendung die Unit ShareMem einbinden. Diese wiederum stellt die Verbindung zu BORLNDMM.DLL (Shared Memory Manager) her, die Sie mit Ihrer DLL weitergeben müssen. Die Unit ShareMem sollte die erste Unit in der uses-Klausel sein. Beim Import von Strings über die DLL-Schnittstelle bietet Ihnen das Windows-API zwei verschiedene Varianten an. Jede Funktion ist in zwei Versionen in den Windows-Libraries enthalten. Eine Funktion exportiert ANSI-Strings (der Funktionsname endet mit einem 'A'), die andere UNICODE-Strings (an den Funktionsnamen ist ein 'W' angehängt). BEISPIEL: (windows.pas) // ANSI function WritePrivateProfileSectionA(lpAppName, lpString, lpFileName: PAnsiChar): BOOL; stdcall; external kernel32 name 'WritePrivateProfileSectionA'; // UNICODE function WritePrivateProfileSectionW(lpAppName, lpString, lpFileName: PWideChar): BOOL; stdcall; external kernel32 name 'WritePrivateProfileSectionW'; // ANSI-Standard function WritePrivateProfileSection(lpAppName, lpString, lpFileName: PChar): BOOL; stdcall; external kernel32 name 'WritePrivateProfileSectionA';

Wie Sie dem obigen Quellcode entnehmen können, geht Delphi noch einen Schritt weiter und definiert gleich drei Varianten für eine Funktion. Mit der dritten Variante wird standardmäßig die ANSI-Funktion eingebunden, da auch alle Pascal-Stringtypen derzeit die ANSI-Variante verwenden. Wer bisher Schwierigkeiten bei der Übergabe von nullterminierten Strings an API-Funktionen hatte, wird sich freuen: Die Übergabe langer Strings kann als PChar() erfolgen. Erwartet die API-Funktion allerdings einen Puffer, müssen Sie diesen auch bei langen Strings initialisieren.

Datentypen Mit der Umstellung von 16 auf 32 Bit wurde auch eine neue Fehlerquelle zum Leben erweckt: Ärger mit den Datentypen.

488

Kapitel 10

Programmschnittstellen/Peripherie

Wurde bisher ein Integerwert mit 2 Byte gespeichert, sind es jetzt 4 Byte. Unglücklicherweise werden bei einigen Anwendungen/Programmiersprachen immer noch 2 Byte verwendet. Stellen Sie sich gegebenenfalls darauf ein und verwenden Sie statt Integer in diesem Fall SmallInt. Gleiches trifft auch auf die Verwendung von Records zu. Sehen wir einmal von der Veränderung der enthaltenen Datentypen ab, tritt ein weiteres Problem auf: Records werden in Delphi so gespeichert, dass sie möglichst an 32-Bit-Grenzen ausgerichtet sind. BEISPIEL: Der nachstehende Record lässt vermuten, dass er 5 Byte belegt, stattdessen werden 8 Byte reser-

viert. type TTest = record a:Byte; b:Integer; end;

// SizeOf(TTest) = 8 Byte

Konsequenterweise belegt der folgende Record aber nicht acht, sondern zwei Byte: type TTest = record a:Byte; b:Byte; end;

// SizeOf(TTest) = 2 Byte

Wollen Sie diesem doch recht eigenwilligen Verhalten entgehen, müssen Sie die Option packed verwenden, die Variablen so in einem Record anordnet, wie es der Datentyp vorgibt. Dies gilt umso mehr für den Zugriff auf typisierte Dateien. type TTest = packed record a:Byte; b:Integer; end;

// SizeOf(TTest) = 5 Byte

Wer trotzdem mit den normalen Delphi-Records arbeitet, sollte statt der festen Zuweisung bei der Übergabe von Recordgrößen besser die Funktion SizeOf verwenden.

Weitere Unterschiede Zum Schluss wollen wir noch auf eine wesentliche Änderung eingehen. Wurde bisher beim mehrmaligen Aufruf einer DLL ein und derselbe Heap verwendet, wird jetzt bei jedem Aufruf der DLL der Heap des aufrufenden Prozesses genutzt. Das führt zu der durchaus erfreulichen Feststellung, dass bisher auftretende Seiteneffekte (Programm A setzt Variable und Programm B löscht diese) nicht mehr zu beobachten sind. Aus diesem Grund wird auch der Begin-End-Abschnitt der DLL bei jedem Aufruf durch einen weiteren Prozess erneut durchlaufen (zur Initialisierung von Variablen). Damit entfällt natürlich aber auch die Möglichkeit, Daten zwischen zwei Programmen über eine DLL auszutauschen.

10.2 DLL-Programmierung

489

PS: Eine gute Nachricht für schreibfaule Programmierer: Die Angabe Export hinter dem Prozedurbzw. Funktionsnamen wird nicht mehr benötigt, es genügt, wenn die Funktion im ExportsAbschnitt auftaucht.

10.2.3 DLL-Programmierung mit Delphi Die Programmierung einer DLL in Delphi ist relativ einfach, öffnen Sie mit Datei|Neu|Weitere... die Objektgalerie und wählen Sie DLL-Experte.

Sollten Sie schon einmal eine Unit programmiert haben, werden Sie kaum Probleme bekommen. Ähnlich wie in einer Unit können auch in einer DLL Prozeduren/Funktionen exportiert werden. Die wichtigsten Unterschiede: ■ eine Unit wird in die EXE-Datei eingebunden ■ eine Unit kann Variablen, Konstanten und Typen exportieren ■ eine Unit kann Objekte exportieren1 Ein weiterer Unterschied ergibt sich aus der Möglichkeit, eine DLL durch mehrere Programme gleichzeitig zu nutzen. Der Zugriff auf Variablen innerhalb einer DLL ist nur mit Hilfe einer Funktion oder Prozedur möglich.

1

Auf OLE-DLLs wollen wir an dieser Stelle nicht weiter eingehen.

490

Kapitel 10

Programmschnittstellen/Peripherie

Das "Grundgerüst" einer Pascal-DLL sieht folgendermaßen aus: library ; uses ; procedure ; ; begin ; end; function :; ; begin ; end; exports index resident, ... index resident; begin end.

HINWEIS: Beachten Sie die Groß-/Kleinschreibung bei Prozedur- und Funktionsnamen, diese

wird bei 32-Bit-DLLs unterschieden. Einige Hinweise zu den einzelnen Elementen des DLL-Grundgerüsts: ■ Statt program schreiben Sie einfach library, alle Funktionen/Prozeduren, die Sie exportieren wollen, müssen im Exports-Abschnitt der DLL aufgeführt werden. ■ Die index-Angabe ist optional, ermöglicht aber bei der späteren Einbindung der DLL einen schnelleren Zugriff, da nicht erst in der Namenstabelle nach der Anweisung gesucht werden muss (sollte nicht mehr verwendet werden). ■ Ebenfalls optional, aber empfehlenswert, ist die Option resident, die bestimmt, ob Exportinformationen im Speicher gehalten werden, nachdem die DLL geladen wurde. Daraus resultiert eine kürzere Ladezeit, wenn ein Programm die Funktion über ihren Namen einbindet. ■ Hinter der Deklaration der Funktion bzw. Prozedur können Sie eine Aufrufkonvention angeben, d.h., Sie bestimmen, wie, wo und in welcher Reihenfolge die Parameter übergeben werden. Zur Auswahl stehen die folgenden Möglichkeiten: stdcall, register, cdecl, pascal. Schreiben Sie eine DLL für Delphi-Programme, sollten Sie die Option register einsetzen, in allen anderen Fällen ist stdcall empfehlenswert.

Funktionsparameter Eine Prozedur oder Funktion erwartet im Allgemeinen einen oder mehrere Parameter. Dabei müssen Sie zwischen zwei grundsätzlichen Möglichkeiten unterscheiden:

10.2 DLL-Programmierung

491

■ Übergabe eines Wertes (Kopie) ■ Übergabe einer Referenz (Zeiger) Im ersten Fall erstellen Sie quasi eine Kopie der Variablen und übergeben die Kopie an die Funktion, im zweiten Fall "sagen" Sie der Funktion, wo sich die Variable im Speicher befindet. Daraus resultieren auch die konkreten Anwendungsfälle beider Varianten. Da bei der Zeigerübergabe die eigentliche Variable "bekannt" ist, kann diese nicht nur gelesen, sondern auch geschrieben werden. Bei der Übergabe des Wertes (Kopie) kann dieser zwar auch verändert werden, die Variable selbst hat damit jedoch nichts mehr zu tun. Verwenden Sie die Option var nur, wenn Sie Werte an ein Programm zurückgeben. Dies bedeutet, dass die aufrufende Anwendung nicht den Wert, sondern einen Zeiger auf den Wert übermittelt. BEISPIEL: Die folgenden Codefragmente zeigen sowohl die Definition in Object Pascal als auch die Ein-

bindung in eine andere Anwendung (Visual Basic). library Test; procedure wert(x:Double;var y:Double); stdcall; begin y:= sin(x) end;

Die Variable x wird als Wert, die Variable y als Referenz (Pointer) nach VB übermittelt: Declare Sub wert Lib "test.dll" (ByVal x As Double, y As Double) ... Dim x As Double, y As Double x = 0.7 wert x,y Print y

An die Prozedur übergeben wir einen x-Wert, der y-Wert wird berechnet und zurückgeliefert. Natürlich hätte man in diesem Fall auch eine Funktion schreiben können, sollen jedoch mehrere Werte zurückgegeben werden, ist eine andere Realisierung kaum möglich. Solange Sie die DLL lediglich für ein Delphi-Programm schreiben, brauchen Sie bei der Wahl des Datentyps keine Rücksicht zu nehmen, es gelten die normalen Regeln für die Auswahl von Funktionsparametern. Anders sieht die Sache allerdings aus, wenn die DLL auch von einem VB-Programm eingebunden werden muss. In diesem Fall müssen Sie sich an den Datentypen der anderen Programmierumgebung orientieren. Lesen Sie dazu die Abschnitte 10.2.5 und 10.2.6.

Ein-/Austrittsprozedur Eine DLL besitzt zwei typische Prozeduren, die beim Start bzw. beim Beenden aufgerufen werden. Die "Startprozedur" ist der begin-end-Abschnitt am Ende der DLL, in dem Sie Initialisierungsroutinen aufrufen können. Entgegen der Verfahrensweise bei 16 Bit wird dieser Abschnitt bei jedem Aufruf der DLL durch einen neuen Prozess erneut durchlaufen. HINWEIS: Ein aussagekräftiges Beispiel finden Sie im Praxisteil dieses Kapitels.

492

Kapitel 10

Programmschnittstellen/Peripherie

Die zweite Routine ist nicht so einfach erstellt, denn Sie müssen sich einen Zeiger auf die alte ExitProzedur holen und Ihre eigene Exitprozedur "einklinken". Nach dem Aufruf durch die WindowsVerwaltung restaurieren Sie noch die originale Exitprozedur, den Zeiger darauf hatten wir ja bereits gespeichert. Das Ganze im Listing: library testDLL; uses Windows; var OldExit: Pointer; procedure NewExit; far; begin if ExitCode = WEP_System_Exit then { System wird heruntergefahren } else { DLL wird entladen } ExitProc := OldExit; end; { die Initialisierungsroutine begin-end :} begin OldExit := ExitProc; { sichern alten Status } ExitProc := @NewExit; { neue Exitprozedur } end.

Noch einfacher können Sie eine Exitprozedur über die Funktion AddExitProc aus der Unit SysUtils installieren. Rufen Sie die Funktion einfach im Initialisierungsteil Ihrer DLL oder in einer anderen Funktion auf. Sie können mehrere Exit-Prozeduren installieren, die zuletzt installierte wird beim Beenden zuerst ausgeführt. library test; uses Dialogs, SysUtils; procedure NewExit; begin ShowMessage('Exitprozedur 1'); { DLL wird entladen } end; procedure NewExit1; begin ShowMessage(' Exitprozedur 2'); { DLL wird entladen } end; { die Initialisierungsroutine begin-end } begin AddExitProc(NewExit); AddExitProc(NewExit1) end.

10.2 DLL-Programmierung

493

Export von Formularen in DLLs Brauchen Sie häufig die gleichen Formulare, oder wollen Sie anderen Anwendern Formulare zur Verfügung stellen, ohne gleich den Code weiterzugeben? Dann wäre eine DLL mit eingebundenen Formularen die ideale Lösung. Die Vorgehensweise gleicht dem Erstellen "normaler" Projekte: Sie erzeugen Formulare und füllen die Ereignisroutinen aus. Wenn Sie die Formulare ausgiebig getestet haben, können Sie das Projekt in eine DLL umwandeln. Gehen Sie dabei wie folgt vor: ■ Löschen Sie in der Projektdatei das Hauptprogramm. ■ Ändern Sie die Bezeichnung program in library. ■ Erstellen Sie eine Schnittstellenroutine. Die Schnittstellenroutine übernimmt die Funktion des bisherigen Hauptprogramms, d.h. das Erstellen von Formularen etc. procedure FensterAnzeigen(Beschriftung: string); begin Form1 := TForm1.Create(Application); try Form1.ShowModal // unbedingt nötig !!!!!!!!!!!! finally Form1.Release end; end;

Sie werden sich vielleicht wundern, warum die Methode ShowModal verwendet wird. Die Antwort findet sich, wenn Sie stattdessen Show verwenden: Das Formular wird kurz angezeigt und sofort wieder geschlossen, da die Free-Methode unmittelbar darauf folgt. Soll das Formular nicht modal angezeigt werden, könnten Sie auch zwei getrennte Funktionen verwenden. Die erste zeigt das Formular an, die zweite löscht es wieder. procedure Anzeigen; begin if Form2 = Nil then Form2 := TForm1.Create(Application); Form2.Show end; procedure Entfernen; begin Form2.Hide end;

Einbinden von DLLs Nach dem Erstellen der DLL sollte diese auch in ein Delphi-Programm eingebunden werden. Zwei unterschiedliche Verfahren bieten sich an:

494

Kapitel 10

Programmschnittstellen/Peripherie

■ statische DLL-Einbindung ■ dynamische DLL-Einbindung Im Normalfall genügt die erste (und einfachere) Methode: Beim Compilieren wird ein fester Hinweis auf die zugehörige DLL in die EXE gelinkt. Mit dem Programmaufruf startet zuerst die DLL, danach die Programmausführung. Aus diesem Ablauf resultiert auch die Notwendigkeit für das zweite Verfahren. Ist die DLL nicht vorhanden oder möchten Sie DLLs mit unterschiedlichen Namen1 zur Laufzeit einbinden, versagt das erste Verfahren. In diesem Fall müssen Sie mit LoadLibrary und GetProcAddress die Routinen aus der DLL dynamisch einlinken. Ein aufschlussreiches Beispiel zu diesem Thema finden Sie im Praxisteil dieses Kapitels. Die statische Einbindung einer DLL-Routine ist relativ einfach: procedure definiere(s:string); stdcall; external 'FPARSER';

Es genügt die Angabe des Prozedurkopfes, des DLL-Namens sowie die Deklaration als external. Weiterhin müssen Sie gegebenenfalls die Aufrufkonvention angeben, falls diese von registers abweicht (für API-Funktionen immer stdcall).

Fehlerbehandlung in DLLs Fehler können Sie in einer DLL wie in einem Programm mit Try-Except-Blöcken kapseln. Verzichten Sie darauf und tritt trotzdem ein Fehler auf, wird dieser an das aufrufende Programm weitergegeben. Dort können Sie den Fehler dann gegebenenfalls behandeln. Delphi ist in diesem Zusammenhang allerdings sehr tolerant, fast kein Fehler führt zu einem Programmabbruch, in den meisten Fällen wird eine Dialogbox angezeigt, die "Gesprächsbereitschaft" signalisiert. Etwas anders sieht die Sache aber bei einem VB-Programm aus. Dort müssen Sie eine eigene Fehlerbehandlung installieren, sonst wird Ihr Programm abgebrochen. Alternativ steht Ihnen die Fehlerbehandlung innerhalb der DLL zur Verfügung.

10.2.4 DLL-Programmierung mit C Und schon sind wir bei der C-Programmierung angelangt! Für die Beispielprogramme verwenden wir zur Abwechslung einmal den MS Visual C++ Compiler, es hätte aber genauso gut auch Borland C oder der Borland C++ Builder sein können. Prinzipiell unterscheidet sich die DLL-Programmierung nicht von der Programmierung in Pascal, lediglich der Verwaltungsaufwand ist etwas höher. Die Entschädigung für diese Mehrarbeit: schnellerer und kompakterer Code und teilweise universellere Routinen.

Einführung Die Entwicklungsumgebung des VC-Compilers dürfte viele Programmierer eher abschrecken als zum Programmieren ermuntern. Aus diesem Grund wollen wir an dieser Stelle eine Kurzanleitung geben, wie Sie auf möglichst einfache Weise ein DLL-Programmgerüst erzeugen. Wer bereits über 1

Die Grafikfilter von Word sind ein Beispiel für dynamisch gelinkte DLLs.

10.2 DLL-Programmierung

495

Erfahrungen mit der DLL-Programmierung in VC verfügt, kann den folgenden Abschnitt bedenkenlos überspringen. Grundvoraussetzung für eine DLL ist ein so genanntes Projekt (auch als Workspace bezeichnet), das alle relevanten Dateien zusammenfasst. Starten Sie die Entwicklungsumgebung und wählen Sie das Menü File|New, Sie müssen sich nun für einen Projekttyp entscheiden. Für eine einfache DLL genügt der Projekttyp "Win32 Dynamic Link Library" völlig, die Variante "MFC AppWizard (DLL)" bringt nur unnötigen Overhead mit sich. In dieses Projekt müssen Sie mindestens zwei Dateien einbinden: eine DEF-Datei und natürlich all die Dateien, in denen sich der C-Quellcode befindet. Die Files können Sie aus der Entwicklungsumgebung heraus anlegen und im Projektverzeichnis speichern. Die Definitionsdatei (DEF) legt neben dem internen Namen der DLL einige Linker-Optionen fest: LIBRARY CODE PRELOAD MOVEABLE DISCARDABLE DATA PRELOAD MOVEABLE EXPORTS @<Exportnummer> @<Exportnummer>

Der interne Name sollte mit dem späteren Dateinamen übereinstimmen, um Probleme zu vermeiden. Wie Sie obiger Darstellung entnehmen können, geben Sie unter Exports die Namen aller Funktionen an, die Sie aus der DLL exportieren möchten. Neben dem Aufruf über den Namen besteht auch die Möglichkeit, die Funktion über einen numerischen Wert zu starten (Exportnummer). BEISPIEL: Eine einfache DEF-Datei LIBRARY Sortierroutinen CODE PRELOAD MOVEABLE DISCARDABLE DATA PRELOAD MOVEABLE EXPORTS Sortiere @1 TestByte @2

Damit dürfte alles Wesentliche zur DEF-Datei gesagt sein, und wir können uns dem eigentlichen Quelltext zuwenden, dem C-Quellfile. Das minimale Grundgerüst sieht folgendermaßen aus: #include <windows.h> ... BOOL WINAPI DllMain (HINSTANCE hDLL, DWORD dwReason, LPVOID lpReserved) { return TRUE; }

496

Kapitel 10

Programmschnittstellen/Peripherie

Da wäre zunächst einmal die Einbindung von windows.h für die Unterstützung der grundlegenden Windows-Deklarationen. Sollten Sie mit dem Datentyp VARIANT experimentieren, müssen Sie zusätzlich #include

einbinden. Danach kommen Ihre selbst definierten Funktionen. Was es mit DllMain auf sich hat, klärt der folgende Abschnitt.

Ein- und Austrittsprozedur Sollten Sie bereits irgendwann in grauer Vorzeit 16-Bit-DLLs entwickelt haben, müssen Sie sich etwas umstellen, insbesondere die Eintrittsprozedur muss angepasst werden. SYNTAX:

BOOL WINAPI DllMain (HINSTANCE hDLL, DWORD dwReason, LPVOID lpReserved)

Beachten Sie, dass die Funktion die WINAPI-Konvention nutzt, die bisherige Verfahrensweise mit FAR PASCAL wird nicht mehr verwendet. Lassen Sie sich vom Schlüsselwort WINAPI nicht verwirren, wie schon mehrfach erwähnt, handelt es sich um stdcall: define WINAPI __stdcall

Für die weitere Arbeit werden Sie in den meisten Fällen den Parameter dwReason auswerten müssen, dieser entscheidet über die folgenden Zustände: Wert

Beschreibung

DLL_PROCESS_ATTACH

Ein neuer Prozess (z.B. Ihr Delphi-Programm) versucht auf die DLL zuzugreifen.

DLL_THREAD_ATTACH

Ein neuer Thread eines existierenden Prozesses versucht auf die DLL zuzugreifen (da Sie als Programmierer in Delphi keinen zweiten Thread erzeugen können, tritt dieser Fall auch nicht ein).

DLL_PROCESS_DETACH

Ein Prozess trennt sich von der DLL, das heißt jedoch nicht, dass die DLL aus dem Speicher entfernt wird. Es könnten ja noch weitere Prozesse auf die DLL zugreifen.

DLL_THREAD_DETACH

Ein Thread trennt sich von der DLL.

BOOL WINAPI DllMain (HINSTANCE hDLL, DWORD dwReason, LPVOID lpReserved) { double r; switch (dwReason) { case DLL_PROCESS_ATTACH: MessageBox ( GetFocus(),(LPCTSTR) "Build 7.001",(LPCTSTR) "Info", MB_OK | MB_SYSTEMMODAL); r= 3.14159265358/180; Stift1=CreatePen(PS_SOLID,1,0); Stift2=CreatePen(PS_SOLID,1,0xffffff); break; case DLL_PROCESS_DETACH:

10.2 DLL-Programmierung

497

DeleteObject(Stift1); DeleteObject(Stift2); break; } return TRUE; }

Wird die DLL zum ersten Mal aufgerufen, erscheint ein einfaches Meldungsfenster. Zusätzlich werden zwei Stifte für die Grafikausgabe erzeugt. Beim Entladen der DLL (Programmende) sollten alle generierten GDI-Objekte wieder gelöscht werden, über DLL_PROCESS_DETACH können Sie diesen Zustand ermitteln. Auf den bisher bekannten Parameter wDataSegment können wir verzichten, da unter Win 32 der Speicher nicht segmentiert ist. Die Heap-Größe wird durch den Anwendungs-Heap bestimmt, Kommandozeilenparameter lassen sich mit der API-Funktion GetCommandLine ermitteln.

Aufrufkonventionen Entgegen der bisherigen Verfahrensweise wird statt der Pascal-Konvention far pascal _export

die folgende Syntax verwendet: _stdcall short _stdcall TestInteger (short intgr, short far *pintgr)

Die neue Aufrufsyntax beeinflusst die Ausrichtung der übergebenen Argumente auf dem Stack (von rechts nach links), verändert den internen Namen und erweitert die übergebenen Argumente auf ein Vielfaches von 4 Byte. Wichtig ist nur, dass Sie beim Umschreiben von 16-Bit-DLLs die bisherige Konvention ersetzen.

Funktionsparameter und Variablentypen Während Sie in C eine reiche Auswahl an Datentypen haben, müssen die Endverbraucher der DLL häufig mit einer eingeschränkten Typanzahl zurechtkommen. Delphi bietet für fast alle C-Datentypen einen eigenen Datentyp an. Das folgende Listing zeigt die Deklaration einiger C-Typen (für API-Zugriff interessant) in Pascal: LPSTR = PAnsiChar; LPCSTR = PAnsiChar; LPWSTR = PWideChar; LPCWSTR = PWideChar; DWORD = Integer; BOOL = LongBool; PBOOL = ^BOOL; PByte = ^Byte; PINT = ^Integer; PSingle = ^Single; PWORD = ^Word; PDWORD = ^DWORD;

498

Kapitel 10

Programmschnittstellen/Peripherie

LPDWORD = PDWORD; UCHAR = Byte; PUCHAR = ^Byte; SHORT = Smallint; UINT = Integer; PUINT = ^UINT; ULONG = Longint; PULONG = ^ULONG; PLongint = ^Longint;

Bei der Parameterdefinition ist die Unterscheidung zwischen Wert- und Referenz-Übergabe wichtig. Die folgenden Listings zeigen Beispiele für die Definition von Prozeduren/Funktionen: BEISPIEL: Eine Funktionseinbindung: double _stdcall Test_Function (void) { return 110; }

Einbindung in Pascal: function Test_Function : double; stdcall; external 'Test.dll';

BEISPIEL: Eine Prozedureinbindung: void _stdcall Test_Procedure () { int i; i = 10; i++; }

Einbindung in Pascal: procedure Test_Procedure; stdcall; external 'Test.dll';

BEISPIEL: Eine Integerübergabe: void _stdcall Test_Integer (int nr) { nr = nr + 4711; }

Einbindung in Pascal: procedure Test_Integer(nr : Integer); stdcall; external 'Test';

BEISPIEL: Eine Integerübergabe mit Pointer: void _stdcall Test_PInteger (int *nr) { *nr = *nr + 4711; }

Einbindung in Pascal: procedure Test_PInteger(var nr : Integer); stdcall; external 'Test';

BEISPIEL: Eine Stringübergabe mit Pointer:

(als Typdeklaration wäre auch "char *s" möglich)

10.2 DLL-Programmierung

499

void _stdcall Test_PString (LPSTR s) // Umwandlung evtl. mit: // static char hinweis[2000]; // .... lstrcopy(hinweis,s); // für Windows-Funktionen im allgemeinen Pointer to string { MessageBox(0,s,"Hinweis",64); }

Einbindung in Pascal: procedure Test_PString(s :PChar); stdcall; external 'Test';

Bei der Übergabe von Arrays müssen Sie einen Pointer auf das Array übergeben. Das bedeutet jedoch nicht, dass wir in der C-DLL nur das erste Element bearbeiten können. Durch die Zeigerübergabe ist der Zugriff auf die weiteren Elemente problemlos möglich. Wichtig ist nur, dass als zweiter Parameter die korrekte Anzahl der Feldelemente angegeben wird, die DLL greift sonst ins "Leere" bzw. dahin, wo sie nichts zu suchen hat. Delphi ermöglicht die Definition von Feldober- und -untergrenze, diese Möglichkeit besteht in C nicht. Feldindizes beginnen hier immer mit null. BEISPIEL: Wenn Sie folgendes Array in Pascal definieren var feld : array(10 .. 100) of Integer

können Sie in C natürlich nicht auf das Element 99 zugreifen. Die entsprechende Array-Definition in C schränkt den Wertebereich auf 0 ... 90 ein: int feld(90);

Die Verwendung einer Felduntergrenze in Pascal gehört eigentlich zum schlechten Programmierstil und sollte im Interesse einer übersichtlichen Programmierung weitestgehend vermieden werden. Neben der Portierbarkeit von Algorithmen leidet auch die Performance, da teilweise aufwändige Offsetberechnungen nötig werden. Als kurzes Beispiel für eine C-DLL soll der folgende Sortieralgorithmus dienen: #include <windows.h> /*************************************************************************** Sortieralgorithmus : Shellsort Parameter : Array, Anzahl Feldelemente ***************************************************************************/ void _stdcall Sortiere(double a[],long n) { long k,i,j; double h; k=n/2; while (k>0) { for (i=0; i=0 && a[j]>a[j+k])

500

Kapitel 10

Programmschnittstellen/Peripherie

{ h=a[j]; a[j]=a[j+k]; a[j+k]=h; j=j-k; } } k=k/2; } } BOOL WINAPI DllMain (HINSTANCE hDLL, DWORD dwReason, LPVOID lpReserved) { switch (dwReason) { case DLL_PROCESS_ATTACH: MessageBox ( GetFocus(),"Attache DLL",(LPCTSTR)"Info", MB_OK | MB_SYSTEMMODAL); break; case DLL_PROCESS_DETACH: MessageBox ( GetFocus(),(LPCTSTR) "Detache DLL",(LPCTSTR) "Info", MB_OK | MB_SYSTEMMODAL); break; } return TRUE; }

Die DLLMain-Funktion wurde im obigen Beispiel so erweitert, dass Sie die Initialisierung und Deinitialisierung der DLL mitverfolgen können. In Delphi rufen wir die Funktion nach der Deklaration procedure Sortiere(a : pointer; n : integer); stdcall; external 'sortier.dll';

mit dem Zeiger auf das Feld auf: var feld : array[0..10] of double; ... sortiere(@feld,11);

Damit wollen wir unsere kleine Exkursion in die C-DLL-Programmierung beenden und uns der Einbindung von Delphi-DLLs in Visual Basic zuwenden.

10.2.5 Einbinden in Visual Basic Nun kommen wir zu einem reinen DLL-"Endverbraucher": Microsoft Visual Basic1. Um Funktionen bzw. Prozeduren aus einer DLL zu importieren, müssen zum einen der Name der Funktion und zum anderen deren Parameterliste bekannt sein. Mit diesem Wissen können Sie im Declarations-Abschnitt eines Moduls oder einer Form die Einbindung vornehmen. Wie Pascal unterscheidet auch Visual Basic zwischen Funktionen und Prozeduren, Sie müssen also eine der beiden Declare-Anweisungen verwenden: SYNTAX:

Declare Sub name Lib "DLL-name" [Alias "aliasname" ][([argumentliste])]

bzw.

1

Dieser Abschnitt ist natürlich nur dann für Sie interessant, wenn Sie selbst in VB programmieren oder wenn Sie DLLs für VB-Programmierer entwickeln!

501

10.2 DLL-Programmierung

SYNTAX:

Declare Function name Lib "DLL-name" [Alias "aliasname" ] [([argumentlist])] _ [As type]

Der Parameter name ist der Bezeichner der Funktion im Programm. Weicht dieser von der Bezeichnung in der DLL ab, müssen Sie den Alias-Parameter aufführen. Gründe für dieses Vorgehen gibt es viele, z.B.: ■ Der Funktionsname in der DLL beginnt mit einem Unterstrich (_), der in Visual Basic nicht erlaubt ist. ■ Der Funktionsname in der DLL ist in Visual Basic bereits vergeben (z.B. MKDIR). ■ Sie möchten ein und dieselbe Funktion mit verschiedenen Namen und Parametern importieren. Bevor auf die spezielle Einbindung bzw. die Parametertypen eingegangen wird, wollen wir die Einschränkungen erwähnen. Grundsätzlich können Sie alle Funktionen in Visual Basic einbinden (seit Version 5 werden auch Callback-Routinen und damit die Übergabe von Funktions-Pointern unterstützt). Natürlich muss auch die genaue Syntax der Funktion bekannt sein. Dies schließt den Prozedur/Funktionsnamen sowie die Liste der Parameter ein. Sollten Sie Tools für VB entwickeln, ist es günstig, wenn Sie zu Ihrer DLL auch gleich den kompletten Declare-Abschnitt mitliefern.

Syntax und Parameterliste In den beiden vorangegangenen Abschnitten wurde die Zuordnung der Datentypen für die jeweilige Programmiersprache bereits erschöpfend behandelt, deshalb an dieser Stelle nur eine kurze Zusammenfassung der VB-Datentypen: Basic

Pascal

Speicherplatz

Integer

Integer

4 Byte

Long

LongInt

4 Byte

Currency

Currency

8 Byte

Single

Single

4 Byte

Double

Double

8 Byte

String

String oder PChar

ca. 1 Byte pro Zeichen

Variant

Variant

variabel

Wichtig: ■ Funktionen und Prozeduren müssen Sie in Delphi immer mit stdcall definieren, um diese in VB einbinden zu können. ■ Den Parameter ByVal verwenden Sie, wenn der Wert einer Variablen übergeben wird. In allen anderen Fällen wird an die DLL ein Zeiger auf die Variable übergeben, und die DLL kann die Variable ändern, was mit ByVal nicht möglich ist (also: wenn in Pascal var, dann in VB kein ByVal!).

502

Kapitel 10

Programmschnittstellen/Peripherie

■ Auch wenn Visual Basic keine Funktionen für die Arbeit mit Zeigern kennt, wird doch bei der Übergabe von Parametern an eine Funktion/Prozedur nicht der Wert, sondern ein Zeiger auf die entsprechende Variable übermittelt. Speziell für die Übergabe von Strings an DLLs haben die VB-Entwickler vorgesorgt. Der VB-String wird automatisch in einen nullterminierten String (PChar) umgewandelt. Strings werden also immer mit ByVal übergeben, intern übermittelt Visual Basic einen Zeiger auf die Zeichenkette. ■ Für die Übergabe beliebiger Datentypen sollten Sie den Typ Any verwenden. ■ Felder werden sinnvollerweise als Zeiger auf das erste Feldelement übergeben. ■ Records können Sie ohne Probleme übergeben, VB verwendet die gleiche Speicherausrichtung wie Delphi. BEISPIEL: Die Einbindung einer Pascal-Prozedur: procedure rasterEinblenden (hwnd:thandle; breite:integer; hoehe:integer; abstand:integer); stdcall; export;

Import in VB: Declare Sub RasterEinblenden Lib "raster.dll" (ByVal hWnd%, ByVal breite%, ByVal hoehe%, ByVal abstand%)

BEISPIEL: Die Übergabe von Strings: procedure Testv(v:String); stdcall;

In Basic: Declare Sub Testv Lib "Test.dll" (ByVal v As String)

10.2.6 Tipps und Tricks Der frisch gebackene DLL-Programmierer sollte einige Grundregeln beachten: ■ Bevor Sie Ihr Programm mit einer DLL testen, sollten Sie alle nicht benötigten Anwendungen schließen bzw. deren Inhalte sichern. ■ Ist die DLL abgestürzt, überzeugen Sie sich vor dem nächsten Start, ob nicht doch noch die alte Version im Speicher ist (siehe Versionsabfrage). Am einfachsten geht dies, wenn Sie versuchen, die DLL auf der Festplatte mit einer neuen Version zu überschreiben. Schlägt der Versuch fehl, ist die DLL noch in Benutzung. ■ Da das Debuggen von DLLs recht umständlich ist, empfiehlt sich die Verwendung von OutputDebugString für die Ausgabe von internen DLL-Zuständen (Variablen etc.). Alternativ können Sie auch Ausgaben über die ShowMessage-Funktion realisieren. ■ Beachten Sie die Groß-/Kleinschreibung von Funktionsnamen. ■ Kontrollieren Sie die korrekte Verwendung von var.

10.2 DLL-Programmierung

503

■ Wird die DLL nur von einer Anwendung benötigt, kopieren Sie die Library in Ihr Anwendungs- und nicht in das Systemverzeichnis. ■ Vermeiden Sie Pfadangaben bei der DLL-Einbindung, DLLs können im Programmverzeichnis, dem Windows-Verzeichnis und allen Verzeichnissen mit Suchpfad stehen.

DLL-Debugging Endlich sind die Zeiten vorbei, in denen man bei der DLL-Programmierung fast verzweifelt ist. Jedes Mal compilieren mit dem Stoßgebet "Bloß keine Fehler in der DLL!". Ein Debuggen von DLLs war bis zur Version 2 nicht möglich, mit dem Prozedur- oder Funktionsaufruf war die Überwachung vorbei. Anscheinend hatten die Borland-Entwickler selbst feststellen müssen, dass es so nicht bleiben konnte: Seit der Version 3 findet sich dieses Feature. Der Ablauf ist relativ einfach. Compilieren Sie die Anwendung und öffnen Sie danach die DLL in der Delphi-IDE. Setzen Sie nun Breakpoints und Überwachungsausdrücke, wie Sie es gewohnt sind. Bevor Sie jetzt versuchen, mit F9 das Programm zu starten, müssen Sie über Start|Parameter... die Host-Anwendung (das ist die aufrufende EXE) bestimmen.

Danach kann der Startschuss gegeben werden (F9). Ihre Hostanwendung wird jetzt ausgeführt, bis einer der Breakpoints in der DLL erreicht wird.

Namensgebung Da wir mittlerweile davon ausgehen können, dass das Dateisystem lange Dateinamen unterstützt, sollten Sie auch nicht zögern, Ihren DLLs einen aussagekräftigen Namen zu geben. Auf diese Weise vermeiden Sie Probleme mit gleichnamigen DLLs anderer Anbieter/Hersteller. Ein DLL-Name solle z.B. eindeutig kennzeichnen, ob es sich um eine 32- oder eine 16-Bit-Variante handelt. Hängen Sie dazu an den Namen "32" oder "16" an. Dem Namen sollte weiterhin eine Beziehung zu Ihrem Produkt oder Ihrer Firmenbezeichnung zu entnehmen sein.

504

Kapitel 10

Programmschnittstellen/Peripherie

mstool32.dll vb60032.dll

Versionskontrolle Bevor es zu Konflikten mit verschiedenen DLL-Versionen kommt, sollten Sie dem mit einer Versionskontrolle vorbeugen. function Version: Integer; stdcall; begin Version := 2 end;

Ihr Programm muss als Erstes prüfen, ob die DLL-Version korrekt ist. Dies könnte zum Beispiel im FormCreate-Event geschehen. Während der Testphase ist es empfehlenswert, sich die Versionsnummer von der DLL anzeigen zu lassen. Erweitern Sie dazu die Eintrittsprozedur wie folgt: BEISPIEL: In Delphi: uses Dialogs; ... begin ShowMessage('Versionsinfo: Build 1.241') end.

BEISPIEL: In C: BOOL WINAPI DllMain (HINSTANCE hDLL, DWORD dwReason, LPVOID lpReserved) { switch (dwReason) { case DLL_PROCESS_ATTACH: MessageBox ( GetFocus(),(LPCTSTR) "Build 1.241", (LPCTSTR) "Info", MB_OK | MB_SYSTEMMODAL); ...

10.3 Drucker In den entsprechenden Handbüchern ist alles ganz einfach: Man nehme die Methode XY, gebe das Ganze auf dem Drucker aus, und alles ist in bester Ordnung. Prinzipiell stimmt das auch, da Windows keine Unterschiede zwischen den Ausgabegeräten kennt. Dass die Druckerausgabe unter Windows dennoch kein triviales Problem ist, werden Sie sicher schon festgestellt haben. Aber beginnen wir von vorn. Wer erinnert sich noch an die Möglichkeiten der Druckerausgabe unter DOS? WriteLn(prn, Chr(12)); WriteLn(prn, 'bla bla ...');

{ neue Seite } { Ausgabe Text }

505

10.3 Drucker

WriteLn(prn, 'bla bla ...'); ...

{ Ausgabe Text }

Die gleiche Vorgehensweise ist prinzipiell auch unter Windows möglich, sollte jedoch weitestgehend vermieden werden. Zum einen "verschenken" Sie die Möglichkeiten, die der jeweilige Druckertreiber bietet, zum anderen machen Sie Ihr Programm wieder hardwareabhängig. HINWEIS: Für alle, die sich nicht unbedingt mit Printer-Objekten herumschlagen wollen, bietet

sich auch die Möglichkeit, über die QuickReport-Komponenten eine ansprechende Druckausgabe zu realisieren. Ein positiver Nebeneffekt: Sie integrieren auf diese Weise gleich noch eine Druckvorschau in Ihr Programm. Nähere Informationen zum Thema "QuickReport" finden Sie im Kapitel 9 .

10.3.1 Das Printer-Objekt Delphi stellt uns für die Druckausgabe einen TPrinter-Objekttyp zur Verfügung. Im Gegensatz zur Delphi-Version 2 wird keine globale Variable Printer bereitgestellt, sondern es handelt sich um eine Funktion, die ein TPrinter-Objekt zurückgibt. Für den Anwender selbst hat dies keine Auswirkungen, ältere Projekte lassen sich ohne Änderung compilieren. Der Vorteil dieser Umstellung: Wenn Sie die Unit printers in Ihr Projekt einbinden, ohne den Printer tatsächlich zu verwenden, wird nicht mehr wie bisher der entsprechende VCL-Code gelinkt, da auch keine Funktion verwendet wird. Dies ändert jedoch nichts an der Tatsache, dass jeweils nur ein Printer-Objekt bereitgestellt wird. Das dürfte auf den ersten Blick nicht ganz einsichtig sein, da man ja mehrere Drucker unter Windows installieren kann. Der Grund für diese Einschränkung ist darin zu suchen, dass immer nur ein Drucker als Standarddrucker definiert und damit aktiv ist. Wenn Ihr Programm etwas ausdrucken soll, müssen Sie als Erstes die Unit Printers in die usesListe der Form-Unit aufnehmen. Die Tabelle zeigt die wichtigsten Eigenschaften: Eigenschaft

Erklärung

Aborted

... ist True, wenn der Druckauftrag abgebrochen wurde.

Canvas

Druckoberfläche einer Seite mit den untergeordneten Eigenschaften Brush, Pen, Font (siehe Grafikkapitel 7).

Canvas.Handle

Ein "echter" Gerätekontext (nur zwischen BeginDoc und EndDoc verfügbar).

Fonts

Liste der verfügbaren Druckerschriftarten (Array).

Handle

... es handelt sich um einen Informationsgerätekontext, nicht um einen Ausgabegerätekontext! Sie können diesen Handle nur für die Informationsgewinnung, nicht für Ausgaben nutzen!

Orientation

... bestimmt, ob vertikal (poPortrait) oder horizontal (poLandscape) gedruckt wird. Der Wert kann auch über den Druckersetup-Dialog geändert werden.

PageHeight

Seitenhöhe in Pixel (so ein Unsinn!!!).

PageNumber

Anzahl der gedruckten Seiten seit dem letzten BeginDoc.

506

Kapitel 10

Programmschnittstellen/Peripherie

Eigenschaft

Erklärung

PageWidth

Seitenbreite in Pixel (siehe PageHeight).

PrinterIndex

Auswahl des aktuellen Druckers (Standarddrucker → -1).

Printers

Liste der verfügbaren Drucker (Array).

Printing

... ist True, falls gerade gedruckt wird.

Title

Kurztext, der im Druckmanager angezeigt wird.

Die Schlüsselmethoden des Printer-Objekts: Methode

Erklärung

Abort

... bricht Druckauftrag vor dessen Beendigung ab. Der Drucker wird neu initialisiert.

BeginDoc

... schickt Druckauftrag an den Drucker.

EndDoc

... beendet aktuellen Druckauftrag.

GetPrinter

... liefert den aktuellen Drucker.

NewPage

... beginnt Druck auf neuer Seite (erhöht PageNumber und setzt die Einfügeposition des Canvas auf (0,0)).

SetPrinter

... setzt einen neuen aktuellen Drucker. Verwenden Sie besser die Eigenschaft PrinterIndex.

Das vorhergehende Beispiel, unter Delphi realisiert, würde wie folgt aussehen: uses printers; ... Printer.BeginDoc; Printer.Canvas.TextOut(0, 0, 'bla bla...'); Printer.Canvas.TextOut(0,25, 'bla bla...'); Printer.EndDoc;

// neue Seite

// Ausgabe schließen

HINWEIS: Vergessen Sie niemals die EndDoc-Methode, der Druckauftrag wird sonst erst mit

dem Ende Ihres Programms abgeschickt! Für das weitere Verständnis sollte man wissen, dass die eigentliche Ausgabe durch den Druckertreiber realisiert wird. Abfragen über die Möglichkeiten und Eigenschaften eines Ausgabegerätes werden über entsprechende API-Funktionen direkt an den Druckertreiber weitergeleitet.

10.3.2 Druckerkonfiguration Bevor wir zum eigentlichen Thema kommen, wollen wir uns in diesem Abschnitt mit der Auswahl eines Druckers und dessen Konfiguration beschäftigen. Unter Windows können zwar mehrere Ausgabegeräte installiert werden, ein Drucker ist aber immer als Standardausgabegerät ausgewählt.

507

10.3 Drucker

Dieser Standarddrucker wird automatisch über die Printer-Funktion von Delphi zurückgegeben, d.h., alle Properties, die Sie über das Objekt abfragen, beziehen sich auf diesen Drucker. Was aber tun, wenn man mit einem anderen Drucker arbeiten möchte? Das Ändern der entsprechenden Einträge in der Systemsteuerung ist sicher keine besonders geniale Idee. Als Ausweg bleibt die Einbindung einer entsprechenden Dialogbox in die eigene Anwendung. Für diesen Fall haben die Delphi-Entwickler mit den Komponenten PrintDialog und PrinterSetupDialog vorgesorgt. Glauben Sie jedoch nicht, dass diese Dialogboxen innerhalb der Komponenten programmiert sind, es ist vielmehr so, dass jede Komponente auch nur auf die in Windows enthaltenen Standarddialoge zugreift. Sie können dies jederzeit mit der Funktion PrintDlg() aus comdlg32.dll nachvollziehen. Der Aufruf der entsprechenden Dialoge erfordert jedoch umfangreiche Vorarbeiten, die Nutzung der beiden Komponenten ist bedeutend einfacher.

Welche Druckerdialoge können Sie nutzen? Drei verschiedene Dialoge werden von Delphi direkt bereitgestellt (Palette Dialoge): ■ PrintDialog (Seitenauswahl, Druckerauswahl, Sortierfolge) ■ PrintSetupDialog (Druckerauswahl, Papierauswahl, Papierquelle, Seitenausrichtung) ■ PageSetupDialog (Paierauswahl, Papierquelle, Seitenformat und Seitenränder)

PrintDialog Die wichtigsten Eigenschaften: Eigenschaft

Beschreibung

Collate

Status des Optionsfeldes "Exemplare sortieren"

Copies

Anzahl der Exemplare

FromPage, ToPage

Vom Anwender eingegebener Seitenbereich

MaxPage, MinPage

Für den Anwender verfügbarer Seitenbereich

Option

Bestimmt das Aussehen der Dialogbox

PrintRange

Status der Radiobuttons "Druckbereich"

508

Kapitel 10

Programmschnittstellen/Peripherie

BEISPIEL: Die Anzeige der Dialogboxen erreichen Sie mit der Execute-Methode: PrintDialog1.Execute

Neben der Auswahl von bestimmten Druckbereichen, der Umleitung in eine Datei, der Bestimmung der Druckqualität usw. können Sie über den Button "Einrichten" den Drucker-Setup-Dialog aufrufen. Diese Möglichkeit besteht auch mit der Komponente PrinterSetupDialog.

PrinterSetupDialog Im Drucker-Setup-Dialog haben Sie die Möglichkeit, einen neuen Standarddrucker auszuwählen, das Druck-/Seitenformat zu ändern sowie den druckerspezifischen Optionsdialog aufzurufen.

509

10.3 Drucker

Für einen Druck-Dialog ist natürlich der Rückgabewert interessant. Diese Information liefert Ihnen die Execute-Methode (True oder False).

PageSetupDialog Neu in Delphi 7 ist der PageSetupDialog, den Sie zum Beispiel von Wordpad (Seite einrichten) oder ähnlichen Programmen kennen. Sie haben hier die Möglichkeit, die wichtigsten Seitenparameter abzufragen.

Dabei steht Ihnen über die Eigenschaften MarginBottom, MarginRight, MarginLeft und MarginTop die jeweiligen Seitenränder sowie über PageHeight und PageWidth die Seitenabmessungen in 1/100 Millimetern zur Verfügung. HINWEIS: Doch Achtung: Egal was für Ränder im Dialog ausgewählt werden, Sie als Program-

mierer müssen dafür sorgen, dass Ihr Programm diese auch einhält. Das PrinterObjekt selbst ist dazu nicht in der Lage. Über die MinMarginBottom …-Eigenschaften können Sie Mindestränder festlegen, beispielsweise können Sie hier die physikalischen Ränder des Druckers berücksichtigen

510

Kapitel 10

Programmschnittstellen/Peripherie

Drucker-Setup ohne Standarddialoge Möchte man den Drucker ohne Dialog konfigurieren, ist das Printer-Objekt interessant. Mit der Eigenschaft Orientation können Sie das Blattformat verändern (quer/hoch), weiterhin lässt sich über die Eigenschaft PrinterIndex ein anderer Drucker auswählen. Durch folgende einfache Zuweisung wechseln Sie den voreingestellten Drucker (den Standarddrucker stellen Sie mit -1 ein): Printer.PrinterIndex := 2

Zusammen mit den Eigenschaften des Printer-Objekts können Sie zum Beispiel eine eigene Dialogbox erstellen, die alle verfügbaren Drucker anzeigt. Sie füllen eine ListBox mit den Druckernamen: listBox1.Items := Printer.Printers

Nach dem Klick auf einen Eintrag wechselt dann der Drucker: procedure TForm1.ListBox1Click(Sender: TObject); begin Printer.PrinterIndex := ListBox1.ItemIndex end;

// Zuweisung aktiver Drucker

Für die nachfolgend beschriebenen Ausgabemöglichkeiten ist es nicht unerheblich, ob es sich beim Ausgabegerät um einen Laser- oder Typenraddrucker handelt. Auch Ausgabebreite, Farbmöglichkeiten etc. sind interessant. Wie Sie all dies und noch viel mehr erfahren können, lesen Sie im Praxisteil des vorliegenden Kapitels. Weitere direkte Einstellungen am Drucker lassen sich jedoch nur mit der API-Funktion DocumentProperties vornehmen. Doch stellen Sie sich die Anwendung dieser Funktion nicht zu einfach vor. Über die Funktion müssen Sie zuerst die Größe der Struktur DEVMODE ermitteln, danach Speicher reservieren, die aktuellen Werte abfragen, gegebenenfalls Werte verändern und erneut die Funktion DocumentProperties aufrufen, um die Werte zu setzen. Über DEVMODE haben Sie unter anderem Einfluss auf Papiergröße, Blattausrichtung, Druckqualität, Auflösung usw.

10.3.3 Drucken von Vektor- und Rastergrafiken Die Ausgabe von Vektorgrafiken auf dem Drucker entspricht weitgehend der Ausgabe von Grafiken in einem Fenster oder Bildfeld (siehe Kapitel 7, Grafikprogrammierung). Bereits mit der einfachen Anweisung Printer.BeginDoc; Printer.Lineto (40, 40); Printer.EndDoc;

können Sie eine Linie auf dem Drucker ausgeben. Das Gleiche ist auch mit allen anderen Grafikmethoden möglich.

511

10.3 Drucker

Im Wesentlichen können Sie alle Ausführungen aus dem Grafik-Kapitel 7 auf den Drucker verallgemeinern. Einziger Unterschied: Alle Ausgaben auf dem Drucker müssen nach folgendem Schema ablaufen:

Anwendung

BeginDoc

NewPage

Abort

Grafik-Methoden

Ja

Weitere Seiten

Nein

Abbruch

Ja

Nein EndDoc

Wichtig: ■ Vergessen Sie nicht den EndDoc-Befehl am Ende der Druckausgabe. ■ Setzen Sie API-Funktionen für die Ausgabe ein, müssen Sie Printer.Canvas.Handle als DC verwenden (nur zwischen BeginDoc und EndDoc). ■ Für die Informationsgewinnung (GetDeviceCaps) ist Printer.Handle geeignet. In diesem Zusammenhang kommt uns die Fähigkeit geräteunabhängiger Ausgabe unter Windows sehr entgegen. Allerdings haben die Delphi-Programmierer hier etwas geschlafen, statt Millimeter oder wenigstens Zoll hat der Drucker die in diesem Zusammenhang sehr fragwürdige Maßeinheit Pixel. BEISPIEL: Die Ausgabe einer fertigen Grafik (BMP oder WMF) ist mit relativ wenig Aufwand erledigt, Sie

brauchen lediglich die Grafik mit StretchDraw auf den Canvas des Druckers zu kopieren. Ob es sich um eine Pixel- oder Vektorgrafik handelt, entscheidet sich mit dem Picture-Objekt (Picture.Metafile oder Picture.Bitmap): procedure TForm1.Button1Click(Sender: TObject); var rect : TRect; s : string;

512

Kapitel 10

Programmschnittstellen/Peripherie

begin Printer.BeginDoc; Screen.Cursor:=crHourglass; with Printer.Canvas do begin rect:=Bounds(0,0, Printer.PageWidth, Printer.PageHeight); StretchDraw(Rect, Image1.Picture.Metafile); end; Printer.EndDoc; Screen.Cursor:=crDefault end;

bzw. procedure TForm1.Button2Click(Sender: TObject); var rect : TRect; s : string; begin ... StretchDraw(Rect,Image2.Picture.Bitmap) ... end;

HINWEIS: Wer große Bitmaps auf den meisten Druckern fehlerfrei zu Papier bringen will, sollte

die Ausgabe einiger Euros nicht scheuen und sich mit der TExcellentImagePrinterKomponente von Joe Hecht anfreunden. Alle anderen Versuche werden früher oder später an einem Druckertreiber oder mangelndem Arbeitsspeicher scheitern. Ä http://www.code4sale.com/joehecht/prndib.htm

10.3.4 Drucken in Millimetern Wie auch in den Kapiteln 7 bzw. 15 erwähnt, können Sie einem Windows-Ausgabegerät auch ein neues Koordinatensystem verpassen. In unserem Fall bietet sich auf den ersten Blick der Abbildungsmodus MM_LOMETRIC an. Im Gegensatz zu diesem Abbildungsmodus wird bei der folgenden Variante das Delphi-Koordinatensystem (linke obere Ecke = 0,0) beibehalten, die Ausgabe erfolgt in 1/10 mm. Dazu müssen wir allerdings etwas tricksen, ist es doch nicht möglich, im Abbildungsmodus MM_LOMETRIC eine Veränderung an ViewportExtEx oder WindowExtEx vorzunehmen. Wir werden dazu kurzzeitig den Modus MM_LOMETRIC einstellen, die Werte von ViewportExtEx und WindowsExtEx ermitteln und danach in den Modus MM_ANISOTROPIC schalten, in dem wir die y-Achse auf recht einfache Weise "kippen" können: var w,v : TSize; OUTDC : HDC; begin

Druckauftrag beginnen

10.4 Lernbeispiele für Einsteiger

513

printer.BeginDoc;

... sonst stimmt das Handle nicht! outDC := Printer.Canvas.Handle; SetMapMode(OutDC,mm_lometric); // 1/10 mm, aber Y geht nach oben GetWindowExtEx(OutDC,w); // Auflösung ermitteln GetViewportExtEx(OutDC,v); SetMapMode(OutDC,MM_ANISOTROPIC); // neuer Abb.-Modus SetWindowExtEX(OutDC,w.cx,w.cy,nil); // Skalieren ... SetViewPortExtEx(OutDC,v.cx,-v.cy,nil); // und Kippen .... with Printer.Canvas do begin

Schrifthöhe in 1/10 mm festlegen (Sie können ruhig nachmessen!): Font.Height:=50; Font.Name := 'Arial';

Testausrichtung auf Mitte/Oben festlegen: SetTextAlign(handle,TA_CENTER+TA_TOP);

Danach ist die Blattgröße in 1/10 mm zu ermitteln. Vergessen Sie in diesem Zusammenhang die Eigenschaften PageWidth und PageHeight gleich wieder, die "rechnen" immer noch in Pixel. breite := getDevicecaps(handle,horzsize)*10; hoehe := getDevicecaps(handle,vertsize)*10;

Eine erste Linie auf dem Drucker ausgeben: MoveTo(0,1); LineTo(breite,1);

Eine Millimeterskala ausgeben: while i <= breite do begin MoveTo(i,1); if (i) mod 100 = 0 then begin LineTo(i,50); TextOut(i,50,IntToStr(i div 100)); end else LineTo(i,30); Inc(i,10) end;

10.4 Lernbeispiele für Einsteiger 10.4.1 Arbeiten mit der Zwischenablage Fast jedes Windows-Programm bietet über den Menüpunkt Bearbeiten die Möglichkeit, Daten in die Zwischenablage zu kopieren bzw. von dort einzufügen.

514

Kapitel 10

Programmschnittstellen/Peripherie

Das kleine Beispielprogramm soll zeigen, wie auch Sie Ihre Anwendungen mit derartigen Features aufpeppen können.

Oberfläche Fügen Sie in ein Formular eine Edit-, eine Memo- und eine Image-Komponente ein. Weiterhin brauchen Sie für jede der drei Komponenten zwei Buttons zum Kopieren bzw. Einfügen der Daten.

Quelltext Bevor Sie etwas kopieren können, müssen Sie natürlich entsprechende Eingaben von Text bzw. Grafik in die Komponenten vornehmen können. Edit und Memo bieten diese Funktionalität bereits von Haus aus, beim Image müssen Sie etwas nachhelfen: procedure TForm1.Image1MouseMove(Sender: TObject;Shift: TShiftState; X, Y: Integer); begin if Shift = [ssleft] then Image1.Canvas.LineTo(x,y) end;

Mausbewegungen mit gedrückter linker Maustaste führen demnach zum Zeichnen von Linien. Die eigentlichen Kopierroutinen: Edit-Feld: procedure TForm1.Button1Click(Sender: TObject); begin Clipboard.AsText := Edit1.Text end; procedure TForm1.Button2Click(Sender: TObject);

// Kopieren

// Einfügen

515

10.4 Lernbeispiele für Einsteiger

begin Edit1.Text := Clipboard.AsText end;

Memo-Feld: procedure TForm1.Button3Click(Sender: TObject); begin Memo1.CopyToClipboard end; procedure TForm1.Button4Click(Sender: TObject); begin Memo1.PasteFromClipboard end;

// Kopieren

// Einfügen

Image-Komponente: procedure TForm1.Button5Click(Sender: TObject); begin Clipboard.Assign(Image1.Picture) end;

// Kopieren

procedure TForm1.Button6Click(Sender: TObject); // Einfügen begin Image1.Picture.Assign(Clipboard) end;

Test Nach Programmstart sollten Sie zunächst ein paar Striche in die Image-Komponente kritzeln (natürlich mit der Maus!). Dann können Ihre Experimente beginnen. Übertragen Sie z.B. die Grafik oder einen in das Memo geschriebenen Text nach Word für Windows.

10.4.2 Grafiken in die Zwischenablage kopieren Mit diesem kleinen Testprogramm macht das Kopieren und Einfügen von Grafiken erheblich mehr Spaß als im Vorgängerbeispiel.

Oberfläche Auf dem Startformular (Form1) platzieren Sie drei Image-Komponenten (Image1, Image2 und Image3). Weisen Sie der Picture-Eigenschaft jeweils ein Bildchen zu, das Sie vorher z.B. mit Paintbrush gezeichnet haben. Die AutoSize-Property der Image-Komponenten setzen Sie auf True, damit passen sich deren Abmessungen automatisch der Größe der Bildchen an. Unterhalb platzieren Sie drei RadioButtons (RadioButton1, RadioButton2 und RadioButton3) und drei Schaltflächen (Button1, Button2, Button3). Die Checked-Property von RadioButton1 ändern Sie auf True.

516

Kapitel 10

Programmschnittstellen/Peripherie

Quelltext Fügen Sie den Eintrag ClipBrd ans Ende der Uses-Klausel von Unit1 an! Anschließend weisen Sie den drei Buttons folgenden Ereigniscode zu: procedure TForm1.Button1Click(Sender: TObject); // Kopieren begin if RadioButton1.Checked then Clipboard.Assign(Image1.Picture); if RadioButton2.Checked then Clipboard.Assign(Image2.Picture); if RadioButton3.Checked then Clipboard.Assign(Image3.Picture) end; procedure TForm1.Button2Click(Sender: TObject); // Einfügen begin if RadioButton1.Checked then Image1.Picture.Assign(Clipboard); if RadioButton2.Checked then Image2.Picture.Assign(Clipboard); if RadioButton3.Checked then Image3.Picture.Assign(Clipboard) end;

Test Nach dem Programmstart können Sie nach Belieben in die Zwischenablage kopieren bzw. von dort einfügen. Die Operationen beziehen sich immer auf das mit dem Radiobutton markierte Bildchen. Man braucht keine Bedenken zu haben, dass die in den Image-Komponenten eingelagerten Bitmaps durch das Überschreiben verloren gehen. Nach einem erneuten Programmstart ist der ursprüngliche Zustand wiederhergestellt.

10.4.3 Ermitteln der installierten Drucker In Applikationen, die auch etwas zu Papier bringen müssen, ist in der Regel eine Möglichkeit zum Wechseln des aktuellen Druckers vorgesehen. Wie Sie dieses Problem auf relativ einfache Weise mit Delphi lösen können, zeigt das folgende Beispiel.

517

10.4 Lernbeispiele für Einsteiger

Oberfläche Auf dem Formular platzieren Sie zwei Listenfelder (ListBox1 und ListBox2):

Quelltext Mit dem Laden des Formulars erfolgt auch das Füllen des Listenfeldes: procedure TForm1.FormCreate(Sender: TObject); begin ListBox1.Items := Printer.Printers end;

// Listenfeld füllen

Die Auswahl des aktiven Druckers ist mit einer Zeile erledigt: procedure TForm1.ListBox1Click(Sender: TObject); begin

Zuweisung aktiver Drucker: Printer.PrinterIndex := ListBox1.ItemIndex;

Schriften anzeigen: ListBox2.Items := Printer.Fonts end;

Test Sofort nach Programmstart werden die installierten Drucker aufgelistet (siehe oben). Der Klick auf einen Eintrag bringt die verfügbaren Fonts zur Anzeige.

518

Kapitel 10

Programmschnittstellen/Peripherie

10.5 Praxisbeispiele für Fortgeschrittene 10.5.1 Die Optionen des aktiven Druckers ermitteln Für die Druckausgabe braucht man reichlich Informationen über das jeweilige Ausgabegerät. Dass neben den Printer-Properties noch mehr zu erfahren ist, zeigt die vorliegende Demo.

Oberfläche Auf dem Formular platzieren Sie ein StringGrid und eine Befehlsschaltfläche:

Quelltext Die GDI-Funktion GetDeviceCaps liefert uns fast alle notwendigen Informationen. In der DelphiAPI-Hilfe finden Sie dazu die Parameter. Bei Programmstart füllen wir das StringGrid mit den ermittelten Werten: procedure TForm1.FormCreate(Sender: TObject); var dc : THandle; i, n : Integer; begin grid.ColWidths[1] := 200;

Zu diesem Zeitpunkt handelt es sich nicht um einen "echten" DC, sondern nur um einen Informations-Gerätekontext! Sie können also keine GDI-Ausgaben mit diesem Gerätekontext vornehmen. dc := printer.handle; i:= 0;

519

10.5 Praxisbeispiele für Fortgeschrittene

Vom Printer-Objekt bereitgestellt: grid.cells[0,i] grid.cells[1,i] inc(i); grid.cells[0,i] grid.cells[1,i] inc(i);

:= 'Name'; := printer.printers[printer.printerindex]; := 'Treiberversion'; := IntToStr(GetDeviceCaps(dc, driverversion));

Von besonderer Bedeutung für die Grafikausgabe auf einem Drucker ist diese Abfrage: grid.cells[0,i] := 'Technologie'; grid.cells[1,i] := techno[GetDeviceCaps(dc, technology)];

Folgende Rückgabewerte sind möglich: Konstante

Beschreibung

DT_PLOTTER

Vektor-Plotter

DT_RASDISPLAY

Raster-Bildschirm

DT_RASPRINTER

Raster-Drucker

DT_RASCAMERA

Raster-Kamera (Scanner)

DT_CHARSTREAM

Zeichenfolge (z.B. Typenraddrucker)

DT_METAFILE

Meta-Datei

DT_DISPFILE

Bildschirm-Datei (BMP)

Die Information über nutzbare Blattbreite und -höhe gewinnt man wie folgt: inc(i); grid.cells[0,i] grid.cells[1,i] inc(i); grid.cells[0,i] grid.cells[1,i] inc(i); grid.cells[0,i] grid.cells[1,i] inc(i); grid.cells[0,i] grid.cells[1,i] inc(i); grid.cells[0,i] grid.cells[1,i] inc(i); grid.cells[0,i] grid.cells[1,i] inc(i); grid.cells[0,i] grid.cells[1,i]

:= 'Druckbreite (mm)'; := IntToStr(GetDeviceCaps(dc, horzsize)); := 'Druckhöhe (mm)'; := IntToStr(GetDeviceCaps(dc, vertsize)); := 'Breite (Pixel)'; := IntToStr(GetDeviceCaps(dc, horzres)); := 'Höhe (Pixel)'; := IntToStr(GetDeviceCaps(dc, vertres)); := 'Linker Seitenoffset (Pixel)'; := IntToStr(GetDeviceCaps(dc, PHYSICALOFFSETX)); := 'Oberer Seitenoffset (Pixel)'; := IntToStr(GetDeviceCaps(dc, PHYSICALOFFSETY)); := 'DPI (horizontal)'; := IntToStr(GetDeviceCaps(dc, logpixelsx));

520

Kapitel 10

inc(i); grid.cells[0,i] grid.cells[1,i] inc(i); grid.cells[0,i] grid.cells[1,i] inc(i); grid.cells[0,i] grid.cells[1,i] inc(i); grid.cells[0,i] grid.cells[1,i] inc(i);

Programmschnittstellen/Peripherie

:= 'DPI (vertikal)'; := IntToStr(GetDeviceCaps(dc, logpixelsy)); := 'Pinsel'; := IntToStr(GetDeviceCaps(dc, Numbrushes)); := 'Stifte'; := IntToStr(GetDeviceCaps(dc, numpens)); := 'Markierer'; := IntToStr(GetDeviceCaps(dc, nummarkers));

Ob der Drucker auch farbtauglich ist, ermitteln Sie so: grid.cells[0,i] := 'Farben'; grid.cells[1,i] := IntToStr(GetDeviceCaps(dc, numcolors)); inc(i);

Je nach Druckertyp werden unterschiedliche Schriftarten angezeigt: grid.cells[0,i] := 'Schriften'; grid.cells[1,i] := IntToStr(printer.Fonts.count); inc(i); for n := 0 to printer.Fonts.count-1 do begin grid.rowcount := i; grid.cells[1,i] := printer.Fonts[n]; inc(i) end end;

Test Starten Sie das Programm, das Ergebnis müsste sofort sichtbar sein (siehe oben).

10.5.2 DLL programmieren An diesem einfachen Beispiel lernen Sie, wie Sie eine DLL programmieren, die ■ eine Ein- und Austrittsprozedur besitzt, ■ die Parameterübergabe demonstriert und ■ ein Formular anzeigen kann.

DLL-Programmierung Das DLL-Grundgerüst erzeugen Sie über Datei|Neu|Weitere... Es öffnet sich die Objektgalerie, indem Sie das Symbol für den DLL-Experten auswählen.

10.5 Praxisbeispiele für Fortgeschrittene

521

Die weiteren Schritte beschränken sich auf das Erstellen der Funktionen bzw. Prozeduren. Als Erstes wird eine Messagebox angezeigt, wenn die DLL geladen ist. Dazu verwenden wir den Begin-End-Abschnitt der Library (Unit Dialogs einbinden!): begin AddExitProc(NewExit); ShowMessage('DLL wird geladen ...') end.

Die Anweisung AddExitProc (Unit SysUtils) registriert die neue Exit-Prozedur unserer DLL, in der wir ebenfalls eine Messagebox anzeigen. procedure NewExit; begin ShowMessage('Exitprozedur der DLL'); { DLL wird entladen } end;

Erstellen Sie danach ein einfaches Fenster, das von der DLL exportiert werden soll:

Sie können das Fenster aus der späteren Anwendung nicht direkt aufrufen, Sie benötigen dazu eine Interface-Prozedur. Diese tragen Sie in das DLL-Modul ein: procedure Fensteranzeigen; stdcall; begin Form1:= TForm1.Create(Application); try Form1.ShowModal finally Form1.Free end end;

HINWEIS: Auf die Option stdcall könnten Sie an dieser Stelle verzichten, da die DLL nur aus ei-

nem Delphi-Programm aufgerufen werden soll.

522

Kapitel 10

Programmschnittstellen/Peripherie

Die beiden folgenden Funktionen sollen die Parameterübergabe an DLLs demonstrieren: function berechne1(x,y : Single): Single; stdcall; begin result := x+y end; procedure berechne2(x,y: Single;var z: Single); stdcall; begin z := x+y end;

Last but not least müssen die Funktionen auch noch explizit exportiert werden. Den dazu nötigen Exports-Abschnitt stellen Sie an das Ende des Moduls. exports fensterAnzeigen, berechne1, berechne2;

HINWEIS: Achten Sie auf die Schreibweise der Prozedur- und Funktionsnamen, dies ist für die

spätere Einbindung wichtig! Speichern Sie das Projekt unter dem gewünschten DLL-Namen (z.B. formdll.dll). Ein kurzer Compilerlauf (STRG-F9), und im aktuellen Verzeichnis findet sich die neue DLL.

Einbinden der DLL Erstellen Sie ein neues Projekt mit einem Formular (drei Buttons), über das wir die DLL-Funktionen aufrufen werden.

Vor dem Aufruf müssen allerdings die Funktionen erst einmal in unsere Anwendung integriert werden: implementation ...

10.5 Praxisbeispiele für Fortgeschrittene

523

procedure Fensteranzeigen;stdcall;external 'formdll.dll'; function berechne1(x,y : Single): Single;stdcall; external 'formdll.dll'; procedure berechne2(x,y: Single; var z: Single); stdcall;external 'formdll.dll';

Der eigentliche Aufruf unterscheidet sich nicht mehr von einer "normalen" Funktion oder Prozedur: fensterAnzeigen Label1.Caption := Format('%f',[berechne1(11.11,22.22)]); ... var z: Single; ... berechne2(11.11,22.22,z); Label2.Caption := Format('%f',[z]);

Test Kopieren Sie die DLL in das Verzeichnis der Anwendung und starten Sie die Anwendung. Überprüfen Sie, ob die Meldungsfenster wie gewünscht angezeigt werden.

Starten Sie noch eine weitere Instanz Ihrer Anwendung. Sie werden feststellen, dass die Dialogbox "DLL wird geladen ..." erneut angezeigt wird. An dieser Stelle ist die Beschriftung allerdings etwas irreführend, die DLL befindet sich ja bereits im Speicher, es wird lediglich noch einmal der Initialisierungs-Abschnitt durchlaufen. (32-Bit-DLLs verwenden das Datensegment der aufrufenden Anwendung, deshalb muss auch die Initialisierung für jede Instanz erneut abgearbeitet werden.) Löschen Sie einmal die DLL und versuchen Sie, Ihre Anwendung zu starten. Eine Fehlermeldung wird sich nicht vermeiden lassen:

Bemerkung Auch wenn noch keine Funktion der DLL aufgerufen wird, versucht Windows die DLL zu laden. Ist diese nicht vorhanden, wird auch Ihre Anwendung nicht gestartet. Der Grund für dieses Verhalten: Da die DLL statisch in Ihre Anwendung eingebunden ist, muss auch die DLL zum Zeitpunkt des Programmstarts im Suchpfad vorhanden sein. Wie Sie dieses "Problem" umgehen können, ist im folgenden Beispiel beschrieben.

524

Kapitel 10

Programmschnittstellen/Peripherie

10.5.3 DLL dynamisch einbinden Die statische Einbindung von DLLs haben Sie, mehr oder weniger unbewusst, sicher schon verwendet, fast alle API- bzw. GDI-Funktionen sind in den Schnittstellen-Units (windows, mapi ...) bereits deklariert. Etwas anders verhält es sich mit der dynamischen Einbindung von DLLs, die (Sie ahnen es bereits) etwas komplizierter ist. Statt schon zur Entwurfszeit eine spezielle DLL festzulegen, können Sie bei der dynamischen Einbindung zur Laufzeit eine DLL über ihren Namen auswählen. Diese Flexibilität hat jedoch ihren Preis, wir müssen selbst dafür sorgen, dass die DLL geladen, die Funktion ausgeführt und die DLL wieder freigegeben wird. Doch bevor es so weit ist, müssen Sie einen Funktionsprototyp deklarieren, der die jeweiligen Funktionsparameter festlegt. In unserem Beispiel wird es lediglich darum gehen, eine Berechnung durchzuführen. Bei der einen DLL handelt es sich um eine Addition, bei der anderen um eine Multiplikation.

Quellcode Die DLL (Addition): library summe; { die zu exportierende Funktion } function berechne(x,y: Integer): integer; export; begin result := x+y end; exports berechne; { Der Initialisierungsabschnitt } begin end.

Im aufrufenden Programm erstellen wir zuerst einen Funktionsprototyp, der die Funktionsparameter festlegt: type TTestFunktion = function(x,y: Integer): integer;

Der Aufruf der Funktion: procedure TForm1.Button1Click(Sender: TObject); var TestFunktion : TTestFunktion; FuncPtr : TFarProc; DLLHandle : THandle; begin

Laden der DLL: DLLHandle := LoadLibrary(PChar(Edit1.Text));

Adresse der Funktion ermitteln: FuncPtr

:= GetProcAddress(DLLHandle,'berechne');

10.5 Praxisbeispiele für Fortgeschrittene

525

Wenn die Funktion gefunden wurde: if FuncPtr <> nil then begin @TestFunktion := FuncPtr;

Ausführen des Codes: Label3.Caption := IntToStr(Testfunktion(4,5)); FuncPtr:=nil; end else showMessage('Funktion oder DLL nicht gefunden!');

Freigeben der DLL: FreeLibrary(DLLHandle) end;

Sie sehen schon, der Aufwand ist wesentlich größer als bei einer statisch eingebundenen DLL.

Test Im Beispielprogramm können Sie in der Textbox einen DLL-Namen festlegen (Produkt.dll, Summe.dll) und danach die Berechnung starten.

Bemerkungen ■ Einsatzmöglichkeiten für diese Technik bieten sich beispielsweise bei Im- und Exportfiltern, die gänzlich verschiedene Dateiformate konvertieren. Lediglich die Funktionsschnittstelle ist einheitlich, der DLL-Name legt das Dateiformat fest. ■ Sollten Sie Probleme bei der Realisierung haben, kontrollieren Sie unbedingt die Schreibweise der Funktionsnamen (32-Bit-DLLs unterscheiden Groß-/Kleinschreibung!).

11

Komponentenentwicklung

Kapitel

11

Komponentenentwicklung Komponenten sind die Bausteine Ihrer Delphi-Anwendung, wie sie zunächst in vielfältiger Gestalt in der Komponentenpalette der IDE angeboten werden. Weil sich der fortgeschrittene Programmierer mit dem Standardangebot kaum zufrieden gibt, wollen wir Ihnen in diesem Kapitel zeigen, wie Sie die Komponentenpalette mit eigenen Kreationen bereichern können. Allerdings beschränken wir uns hierbei auf die Entwicklung "hauseigener" (nativer) Komponenten, wie sie auch Bestandteil der Delphi-VCL (Visual Component Library) sind. Ausgeschlossen sind also die ActiveX-Komponenten der plattformübergreifenden COM-Technologie von Microsoft (siehe dazu Kapitel 12). Im Unterschied zur Programmierung normaler Anwendungen werden Sie bei der Komponentenentwicklung kaum durch die visuellen Werkzeuge der Delphi-IDE unterstützt, hier müssen Sie alles in solider Handarbeit, also per Code, erledigen.

11.1 Überblick Wir wollen keine komplette Anleitung zur Programmierung der Komponente xy geben, sondern wir wollen an einem weitgehend abstrakten Beispiel (gewissermaßen einem wiederverwendbaren Codegerüst) das Programmieren von ■ Eigenschaften, ■ Methoden und ■ Ereignissen demonstrieren. Im Anschluss gehen wir anhand dreier einfacher Beispiele auf die wichtigsten Typen von Komponenten ein: ■ nicht sichtbare Komponenten ■ grafische Komponenten ■ datengebundene Komponenten Wer im vorliegenden Kapitel allgemeine Informationen zur Programmierung von Objekten sucht, wird ebenfalls fündig werden. Fast alles, was zum Thema "Komponenten" gesagt wird, ist auch auf

528

Kapitel 11

Komponentenentwicklung

Objekte zu verallgemeinern. Wesentlichster Unterschied dürfte ein fehlendes Designtime-Interface sein, d.h., die Unterstützung durch den Objektinspektor fehlt. Bevor es ins Detail geht, noch ein allgemeiner Hinweis zur Komponentenentwicklung: So leicht sich Komponenten auch handhaben lassen, nicht für jedes Problem ist eine Komponente die ideale Lösung. Vielfach genügt schon die Kapselung in einer Unit oder die Verwendung eines "normalen" Objekts. HINWEIS: Dass der Erwerb von Fremdkomponenten eine zweischneidige Angelegenheit ist,

dürften alle jene erfahren haben, die Komponenten für ältere Delphi-Versionen ohne deren Quelltexte besitzen. In diesem Fall dürfen Sie jetzt nochmals Geld ausgeben, da die Komponente erneut compiliert werden muss.

11.2 Ableiten der Komponente Bevor Sie sich auf die Komponentenprogrammierung stürzen, sollten Sie sich überlegen, welchen Typ Sie benötigen. Soll es eine zur Laufzeit nicht sichtbare Komponente sein, müssen Sie diese von TComponent ableiten, der Basis-Klasse für alle Komponententypen (die wichtigsten Eigenschaften und Methoden sind hier bereits implementiert). Soll es etwas Spezielleres sein, zum Beispiel ein neues Editierfeld, dann müssen Sie sich einen Komponententyp suchen (in diesem Fall TEdit), der sich weitestgehend Ihren Anforderungen annähert. Diesen erweitern Sie dann um die gewünschte neue Funktionalität oder Sie überschreiben die bisherigen Methoden. Die folgende Abbildung zeigt die wichtigsten Klassen, die für eine Vererbung in Frage kommen (es muss sich um Nachkommen von TComponent handeln). TComponent

TTimer

TScreen

TMenuItem

TGraphicControl

TCustomComboBox TCustomControl TCustomEdit

TControl

TMenu

TCommon Dialog

TGlobal Component

TApplication

TWinControl

TButtonControl TScrollBar TScrollingWinControl

TCustomListBox TForm

11.2 Ableiten der Komponente

529

Wir werden uns im Weiteren vorerst auf eine TComponent-Komponente beschränken. Im Praxisteil finden Sie auch eine Komponente, die von TGraphicControl abgeleitet ist. Erster Schritt zur eigenen Komponente ist der Menüpunkt Datei|Neu|Weitere... In der sich öffnenden Objektgalerie wählen Sie das "Komponente"-Symbol:

Es öffnet sich ein "Experte", wo Sie Folgendes eintragen:

Sie erhalten ein leeres Programmgerüst, das Sie mit "Leben erfüllen" sollen: unit Beispiel; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;

530

Kapitel 11

Komponentenentwicklung

type TBeispiel = class(TComponent) private { Private-Deklarationen } protected { Protected-Deklarationen } public { Public-Deklarationen } published { Published-Deklarationen } end; procedure Register; implementation procedure Register; begin RegisterComponents('Beispiele', [TBeispiel]); end; end.

11.3 Eigenschaften Als Erstes werden wir uns um die verschiedenen Typen von Eigenschaften kümmern. Zwei verschiedene Varianten sollten Sie gleich zu Beginn unterscheiden: ■ Eigenschaften, die nur zur Laufzeit "sichtbar" sind ■ Eigenschaften, die im Objektinspektor angezeigt und editiert werden können Die Unterscheidung treffen Sie durch die Wahl des interface-Abschnitts in der Klassendefinition. Properties, die im Bereich Public definiert wurden, sind nur zu Laufzeit sichtbar, solche aus dem Abschnitt Published hingegen auch zur Entwicklungszeit. Eine Einschränkung muss an dieser Stelle allerdings gemacht werden: HINWEIS: Schreibgeschützte Eigenschaften haben im Published-Abschnitt nichts verloren, da

sie im Objektinspektor auch nicht bearbeitet werden können.

Einfache Eigenschaften Diese können zum Beispiel vom Typ String oder Integer sein. Im Objektinspektor haben Sie die Möglichkeit, den Wert zu editieren (nur wenn die Eigenschaft dies zulässt). Im Folgenden wollen wir vier verschiedene Realisierungsmöglichkeiten von einfachen Eigenschaften näher betrachten: TBeispiel = class(TComponent) private

11.3 Eigenschaften

531

FValue : Integer; function GetDatum: TDateTime; function GetValue: Integer; procedure SetValue(i:integer); public // nur zur Laufzeit property Datum : TDateTime read GetDatum; published // im Objektinspektor property Value :Integer Read FValue Write FValue; property Value1 :Integer Read FValue; property Value2 :Integer Read GetValue Write SetValue; end;

Die Eigenschaft Value lässt sowohl das Lesen als auch das Schreiben zu. Verantwortlich dafür sind die Optionen Read bzw. Write, die beide direkt auf die private Variable FValue zugreifen. Für die Eigenschaft Value1 existiert keine Write-Option, die Variable FValue kann also nur gelesen werden. Damit wird diese Eigenschaft auch nicht im Objektinspektor angezeigt. Die Property Value2 verhält sich ähnlich wie Value, beim Lesen bzw. Schreiben wird jedoch nicht direkt auf die Variable FValue zugegriffen, sondern es wird der Umweg über eine Prozedur (Schreiben) bzw. eine Funktion (Lesen) gewählt. Der Vorteil: Sie haben die Möglichkeit, Wertebereiche zu prüfen, oder Sie können Berechnungen für die Bestimmung der Werte ausführen: function TBeispiel.GetValue: Integer; begin result := FValue+2 end; procedure TBeispiel.SetValue(i: Integer); begin if i <> FValue then FValue := i + 10 end;

Ein gutes Beispiel ist in diesem Zusammenhang die Eigenschaft Datum. Die Abfrage des Wertes geschieht über die Funktion GetDatum, in der das Systemdatum bestimmt wird: function TBeispiel.GetDatum: TDateTime; begin result := Date end;

Schauen wir uns die Read- und die Write-Methode einmal genauer an:

Die Read-Methode Es handelt sich um eine Funktion, die keine Parameter annimmt und einen Wert vom Typ der Eigenschaft zurückliefert. Vereinbarungsgemäß lautet der Funktionsname "Get...". Die ReadMethode für eine Eigenschaft mit dem Namen Value würde also getValue heißen. Die Regel "keine Parameter" kennt eine Ausnahme, nämlich bei Array-Eigenschaften, die ihre Indizes als Parameter übergeben.

532

Kapitel 11

Komponentenentwicklung

Wenn keine Read-Methode deklariert wird, erlaubt die Eigenschaft nur Schreibzugriff, was allerdings nur selten einen Sinn ergeben dürfte.

Die Write-Methode Es handelt sich um eine Prozedur mit genau einem Parameter. Dieser muss vom gleichen Typ sein wie die Eigenschaft. Er kann durch Referenz (var) oder als Wert übergeben werden und jeden beliebigen Namen haben. Vereinbarungsgemäß ist der Name der Prozedur "Set..." (z.B. setValue). Ohne Write-Methode gestattet die Eigenschaft nur Lesezugriff. Üblicherweise wird vor dem Setzen des Wertes überprüft, ob sich der neue Wert vom aktuellen unterscheidet. BEISPIEL: Die folgende Write-Methode für eine Integer-Eigenschaft namens Value speichert ihren aktuellen

Wert in dem Feld F_Value: procedure TMyComponent.SetValue(Value: Integer); begin if Value <> F_Value then F_Value:= Value end;

Die Beschränkung auf private Zugriffsmethoden dient auch der Sicherheit. Anwender von selbst definierten Komponenten können diese Methoden nicht versehentlich von außerhalb aufrufen und damit Eigenschaften irreparabel verändern.

11.3.1 Eigenschaften von Aufzählungstypen Ist der Wertebereich einer Eigenschaft zur Entwicklungszeit bereits bekannt, können Sie die Fehlermöglichkeiten dadurch einschränken, dass Sie einen Aufzählungstyp verwenden. Im Objektinspektor wird in diesem Fall eine Liste der zulässigen Werte angezeigt:

Der Vorteil für den Endanwender liegt auf der Hand: Statt irgendwelcher numerischer Werte werden aussagefähige Beschriftungen angezeigt. Auf die Verwendung der Hilfefunktion kann deshalb fast immer verzichtet werden. Für Sie als Entwickler bedeutet ein Aufzählungstyp ein wenig mehr Arbeit, da Sie zuerst einen entsprechenden Typ deklarieren müssen.

533

11.3 Eigenschaften

Die eigentliche Umsetzung in der Komponentendefinition unterscheidet sich nicht von der einer einfachen Eigenschaft, mit dem Unterschied, dass Sie auf eine Prozedur für das Setzen der Eigenschaft verzichten können (die Fehlerprüfung nimmt der Compiler vor). TAufzaehlung = (Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag);

BEISPIEL: Die Verwendung in der Komponentendefinition: TBeispiel = class(TComponent) private FTag : TAufzaehlung; published // im Objektinspektor property Verabredung: TAufzaehlung read FTag write FTag; end;

11.3.2 Eigenschaften von Mengentypen Mengentypen gestatten die Auswahl von mehr als einer Option. Im Objektinspektor können Sie entweder die einzelnen Optionen in eckigen Klammern angeben, oder Sie expandieren die Eigenschaft und legen die Optionen getrennt fest (True/False):

Wie bei den Aufzählungstypen ist es notwendig, vor der Klassendefinition einen neuen Typ zu definieren, der alle zulässigen Optionen festlegt. TMengentyp

= set of (Editieren, Kopieren, Einfuegen, Loeschen);

Die Umsetzung in der Komponentendefinition: TBeispiel = class(TComponent) private FMengentyp : TMengentyp; published // im Objektinspektor property Options: TMengentyp read FMengentyp write FMengentyp; end;

11.3.3 Objekt-Eigenschaften Während Sie beim vorhergehenden Eigenschaftstyp lediglich True-/False-Werte als einzelne Optionen festlegen können, bietet eine Objekt-Eigenschaft wesentlich mehr. Das wohl prominenteste Beispiel dürfte die Eigenschaft Font sein, die wiederum über eigene Eigenschaften verfügt.

534

Kapitel 11

Komponentenentwicklung

Im Objektinspektor können Sie entweder einen Eigenschaften-Editor verwenden, oder Sie expandieren den Eintrag und legen die Objekt-Eigenschaften einzeln fest:

BEISPIEL: Implementieren eines TFont-Objekts in unserer Beispielkomponente TBeispiel = class(TComponent) private FFont : TFont; public // nur zur Laufzeit constructor Create(AOwner:TComponent); override; published // im Objektinspektor property Font : TFont read FFont write FFont; end;

Abweichend von der bisherigen Vorgehensweise ist es jetzt erforderlich, den Konstruktor Create zu überschreiben, da das TFont-Objekt zuerst initialisiert werden muss: Constructor TBeispiel.Create(AOwner:TComponent); begin inherited Create(AOwner); // Methode des Vorfahren ausführen // ... eigener Initialisierungscode FFont := TFont.Create end;

Komplizierter wird die ganze Geschichte, wenn Sie ein neues Objekt erstellen wollen. In diesem Fall genügt es nicht, wenn Sie das Objekt von TObject ableiten, es muss schon die Klasse TPersistent sein. BEISPIEL: Unser Objekt soll drei Eigenschaften vom Typ Integer aufweisen.

Die Objektdefinition: TTestObjekt = class(TPersistent) private FValue1 : Integer;

535

11.3 Eigenschaften

FValue2 FValue3 published property property property end;

: Integer; : Integer; Value1 Value2 Value3

:Integer Read FValue1 Write FValue1; :Integer Read FValue2 Write FValue2; :Integer Read FValue3 Write FValue3;

Das Einbinden in die Komponentendefinition: TBeispiel = class(TComponent) private FTestObjekt: TTestObjekt; public // nur zur Laufzeit constructor Create(AOwner:TComponent); override; published // im Objektinspektor property TestObjekt : TTestObjekt read FTestObjekt write FTestObjekt; end;

Die Initialisierung darf natürlich nicht vergessen werden: Constructor TBeispiel.Create(AOwner:TComponent); begin inherited Create(AOwner); // Methode des Vorfahren ausführen FTestObjekt := TTestObjekt.Create; FTestObjekt.value1:=111; FTestObjekt.value2:=222; FTestObjekt.value3:=333 end;

11.3.4 Komponenten-Eigenschaften Diese kennen Sie sicher von den Datenbank-Komponenten her, bei denen Sie beispielsweise die DataSource-Eigenschaft recht komfortabel festlegen können. Ähnlich wie bei einem Aufzählungstyp werden in einer Klappbox alle Komponenten aufgelistet, die den gewünschten Klassentyp aufweisen. BEISPIEL: Wir wollen die Komponente mit einer Eigenschaft ausstatten, die eine Verknüpfung mit TEdit-

Komponenten ermöglicht:

Die Umsetzung ist relativ einfach bewerkstelligt, Sie brauchen lediglich der Eigenschaft den entsprechenden Datentyp zuzuweisen:

536

Kapitel 11

Komponentenentwicklung

TBeispiel = class(TComponent) private FEdit : TEdit; published // im Objektinspektor property Editbox: TEdit read FEdit write FEdit; end;

Im Programm haben Sie später die Möglichkeit, beispielsweise mit TBeispiel.FEdit.Text := 'Hallo';

die Text-Eigenschaft der verknüpften Komponente zu ändern. An dieser Stelle müssen Sie sich allerdings auf ein Problem einstellen: Belassen Sie es bei obigen Codefragmenten, kommt es unweigerlich zu einer Schutzverletzung, wenn Sie die verknüpfte Komponente löschen. Die Ursache ist schnell geklärt. Da in Ihrer Komponente ein Zeiger auf das andere Objekt abgespeichert ist, dieser aber auf ein nicht mehr existentes Objekt verweist, gibt es Ärger. Wie nicht anders zu erwarten, haben die Borland-Programmierer natürlich auch für diesen Fall einen Mechanismus vorgesehen, die betroffenen Komponenten von derart wichtigen Änderungen zu benachrichtigen.

Die Notification-Methode Jede Veränderung (Erzeugen oder Löschen) von Komponenten führt zu einem Aufruf der Methode Notification. Über die Parameter der Funktion lässt sich zum einen die betroffene Komponente, zum anderen die eigentliche Operation unterscheiden. Ihre Aufgabe als Programmierer besteht nun darin, diese Methode zu erweitern, d.h. zu prüfen, ob Eigenschaften Ihrer Komponente von den Änderungen betroffen sind. Erweitern Sie deshalb die Klassendefinition um folgende Anweisungen: ... protected procedure Notification(AComponent: TComponent; Operation: TOperation); override; ...

Die eigentliche Implementierung der Methode: procedure TDBMyEdit.Notification(AComponent: TComponent; Operation: TOperation); begin

Aufruf der geerbten Funktion: inherited Notification(AComponent, Operation);

Wird eine Komponente gelöscht und verweist die Eigenschaft auf die zu löschende Komponente, dann wird die Eigenschaft zurückgesetzt (nil): if (Operation = opRemove) and (FEdit <> nil) and (AComponent = Editbox) then EditBox := nil end;

11.4 Methoden

537

Durch die Zuweisung von nil wird wieder ein eindeutiger Zustand der Eigenschaft hergestellt, Schutzverletzungen können jetzt nicht mehr auftreten.

Array-Eigenschaften Array-Eigenschaften können Sie nicht direkt im Objektinspektor bearbeiten. Entweder benutzen Sie eigene Eigenschafts-Editoren (siehe z.B. Lines), oder Sie stellen die Eigenschaft nur zur Laufzeit zur Verfügung. BEISPIEL: Unser Array besteht aus sieben Einträgen, die bereits zur Entwurfszeit festgelegt wurden. const tage : array[1..7] of string[2] = ('Mo','Di','Mi','Do','Fr','Sa','So');

Sie könnten auch ein dynamisches Array oder eine Liste zur Laufzeit erzeugen und diese als Basis für die Array-Eigenschaft verwenden. Die Deklaration: type TBeispiel = class(TComponent) private function GetWochentag(Index: Integer): string; public // nur zur Laufzeit property Wochentag[Index: Integer]: string read GetWochentag; end;

Array-Eigenschaften werden immer über eine Funktion ausgelesen, da sie einen Index übergeben müssen. Die Realisierung der Methode: function TBeispiel.GetWochentag(Index: Integer): string; begin if index in [1..7] then result := tage[Index] else result := 'Unbekannt' end;

Damit dürften wir die wichtigsten Varianten von Eigenschaften berücksichtigt haben. Auf alle Kombinationsmöglichkeiten können wir aus Platzgründen leider nicht eingehen, die gezeigten Beispiele dürften jedoch manche Unklarheit beseitigt haben.

11.4 Methoden Hinter den Methoden von Komponenten verbergen sich nichts anderes als normale Prozeduren oder Funktionen, die jedoch fest an die jeweilige Komponente gekoppelt sind. Aus der Realisierung resultiert auch das Einsatzgebiet: Methoden sollten, im Gegensatz zu Eigenschaften, Aktionen auslösen, die teilweise mit Rückgabewerten verbunden sind (Funktionen). Gleichzeitig bieten sich

538

Kapitel 11

Komponentenentwicklung

Methoden auch dann an, wenn es darum geht, mehrere Eigenschaften gleichzeitig zu beeinflussen. Als Beispiel kann in diesem Zusammenhang die SetBounds-Methode genannt werden, diese beeinflusst die Eigenschaften Left, Top, Width und Height.

11.4.1 Allgemeines Deklarationsabschnitt Grundsätzlich können Sie Methoden in den Abschnitten public, protected und private der Klassendefinition deklarieren. Die letzte Variante ist allerdings kaum für die Definition eines Interfaces geeignet, lediglich die Property-Get- und -Set-Funktionen bzw. -Prozeduren sollten Sie in diesem Abschnitt deklarieren, um den direkten Zugriff durch den Anwender der Komponente zu verhindern. Der protected-Abschnitt verbirgt die Methoden vor dem "normalen" Quelltext eines Programms, abgeleitete Objekte können jedoch problemlos auf derartige Methoden zugreifen. BEISPIEL: Die Klasse TObject1 definiert eine Methode ausgabe im protected-Abschnitt. Die Klasse TObject2

ist von TObject1 abgeleitet und versucht, auf die Methode ausgabe zuzugreifen. type TObject1 = class protected procedure ausgabe; virtual; end; procedure TObject1.ausgabe; begin ShowMessage('Hier ist TObject1') end; type TObject2 = class(TObject1) end; var o1 : TObject1; o2 : TObject2;

Die folgenden Zeilen würden zu einem Fehler führen (undefinierter Bezeichner): o1 := TObject1.Create; o1.ausgabe;

// !!!!! Fehler

Hingegen ist es für die Klasse TObject2 kein Problem, die Methode zu verwenden: o2 := TObject2.Create; o2.ausgabe;

Was bleibt, ist der public-Abschnitt, in dem Sie alle Methoden deklarieren, die sowohl in der eigenen Instanz als auch in allen abgeleiteten Klassen verfügbar sind.

539

11.4 Methoden

HINWEIS: Der Abschnitt published (Anzeige im Objektinspektor) dürfte wohl kaum für Metho-

den geeignet sein, da diese immer erst zur Laufzeit verfügbar sind.

Static, Virtual, Dynamic, Abstract In der Interface-Deklaration müssen Sie neben Methodennamen, Parametern etc. auch den Typ bzw. Zuteilung/Gültigkeitsbereich der Methode deklarieren: Static

(Default) Die Methode wird wie jede andere Prozedur oder Funktion behandelt, der Compiler setzt die Adresse in das Programm ein. Static-Methoden können nicht überschrieben, sondern nur ersetzt werden. type TObject1 = class protected procedure ausgabe; end;

Virtual

Die Methode kann durch eine abgeleitete Klasse überschrieben werden und wird erst zur Laufzeit mit dem zugehörigen Code verbunden. Zur Verwaltung verwendet das Programm eine so genannte Virtual Methode Table (VMT). Virtuelle Methoden sind geringfügig langsamer als statische Methoden. type TObject1 = class protected procedure ausgabe; virtual; end;

Dynamic

Diese Methoden funktionieren wie virtuelle Methoden, der Verwaltungsmechanismus unterscheidet sich jedoch. Dies führt zu einer etwas langsameren Ausführungsgeschwindigkeit, der Speicher wird jedoch nicht durch die Einträge in der VMT belastet.

Abstract

Hierbei handelt es sich eigentlich nur um die Deklaration der Schnittstellen, um die Implementierung müssen sich die Nachfahren der Klasse kümmern. Wird die Methode ohne Implementierung aufgerufen, führt dies zu einem Laufzeitfehler. Abstrakte Methoden müssen immer als virtual oder dynamic deklariert sein. type TObject1 = class protected procedure ausgabe; virtual; abstract; end;

Die Implementierung in der abgeleiteten Klasse: type Tobject2 = class(TObject1) procedure ausgabe; end; procedure TObject2.ausgabe; begin showMessage('Hier ist TObject2') end;

540

Kapitel 11

Komponentenentwicklung

Konstruktoren und Destruktoren In beiden Fällen handelt es sich um spezielle Methoden, die bereits vom allgemeinen Vorfahren TObject geerbt wurden.

Konstruktoren Konstruktoren werden zum Erzeugen und Initialisieren neuer Objekte benutzt (Instanzenbildung). var b : TButton; ... b := TButton.Create(self);

Normalerweise wird der Konstruktor mit Create bezeichnet, es ist jedoch ohne weiteres möglich, andere Namen zu verwenden. Weiterhin kann ein Objekt auch mehrere Konstruktoren besitzen. Bestes Beispiel dürfte in diesem Zusammenhang die Klasse Exception sein: Exception = class(TObject) private FMessage: string; FHelpContext: Integer; public constructor Create(const Msg: string); constructor CreateFmt(const Msg: string; const Args: array of const); constructor CreateRes(Ident: Integer); constructor CreateResFmt(Ident: Integer; const Args: array of const); constructor CreateHelp(const Msg: string; AHelpContext: Integer); constructor CreateFmtHelp(const Msg: string; const Args: array of const; AHelpContext: Integer); constructor CreateResHelp(Ident: Integer; AHelpContext: Integer); constructor CreateResFmtHelp(Ident: Integer; const Args: array of const; AHelpContext: Integer); ...

Wie Sie sehen, können die einzelnen Konstruktoren mit völlig verschiedenen Parametern aufgerufen und initialisiert werden. Bei Aufruf eines Konstruktors wird auf dem Heap Speicherplatz für das Objekt allokiert und mit 0 initialisiert. Weiterhin wird der Implementierungscode ausgeführt und eine Referenz auf den neu allokierten und initialisierten Speicherbereich zurückgegeben (Instanz). Im Zusammenhang mit dem Konstruktor ist es in vielen Fällen erforderlich, auch die KonstruktorMethode des Vorgänger-Objekts auszuführen, um dessen Initialisierungen nicht zu überschreiben. Verwenden Sie dazu einen Aufruf des geerbten Konstruktors im Zusammenhang mit dem Schlüsselwort inherited. type TObject2 = class(TObject1) private FCount : Integer; protected constructor Create (count : Integer);

541

11.4 Methoden

public procedure ausgabe; end; constructor TObject2.Create(count : Integer); begin inherited Create; // Aufruf der geerbten Methode FCount := count // Initialisieren privater Variablen end;

Rufen Sie den Vorgänger-Konstruktor immer vor dem neuen Code auf. HINWEIS: Ein derartiger Aufruf führt lediglich den entsprechenden Code aus und liefert keiner-

lei Referenz auf ein neues Objekt.

Destruktoren Diese werden zum Löschen und Deinitialisieren von Objekten verwendet. Im Gegensatz zum Konstruktor müssen Sie die eigenen Anweisungen (Freigabe von Ressourcen etc.) vor dem Aufruf des geerbten Destruktors ausführen (inherited). Danach gibt der Destruktor den vom Objekt allokierten Speicherbereich frei. Wie beim Konstruktor ist es auch hier möglich, für eine Klasse verschiedene Destruktoren zu deklarieren, Sie sollten jedoch immer nur den ererbten Destruktor Destroy überschreiben.

11.4.2 Überschreiben von Methoden Eigentlich haben Sie bereits eine Möglichkeit zum Überschreiben von Methoden kennen gelernt: die Deklaration neuer Konstruktoren und Destruktoren. Ähnliches ist auch ganz allgemein für Methoden möglich. Ein etwas längeres Beispiel soll den Ablauf verdeutlichen. Deklarieren der Parent-Klasse: type TObject1 = class protected procedure ausgabe; virtual; end; procedure TObject1.ausgabe; begin ShowMessage('Hier ist TObject1') end;

Die Klasse TObject2 überschreibt die Methode ausgabe, ruft aber die ursprüngliche Methode auf: type TObject2 = class(TObject1) public procedure ausgabe; override; end;

542

Kapitel 11

Komponentenentwicklung

procedure TObject2.ausgabe; begin inherited ausgabe; ShowMessage('Hier ist TObject2') end;

Wie schon erwähnt, lassen sich nur virtual- und dynamic-Methoden überschreiben, handelt es sich um eine static-Methode, wird diese komplett ersetzt. HINWEIS: Eine abstrakte Methode können Sie wie jede virtuelle oder dynamische Methode

überschreiben, in der Implementierung ist es jedoch nicht möglich, eine inheritedMethode aufzurufen.

11.4.3 Methoden überladen Seit der Version 4 bietet Delphi auch die Möglichkeit, Methoden, d.h. unter anderem auch die Konstruktoren, zu "überladen" (overloading). Im Grunde wird damit nichts anderes gemeint, als dass unter dem gleichen Prozedur-/Methodennamen verschiedene Implementierungen realisiert werden. Das Problem für den Compiler: Wie können diese verschiedenen Versionen zugeordnet werden? Die Antwort findet sich in einer Einschränkung des Overloading-Mechanismus: Die Methoden müssen sich in Art und/oder Anzahl der Parameter unterscheiden. constructor Create(Person: TPerson); overload; override;

und gleichzeitig constructor Create(Person: TPerson; gehalt: Double); overload;

Ein sinnvoller Einsatzzweck sind beispielsweise getrennte Methoden-Implementationen für Gleitkomma- und Ganzzahl-Operationen, d.h., Sie rufen z.B. eine Methode Berechne auf und müssen sich keine Gedanken um den Datentyp machen. Diese Aufgabe übernimmt für Sie der Compiler.

11.5 Ereignisse (Events) Nicht ganz so einfach wie das Programmieren von Methoden ist die Realisierung von Ereignissen bzw. Ereignisprozeduren. Events stellen einen Mechanismus dar, der ein externes Ereignis (zum Beispiel eine Windows-Botschaft) mit einer Pascal-Routine verbindet. Genauer gesagt handelt es sich um einen Zeiger auf eine Objekt-Methode. Ereignisse werden wie Properties deklariert, mit dem Unterschied, dass Sie mit read und write jeweils direkt auf eine private-Variable zugreifen. Diese Variable hat denselben Typ wie die Eigenschaft und muss ein Methodenzeigertyp, wie zum Beispiel TNotifyEvent, sein: TNotifyEvent = procedure (Sender: TObject) of Object; type TXYZ = class(TComponent) private FOnClick: TNotifyEvent;

543

11.5 Ereignisse (Events)

... protected property OnClick: TNotifyEvent read FOnClick write FOnClick; end;

Sollen weitere Informationen an die Ereignisprozedur übergeben werden (Koordinaten etc.), können Sie auch einen eigenen Objekttyp deklarieren: type TDragDropEvent = procedure(Files : TStringList) of Object; TSystem = class(TComponent) private FOnDragDrop : TDragDropEvent; published property OnDragDrop: TDragDropEvent read FOnDragDrop write FOnDragDrop;

Alternativ können Sie auch Werte aus einer Ereignisprozedur an die Komponente zurückgeben. Deklarieren Sie in diesem Fall die Parameter des Methodenzeigertyps als var. type TKeyPressEvent = procedure(Sender: TObject; var Key: Char) of Object;

11.5.1 Standardereignisse Komponenten, die Sie von TControl bzw. einem Nachfahren von TControl ableiten, verfügen bereits über einen Satz von Ereignissen, die jedoch als protected deklariert sind.

Standardereignisse für Dialogelemente (Parent TControl) Die folgenden Ereignisse erben alle Komponenten, die von TControl abgeleitet werden: OnClick OnDblClick

OnDragDrop OnDragOver

OnEndDrag OnMouseDown

OnMouseMove OnMouseUp

Die zugehörigen Methoden sind als dynamic in TControl deklariert, die Methodenbezeichner entsprechen den Ereignisnamen ohne das vorangestellte "On".

Standardereignisse für Standarddialogelemente (TWinControl) Windows-Dialogelemente verfügen zusätzlich über die folgenden Ereignisse: OnEnter OnKeyUp

OnKeyDown OnExit

OnKeyPress

Wollen Sie die oben genannten Methoden dem Anwender zur Verfügung stellen, müssen Sie die Deklaration in public oder published ändern. Parameter bzw. Implementierung müssen Sie nicht erneut aufführen: TTestControl = class(TWinControl) published

544

Kapitel 11

Komponentenentwicklung

property OnClick; { Published-Deklarationen } end;

Binden Sie diese Komponente in ein Projekt ein, steht Ihnen im Objektinspektor als einziges Ereignis OnClick zur Verfügung.

11.5.2 Überschreiben der Standardereignisse Wollen Sie das Standardverhalten von Komponenten verändern, können Sie die Ereignismethoden auch überschreiben. Beispielsweise soll bei jedem Tastendruck in einem TEdit-Feld ein Piepton erzeugt werden, ansonsten soll aber alles beim Alten bleiben. Wir leiten zu diesem Zweck eine neue Komponente TBeepEdit von TEdit ab: type TBeepEdit = class(TEdit) protected procedure KeyPress( var Key: char ); override; end;

HINWEIS: Vergessen Sie keinesfalls die Anweisung override!

Tritt das Ereignis auf, wird zunächst die Standardbehandlungsroutine (vom Parent) aufgerufen. Zum Schluss fügen wir eigenen Code hinzu: procedure TBeepEdit.KeyPress( var Key: char ); begin inherited KeyPress( Key); Beep end;

Sie könnten auf diese Weise auch die Eingabe auf numerische Zeichen beschränken. Allerdings sollten Sie in diesem Fall erst die eigene Routine und danach die geerbte Methode ausführen: procedure TBeepEdit.KeyPress( var Key: Char); begin if not key in ['0' ... '9'] then key:= #0; inherited KeyPress( Key ); Beep end;

11.5.3 Neue Ereignisse Der erste Schritt zum neuen Ereignis ist die Typdefinition für die Ereignisbehandlungsroutine (Event-Handler). Dabei können Sie entweder die bereits vordefinierten Typen verwenden, oder Sie erstellen einen neuen Typ. TDragDropEvent = procedure(Files : TStringList) of Object;

545

11.5 Ereignisse (Events)

Wie schon erwähnt, können Sie auch Werte aus der Routine zurückgeben. Deklarieren Sie die Übergabewerte als var-Parameter. Als Nächstes müssen Sie sich um den Methodenzeiger kümmern, deklarieren Sie dazu eine private Variable: TSystem = class(TComponent) private FOnDragDrop : TDragDropEvent;

Letzter Schritt bei der Interface-Deklaration ist die Eigenschaft für das Ereignis: published property OnDragDrop: TDragDropEvent read FOnDragDrop write FOnDragDrop;

Diese muss sich natürlich im published-Abschnitt befinden, da andernfalls das Ereignis nicht im Objektinspektor angezeigt wird. Was jetzt noch fehlt, ist ein Auslöser für das Ereignis. Zwei verschiedene Varianten bieten sich dazu an: ■ Das Ereignis ist die Folge einer Windows-Message. ■ Sie lösen das Ereignis aus einer Methode der Komponente aus. Beispielsweise könnten Sie bei der TBeepEdit-Komponente dann aus dem vorhergehenden Abschnitt ein OnError-Ereignis auslösen, wenn kein numerisches Zeichen eingegeben wird. type TBeepEdit = class(TEdit) private FOnError: TNotifyEvent; protected procedure KeyPress(var Key: char); override; published property OnError: TNotifyEvent read FOnError write FOnError; end; procedure TBeepEdit.KeyPress(var Key: char); begin if (Key < '0')or(Key > '9') then begin if Assigned(OnError) then OnError(Self); Key := #0 end; inherited KeyPress( Key ) end;

Wie Sie dem Beispiel entnehmen können, wird die Ereignisroutine nicht sofort aufgerufen, vielmehr wird vorher geprüft, ob der Anwender das Ereignis auch belegt hat (if Assigned1).

1

Sie können auch direkt einen Vergleich mit nil verwenden.

546

Kapitel 11

Komponentenentwicklung

BEISPIEL: Für eine Windows-Message, die Event-Auslöser ist, wollen wir WM_SIZE verwenden, das immer

an ein fensterähnliches Dialogelement gesendet wird, wenn eine Größenänderung stattgefunden hat (das betrifft auch die Komponente TEdit, von der wir TBeepEdit ableiten). type TBeepEdit = class(TEdit) private FOnResize: TNotifyEvent; protected procedure WMSize( var Message: TWMSize ); message WM_SIZE; published property OnResize: TNotifyEvent read FOnResize write FOnResize; end; procedure TBeepEdit.WMSize(var Message: TWMSize); begin if Height <> 21 then begin Height := 21; Refresh end; if Assigned(OnResize) then OnResize(Self) end;

Mit der Message-Prozedur (an dieser Stelle handelt es sich noch nicht um die Event-Prozedur) verhindern wir einerseits, dass die Komponente höher als 21 Pixel wird, andererseits lösen wir das Ereignis OnResize aus. Beachten Sie, dass zwar der Code innerhalb von WMSize zur Entwurfszeit ausgeführt wird, nicht jedoch die Ereignisroutine.

11.6 Die wichtigsten Komponententypen Wie schon in der Einführung dieses Kapitels erwähnt, wollen wir uns nach dem eigentlichen Theorieteil noch einmal speziellen praktischen Themen zuwenden. Ausgehend von jeweils einem Beispiel möchten wir Ihnen im Zusammenhang die wichtigsten Schritte zur fertigen Komponente aufzeigen.

11.6.1 Datengebundene Komponenten Als Beispiel für eine datengebundene Komponente wollen wir einen absolut simplen Nachfahren von TEdit erzeugen, der sich an eine Tabellenspalte binden lässt. "Nicht sehr anspruchsvoll" werden Sie sagen, zumal eine entsprechende Komponente bereits existiert. Umso besser: So brauchen wir uns um die Funktionsbeschreibung nicht weiter zu kümmern, wir können gleich zu den Einzelheiten kommen. Wie Sie noch sehen werden, ist der Verwaltungsaufwand hinter den Kulissen relativ groß. Ausgangspunkt ist wie immer der Komponentenexperte. Als Vorfahrtyp wählen wir TEdit, unsere neue Komponente bekommt die Bezeichnung TDBMyEdit:

11.6 Die wichtigsten Komponententypen

547

Im Anschluss dürfen Sie die Finger über die Tastatur tanzen lassen, allein die Änderungen an der Klassendefinition sind schon recht umfangreich: type TDBMyEdit = class(TEdit) private { Private-Deklarationen } FDataLink: TFieldDataLink; procedure DataChange(Sender: TObject); procedure EditingChange(Sender: TObject); procedure UpdateData(Sender: TObject); function GetDataField: string; function GetDataSource: TDataSource; function GetField: TField; procedure SetDataField(const Value: string); procedure SetDataSource(Value: TDataSource); procedure CMGetDataLink(var Message: TMessage); message CM_GETDATALINK; protected procedure Change; override; procedure KeyPress(var Key: Char); override; procedure Notification(AComponent: TComponent; Operation: TOperation); override; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; property Field: TField read GetField; published { Published-Deklarationen } property DataField: string read GetDataField write SetDataField; property DataSource: TDataSource read GetDataSource write SetDataSource; end;

Lassen Sie sich nicht abschrecken, dieser Aufwand ist nur nötig, wenn Sie eine datengebundene Komponente aus einer nicht datengebundenen Komponente erzeugen.

548

Kapitel 11

Komponentenentwicklung

Wofür die einzelnen Methoden und Eigenschaften zuständig sind, wollen wir im Folgenden klären.

Konstruktor Mit dem Erstellen der Komponente müssen wir auch ein FieldDataLink-Objekt erstellen (private Variable). Über dieses Objekt wird die Kommunikation mit den anderen Datenbank-Komponenten hergestellt. Weisen Sie dem FieldDataLink-Objekt eine Datenquelle (DataSource) zu, wird Ihre Komponente bei jeder Änderung (Datensatzwechsel, Moduswechsel etc.) benachrichtigt. Als Schnittstellen dienen drei Methoden (OnDataChange, OnEditingChange, OnUpdateData), die Sie entsprechend auswerten müssen. constructor TDBMyEdit.Create(AOwner: TComponent); begin inherited Create(AOwner); FDataLink := TFieldDataLink.Create; FDataLink.Control := Self; FDataLink.OnDataChange := DataChange; FDataLink.OnEditingChange := EditingChange; FDataLink.OnUpdateData := UpdateData end;

Destruktor Beim Zerstören Ihrer Komponente müssen Sie natürlich auch die selbst erstellten Objekte deinitialisieren: destructor TDBMyEdit.Destroy; begin FDataLink.Free; FDataLink := nil; inherited Destroy end;

Die Eigenschaften DataSource und DataField Nächster Schritt ist die Realisierung der Eigenschaften DataSource und DataField mit Hilfe der Schnittstellen-Methoden: function TDBMyEdit.GetDataSource: TDataSource; begin Result := FDataLink.DataSource end;

Gespeichert werden die Werte im DataLink-Objekt: procedure TDBMyEdit.SetDataSource(Value: TDataSource); begin FDataLink.DataSource := Value; if Value <> nil then Value.FreeNotification(Self) end;

11.6 Die wichtigsten Komponententypen

549

function TDBMyEdit.GetDataField: string; begin Result := FDataLink.FieldName end; procedure TDBMyEdit.SetDataField(const Value: string); begin FDataLink.FieldName := Value end;

Die Notification-Methode Wie schon im Theorieteil erwähnt (Abschnitt 11.3.5), müssen wir auch für den Fall vorsorgen, dass eine gebundene Komponente gelöscht wird: procedure TDBMyEdit.Notification(AComponent: TComponent; Operation: TOperation); begin inherited Notification(AComponent, Operation); if (Operation = opRemove) and (FDataLink <> nil) and (AComponent = DataSource) then DataSource := nil end;

Als Nächstes kümmern wir uns um die drei Ereignis-Methoden.

EditingChange, DataChange, UpdateData Jede Änderung des Bearbeitungsmodus (Browse zu Edit etc.) führt zu einem Aufruf von EditingChange. Sie könnten beispielsweise die Komponente farbig hinterlegen, um dem Bearbeiter den neuen Modus anzuzeigen. In der vorliegenden Komponente werden wir das Ereignis nicht weiter auswerten: procedure TDBMyEdit.EditingChange(Sender: TObject); begin inherited end;

Ganz anders beim Ereignis DataChange. Hier reagieren wir auf die Änderung des Feldinhalts. Ursache könnte beispielsweise das Scrollen durch die Datenmenge sein. procedure TDBMyEdit.DataChange(Sender: TObject); begin if FDataLink.Field <> nil then begin if FDataLink.Field is TStringField then Text := FDataLink.Field.AsString; Modified:= False; end else if csDesigning in ComponentState then Text := Name else Text := '' end;

Sollte der Komponente zur Entwicklungszeit (if csDesigning in ComponentState) keine Datenquelle zugewiesen sein, zeigen wir den Namen der Komponente an, sonst einen Leerstring.

550

Kapitel 11

Komponentenentwicklung

Mit dem Ereignis UpdataData können Sie die Inhalte der Komponente in die Tabellenspalte übernehmen: procedure TDBMyEdit.UpdateData(Sender: TObject); begin FDataLink.Field.AsString:= Text end;

Damit haben wir eigentlich alle wesentlichen Funktionen realisiert, allerdings ist unsere Komponente noch nicht sehr kontaktfreudig. Was fehlt, ist die Meldung an die übergeordnete DataSource, dass sich in unserer Komponente etwas getan hat (Eingabe).

Benachrichtigen der übergeordneten Komponenten Jeder Tastendruck in unserer Komponente hat zur Folge, dass die Datenmenge in den Editiermodus umschaltet. Einzige Ausnahme: Die ESC-Taste führt dazu, dass der alte Feldinhalt wiederhergestellt wird: procedure TDBMyEdit.KeyPress(var Key: Char); begin inherited KeyPress(Key); if Key = #27 then FDataLink.Reset else FDataLink.Edit end;

Über Änderungen in der Komponente benachrichtigen wir die anderen Komponenten über das Change-Ereignis. Durch den Aufruf von Modified wird signalisiert: "Hier hat sich etwas geändert!" procedure TDBMyEdit.Change; begin inherited Change; if Modified then begin FDataLink.Modified end end;

Wie Sie sehen, wird die gesamte Kommunikation mit den anderen Datenbank-Komponenten über das DataLink-Objekt abgewickelt. Sie haben sicherlich erkannt, dass es nicht ganz trivial ist, eine datengebundene Komponente zu entwickeln. Auch das vorliegende Beispiel konnte nur einen kleinen (aber wesentlichen) Teil der Funktionalität aufzeigen. Wichtig ist an dieser Stelle nur, dass Sie mit obigem Grundgerüst die wesentlichen Aufgaben einer datengebundenen Komponente abdecken können. Damit wenden wir uns der nächsten Gruppe von Komponenten zu.

11.6 Die wichtigsten Komponententypen

551

11.6.2 Nicht sichtbare Komponenten Ausgangspunkt für derartige Komponenten, die zur Laufzeit ein Schattendasein führen, ist die Klasse TComponent. Im Theorieteil dieses Kapitels wurden bereits alle wesentlichen Aspekte dieses Komponententyps dargestellt, wir wollen uns deshalb auf eine Komponente beschränken, die ein Dialogformular verwaltet (ähnlich TOpenDialog). Dabei wollen wir uns nicht auf das einfache Anzeigen des Dialogs beschränken, sondern auch eine Interaktion ermöglichen. Dazu ist es nötig, Ereignisse des Formulars über das Komponenten-Interface zur Verfügung zu stellen.

Klassendefinition Ausgangspunkt ist, wie nicht anders zu erwarten, eine Ableitung der Klasse TComponent: type TNonVis = class(TComponent) private { Private-Deklarationen } FOnYesClick: TNotifyEvent; FOnNoClick: TNotifyEvent; FOnHelpClick: TNotifyEvent; FBoundedEdit: TEdit; protected procedure Notification(AComponent: TComponent; Operation: TOperation); override; public procedure ShowDialog; published { Published-Deklarationen } property BoundedEdit: TEdit read FBoundedEdit write FBoundedEdit; property OnYesClick: TNotifyEvent read FOnYesClick write FOnYesClick; property OnNoClick: TNotifyEvent read FOnNoClick write FOnNoClick; property OnHelpClick: TNotifyEvent read FOnHelpClick write FOnHelpClick; end;

Neben drei Ereignissen (wir kommen später darauf zurück) werden eine Eigenschaft (ein gebundenes Editfeld) sowie eine Methode (die Anzeige des Dialogs) über die Komponente bereitgestellt.

Implementieren des Formulars Erzeugen Sie einen einfachen Dialog mit folgendem grundsätzlichen Aufbau:

552

Kapitel 11

Komponentenentwicklung

Erweitern Sie nachfolgend die Klassendefinition des Formulars: type TMyForm1 = class(TForm) BitBtn1: TBitBtn; BitBtn2: TBitBtn; BitBtn3: TBitBtn; Edit1: TEdit; procedure BitBtn1Click(Sender: TObject); procedure BitBtn2Click(Sender: TObject); procedure BitBtn3Click(Sender: TObject); private { Private-Deklarationen } public { Public-Deklarationen } FKompo : TNonvis; end;

Über diese recht einfach implementierte Eigenschaft FKomp (Sie könnten auch zwei InterfaceMethoden schreiben) werden wir eine Referenz auf die Komponenten-Instanz übergeben. Auf diese Weise wird es uns möglich, aus dem Dialog heraus auf Ereignisse und Eigenschaften der Komponente Einfluss zu nehmen. In unserem speziellen Beispiel geht es darum, dass jeder Tastendruck ein Ereignis in der Komponente auslösen soll: procedure TMyForm1.BitBtn1Click(Sender: TObject); begin if Assigned(fkompo.OnYesClick) then fkompo.OnYesClick(Self); if Assigned(fkompo.BoundedEdit) then fkompo.BoundedEdit.Text:= Edit1.Text; Close end; procedure TMyForm1.BitBtn2Click(Sender: TObject); begin if Assigned(fkompo.OnNoClick) then fkompo.OnNoClick(Self); Close end; procedure TMyForm1.BitBtn3Click(Sender: TObject); begin if Assigned(fkompo.OnHelpClick) then fkompo.OnHelpClick(Self) end;

Nach dem Test, ob die jeweilige Methode bzw. Eigenschaft auch zugewiesen wurde (if Assigned), können wir die Ereignisse auslösen bzw. die Eigenschaften setzen.

Komponenten-Interface Bleibt lediglich die Implementierung der Komponente:

11.6 Die wichtigsten Komponententypen

553

uses mForm1;

Vor der Anzeige der Dialogbox müssen wir die aktuelle Instanz (Self) der Komponente an den Dialog übergeben. procedure TNonVis.ShowDialog; begin myForm1.FKompo := Self; myForm1.ShowModal end;

Werden gebundene Komponenten geändert (Eigenschaft BoundedEdit), müssen wir darauf reagieren: procedure TNonVis.Notification(AComponent: TComponent; Operation: TOperation); begin inherited Notification(AComponent, Operation); if (Operation = opRemove) and (FBoundedEdit <> nil) and (AComponent = BoundedEdit) then BoundedEdit := nil end;

Damit ist unsere Komponente auch schon fertig. In einem Programm kann nach dem Einbinden der Komponente und dem Aufruf der Methode ShowDialog über die Ereignisse der aktuelle Status der Dialogbox abgefragt werden. BEISPIEL: Reaktion auf die "Nein"-Taste procedure TForm1.NonVis1NoClick(Sender: TObject); begin ShowMessage('No wurde gewählt'); Abort end;

Auf ein Problem möchten wir Sie noch aufmerksam machen: HINWEIS: Nicht sichtbare Komponenten können keine Windows-Botschaften empfangen, da es

sich nicht um Fenster handelt. Wie es dennoch geht, zeigt Ihnen das Beispiel 11.10.2 aus dem Praxisteil.

11.6.3 Grafische Komponenten Eine dritte Gruppe von Komponenten ist für die grafische Ausgabe im weitesten Sinne zuständig. Dabei kann es sich um einfache Grafiken (Vektor/Bitmap) oder auch um komplexe Darstellungen (Tabellen etc.) handeln. In die Wahl des Vorfahrtyps sollten Sie folgende Überlegungen einbeziehen: ■ Braucht die Komponente einen Fenster-Handle?

554

Kapitel 11

Komponentenentwicklung

■ Soll die Komponente zur Laufzeit den Fokus erhalten? ■ Sollen andere Komponenten im Clientbereich der Komponente abgelegt werden? Ist keine der obigen Forderungen zu erfüllen, können Sie die Komponente von TGraphicControl ableiten. Andernfalls ist TWinControl oder einer der Nachfahren von TWinControl die richtige Wahl. HINWEIS: Komponenten, die von TGraphicControl abgeleitet werden, brauchen weniger

Systemressourcen, da keine Fenster-Handle verwaltet werden müssen. Als Beispiel wollen wir eine einfache Komponente realisieren, die in der Lage ist, Grafiken aus einer ImageList anzuzeigen. Zwei Eigenschaften bilden dabei die Schnittstelle: ■ ImageList ■ ImageIndex Erzeugen Sie also eine neue Komponente (z.B. ImageView), die von der Klasse TGraphicControl abgeleitet ist.

Komponenten-Interface Erweitern Sie die Klassendefinition wie folgt: type TImageView = class(TGraphicControl) private FImageList : TImageList; FImageIndex : Integer; procedure SetImageList(value: TImageList); function GetImageList:TImageList; procedure SetImageIndex(value: Integer); function GetImageIndex: Integer; protected procedure paint; override; procedure Notification(AComponent: TComponent; Operation: TOperation); override; public constructor Create(AOwner:Tcomponent); override; published property ImageList: TImageList read getImageList write setImageList; property ImageIndex: Integer read getImageIndex write setImageindex; end;

Neben einer privaten Variablen zum Speichern der Referenz auf das ImageList-Objekt (FImageList) benötigen wir noch einige Interface-Methoden (Get..., Set...). Wesentlichster Teil unserer Erweiterung ist das Überschreiben der Paint-Methode. Diese wird vom Parent der Komponente immer dann aufgerufen, wenn der Inhalt erneut dargestellt werden muss.

11.6 Die wichtigsten Komponententypen

555

Da die Eigenschaft ImageList an eine weitere Komponente gebunden ist, müssen wir auch die Notification-Methode erweitern.

Der Konstruktor Beim Initialisieren der Komponente sollten Sie eine Mindestgröße festlegen, da andernfalls nichts mehr zu sehen ist. constructor TImageView.Create(AOwner:Tcomponent); begin inherited Create(aOwner); Width := 30; Height := 30 end;

Die Paint-Methode Unsere Ausgabeprozedur ist die Paint-Methode. An dieser Stelle ist es besonders wichtig zu prüfen, ob überhaupt eine ImageList zugewiesen wurde. Nachfolgende Zugriffe auf dieses Objekt würden andernfalls zu Schutzverletzungen führen. procedure TImageView.paint; begin inherited Paint; if FImageList <> NIL then begin if Width <> FImageList.Width then Width := FImageList.Width; if Height <> FImageList.Height then Height := FImageList.Height; FImageList.Draw(Canvas,0,0,FImageIndex) end; if csDesigning in ComponentState then Canvas.DrawFocusRect(Bounds(0,0, Width, Height)) end;

Die eigentliche Darstellung des ImageList-Icons ist relativ simpel. Beachten Sie jedoch die Anweisungen im zweiten Teil der Paint-Methode. Hier wird mit der Methode DrawFocusRect ein FokusRahmen gezeichnet, wenn die Komponente in der Entwurfsumgebung angezeigt wird (ComponentState). Lassen Sie diese Anweisungen weg, ist die Komponente auch zur Entwurfszeit nicht auf dem Formular zu sehen.

Die Notification-Methode Auf das Löschen der ImageList reagieren wir mit: procedure TImageView.Notification(AComponent: TComponent; Operation: TOperation); begin inherited Notification(AComponent, Operation); if (Operation = opRemove) and (FImagelist <> nil) and (AComponent = ImageList) then begin ImageList := nil; ImageIndex :=0 end end;

556

Kapitel 11

Komponentenentwicklung

Interface-Implementierung Unsere Interface-Methoden haben neben der reinen Wertübergabe auch noch weitere Aufgaben: procedure TImageView.SetImageList(value: TImageList); begin FImageList := value; FImageIndex := 0; if FImageList <> nil then begin Width := FImageList.Width; Height := FImageList.Height; paint end end; function TImageView.GetImageList:TImageList; begin Result := FImageList end; procedure TImageView.SetImageIndex(value:Integer); begin if FImageList <> nil then if value > FImageList.Count-1 then value := FImageList.Count-1; FImageIndex := value; paint end; function TImageView.GetImageIndex:Integer; begin Result := FImageIndex end;

So wird neben der Skalierung auch gleich eine Fehlerprüfung (zu große Werte) integriert.

11.7 Test der Komponente Mit dem Test schlägt für unsere selbst gebastelte Komponente die Stunde der Wahrheit, und es beginnen auch die Probleme. Insbesondere der Test des Interface ist eine recht mühselige Aufgabe, muss doch die Komponente bzw. das zugehörige Package jedes Mal neu compiliert werden. Geht es lediglich um einen ersten Test, können Sie auch die Unit mit der Komponente in ein Projekt einbinden und die Komponente "zu Fuß" spezifizieren. uses digit;

// Unit einbinden

procedure TForm1.Button1Click(Sender: TObject); var digit1 : TDigit; // Objekt deklarieren begin digit1 := TDigit.Create(self); // Instanz der Komponente erzeugen

557

11.8 Packages

digit1.Parent := Form1; // Parent zuweisen digit1.Top := 10; digit1.Left := 20 end;

HINWEIS: Besonders wichtig ist in diesem Zusammenhang, dass Sie den Parent angeben.

Diese Testvariante ermöglicht Ihnen auch die Fehlersuche innerhalb der Komponente. Setzen Sie dazu einen Breakpoint in die betreffende Property-Prozedur oder Methode. Ist das Interface bereits getestet und sind lediglich einige Fehler innerhalb der KomponentenMethoden zu beseitigen, können Sie die Komponente zunächst wie gewohnt in das Projekt einbinden. Setzen Sie dann Breakpoints in der Komponenten-Unit und korrigieren Sie, falls nötig, den Quelltext (darf sich aber nicht auf das Interface auswirken!). Derartige Änderungen lassen natürlich den Objektinspektor unbeeindruckt, da das Package nicht aktualisiert wird.

11.8 Packages 11.8.1 Grundsätzliches Prinzipiell handelt es sich um eine Art DLL (Dynamic Link Library), in der Code aus einer oder mehreren Units zusammengefasst ist. Packages können im Gegensatz zu DLLs auch Variablen, Konstanten und Klassen "exportieren". Die Einbindung ist absolut simpel: Geben Sie in der UsesKlausel Ihres Programms eine Unit an, die sich in einem Package befindet, wird damit auch das Package in Ihre Anwendung eingebunden. Zwei Typen von Packages sollten Sie unterscheiden: ■ Entwurfszeit-Packages und ■ Laufzeit-Packages. Während Erstere unbedingt für die Einbindung von Komponenten benötigt werden (eine Komponente muss einem Package zugeordnet sein), sollen die Laufzeit-Packages für eine kleinere EXEDatei sorgen. Die folgende Tabelle zeigt eine teilweise Übersicht der bereits vorhandenen Laufzeit-Packages: Package

eingebundene Units ...

VCL70.BPL

Ax, Buttons, Classes, Clipbrd, Comctrls, Commctrl, Commdlg, Comobj, Comstrs, Consts, Controls, Ddeml, Dialogs, Dlgs, Dsgnintf, Dsgnwnds, Editintf, Exptintf, Extctrls, Extdlgs, Fileintf, Forms, Graphics, Grids, Imm, IniFiles, Isapi, Isapi2, Istreams, Libhelp, Libintf, Lzexpand, Mapi, Mask, Math, Menu, Messages, Mmsystem, Nsapi, Ole2I, Oleconst, Olectnrs, Olectrls, Oledlg, Penwin, Printers, Proxies, Registry, Regstr, Richedit, Shellapi, Shlobj, Stdctrls, Stdvcl, Sysutils, Tlhelp32, Toolintf, Toolwin, Typinfo, Vclcom, Virtintf, Windows, Wininet, Winsock, Winspool, Winsvc

558

Kapitel 11

Komponentenentwicklung

Package

eingebundene Units ...

VCLX70.BPL

Checklst, Colorgrd, Ddeman, Filectrl, Mplayer, Outline, Tabnotbk, Tabs

VCLDB70.BPL

Bde, Bdeconst, Bdeprov, Db, Dbcgrids, Dbclient, Dbcommon, Dbconsts, Dbctrls, Dbgrids, Dbinpreq, Dblogdlg, Dbpwdlg, Dbtables, Dsintf, Provider, SMintf

VCLDBX70.BPL

Dblookup, Report

DSS70.BPL

Mxarrays, Mxbutton, Mxcommon, Mxconsts, Mxdb, Mxdcube, Mxdssqry, Mxgraph, Mxgrid, Mxpivsrc, Mxqedcom, Mxqparse, Mxqryedt, Mxstore, Mxtables, Mxqvb

QRPT70.BPL

Qr2const, Qrabout, Qralias, Qrctrls, Qrdatasu, Qrexpbld, Qrextra, Qrprev, Qrprgres, Qrprntr, Qrqred32, Quickrpt

TEE70.BPL

Arrowcha, Bubblech, Chart, Ganttch, Series, Teeconst, Teefunci, Teengine, Teeprocs, Teeshape

TEEDB70.BPL

Dbchart, Qrtee

TEEUI70.BPL

Areaedit, Arrowedi, Axisincr, Axmaxmin, Baredit, Brushdlg, Bubbledi, Custedit, Dbeditch, Editchar, Flineedi, Ganttedi, Ieditcha, Pendlg, Pieedit, Shapeedi, Teeabout, Teegally, Teelisb, Teeprevi, Teexport

VCLSMP70.BPL

Sampreg, Smpconst

Im Grunde besteht jedes Package aus zwei Dateien: ■ *.DPK (der Quelltext des Package) ■ *.BPL (das eigentliche Package, das Ihrer Anwendung mitgegeben werden muss) In der DPK-Datei führen Sie lediglich auf, welche Units in die BPL eingebunden werden sollen und welche weiteren Packages für das neue Package benötigt werden. Besonders die letzte Aussage ist von nicht zu unterschätzender Bedeutung, darf doch eine Unit nur in einem von mehreren gleichzeitig genutzten Packages enthalten sein. BEISPIEL: Sie nutzen das Package VCL70.BPL und möchten zusätzlich ein Package MyPack.BPL erzeugen,

in dem unter anderem auch die Unit Windows gebraucht wird. Das Einbinden der Unit in das Package MyPack wird Ihnen der Compiler mit einer Fehlermeldung quittieren, da jede Unit nur einmal über ein Package eingebunden werden darf. In diesem Fall bleibt Ihnen nichts anderes übrig: Das Package VCL70.BPL muss als Voraussetzung (requires-Abschnitt) in das neue Package aufgenommen werden. BEISPIEL: Eine DPK-Datei im Quelltext package Package1; {$R *.res} {$ALIGN 8} {$ASSERTIONS ON} {$BOOLEVAL OFF} {$DEBUGINFO ON}

11.8 Packages

559

{$EXTENDEDSYNTAX ON} {$IMPORTEDDATA ON} {$IOCHECKS ON} ... {$SAFEDIVIDE OFF} {$STACKFRAMES OFF} {$TYPEDADDRESS OFF} {$VARSTRINGCHECKS ON} {$WRITEABLECONST OFF} {$MINENUMSIZE 1} {$IMAGEBASE $400000} {$IMPLICITBUILD OFF} requires rtl, vcl, dclusr, designide, vclactnband, vclx; contains NonVis in '..\..\..\..\Bücher\Delphi7\Grundlagen\BuchCD\Beispiel\Kap11\NonVis\NONVIS.PAS'; end.

11.8.2 Eigene Packages erzeugen Ein neues Package können Sie relativ einfach erzeugen. Öffnen Sie die Objektgalerie mit Datei| Neu|Weitere... und wählen Sie das "Package"-Icon. Delphi erleichtert Ihnen die Arbeit dahingehend, dass Sie einen eigenen Package-Editor nutzen können:

Wie Sie sehen, können Sie zum einen alle enthaltenen Units editieren, weiterhin lassen sich alle benötigten Packages einbinden. BEISPIEL: Grundaufbau einer DPK-Datei package testpack; requires vcl;

560

Kapitel 11

Komponentenentwicklung

contains Unit1; end.

Die eigentliche Einbindung des Package in Ihr Projekt erfolgt über Projekt|Optionen|Packages:

Und hier wird auch klar, warum eine Unit nur einmal verwendet werden darf: Wie soll der Compiler unterscheiden, um welche Daten es sich handelt, wenn die Unit XYZ zweimal eingebunden ist? Im unteren Teil der Dialogbox finden Sie auch die wichtigste Option. Die Rede ist von "Mit Laufzeit-Packages compilieren". Aktivieren Sie diese Option, ist Ihre EXE-Datei drastisch kleiner, aber Sie müssen bei der Weitergabe Ihrer Applikation alle verwendeten Packages mitgeben. Wie Sie Komponenten in Ihre Anwendung integrieren, zeigen Ihnen die folgenden Beispiele.

11.9 Lernbeispiele für Einsteiger 11.9.1 Neue Komponenten ableiten Das Prinzip der Komponentenentwicklung soll an einem simplen Beispiel demonstriert werden: Ein neuer Editierfeld-Typ TEditBlack und ein neuer Label-Typ TLabelBlack sind als "Nachkommen" von TEdit und TLabel zu kreieren und der Seite "Beispiele" der Komponentenpalette hinzu-

11.9 Lernbeispiele für Einsteiger

561

zufügen. Im Unterschied zu ihren "Vorfahren" haben TEditBlack und TLabelBlack aber standardmäßig weiße Schrift auf schwarzem Hintergrund1.

Vorbereitungen Neue Komponenten werden nicht, wie bisherige Anwendungen, visuell auf der Basis von Formularen entwickelt, sondern als reiner Quelltext, der in speziellen nutzerdefinierten Units verpackt ist. Eine solche Unit kann den Code für eine oder auch mehrere Komponenten enthalten. Aus diesem Grund brauchen wir für unser Demobeispiel auch keine Bedienoberfläche, auch die Projektdatei ist uninteressant. Wir müssen nur nach einer Möglichkeit suchen, unter Delphi eine neue Unit zu erstellen und diese dann abzuspeichern. Starten Sie also die Delphi-Entwicklungsumgebung wie gewohnt und wählen Sie dann den Menüpunkt Datei|Neu|Unit.

Quelltext Es hat sich ein Editierfenster mit dem extrem mageren Rahmencode einer "Allerwelts"-Unit geöffnet: unit Unit2; interface implementation end.

Unsere erste Aufgabe sollte es sein, unserer neuen Unit einen aussagekräftigeren Namen zu verpassen und anschließend die uses-Klausel durch eine Auflistung von Units zu ergänzen: unit UnitSchwarz; // schwarze Editier- und Label-Komponenten, W.D. interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls;

Woher weiß man denn nun, welche Units überhaupt benötigt werden? Grübeln Sie jetzt bitte nicht darüber nach, entweder man weiß es, oder es hilft einem der "Komponenten-Experte" auf die Sprünge (siehe am Schluss). Nun kommen die entscheidenden Typdeklarationen: type TEditBlack = class(TEdit) public constructor create(aOwner: TComponent); override; end;

TEditBlack wurde als Unterklasse von TEdit abgeleitet. Das Überschreiben der geerbten CreateMethode ist notwendig, da wir ja einige Standardeigenschaften verändern wollen2. 1

2

Der praktische Nutzen solcher "neuer" Komponenten ist natürlich fragwürdig, da man den gleichen Effekt auch durch Setzen von Eigenschaften der bereits vorhandenen Komponenten erreichen kann. Aber hier geht es lediglich um die Demonstration des Prinzips. Initialisierungen der Eigenschaften erfolgen grundsätzlich im Konstruktor (sowohl zur Entwurfs- als auch zur Laufzeit!).

562

Kapitel 11

Komponentenentwicklung

Analog gehen wir bei der Deklaration von TLabelBlack zu Werke: TLabelBlack = class(TLabel) public constructor create(aOwner: TComponent); override; end;

Keinesfalls fehlen darf die (parameterlose) Register-Prozedur, die für das Registrieren der neuen Komponenten in der Delphi-IDE verantwortlich zeichnet: procedure Register;

HINWEIS: Beachten Sie die Groß-/Kleinschreibung von Register, denn register kann zu einem

Compilierfehler führen! Nun zu den Implementierungen1: implementation constructor TEditBlack.Create; begin inherited Create(aOwner); Color := clBlack; Font.Color := clWhite end; constructor TLabelBlack.Create; begin inherited Create(aOwner); Color := clBlack; Font.Color := clWhite end;

Wie allgemein üblich, wurde der (ererbte) Konstruktor für die Objektreferenz in Verbindung mit dem Schlüsselwort inherited aufgerufen, um zunächst alle Felder des Vorfahren zu initialisieren. Erst danach werden die zu modifizierenden Felder des Nachkommen initialisiert. Im Folgenden sorgt die Anweisung RegisterComponents dafür, dass beide Neulinge später auf der Seite "Beispiele" der Komponentenpalette ihren Platz finden: procedure Register; // Groß-/Kleinschreibung beachten!!! begin RegisterComponents('Beispiele', [TEditBlack, TLabelBlack]) end;

Speichern Sie nun die Unit unter dem Namen UniBlack.pas in einem extra Verzeichnis ab (Menüpunkt Datei|Speichern bzw. Strg+S).

1

Aus Gründen der Einfachheit wurde bei den Prozedurköpfen von der verkürzten Schreibweise Gebrauch gemacht (Parameterliste weggelassen).

11.9 Lernbeispiele für Einsteiger

563

Bitmaps Unsere beiden Neuen, TEditBlack und TLabelBlack, sehnen sich nach einem standesgemäßen Outfit, in dem sie sich auf der Komponentenpalette ohne Minderwertigkeitskomplexe präsentieren können und das sie von ihren Vorfahren TEdit und TLabel unterscheidet. Wenn Sie hier aus Bequemlichkeitsgründen untätig bleiben, behalten die Neulinge die von ihren Vorfahren vererbten Buttons. Da man aber diese Paletten-Bitmaps nur in der Entwicklungsumgebung benötigt, wäre es Verschwendung, sie zusammen mit UniBlack.pas zu compilieren. Stattdessen verpacken wir die Bitmaps in eine Ressourcendatei, die die Extension *.DCR ("Dynamic Component Resource") trägt. Zum Erstellen einer solchen Ressourcendatei eignet sich der zu Delphi mitgelieferte Bildeditor, den Sie über das Tools-Menü erreichen. Wählen Sie dort Datei|Neu|Komponenten-Ressourcendatei und dort über das Kontextmenü der rechten Maustaste "Bitmap". Folgende Konventionen sind zu beachten: ■ Die Paletten-Bitmap muss den gleichen Namen wie die Komponenten-Unit tragen, in unserem Fall also UniBlack.DCR. ■ Die Paletten-Bitmap muss sich im gleichen Verzeichnis wie die Unit befinden. ■ Den einzelnen Bitmaps innerhalb der Palette muss der gleiche Name zugewiesen werden, wie ihn die entsprechende Komponente trägt, in unserem Fall also TEditBlack und TLabelBlack.

Installieren Klicken Sie nun den Menüpunkt Komponente|Komponente installieren... ■ Name der Unit Wählen Sie über die "Durchsuchen"-Schaltfläche die UniBlack.pas. ■ Name des PackageWie in der folgenden Abbildung gezeigt, sollten Sie bereits ein extra Package NeueBspl.dpk für Ihre Komponentenexperimente angelegt haben. Falls nicht, so wählen Sie die Seite "In neues Package".

564

Kapitel 11

Komponentenentwicklung

Klicken Sie OK und holen Sie tief Luft. Für einen Moment hören Sie die Festplatte bedrohlich rasseln und werden (hoffentlich) mit nachfolgender Meldung belohnt:

Schauen Sie nun auf der "Beispiele"-Seite der Komponentenpalette nach und lassen Sie sich überraschen! Wie Sie der Abbildung entnehmen, haben sich die Autoren keine allzu große Mühe mit dem Bildeditor gemacht, denn das Gelbe vom Ei ist das Outfit der beiden neu hinzugekommenen Icons nicht gerade, lediglich der schwarze Rahmen unterscheidet sie von ihren Vorfahren:

Test Der Rest ist normaler Entwickler-Alltag. Sie starten ein neues Projekt und können die neu hinzugekommenen "schwarzen Schafe" so wie jede andere Komponente verwenden:

Im Objektinspektor sehen Sie die geänderten Komponentennamen und auch die modifizierten Standard-Eigenschaften Color und Font.Color: HINWEIS: Falls Sie das Beispiel erstmalig von der Buch-CD laden, erhalten Sie zunächst eine

Fehlermeldung "Klasse TLabelBlack nicht gefunden!". Ignorieren Sie den Fehler und installieren Sie die Komponente wie oben beschrieben.

Der Komponenten-Experte Sie hoffen, dass er Ihnen einiges an Arbeit abnehmen kann? Lassen Sie sich überraschen! Das Tool lässt sich auf zweierlei Weise starten:

11.9 Lernbeispiele für Einsteiger

565

■ Datei|Neu|Weitere...Suchen Sie dann in der Objektgalerie das Icon "Komponente". ■ Komponente|Neue Komponente... In beiden Fällen erscheint eine Dialogbox, die Sie zu einer Handeingabe (Klassenname) und zur Auswahl des Vorfahren und der Palettenseite auffordert:

Nach dem Klick auf "Unit erstellen" hat der Experte in Windeseile ein Unit-Gerüst erstellt, in Abhängigkeit vom Typ des Vorfahren die uses-Klausel komplettiert, die Typdeklaration vorgenommen und schließlich auch die Registrierung besorgt: unit Edit1; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type TEditBlack = class(TEdit) private protected public published end; procedure Register; implementation procedure Register; begin RegisterComponents('Beispiele', [TEditBlack]); end; end.

566

Kapitel 11

Komponentenentwicklung

Sie erkennen schon jetzt die Schwachstelle des "Experten": Nur eine einzige Komponente pro Unit ist jeweils möglich, auch um das Überschreiben der ererbten Create-Methode müssen Sie sich selbst kümmern. Wenn Sie, wie in unserem Beispiel, mehrere Komponenten in eine Unit packen und auch noch neue Standardeigenschaften setzen wollen, ist noch ein gerüttelt Maß an Handarbeit fällig. Benutzen Sie also den Experten nur für die erste Komponente und ergänzen Sie dann den Code für eventuelle weitere Komponenten per Hand.

11.10 Praxisbeispiele für Fortgeschrittene 11.10.1 Komponente für Digitalanzeige In einigen Programmen wünscht man sich für die Ausgabe numerischer Werten eine Anzeige, die einen "technischen" Eindruck macht. Das soll in unserem Fall heißen, dass statt eines Labels eine 7-Segment-Anzeige erscheint. Das vorliegende Beispiel ermöglicht die Anzeige eines bis zu zehnstelligen Integer-Wertes. Die Anzahl der Segmente können Sie frei festlegen, eine Größenänderung der Komponente ist allerdings nicht möglich, da die Abmessungen aus der Anzahl der Segmente bestimmt werden. Für die Realisierung bieten sich zwei prinzipielle Varianten an: ■ Einblenden von verschiedenen Bitmaps (Ziffern 0 ... 9) ■ Zeichnen der Grafik über Line- oder Polyline-Befehle Während die erste Variante vom Aufwand her wesentlich einfacher ist, bietet Variante 2 den Vorteil, auch eine Skalierung der Komponente zuzulassen. Wir haben uns aus notorischer Faulheit für Variante 1 entschieden, wer aber an der Realisierung der zweiten Variante interessiert ist, dürfte mit dem vorliegenden Komponentengerüst relativ schnell zum Ziel kommen. Folgende Eigenschaften sollen implementiert werden:

Eigenschaften Eigenschaft Beschreibung /Beispiel

Digits

... die Anzahl der Stellen (1 ... 10).

DisplayOn

... (True/False) entscheidet darüber, ob lediglich ein schwarzer Hintergrund angezeigt wird oder der aktuelle Wert.

Value

... der darzustellende Wert (Integer).

Methoden und Ereignisse werden wir bei dieser Komponente nicht benötigen.

11.10 Praxisbeispiele für Fortgeschrittene

567

Oberfläche Eigentlich ist die Bezeichnung "Oberfläche" nicht ganz zutreffend, es geht lediglich darum, ein Ressourcen-File mit den benötigten Bitmaps zu erstellen. Zusätzlich könnten Sie auch ein neues Icon für die Werkzeugleiste entwerfen. Speichern Sie die Bitmaps für die einzelnen Segmentzustände in den Dateien 0.bmp ... 9.bmp sowie in der Datei leer.bmp. Mit der letzten Bitmap wird die Anzeige initialisiert bzw. gelöscht.

Nächster Schritt ist ein Ressouren-File (digit.rc), das in die Komponente eingebunden wird: 100 101 102 103 104 105 106 107 108 109 110

BITMAP BITMAP BITMAP BITMAP BITMAP BITMAP BITMAP BITMAP BITMAP BITMAP BITMAP

0.bmp 1.bmp 2.bmp 3.bmp 4.bmp 5.bmp 6.bmp 7.bmp 8.bmp 9.bmp leer.bmp

Quelltext Obwohl es sich um eine relativ triviale Komponente handelt, ist der Quelltext doch recht umfangreich. Die Komponente leiten wir von TGraphicControl ab, eine Klasse, die alle für uns wesentlichen Eigenschaften zur Verfügung stellt. Vorher binden wir jedoch noch die Ressourcen (Bitmaps) ein: unit digit; {$R digit.res} uses SysUtils, Classes, Graphics, Controls; type TDigit = class(TGraphicControl) private { Private-Deklarationen }

In folgendem Array werden die Bitmaps zwischengespeichert: FBmp: array[0..10]of TBitmap;

568

Kapitel 11

Komponentenentwicklung

Interne Statusvariablen: FValue: Integer; FDigits: Integer; FOn: Boolean; FOldDisplay: String[10];

Interface-Methoden für Properties: procedure SetValue(Value: Integer); procedure SetDigits(Value: Integer); procedure SetOn(Value: Boolean); protected

Die Anzeige-Prozedur: procedure Paint; override; public { Public-Deklarationen } constructor Create(AOwner: TComponent); override; destructor Destroy; override; published { Published-Deklarationen }

Die Eigenschaften: property Value: Integer read FValue write SetValue; property Digits: Integer read FDigits write SetDigits; property DisplayOn: Boolean read FOn write SetOn; end; procedure Register; implementation

Registrieren der Komponente: procedure Register; begin RegisterComponents('Beispiele', [TDigit]) end;

Im Konstruktor wird neben diversen Statusvariablen auch die Default-Größe festgelegt. Weiterhin laden wir die Bitmaps aus der Ressource, auf diese Weise vermeiden wir Verzögerungen bei der späteren Anzeige: constructor TDigit.Create(AOwner: TComponent); var i: Integer; begin inherited Create(AOwner); FDigits:= 10; FOn:= True; FValue:= 0; Height:= 28;

11.10 Praxisbeispiele für Fortgeschrittene

569

Width:= FDigits * 14; for i:= 0 to 10 do begin FBmp[i]:= TBitmap.Create; FBmp[i].LoadFromResourceID(HInstance, i + 100) end; FOldDisplay := ' ' end;

Im Destruktor sollten reservierte Speicherbereiche wieder freigegeben werden: destructor TDigit.Destroy; var i: Integer; begin for i:= 0 to 10 do FBmp[i].Free; inherited Destroy end;

Die Interface-Methode für die Eigenschaft Value: procedure TDigit.SetValue(Value: Integer); var Display: String[10]; i : Integer; begin FValue:= Value; if not(FOn) then exit; Display:= Format('%10d', [abs(FValue)]); for i:= 11-fDigits to 10 do if Display[i] <> FOldDisplay[i] then if Display[i] = ' ' then Canvas.Draw(14*(i-(11-FDigits)), 0, FBmp[10]) else Canvas.Draw(14*(i-(11-FDigits)), 0, FBmp[ord(Display[i])-48]); FOldDisplay:= Display end;

Je nach Ziffer wird die entsprechende Bitmap eingeblendet. Dabei ist uns das Bitmap-Array recht hilfreich, über den Index kann gleich die richtige Bitmap ausgewählt werden. Festlegen der Anzeigestellen: procedure TDigit.SetDigits(Value: Integer); begin if not (Value in [1..10]) then exit; if Value = FDigits then exit; FDigits:= Value; Width:= FDigits * 14; Height:= 28; paint end;

570

Kapitel 11

Komponentenentwicklung

Ein-/Ausschalten: procedure TDigit.SetOn(Value: Boolean); begin if Value = FOn then Exit; FOn:= Value; if FOn then FOldDisplay:= Format('%10d', [abs(FValue)]) else FOldDisplay:= ' paint end;

';

Für den Refresh nach dem Verdecken oder zur erstmaligen Anzeige wird die Methode Paint benötigt und deshalb überschrieben: procedure TDigit.Paint; var i: Integer; begin if Height <> 28 then Height:= 28; if Width <> FDigits * 14 then Width:= FDigits * 14; for i:= 11-fDigits to 10 do if FOldDisplay[i] = ' ' then Canvas.Draw(14*(i-(11-fDigits)), 0, FBmp[10]) else Canvas.Draw(14*(i-(11-FDigits)), 0, FBmp[ord(FOldDisplay[i])-48]) end;

Demoprogramm Unser Demoprogramm fällt diesmal etwas dürftig aus, wird allerdings völlig ausreichen, um die Funktionsweise der Komponente zu demonstrieren. Der Einfachheit halber erstellen wir die Komponente erst zur Laufzeit, so gewinnen wir schnell einen Eindruck, ohne erst die Library neu compilieren zu müssen. Allerdings werden wir die Komponente dann nicht auf der Palette finden. var Digit1, Digit2: TDigit; ... procedure TForm1.FormCreate(Sender: TObject); begin Digit1:= TDigit.Create(Self); with Digit1 do begin Parent:= Self; DisplayOn:= True; Left:=100; Top:= 50 end; Digit2:= TDigit.Create(Self); with Digit2 do begin Parent:= Self; DisplayOn:= True; digits := 5; Left:=300; Top:= 50 end;

571

11.10 Praxisbeispiele für Fortgeschrittene

Um etwas Bewegung in die Anzeige zu bringen, verwenden wir zwei Timer, die zyklisch den Wert der Value-Eigenschaft von Digit1 und Digit2 inkrementieren. Die Abbildung zeigt das Ergebnis zur Laufzeit:

Bemerkung Wenn Sie die Komponente nicht erst zur Laufzeit erstellen, sondern ihr einen Platz auf der Komponentenpalette verschaffen wollen, so müssten Sie dies über das Menü Komponente|Komponente installieren... erledigen (siehe Vorgängerbeispiel). Sie würden die Komponente dann auf der Seite "Beispiele" entdecken. Die Eigenschaften können Sie dann bereits zur Entwurfszeit mittels Objektinspektor einstellen.

11.10.2 Multimedia-Timer-Komponente Die im Folgenden vorgestellte Komponente ist ein Beispiel dafür, wie Sie auch bei nicht sichtbaren Komponenten mit Windows-Botschaften arbeiten können. Doch zunächst stellen wir Ihnen den technischen Hintergrund der Komponente vor. Wem die Delphi Timer-Komponente zu ungenau ist, der findet hier hochgenauen Ersatz. Zwei Varianten bieten sich an: ■ Direkte API-Programmierung (für alle, die ein Maximum an Genauigkeit und ein Minimum an Rechenzeit anstreben) ■ Eine Komponente, die alle API-Funktionen kapselt (etwas langsamer, da interne Botschaftsbehandlung erforderlich)

API-Programmierung Der Zugriff auf den Multimedia-Timer des Systems ist relativ trivial, alles, was Sie dazu benötigen, findet sich in der Unit mmsystem. uses mmSystem; var FID: Integer;

// ID des MMTimers

572

Kapitel 11

Komponentenentwicklung

Die Deklaration einer Callback-Prozedur (hier platzieren Sie den Code, der bei jedem Timer-Intervall ausgeführt werden soll): procedure TimeCallback(TimerID, //ID von timeSetEvent Msg: UINT; //reserviert dwUser, //UserDaten aus timeSetEvent dw1, //reserviert dw2: DWord); //reserviert pascal; begin Form1.Label1.Caption := Form1.Label1.Caption + '#'; end;

Die Initialisierung des Timers: procedure TForm1.Button1Click(Sender: TObject); begin FID:= timeSetEvent(100, 0, @TimeCallback,0,TIME_PERIODIC) end;

Übergabewerte sind das Intervall in Millisekunden, die Präzision bzw. Auflösung (0 = Maximum), die Adresse der Callback-Prozedur, ein optionaler Wert, um Parameter an die Callback-Prozedur zu übergeben, sowie eine Konstante, die darüber entscheidet, in welchem Modus der Timer läuft: TIME_ONESHOT TIME_PERIODIC

Ereignis wird einmal nach Ablauf der Wartezeit ausgelöst. Ereignis wird im Intervall ausgeführt.

Zum Schluss sollten Sie nicht vergessen, das Timer-Ereignis auch wieder zu beenden: procedure TForm1.Button2Click(Sender: TObject); begin if FID <> 0 then timeKillEvent(FID) end;

Die Komponente MM_Timer Wer es lieber etwas einfacher hätte, der bevorzugt sicher die Variante mit der Komponente. Hier genügen das Setzen einiger Eigenschaften und die Programmierung der Ereignisprozedur. Zum internen Ablauf nur so viel: Prinzipiell werden die gleichen Funktionen wie im vorhergehenden Rezept angesprochen. Allerdings müssen wir einen kleinen Umweg bei der Realisierung der Ereignisprozedur gehen, da eine Methode nicht als Callback-Prozedur übergeben werden kann. Wir werden also ein unsichtbares Fenster erstellen, an das aus der Callback-Prozedur eine Botschaft gesendet wird. Die Fensterprozedur löst wiederum die Ereignis-Methode aus (hört sich komplizierter an, als es ist). unit MM_Timer; interface

573

11.10 Praxisbeispiele für Fortgeschrittene

Uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, MMSystem; const WM_MMTimer = WM_USER + $1000; // die bewusste Message

Ein neuer Ereignistyp: type TFNTimeCallBack = procedure(uTimerID, uMessage: UINT; dwUser, dw1, dw2: DWORD); pascal; //Pascal notwendig!!! (Falsch dekl. in MMSystem); type TMMTimerEvent = procedure(Sender: TObject; Time: Cardinal)of object; TMMTimer = class(TComponent) private { Private-Deklarationen } FWnd: hWnd; //FensterHandle FTimeCaps: TTimeCaps; //Dev-Caps MMTimer FEnabled: Boolean; FInterval: Cardinal; FResolution: Cardinal; FPeriodic: Boolean; FID: Integer; // ID des MMTimers FOnTimer: TMMTimerEvent; FResult: Integer; protected { Protected-Deklarationen } procedure UpdateTimer; procedure SetEnabled(Value: Boolean); procedure SetInterval(Value: Cardinal); procedure SetResolution(Value: Cardinal); procedure SetPeriodic(Value: Boolean); procedure WndProc(var Msg: TMessage); procedure DoOnTimer(Time: Cardinal); dynamic; public { Public-Deklarationen } constructor Create(AOwner: TComponent); override; destructor Destroy; override; property Result: Integer read FResult; published property Interval: Cardinal read FInterval write SetInterval; property Resolution: Cardinal read FResolution write SetResolution; property Periodic: Boolean read FPeriodic write SetPeriodic; property Enabled: Boolean read FEnabled write SetEnabled; property OnTimer: TMMTimerEvent read FOnTimer write FOnTimer; end; procedure Register; implementation procedure TimeCallback(TimerID, Msg: UINT; dwUser,

//ID von timeSetEvent //reserviert //UserDaten aus timeSetEvent

574

Kapitel 11

dw1, dw2: DWord); pascal;

//reserviert //reserviert

begin PostMessage(dwUser, WM_MMTimer, TimeGetTime, 0) end;

Unsichtbares Fenster erstellen, Timer-Parameter ermitteln: constructor TMMTimer.Create(AOwner: TComponent); begin inherited Create(AOwner); FWnd:= AllocateHWnd(WndProc); FResult:= timeGetDevCaps(@FTimeCaps, SizeOf(FTimeCaps)); FResolution:= FTimeCaps.wPeriodMin; FInterval:= FTimeCaps.wPeriodMax; FResult:= timeBeginPeriod(FResolution); FPeriodic:= True; FEnabled:= True; FID:= 0 end;

Fenster und Komponente zerstören: destructor TMMTimer.Destroy; begin if FID <> 0 then FResult:= timeKillEvent(FID); FResult:= timeEndPeriod(FResolution); DeallocateHWnd(FWnd); inherited Destroy end;

Fensterprozedur zur Message-Behandlung: procedure TMMTimer.WndProc(var Msg: TMessage); begin with Msg do begin if Msg = WM_MMTimer then DoOnTimer(wParam) else DefWindowProc(FWnd, Msg, wParam, lParam) end end;

Event auslösen: procedure TMMTimer.DoOnTimer(Time: Cardinal); begin if Assigned(FOnTimer) then FOnTimer(Self, Time); end;

Komponentenentwicklung

11.10 Praxisbeispiele für Fortgeschrittene

Timer starten (gegebenenfalls zurücksetzen): procedure TMMTimer.UpdateTimer; var Mode: UINT; begin if not (csDesigning in ComponentState) then begin if FID <> 0 then timeKillEvent(FID); if FPeriodic then Mode:= TIME_PERIODIC else Mode:= TIME_ONESHOT; FID:= timeSetEvent(FInterval, FResolution, @TimeCallback, //Proc-Adr. FWnd, //User-Daten Mode); end end;

Zugriffsmethoden der Eigenschaften: procedure TMMTimer.SetEnabled(Value: Boolean); begin if Value <> FEnabled then begin FEnabled:= Value; UpdateTimer end end; procedure TMMTimer.SetInterval(Value: Cardinal); begin if (Value <> FInterval) and (Value >= FTimeCaps.wPeriodMin) and (Value <= FTimeCaps.wPeriodMax)then begin FInterval:= Value; UpdateTimer end end; procedure TMMTimer.SetResolution(Value: Cardinal); begin if (Value <> FResolution) and (Value <= FInterval) then begin FResolution:= Value; UpdateTimer end end; procedure TMMTimer.SetPeriodic(Value: Boolean); begin if Value <> FPeriodic then begin FPeriodic:= Value; UpdateTimer end end;

575

576

Kapitel 11

Komponentenentwicklung

procedure Register; begin RegisterComponents('Beispiele', [TMMTimer]); end;

Test Über das Menü Komponente|Komponente installieren... bringen Sie die Komponente wie gewohnt auf die Komponentenpalette (Seite "Beispiele"). Öffnen Sie dann ein neues Projekt (Anwendung) und platzieren Sie die Komponente auf das Startformular. Legen Sie die Interval-Eigenschaft z.B. auf 1000 ms fest. Um die prinzipielle Funktionsfähigkeit zu testen, genügt ein "Sekundenticker": procedure TForm1.MMTimer1Timer(Sender: TObject; Time: Cardinal); begin Beep end;

Bemerkung Legen Sie einen zu kleinen Wert für das Intervall fest und dauert die Abarbeitung innerhalb der Timer-Prozedur zu lange, gibt es Ärger. Selbst das sonst recht robuste Windows 2000/XP kommt ins Wanken, da die gesamte Rechenzeit für den Aufruf der Callback-Prozedur verbraucht wird.

12

OLE-Automation/ActiveX

Kapitel

12

OLE-Automation/ActiveX In diesem Kapitel geht es um mehr als nur um die Interaktion zwischen verschiedenen WindowsProgrammen auf Basis des altbekannten OLE (heute allgemein als Automation bezeichnet), sondern allgemein um die wichtigsten Möglichkeiten, die Delphi 7 für die plattformübergreifende komponentenbasierte Entwicklung bietet. HINWEIS: Verwechseln Sie die ActiveX- und .NET-Komponenten nicht mit den nativen

Delphi-Komponenten, wie sie unmittelbarer Bestandteil der VCL (Visual Component Library) sind (siehe Kapitel 11)! Da der nachfolgende Stoff leider doch ziemlich trocken ist, werden dem Ungeduldigen diesmal besonders die Praxisbeispiele am Ende des Kapitels nahe gelegt!

12.1 Begriffe Jeder Windows-Programmierer, der an umfangreicheren Anwendungsentwicklungen beteiligt ist, muss dafür unterschiedliche Komponenten (die auch eigenständige Programme sein können!) einsetzen. Einige dieser Komponenten/Programme werden direkt von Microsoft angeboten, andere können von Drittanbietern bezogen werden. Schließlich müssen auch eigene Komponenten entwickelt werden. OLE bzw. ActiveX sind der "Klebstoff", der diese Komponenten verbindet. ActiveX ist ein Teil des Microsoft Component Object Model (COM), das eine Zusammenarbeit von verschiedenartigen Anwendungen bzw. Komponenten auf Basis eines einheitlichen Interfaces ermöglicht. Einige Features von ActiveX wurden bisher unter dem Begriff OLE (Object Linking and Embedding) zusammengefasst, neuerdings spricht man nur noch von Automation. In diesem Kapitel werden diese Begriffe mit annähernd gleicher Bedeutung verwendet, lassen Sie sich also nicht verwirren, wenn Sie z.B. mit den Bezeichnungen COM-Server, Automations-Server, OLEServer oder ActiveX-Server konfrontiert werden – es ist meist ein und dasselbe gemeint!

ActiveX-Komponenten Bei ActiveX-Komponenten ist zwischen verschiedenen Typen zu unterscheiden:

578

Kapitel 12

OLE-Automation/ActiveX

■ ActiveX-Controls (früher als OCXe bezeichnet)sind Steuerelemente, die Sie zum Beispiel beim Formularentwurf verwenden können. ActiveX-Controls werden in Dateien vom Typ .OCX gespeichert. In Delphi finden Sie sie vor allem auf der "ActiveX"-Seite der Komponentenpalette. ■ ActiveX-Code-Komponenten (früher als OLE-Server bezeichnet) existieren in zweierlei Gestalt: - ActiveX-DLL (In-Process-Server) - ActiveX-EXE (Out-of-Process-Server) Fügen Sie einer normalen EXE-Datei Automatisierungsobjekte hinzu, erzeugen Sie einen Outof-Process-Server. Erstellen Sie eine "ActiveX-Bibliothek" und fügen Automatisierungsobjekte hinzu, handelt es sich um einen In-Process-Server. ■ ActiveX-Documents sind Formulare, die im Internet-Browser angezeigt werden können. ActiveX-Documents können wiederum weitere ActiveX-Controls enthalten. Diese Formulare bieten sich insbesondere in Intranet-Anwendungen an, können doch auf diese Weise Informationen (HTML-Text) und User-Interaktion (Eingaben) sinnvoll kombiniert werden.

In-Process- und Out-of-Process-Server Im Zusammenhang mit ActiveX-Code-Komponenten wird zwischen "in-Process" (DLL) und "outof-Process" (EXE) unterschieden. Während die DLLs immer im Adressraum der aufrufenden Anwendung laufen (z.B. ADO), handelt es sich bei "out-of-Process"-Komponenten um selbstständige Anwendungen mit eigenem Adressraum (z.B. Access oder Word). ActiveX-DLLs bieten den Vorteil eines schnellen Zugriffs, da nicht über Prozessgrenzen hinweg Daten ausgetauscht werden müssen, es wird jedoch der Thread der aufrufenden Anwendung genutzt. Demgegenüber läuft eine ActiveX-EXE-Komponente in einem unabhängigen Thread, die Ausführung ist quasi parallel. Die Entscheidung, welchen Typ von ActiveX-Server Sie entwickeln, hängt im Wesentlichen vom endgültigen Einsatz ab. Für Anwendungen, die prinzipiell über eine eigene Oberfläche verfügen, aber anderen Programmen Automations-Objekte bereitstellen sollen, bleibt nur die ActiveX-EXE. Möchten Sie lediglich ActiveX-Objekte exportieren (die natürlich auch Formulare enthalten können), sollten Sie eine ActiveX-DLL einsetzen. HINWEIS: Versuchen Sie, wo immer es geht, ActiveX-EXE durch ActiveX-DLLs zu ersetzen,

da diese wesentlich schneller sind.

.NET-Komponenten Borland Delphi 7 bietet erstmals die Möglichkeit zum Importieren von Komponenten, die auf Basis der modernen Microsoft .NET-Technologie entwickelt wurden. Voraussetzung ist allerdings die Installation des .NET-Frameworks auf dem Anwendungsrechner, was bei den Betriebssystemen der nächsten Generation ohnehin der Fall sein wird. Im Abschnitt 12.8 dieses Kapitels sowie in den

12.2 Automatisierung

579

Praxisbeispielen 12.10.3 und 12.10.4 haben Sie Gelegenheit, sich in diese Problematik einzuarbeiten.

TypeLibraries (Typbibliotheken) Geht es um den Import oder Export von ActiveX-Objekten (oder auch um den Import von .NETKomponenten), so spielen die TypeLibraries eine wichtige Rolle. Dabei handelt es sich um binäre Symboldateien, die entweder als Ressource oder als eigenständige Datei mit der Namenserweiterung TLB gespeichert werden. Delphi verfügt über einen recht komfortablen Typbibliothekseditor (Menü Ansicht|Typbibliothek). Mit Hilfe von Typenbibliotheken können Sie oder der Anwender Ihrer ActiveX-Komponenten feststellen, welche Typen von Objekten und Schnittstellen in einem ActiveX-Server verfügbar sind. Dazu gehört auch ein eindeutiger Bezeichner für den Server (die so genannten CLSIDs). Nicht zuletzt sind auch Aufzählungsdatentypen enthalten.

12.2 Automatisierung Mit der (OLE-)Automatisierung steht dem Programmierer eine mächtige Schnittstelle zum Datenaustausch zwischen gänzlich verschiedenen Applikationen zur Verfügung. Delphi kann auf diese Weise z.B. Daten mit MS Excel oder MS Word austauschen oder sogar andere Anwendungen "fernsteuern". Wichtig scheint in diesem Zusammenhang die Unterscheidung der beiden folgenden Begriffe: ■ Automatisierungs-ClientAnwendung, die das Erstellen von Verbunddokumenten erlaubt. Dazu werden so genannte Container verwendet, die das Darstellen und Speichern der Daten übernehmen. ■ Automatisierungs-ServerAnwendung, die eigene Daten und Objekte anderen Programmen (Clients) zum Einbetten oder zum Verknüpfen bereitstellt. ActiveX-Komponenten können sowohl OLE-Client als auch OLE-Server sein, selbst das Programm Word kann als ActiveX-Komponente betrachtet werden. Als Client, wenn Sie z.B. eine Excel-Tabelle in ein Dokument einfügen, als Server, wenn Sie z.B. aus Delphi die OLE-Automationsobjekte (Code-Klassen) von Word nutzen wollen.

Einfügen oder Einbetten? Einfügen (Linking) bzw. Einbetten (Embedding) bezeichnet den Vorgang, bei dem eine Verbindung zwischen OLE-Server und OLE-Client hergestellt wird. ■ Verknüpfen (Linking)Der Client speichert lediglich einen Verweis auf den Ursprung der OLE-Daten, um das Speichern der eigentlichen Daten kümmert sich der Server. Der Vorteil für den Client besteht im geringen Platzbedarf in der Client-Anwendung. ■ Einbetten (Embedding)Eingebettete Objekte lassen sich relativ einfach verwalten, werden doch alle Informationen im Client abgespeichert.

580

Kapitel 12

OLE-Automation/ActiveX

Eine allgemein gültige Empfehlung, ob ein Objekt eingebettet oder verknüpft werden soll, kann nicht gegeben werden, das hängt vom konkreten Einsatzfall ab. Daten, mit denen mehrere Applikationen arbeiten, werden Sie sicherlich verknüpfen, da sich auf diese Weise die Aktualisierungen auf alle Clients auswirken. Etwas anders sieht es aus, wenn Sie das Programm weitergeben wollen. In diesem Fall ist es günstiger, wenn Sie die Daten direkt in den Client einbetten.

Drag & Drop von Objekten Wenn sowohl OLE-Server als auch OLE-Container (Rahmenanwendung) den OLE2-Standard komplett unterstützen, so kann (gewissermaßen als Alternative zur Zwischenablage) ein Objekt aus einer Anwendung in die andere gezogen und dort abgelegt werden. In Abhängigkeit von der Taste, die Sie beim Ziehen des Objekts gedrückt halten, wird entweder kopiert oder verschoben. Erkennbar ist die Art der Verknüpfung am Mauszeiger: Cursor

Bemerkung

... Ablegen nicht erlaubt, z.B. ist OLEDropAllowed = False. ... Verschieben (Move), z.B. markieren Sie einen Text in Word und kopieren diesen in einen OLEContainer. ... Kopieren (Copy), z.B. markieren Sie einen Text in Word und kopieren diesen in einen OLEContainer. Gleichzeitig halten Sie die STRG-Taste gedrückt.

12.2.1 Die OLEContainer-Komponente Sie finden den OLEContainer auf der "System"-Seite der Komponentenpalette. Damit ist es möglich, OLE-Objekte innerhalb eines Delphi-Programms darzustellen. Die Komponente verfügt über eine ganze Reihe von Eigenschaften, von denen allerdings die wenigsten von Ihnen geändert werden müssen. Die wichtigsten Properties können Sie der folgenden Übersicht entnehmen: Eigenschaft Beschreibung

AllowInPlace ... ermöglicht die Vor-Ort-Aktivierung eines OLE-Objektes, d.h., die Bearbeitung im Delphi-Fenster. Dazu können sowohl Menüleiste als auch Statusleiste und Toolbar vom OLE-Server überblendet werden. AutoActivate

... entscheidet darüber, wie das OLE-Objekt aktiviert wird (Doppelklick, Fokus, manuell mit DoVerb(ovShow)).

CanPaste

... abfragen, ob sich in der Zwischenablage ein Objekt befindet, das in die Komponente eingefügt werden kann.

Iconic

... entscheidet darüber, wie die OLE-Daten angezeigt werden (Icon oder normal).

Modified

... True, wenn das OLE-Objekt geändert, gelöscht oder ersetzt wurde.

OleObject

... gibt ein OLE-Automatisierungsobjekt für das OLE-Objekt zurück.

581

12.2 Automatisierung

Eigenschaft Beschreibung

ObjClass

... bestimmt die Objektklasse des einzulagernden Objektes. Beispiel: "Word 8.0 Dokument"

ObjDoc

... spezifiziert das OLE-Dokument im OLE-Container. Beispiel: "C:\TEST.DOC"

ObjItem

... spezifiziert den OLE-Eintrag eines Objektes.

SizeMode

... bestimmt, wie das OLE-Objekt angezeigt wird. Zulässige Werte: smClip, SmCenter, SmScale, SmStretch und SmAutoSize.

State

... informiert über den Status der Komponente. Mögliche Rückgabewerte: osEmpty, osLoaded, osRunning, osOpen, osInPlaceActive,osUIActive.

Die restlichen Eigenschaften finden Sie auch bei anderen Komponenten. Auf einige Eigenschaften wollen wir jedoch noch etwas detaillierter eingehen. ObjClass Diese Eigenschaft legt den Klassennamen (Objekttyp) fest. Die Spezifikation erfolgt mit dem ProgID-Eintrag innerhalb von RegEdit. Die Klassen sind unter dem Schlüssel HKEY_LOCAL_MACHINE\SOFTWARE\Classes gespeichert. Ein Ausschnitt aus der Windows-Registrierung:

Für OLE2-Klassennamen gilt folgende Schreibweise: Anwendungsname.Objekttyp.Version

Die Angabe der Versionsnummer ist optional. Lassen Sie den Wert weg und sind mehrere Versionen installiert, wird die neueste verwendet. BEISPIEL: Gültige Klassennamen Excel.Application.5 Word.Document.8

582

Kapitel 12

OLE-Automation/ActiveX

ObjDoc Die Eigenschaft legt den Namen der Datei fest, die in das Steuerelement (Control) geladen werden soll. Der Dateityp (z.B. DOC) muss mit einer gültigen Klasse verknüpft sein:

Beispielsweise können Sie eine Word-Datei als SourceDoc setzen. SizeMode Die Eigenschaft bestimmt die Anpassung des OLE-Objekts an den umgebenden Rahmen: smClip

Abschneiden: Das Objekt wird in tatsächlicher Größe angezeigt. Ist das Objekt größer als der OLEContainer, wird die Anzeige an den Begrenzungslinien des Steuerelements abgeschnitten.

smStretch

Strecken: Das Objekt wird so skaliert, dass es in den Container passt. Die Objektproportionen bleiben unberücksichtigt.

smAutoSize

Automatische Größenanpassung: Das Control wird an die Abmessungen des enthaltenen Objekts angepasst.

smScale

Zoom: Das Objekt wird so skaliert, dass es in das OLEContainer-Steuerelement passt, die Objektproportionen werden beibehalten.

smCenter

Zentrieren: Das Objekt wird in tatsächlicher Größe im Container zentriert.

Methoden Über die Methoden ist es möglich, auch zur Laufzeit des Programms neue OLE-Objekte in den Container einzufügen bzw. OLE-Objekte über die Zwischenablage auszutauschen. Die folgende Tabelle zeigt die wichtigsten Methoden: Methode

Beschreibung

Close

... schließt die offene Serveranwendung, der Inhalt des OLE-Containers wird aktualisiert.

Copy

... kopiert den Inhalt des OLEContainers in die Zwischenablage.

Paste

... fügt den Inhalt der Zwischenablage in den OLEContainer ein. Prüfen Sie vorher mit CanPaste, ob sich auch ein gültiges Objekt in der Zwischenablage befindet.

CreateLinkToFile

... erstellt aus dem Inhalt der angegebenen Datei ein verknüpftes Objekt.

583

12.2 Automatisierung

Methode

Beschreibung

CreateObjectFromFile

... erstellt aus dem Inhalt einer Datei ein eingebettetes Objekt.

CreateObject

... erzeugt ein neues Objekt über dessen Klassennamen.

DestroyObject

... löscht das Objekt im OLEContainer.

DoVerb

... löst eine OLE-Objekt-Aktion aus, z.B. Anzeige (ovShow). Vordefiniert sind die folgenden Konstanten: ovShow, ovOpen, ovHide, ovUIActivate, ovInPlaceActivate, ovDiscardUndoState, ovPrimary

InsertObjectDialog

... Anzeige eines Dialogs zum Verknüpfen bzw. Einbetten eines OLEObjekts (siehe folgende Abschnitte).

PasteSpecialDialog

... Anzeige eines Dialogs, über den ein bestimmtes Objekt aus der Zwischenablage eingefügt werden kann (siehe folgende Abschnitte).

LoadFromFile SaveToFile

... Laden und Speichern von OLE-Objekten in einem eigenen Dateiformat.

ObjectPropertiesDialog ... zeigt einen Dialog zur Konfiguration des OLE-Objekts an. Run

... startet die Serveranwendung, das Objekt wird jedoch nicht aktiviert. Auf diese Weise können Sie beim späteren Aufruf Zeit sparen.

UpdateObject

... aktualisiert den Inhalt verknüpfter Objekte.

Programmierung Ziehen Sie einfach die OLEContainer-Komponente in ein Formular und klicken Sie mit der rechten Maustaste auf die Komponente. Wählen Sie den Menüpunkt Objekt einfügen. Es öffnet sich das folgende Dialogfenster, dessen Inhalt davon abhängt, welche OLE-fähigen Anwendungen Sie installiert haben:

584

Kapitel 12

OLE-Automation/ActiveX

Wählen Sie einen Objekttyp aus. Nachfolgend startet der OLE-Server (z.B. Windows-Paintbrush), in dem das Objekt zu erstellen ist. Dann müssen Sie den OLE-Server wieder verlassen (z.B. Windows-Paintbrush schließen). Die OLEContainer-Komponente zeigt das Objekt bereits zur Entwurfszeit an:

Das Hinzufügen einer MainMenu-Komponente empfiehlt sich, um zur Laufzeit auch über die Menüfunktionen des OLE-Servers verfügen zu können. Zusätzlich können Sie über die rechte Maustaste ein Popup-Menü aufrufen, das die verfügbaren Aktionen (Öffnen, Bearbeiten) zur Auswahl anbietet. Wählen Sie Bearbeiten, können Sie vor Ort, d.h. in Ihrer Delphi-Anwendung, das Objekt bearbeiten (wenn der OLE-Server In-Place-Editing unterstützt):

Wenn Sie anstatt Bearbeiten im PopUp-Menü des OLEContainers Öffnen wählen, wird der OLEServer (z.B. Paint) direkt gestartet, was natürlich etwas mehr Zeit in Anspruch nimmt.

12.2 Automatisierung

585

Past Special (Entwurfszeit) Neben oben beschriebener Möglichkeit, ein OLE-Objekt in Ihre Anwendung einzufügen, existiert diese weitere Alternative, die zur Entwurfszeit verfügbar ist. ■ Starten Sie eine OLE-Server-Applikation, wie zum Beispiel PaintBrush. ■ Markieren Sie das gewünschte Objekt (Text, Tabellen, Grafiken etc.) und fügen Sie dieses in die Zwischenablage ein (Copy). ■ Aktivieren Sie die OLE-Komponente, klicken Sie auf die rechte Maustaste und wählen Sie den Menüpunkt Inhalte einfügen. Danach öffnet sich das folgende Fenster:

586

Kapitel 12

OLE-Automation/ActiveX

In diesem Fenster wählen Sie den gewünschten Objekttyp aus. Im Weiteren verfahren Sie analog zur vorangegangenen Methode.

Paste Special (Laufzeit) Eine der Möglichkeiten, zur Laufzeit ein Objekt in das OLE-Control einzufügen, ist die PasteSpecialDialog-Methode. Analog zur vorangegangenen Methode kopieren Sie aus der Quellanwendung (zum Beispiel PaintBrush) ein Objekt in die Zwischenablage. Im Quelltext Ihres Programmes rufen Sie dann die PasteSpecialDlg-Methode auf. Der weitere Ablauf entspricht dem Vorgehen zur Entwurfszeit, d.h., obiges Dialogfenster "Inhalte einfügen" erscheint. Allerdings wird das Objekt nicht automatisch im Control gespeichert, Sie müssen also selbst dafür Sorge tragen, dieses mit SaveToFile zu speichern. BEISPIEL: Das Dialogfenster "Inhalte einfügen" erscheint. Nachdem der Inhalt der Zwischenablage dem

OLEContainer manuell zugewiesen ist, wird der Inhalt in einer Datei 'Test' gespeichert. OLEContainer1.PasteSpecialDialog; OLEContainer1.SaveToFile('Test');

Nach dem erneuten Starten der Anwendung wird der (zunächst leere) OLEContainer mit dem Inhalt der Datei 'Test' gefüllt: OLEContainer1.LoadFromFile('Test');

Paste Wollen Sie ohne Dialog auskommen, lässt sich ein in die Zwischenablage kopiertes Objekt auch mit der Paste-Methode in das OLE-Control einfügen. Allerdings sollten Sie vorher mit CanPaste überprüfen, ob sich auch ein gültiges Objekt in der Zwischenablage befindet. if OLEContainer1.CanPaste then OLEContainer1.Paste else ShowMessage('Kein gültiges Objekt verfügbar!');

12.2.2 Arbeiten mit Automations-Servern Eine Windows-Applikation, wie z.B. Word oder Visio, ist ein OLE- bzw. ActiveX-Server (genauer eine ActiveX-EXE), der Objekte zur Verfügung stellt, über die sich die Applikation von Ihrem Delphi-Programm aus quasi "fernsteuern" lässt. Nach Definition einer entsprechenden Objektvariablen (Variant) können Sie auf Eigenschaften und Methoden dieser Objekte genauso zugreifen, als ob es sich um Delphi-Objekte handeln würde. Wie Sie bereits wissen, ist ein weiterer Typ eines ActiveX-Servers die ActiveX-DLL. Im Unterschied zur konventionellen DLL exportiert diese jedoch keine Funktionen und Prozeduren, sondern komplette Objekte mit deren Eigenschaften, Methoden und Ereignissen. Konkrete Anwendungsbeispiele finden Sie im Praxisteil des vorliegenden Kapitels.

12.2 Automatisierung

587

Instanzen bilden (Variant) Dreh- und Angelpunkt für die Programmierung eines (OLE-)Automations-Clients, dem keine Typbibliothek zur Verfügung steht, ist eine Variable vom Typ Variant, die das importierte Objekt aufnimmt. Doch bevor es so weit ist, müssen Sie das Objekt erst einmal bereitstellen. Delphi bietet Ihnen dazu die beiden Funktionen CreateOleObject und GetActiveOleObject an, die über die Unit ComObj importiert werden. Während CreateOleObject davon ausgeht, dass sich der OLE-Server nicht im Speicher befindet und deshalb erst geladen werden muss, erwartet GetActiveOleObject, dass der Server schon geladen ist. Verwenden Sie GetActiveOleObject also immer dann, wenn Sie davon ausgehen können, dass der Server schon läuft (z.B. bei Add-ins) oder wenn Sie vermeiden wollen, dass mehrere Instanzen des Servers geladen werden. Im zweiten Fall ist es allerdings ratsam, eine Fehlerbehandlung durchzuführen und gegebenenfalls die Funktion CreateOleObject aufzurufen. BEISPIEL: Starten eines Excel-OLE-Servers Var excel : Variant; begin try excel := GetActiveOleObject('Excel.Application') except try excel := CreateOleObject('Excel.Application') except ShowMessage('Das war wohl nichts!'); Exit end end;

Nach der Ausführung der obigen Anweisungen können Sie davon ausgehen, dass die Variable Excel mit einem OLE-Objekt initialisiert ist. Der weitere Ablauf dürfte Ihnen vertraut vorkommen, können Sie doch mit dieser Variable wie mit jedem anderen Delphi-Objekt arbeiten, nur eben mit dem kleinen Unterschied, dass es sich um ein externes Objekt handelt, das in einer ganz anderen Programmiersprache geschrieben sein kann (z.B. auch in Visual Basic). Welches Objekt Sie für die OLE-Automatisierung nutzen, bestimmen Sie durch die Angabe der Objektklasse beim Initialisieren der Variant-Variablen. Die folgende Abbildung zeigt einen Ausschnitt der Registrierdatenbank, in dem sich unter anderem auch die Deklaration für das Excel. Application-Objekt befindet:

588

Kapitel 12

OLE-Automation/ActiveX

HINWEIS: Für den OLE-Client-Programmierer genügt die Information völlig, welche Objekte

der Server bereitstellt. Wo sich die Anwendung oder DLL auf der Festplatte befindet, ist uninteressant.

Instanzen bilden (TypeLibrary) Ein etwas anderer Weg bietet sich mit der Einbindung einer Typbibliothek (-library). Über den Menüpunkt Projekt|Typbibliothek importieren wählen Sie eine TypeLibrary aus bzw. erzeugen eine Schnittstellen-Unit, die Sie in Ihr Projekt einbinden können. BEISPIEL: Schnittstellen-Unit zur TypeLibrary "MyAxServer" (exportiert werden die Eigenschaft "Meine-

Eigenschaft" und die Methode "MeineMethode")1 unit MyAXServer_TLB; interface uses Windows, ActiveX, Classes, Graphics, OleCtrls, StdVCL;

Hier finden Sie die ID wieder (TGUID), über die jedes ActiveX-Objekt eindeutig identifiziert ist: const LIBID_MyAXServer: TGUID = '{CD985E71-03F3-11D1-A5EC-00804898FA90}'; const { Komponentenklassen-GUIDs } Class_MYClass: TGUID = '{CD985E79-03F3-11D1-A5EC-00804898FA90}'; type { Forward-Deklarationen: Interfaces } _MYClass = interface; _MYClassDisp = dispinterface;

1

Zugegeben: Der ActiveX-Server ist prinzipiell recht sinnlos, für das Grundverständnis aber ganz brauchbar.

12.2 Automatisierung

589

An dieser Stelle wird es interessant, Delphi erzeugt ein Interface für die enthaltene(n) Klasse(n): MYClass = _MYClass; _MYClass = interface(IDispatch) ['{CD985E78-03F3-11D1-A5EC-00804898FA90}'] function MeineMethode: WordBool; safecall; procedure _Set_MeineEigenschaft(Value: OleVariant); safecall; procedure Set_MeineEigenschaft(var Value: OleVariant); safecall; function Get_MeineEigenschaft: OleVariant; safecall; property MeineEigenschaft: OleVariant read Get_MeineEigenschaft write Set_MeineEigenschaft; end; _MYClassDisp = dispinterface ['{CD985E78-03F3-11D1-A5EC-00804898FA90}'] function MeineMethode: WordBool; dispid 1610809345; property MeineEigenschaft: OleVariant dispid 1745027072; end;

Die folgende Klasse ist für die weitere Arbeit von wesentlicher Bedeutung, wird doch über diese Klasse später die Instanz gebildet: CoMYClass = class class function Create: _MYClass; class function CreateRemote(const MachineName: string): _MYClass; end;

Zwei Varianten der Instanzenbildung sind möglich: Auf dem lokalen Computer oder auf einem anderen Rechner (Remote). Voraussetzung für die zweite Variante ist zum Ersten ein Out-ofProcess-Server, zum Zweiten eine Installation von DCOM. implementation uses ComObj; class function CoMYClass.Create: _MYClass; begin Result := CreateComObject(Class_MYClass) as _MYClass; end; class function CoMYClass.CreateRemote(const MachineName: string): _MYClass; begin Result := CreateRemoteComObject(MachineName, Class_MYClass) as _MYClass; end;

Nach der Einbindung der obigen Schnittstellen-Unit in Ihr Programm ist die Instanzenbildung genauso einfach wie bei einer Delphi-Klasse: uses MyAXServer_TLB; procedure TForm1.Button1Click(Sender: TObject); var MeineInstanz : MyClass; begin MeineInstanz := coMyClass.Create; MeineInstanz.MeineMethode; end;

590

Kapitel 12

OLE-Automation/ActiveX

Der Vorteil dieser auf den ersten Blick etwas umständlichen Variante: ■ Die Typenprüfung kann zur Entwurfszeit durchgeführt werden. ■ Sie können eine frühe Bindung für die OLE-Automatisierung einsetzen und verbessern so die Ausführungsgeschwindigkeit zur Laufzeit. Auch beim Editieren des Quelltextes können Sie die Vorteile nutzen (Programmierhilfe):

Instanzenbildung mit Hilfe von Datei-Extensions Möchten Sie die Instanz einer ActiveX-Klasse bilden, von der Ihnen nur der Dateiname bekannt ist (z.B. DOC, XLS etc.), dann können Sie folgende kleine Funktion einsetzen. uses registry; function GetClassname(app:string) : string; var regist : TRegistry; ext : string; begin regist := TRegistry.Create; regist.RootKey := HKEY_CLASSES_ROOT; ext := ExtractFileext(app); regist.OpenKey(ext,False); // Schlüssel auswählen result := regist.ReadString('') end;

Diese ermittelt mit Hilfe der Registrierdatenbank den zugehörigen OLE-Server. BEISPIEL: Der Einsatz der Funktion var v: Variant; ... v := CreateOleObject(GetClassname('c:\test1.doc')) ; v.Application.Visible := True;

591

12.2 Automatisierung

Instanzen bilden über Server-Komponenten Die Überschrift dürfte zunächst für etwas Verwirrung sorgen, die Lösung ist aber schnell gefunden. Seit Delphi 5 besteht die Möglichkeit, COM-Server (wie MS Word oder Visio) als Komponenten zu installieren, die "Server"-Seite der Komponentenpalette hält dazu ein gigantisches Angebot bereit (die folgende Abbildung zeigt nur einen Ausschnitt).

Diese Komponenten können Sie wie gewohnt auf einem Formular platzieren und über den Objektinspektor konfigurieren. Von Interesse ist in diesem Zusammenhang die Eigenschaft ConnectKind: Wert

Beschreibung

CkRunningOrNew

Läuft der Server, wird diese Instanz verwendet, andernfalls wird eine neue gestartet.

CkNewInstance

Es wird immer eine neue Instanz des Servers erzeugt.

CkRunningInstance

Eine laufende Instanz des Servers wird genutzt.

CkRemote

Hiermit besteht die Möglichkeit, auf dem durch RemoteMachineName genannten Computer eine Instanz zu starten.

CkAttachToInterface Diese Option ermöglicht den Zugriff auf die COM-Schnittstelle mit Hilfe der Methode ConnectTo. Dass mit diesen Komponenten recht unkompliziert eine Verbindung zum gewünschten Automations-Server aufgebaut werden kann, zeigt das folgende Beispiel. BEISPIEL: Verbinden mit MS-Word (ein Dokument ist geöffnet!), Ausgeben eines Textes und nachfolgendes

Drucken. with WordApplication1 do begin Connect; Visible := True; Selection.TypeText('Ein kleiner TEST !!!!!'); PrintOut end;

Ein weiterer Vorteil: Sie sparen nicht nur die Instanziierung, sondern es steht Ihnen über die betreffende Typbibliothek auch der komplette Satz aller Eigenschaften und Methoden zur Verfügung. Ganz nebenbei sind auch die vom COM-Server bereitgestellten Ereignisse verfügbar.

592

Kapitel 12

OLE-Automation/ActiveX

BEISPIEL: Ereignisse des WordApplication-Objektes

Erzeugen eigener COM-Server-Komponenten TOleServer (Unit OleServer) ist die abstrakte Basisklasse für Komponenten, die einen COM-Server repräsentieren. Erzeugen Sie keine Instanzen von TOleServer, verwenden Sie stattdessen einen Nachkommen von TOleServer, der den gewünschten Server kapselt. Ruft eine Anwendung eine Methode des TOleServer-Nachkommen auf oder setzt eine seiner Eigenschaften, so richtet die Komponente automatisch eine Verbindung zum COM-Server ein. Mittels Connect-Methode können Sie auch direkt Verbindung aufnehmen (siehe obiges Beispiel). Auf der "Server"-Seite der Komponentenpalette werden zahlreiche TOleServer-Nachkommen angeboten. Zusätzlich können Sie eigene Nachkommen erzeugen, indem Sie über den Menüpunkt Projekt|Typbibliothek importieren den gewünschten COM-Server auswählen. Auf Wunsch wird auch ein so genannter VCL-Wrapper, d.h. eine dazugehörige VCL-Komponente erzeugt. BEISPIEL: Einbinden der DAO-Libraries als VCL-Komponenten

593

12.2 Automatisierung

HINWEIS: Achten Sie auch auf die zu importierenden Klassen. Sollten Namensübereinstimmun-

gen mit vorhandenen Delphi-Klassen absehbar sein (z.B. TField), ändern Sie den Klassennamen in der obigen Dialogbox einfach ab. Andernfalls kommt es zu Problemen bei der Einbindung.

12.2.3 Zugriff auf Objekte im OLE-Container Geht es darum, einen OLE-Server zu steuern, der sich in einer OLE-Container-Komponente befindet, müssen Sie sich schon etwas bemühen. Es gibt zwar die Eigenschaft OleObject, über die Sie ein eventuell vorhandenes OLE-Automatisierungsobjekt abfragen können, Sie müssen jedoch vorher einiges beachten. So muss unter anderem der OLE-Server gestartet werden. Ein weiteres Problem resultiert daraus, wie Sie den OLE-Server starten. Bei einer "Vor-Ort"-Aktivierung sind zum Beispiel einige Methoden nicht verfügbar (Print, Preview etc.). Ein Beispiel zeigt die Vorgehensweise: BEISPIEL: Drucken eines eingebetteten Excel-Objekts aktivieren var excel : Variant; begin OleContainer1.DoVerb(ovOpen); excel := OleContainer1.OleObject; excel.Charts[1].PrintOut; excel.Close; OleContainer1.Close end;

Hätten Sie OleContainer1.DoVerb(ovUIActivate) gewählt, wäre die Methode PrintOut mit einer Fehlermeldung abgebrochen worden.

12.2.4 Parameter von ActiveX-Objekten Haben Sie es mit ActiveX-Objekten zu tun, werden Sie sich auch mit den entsprechenden Datentypen auseinander setzen müssen.

Datentypen Grundsätzlich besteht das Interface einer ActiveX-Klasse nur aus folgenden Grunddatentypen: Pascal-Typ

OLE-Variantentyp

Beschreibung

Smallint

VT_I2

2-Byte-Integer mit Vorzeichen

Integer

VT_I4

4-Byte-Integer mit Vorzeichen

Single

VT_R4

4-Byte-Real

Double

VT_R8

8-Byte-Real

Currency

VT_CY

Währungswert

TDateTime

VT_DATE

Datum/Zeit

594

Kapitel 12

OLE-Automation/ActiveX

Pascal-Typ

OLE-Variantentyp

Beschreibung

WideString

VT_BSTR

binärer String

IDispatch

VT_DISPATCH

Zeiger auf IDispatch-Schnittstelle

SCODE

VT_ERROR

OLE-Fehlercode

WordBool

VT_BOOL

Boolean (True = -1, False = 0)

OleVariant

VT_VARIANT

Ole-Variant

IUnknown

VT_UNKNOWN

Zeiger auf IUnknown-Schnittstelle

Byte

VT_UI1

1-Byte-Integer ohne Vorzeichen

Zusätzlich werden auch Aufzählungsdatentypen (basierend auf einem SmallInt-Wert) sowie Unterklassen (die wiederum aus obigen Grundtypen bestehen können) unterstützt.

Benannte und optionale Parameter Eine wesentliche Änderung gegenüber dem Aufruf von Delphi-Methoden stellen die benannten und optionalen Parameter dar, zwei sehr leistungsfähige Möglichkeiten1, die Übergabe von Parametern an Methoden zu vereinfachen. BEISPIEL: Übergabe von benannten und optionalen Parametern var vb : Variant; begin

Initialisierung der Variablen: vb := CreateOleObject('VBBeispiel.Application');

Übergabe einer variablen Anzahl von Parametern: Label1.Caption := vb.summe(12, 14, 72,111,333); Label2.Caption := vb.summe(12,343,323,2323,6764,2323,14,72,111,333);

Die Methode berechnet die Summe aller übergebenen Werte. Die Anzahl ist beliebig. Übergabe von benannten Parametern (die Reihenfolge ist unerheblich): vb.anzeigen(a := 10, b := 15); vb.anzeigen(c := 30, a := 1, b := 0); vb.anzeigen(c := 45);

Reihenfolge und Anzahl der Parameter können Sie beliebig wählen. Um der Funktion eine eindeutige Zuordnung zu ermöglichen, müssen Sie den Namen des Parameters ebenfalls mit angeben. Übergabe von optionalen Parametern: vb.anzeigen(10,15,20); vb.anzeigen(10,,20); 1

"Leistungsfähig" bezieht sich hier nicht auf die Geschwindigkeit. In Bezug auf die Performance sind derartige Schnittstellen absolute "Schlusslichter".

595

12.2 Automatisierung

vb.anzeigen(10); vb.anzeigen(,,,20); end;

Bei optionalen Parametern können Sie nur Parameter auslassen, die Anzahl steht jedoch fest. Lassen Sie einen Parameter weg, müssen Sie trotzdem das Komma einfügen. Am Ende können Sie beliebig viele Werte weglassen. Wie sieht die ganze Sache eigentlich auf der Server-Seite aus? Aufschluss soll folgendes Visual Basic-Listing geben: Public Sub If Not If Not If Not End Sub

anzeigen(Optional IsMissing(a) Then IsMissing(b) Then IsMissing(c) Then

a, Optional b, Optional c) MsgBox Format(a, "A: ###,###,###"); MsgBox Format(b, "B: ###,###,### Euro"); MsgBox Format(c, "C: ###,###,###.00")

Public Function summe(ParamArray summanden() As Variant) As Variant Dim zwischensumme As Single, i% for i = 0 to UBound(summanden) zwischensumme = zwischensumme + summanden(i) next i summe = zwischensumme end function

Beide Funktionen sind in einer Klasse VBBeispiel als public deklariert.

Deinitialisieren von ActiveX-Objekten Möchten Sie zum Schluss die OLE-Variant-Variable zurücksetzen, können Sie die Konstante Unassigned zuweisen. var Excel: Variant; begin Excel := CreateOleObject('Excel.Application'); ... Excel := Unassigned;

12.2.5 Konvertieren von VB-Beispielen Da Visual Basic eine der ersten Programmiersprachen war, die OLE-Automation unterstützt hat, und weil es den unbestrittenen Vorteil hat, relativ einfach zu sein, finden sich in vielen Dokumentationen OLE-Demos in Visual Basic. Der folgende Abschnitt zeigt an einigen Beispielen, wie Sie diese in Pascal umsetzen können. VB

Delphi

Dim excel As Object

var excel : Variant;

Set excel = CreateObject("Excel.Application")

excel := CreateOLEObject('Excel.Application');

excel.Sheets(1).Activate

excel.Sheets[1].Aktivieren

596

Kapitel 12

VB

OLE-Automation/ActiveX

Delphi

excel.Cells(zeile, spalte).value := 10

excel.Cells[zeile, spalte].Wert := 10;

Set seitensheet = Seite.Shapes("ThePage")

seitenSheet := Seite.Shapes['ThePage'];

Set excel = Nothing

excel := Unassigned;

HINWEIS: Bevor Sie verzweifelt nach einem Fehler suchen (Methode nicht gefunden, Element

nicht gefunden etc.), sollten Sie den Klammertyp überprüfen. In Delphi müssen Sie für Auflistungen (z.B. Shapes) unbedingt eckige Klammern verwenden. Andernfalls wird der Aufruf als Methode interpretiert, und die ist nun einmal nicht da. Vielfach wird in VB-Programmen die Schreibweise etwas abgekürzt. Dazu werden Teilobjekte (z.B. aus Auflistungen) einer neuen Objektvariablen (in Delphi Variant) zugewiesen. BEISPIEL: VB Dim seite As object, visio As object, seitensheet As object Set visio = CreateObject("Visio.Application") Set seite = visio.activePage If seite Is Nothing Set seite = visio.activeDocument.pages(1) Set seitenSheet = seite.Shapes("ThePage")

BEISPIEL: Delphi var visio, seite, seitensheet : Variant; visio := CreateOleObject('Visio.Application'); seite := visio.ActivePage; if VarIsEmpty(seite) then seite := visio.ActiveDocument.Pages[1]; seitenSheet := Seite.Shapes['ThePage'];

HINWEIS: Beachten Sie, dass Sie in Delphi nicht die With-Anweisung verwenden können.

12.3 Einige Automatisierungs-Beispiele 12.3.1 OLE-Automatisierung mit Visio Das Zeichenprogramm Visio bot als eine der ersten Windows-Applikationen überhaupt eine umfassende Unterstützung der OLE-Spezifikation. Warum erwähnen wir an erster Stelle Visio und nicht etwa Word oder Excel? Die Antwort ist, dass uns Visio sowohl vom Konzept als auch von seinen praktischen Anwendungsmöglichkeiten her am meisten beeindruckt hat und dass die OLE-Schnittstelle sauber dokumentiert ist.

12.3 Einige Automatisierungs-Beispiele

597

Wie wird die Verbindung zu Visio aufgebaut? Grundsätzlich müssen wir zwischen zwei Anwendungsfällen unterscheiden: ■ Delphi fungiert als OLE-Container für Visio. ■ Delphi steuert Visio über OLE-Automation.

OLE-Container Wenn Sie von Ihrem Programm aus eine Visio-Zeichnung bearbeiten möchten, brauchen Sie neben einer OLEContainer- auch eine OpenDialog-Komponente. Tragen Sie in das FormShow-Ereignis folgenden Code ein: If OpenDialog1.Execute then begin OLEContainer1.CreateObjectFromFile(OpenDialog1.Filename, False); OLEContainer1.doVerb(ovInPlaceActivate) end;

Nach Programmstart wählen Sie im Dateidialog eine Visio-Datei (*.vsd). Es vergeht etwas Zeit, bis die ausgewählte Zeichnung im OLE-Objekt angezeigt und für die Bearbeitung zur Verfügung steht. Auch die aktiven Schablonen (Werkzeugleisten) erscheinen. Nach Klick mittels rechter Maustaste blendet Visio ein Kontextmenü ein (Abbildung).

598

Kapitel 12

OLE-Automation/ActiveX

HINWEIS: Verfügte das Delphi-Fenster über ein Menü, ersetzt Visio dieses durch sein eigenes.

Um die obige OLE-Verknüpfung zu beenden, brauchen Sie eine Taste mit folgendem Ereigniscode: OLEContainer1.Close;

Mit etwas mehr Aufwand lassen sich neben dem Menü auch die Werkzeugleisten von Visio anzeigen. Ändern Sie dazu die FormStyle-Eigenschaft des Formulars in fsMDIForm und fügen Sie eine Panel-Komponente hinzu (Align = alTop). Aktivieren Sie jetzt das OLE-Objekt, so unterscheidet sich Ihr Delphi-Programm kaum noch vom eigentlichen Visio. Lassen Sie sich trotzdem nicht verwirren, speichern und drucken können Sie über die Menüleiste zum Beispiel nicht!

12.3 Einige Automatisierungs-Beispiele

599

Wie bei jedem zur Laufzeit in das OLE-Control eingefügten Objekt müssen Sie auch bei VisioObjekten dafür sorgen, dass der Inhalt gespeichert wird. Verwenden Sie dazu die SaveToFileMethode: OLEContainer1.SaveToFile('C:\Test.OLE')

OLE-Objekte Ob Sie mit CreateOleObject oder GetActiveOleObject eine OLE-Automation starten, hängt von zwei Alternativen ab: ■ Visio läuft, und Sie rufen Ihr Delphi-Programm aus Visio auf. ■ Sie möchten Visio von Ihrem Delphi-Programm aus aufrufen. Für beide Fälle kann die folgende Routine genutzt werden: uses ComObj; procedure TForm1.Button1Click(Sender: TObject); var i : integer; visio : Variant; breite, hoehe : Double; seite, seitensheet : Variant; begin try

600

Kapitel 12

OLE-Automation/ActiveX

Versuch, eine bestehende Visio-Instanz zu verwenden: visio := GetActiveOleObject('Visio.Application') except try

Gegebenenfalls Visio starten: visio := CreateOleObject('Visio.Application') except

Wahrscheinlich ist Visio nicht installiert: ShowMessage('Das war wohl nichts!'); Exit end end ...

Ist die Routine erfolgreich abgearbeitet, können Sie über die Variable Visio auf alle Objekte, Methoden und Eigenschaften von Visio zugreifen. Die folgende Abbildung zeigt einen kleinen Ausschnitt aus der Objektstruktur: Application

Documents

Add

ActivePage

Shapes[]

Cells[]

DrawLine

BEISPIEL: Zeichnen einiger Linien visio.documents.Add(''); // neues Dokument

Aktive Seite abrufen: seite := visio.ActivePage; if VarIsEmpty(seite) then seite := visio.ActiveDocument.Pages(1); seitenSheet := Seite.Shapes['ThePage'];

12.3 Einige Automatisierungs-Beispiele

601

Höhe und Breite der Seite bestimmen (abhängig vom aktuellen Koordinatensystem): hoehe := Double(seitenSheet.Cells['PageHeight']); breite := Double(seitenSheet.Cells['PageWidth']);

Ein paar Linien ziehen: For i := 0 To 50 do begin seite.drawline(0, hoehe, breite, hoehe - i*0.25); end; end;

Das Resultat in Visio:

12.3.2 OLE-Automatisierung mit Word Für die OLE-Kommunikation mit dem Microsoft-Flaggschiff "Word für Windows" bieten sich zwei Möglichkeiten an: ■ Arbeit mit einem OLE-Steuerelement ■ OLE-Automation über das Objekt Word.Application

602

Kapitel 12

OLE-Automation/ActiveX

Das Einbinden von Word-Dokumenten in einen OLE-Container ist zwar recht eindrucksvoll, Texte lassen sich jedoch nach wie vor besser in einem Textverarbeitungsprogramm als in einem OLEObjekt bearbeiten. Die zweite und wesentlich sinnvollere Möglichkeit bietet die OLE-Automation. BEISPIEL: Das Beispiel fügt formatierten Text in ein neues Word-Dokument ein. Sie brauchen lediglich ein

Textfeld zur Eingabe eines Textes sowie einen Button (Word natürlich auch). uses ComObj; procedure TForm1.Button1Click(Sender: TObject); var word : Variant; begin try word := CreateOleObject('Word.Application') except ShowMessage('WORD konnte nicht gestartet werden !'); Exit end; word.Visible := True; word.Documents.Add; word.Selection.Font.Name := 'Times New Roman'; word.Selection.Font.Size := 12; word.Selection.Font.Bold := True; word.Selection.ParagraphFormat.Alignment := 1; word.Selection.TypeText( Text := Edit1.text) end;

Das Ergebnis:

12.3.3 Informationen über ActiveX-Server Bleibt zum Schluss nur noch die Frage: Wo bekommen Sie Informationen über die OLE-Objektschnittstellen diverser Anwendungen her? Hierzu einige Hinweise: ■ Die Online-Hilfe bzw. die Handbücher diverser Programme enthalten meist recht detaillierte Beispiele für die OLE-Schnittstellen. Obwohl diese Beispiele meist in Visual Basic geschrieben sind, dürfte es kaum Probleme bei der Umsetzung in Delphi geben.

12.4 ActiveX-Code-Komponenten entwickeln

603

■ Sollten Sie zufällig über Visual Basic oder Visual C++ verfügen, bietet sich Ihnen mit dem Programm ole2vw32.exe (OLE 2 Object Viewer) ein nützliches Tool, mit dem Sie nicht nur die verfügbaren Methoden und Eigenschaften von OLE-Servern ermitteln können, sondern auch die Datentypen und die Beschreibung der Funktion. ■ Nicht zuletzt bieten die Import-Units der TypeLibraries genügend Informationen über erwartete Parameter bzw. Datentypen.

12.4 ActiveX-Code-Komponenten entwickeln Bis jetzt haben Sie sich lediglich mit "vorgefertigten" ActiveX-Code-Komponenten beschäftigt, vor allem mit dem Zugriff auf bereits vor Ort vorhandene ActiveX-EXE-Dateien in Gestalt von OLE-/ Automations-Servern, wie z.B. Visio oder Word. Mit Delphi lassen sich aber auch eigene ActiveXCode-Komponenten (ActiveX-EXE oder ActiveX-DLL) erstellen, um sie dann – ganz im Sinn der Microsoft COM-Philosophie – in andere Anwendungen einzubinden. Diese Anwendungen müssen nicht unbedingt mit Delphi, sondern können z.B. auch mit Visual Basic, Java oder C++ entwickelt werden. Das zeigt die Möglichkeiten der komponentenbasierten Entwicklung im Team, wo in verschiedenen Sprachen (Delphi, VB, ...) an einem Projekt gearbeitet werden kann. Für den Entwurf eigener ActiveX-Code-Komponenten bietet Delphi großzügige Unterstützung in Gestalt diverser Assistenten. Bevor Sie aktiv werden, sollten Sie sich das notwendige theoretische Rüstzeug aneignen. Vor allem bedeutet das, dass Sie einigermaßen mit der Microsoft COM-Philosophie1 vertraut sind.

12.4.1 COM-Schnittstellen von Automatisierungsobjekten In COM haben wir es im Wesentlichen mit drei Typen von Schnittstellen zu tun: ■ IUnknown-Schnittstelle ■ IDispatch-Schnittstelle ■ Duale Schnittstelle Im Folgenden sollen die Methoden der drei Schnittstellen grob erklärt werden. Obwohl Sie mit den verschiedenen Methoden direkt kaum zu tun haben werden (Delphi kapselt deren Funktionalität), so kann deren Verständnis doch keinesfalls schädlich für Ihre erfolgreiche Karriere als Programmierer sein.

IUnknown-Schnittstelle IUnknown beschreibt das Grundverhalten eines COM-Objekts und befindet sich an oberster Stelle jeder COM-Schnittstellenhierarchie. Das bedeutet, dass sich die drei in IUnknown definierten Methoden

1

Obwohl innerhalb der Microsoft .NET-Strategie COM nicht mehr dominiert, wird die COM-Schnittstelle nach wie vor unterstützt.

604

Kapitel 12

OLE-Automation/ActiveX

■ QueryInterface (fragt Objekt, ob es eine bestimmte Schnittstelle unterstützt) ■ AddRef (fügt Verweis auf Schnittstelle hinzu) ■ Release (entfernt Verweis) immer am Anfang einer COM-kompatiblen Tabelle von Funktionszeigern (vTable) befinden. Die IUnknown-Schnittstelle erlaubt Early Binding, d.h., die Adressen der aufzurufenden Methoden sind bereits während des Compilierens bekannt durch direkten Aufruf einer Mitgliedsfunktion aus der Tabelle der virtuellen Funktionen (vTable). Falls das Objekt eine Typbibliothek besitzt, können Sie mit dem Typbibliothekseditor direkt auf die benutzerdefinierte Schnittstelle zugreifen.

IDispatch-Schnittstelle Bei der (OLE-)Automation können Clients QueryInterface nicht aufrufen, da eine Typbibliothek nicht vorhanden ist. Wenn ein Client aber keine Informationen von einer Typbibliothek erhält, kann er keine vTable-Bindungen für benutzerdefinierte Schnittstellen generieren. COM löst dieses Problem mit dem IDispatch-Schnittstellentyp. Dieser ermöglicht Late Binding, d.h., Methodenanbindungen werden erst zur Laufzeit ermittelt. Die Methoden von IDispatch: ■ GetTypeInfoCount ■ GetTypeInfo ■ GetIDsOfNames ■ Invoke Da das Anbinden der Objekte nicht schon beim Compilieren erfolgt, ergibt sich eine erheblich schlechtere Performance. Der Client muss das Objekt zunächst erzeugen, um danach die IUnknown-Schnittstelle nach einem Zeiger auf IDispatch abzufragen und nach GetIDsOfNames deren Invoke-Methode aufzurufen.

Duale Schnittstelle Der Automatisierungsobjekt-Assistent in Delphi implementiert standardmäßig eine duale Schnittstelle. Diese kombiniert die Vorteile von benutzerdefinierten (vTable-)Schnittstellen und von Dispatch-Schnittstellen (siehe folgende Abbildung). Die ersten drei Einträge beziehen sich auf IUnknown, die folgenden vier auf IDispatch. Die übrigen sind COM-Einträge für den direkten Zugriff auf die Mitglieder der benutzerdefinierten Schnittstelle.

605

12.4 ActiveX-Code-Komponenten entwickeln

QueryInterface AddRef Release

IDispatchSchnittstelle IUnknown

IUnknown

Benutzerdefinierte Schnittstelle

QueryInterface AddRef Release

Methode1

GetTypeInfoCount

Methode2

GetTypeInfo

Methode1

GetIDsOfNames

Methode2

Invoke

Duale Schnittstelle

IUnknown

QueryInterface AddRef Release

IDispatch

GetTypeInfoCount GetTypeInfo GetIDsOfNames Invoke Methode1 Methode2

12.4.2 Praktischer Entwurf Die Grundlage jeder ActiveX-Anwendung (egal, ob es sich um eine DLL oder EXE handelt) ist eine Klasse, die Sie in Delphi mit einem Assistenten erstellen können. Allerdings müssen Sie an dieser Stelle bereits die Entscheidung getroffen haben, welchen Typ Sie erstellen wollen (EXE oder DLL). ■ Bei einem Out-of-Process-Server (EXE) erstellen Sie eine ganz normale Anwendung, der Sie später die Automatisierungsobjekte hinzufügen. ■ Bei einem In-Process-Server (DLL) müssen Sie zunächst über Datei|Neu|Weitere... eine ActiveX-Bibliothek erstellen, zu der Sie dann die Automatisierungsobjekte hinzufügen.

606

Kapitel 12

OLE-Automation/ActiveX

Eine "normale" DLL (siehe Kapitel 10) genügt an dieser Stelle nicht, da ein In-Process-Server einige Prozeduren exportieren muss. BEISPIEL: Das Grundgerüst eines In-Process-Servers library Project1; uses ComServ; exports DllGetClassObject, DllCanUnloadNow, DllRegisterServer, DllUnregisterServer; {$R *.RES} begin end.

12.4.3 Instanz-Typen Über Datei|Neu|Weitere... öffnen Sie die Seite "ActiveX" der Objektgalerie und fügen Automatisierungsobjekte in Ihren ActiveX-Server ein. Sie müssen sich zum einen für einen Namen, zum anderen für den Instanzierungstyp sowie das Threading-Modell entscheiden:

12.4 ActiveX-Code-Komponenten entwickeln

607

Bei einer ActiveX-EXE ist insbesondere die Instanziierung von Interesse, mit der Sie entscheiden, ob und (wenn ja) wie die Klasse in anderen Applikationen verwendet werden kann. Welche Unterschiede bestehen, zeigt die folgende Tabelle: Typ

Bemerkung

Intern

Die Klasse ist nur für die interne Verwendung in der ActiveX-Komponente vorgesehen, als Anwendungsprogrammierer haben Sie darauf keinen Zugriff. Allerdings können derartige Objekte über eine Anwendungsmethode erstellt und zurückgegeben werden.

Eine Instanz

Sie können neue Instanzen bilden, beachten Sie jedoch, dass jedes neue Objekt eine weitere Instanz der ActiveX-Komponente in den Speicher lädt. Vorteil: Jede Instanz läuft in einem eigenen Thread. Nachteil: Wesentlich erhöhter Speicherbedarf.

Mehrere Instanzen Sie können neue Instanzen dieser Klasse bilden, es wird jedoch nur eine Instanz der ActiveX-Komponente verwendet, der Server befindet sich nur einmal im Speicher. Vorteil: Geringer Speicherbedarf. Nachteil: Mehrere Endanwendungen müssen sich einen Server teilen. Ihr Ärger ist verständlich, denn wer soll diesen Widersinn noch verstehen? Soll etwa "Eine Instanz" bedeuten, dass mehrere Instanzen im Speicher gebildet werden können, und "Mehrere Instanzen", dass nur eine gebildet wird? Tja, leider ist das so. Vielleicht hilft Ihnen folgende Eselsbrücke: ■ "Eine Instanz" im Sinn von "Jedes von der Klasse abgeleitete Objekt benutzt eine (eigene) Instanz". ■ "Mehrere Instanzen" im Sinn von "Mehrere Instanzen benutzen gemeinsam ein Objekt". Die Hauptursache für das Verwirrspiel liegt sicherlich in der unglücklichen Übersetzung aus dem Englischen, wo es "Single Instance" und "Multiple Instance" heißt. Bevor Sie bereits jetzt resigniert "das Handtuch werfen", sollten Sie das Praxisbeispiel 12.9.2 durcharbeiten und sich davon überzeugen, dass die Instanziierung eigentlich gar nicht so schwierig zu verstehen ist.

12.4.4 Threading-Modell Hier legen Sie fest, wie COM die Schnittstellenaufrufe serialisiert. Außerdem legt das ThreadingModell die Art der Registrierung im System fest. Folgende Einstellungen sind möglich: ■ EinfachKeine Thread-Unterstützung.

608

Kapitel 12

OLE-Automation/ActiveX

■ ApartmentDie Methoden des Objekts können nur in dem Thread aufgerufen werden, in dem es erstellt wurde. ■ FreiObjekte können in beliebigen Threads aufgerufen werden. ■ BeidesSowohl Clients mit Threading-Model Apartment als auch Frei werden vom Server unterstützt. Die Standardeinstellung beim Erstellen eines neuen Automatisierungsobjekts ist Apartment, sie wird bei (fast) allen Beispielen dieses Buchs verwendet.

12.4.5 Initialisieren und Entfernen von Instanzen Die Initialisierung von Objekten realisiert COM über die Methode Initialize. Normalerweise brauchen Sie als Entwickler diese Methode nur dann zu überschreiben, wenn Sie Initialisierungen (Zuweisen von Anfangswerten) für das Objekt bereitstellen wollen, nachdem es erzeugt worden ist. TC2 = class(TAutoObject, IC2) protected procedure Initialize; override; end; ... procedure TC2.Initialize; begin inherited Initialize; ShowMessage('Init von C2') end;

HINWEIS: Vergessen Sie nicht den Aufruf von inherited, um vorhergehende Implementierungen

der Methode auszuführen. Das Entfernen einer Instanz aus dem Speicher erledigt COM über den Destructor Destroy. Analog zu Initialize überschreiben Sie die Methode dann, wenn Sie unmittelbar vor dem Zerstören des Objekts noch etwas erledigen wollen. type

TC3 = class(TAutoObject, IC3) destructor Destroy; override; end;

... destructor TC3.Destroy; begin ShowMessage('Destroy von C3'); inherited destroy end;

Wie bei Initialize gilt auch hier, dass inherited aufgerufen werden muss. Allerdings hat der Aufruf jetzt nach den neuen Anweisungen zu erfolgen.

12.4 ActiveX-Code-Komponenten entwickeln

609

HINWEIS: Rufen Sie Destroy nie direkt in einer Clientanwendung auf, sondern verwenden Sie

dort Free. Diese Methode prüft vorher, ob weitere Objekte vom Server abhängig sind, so dass dieser gegebenenfalls freigegeben werden kann.

12.4.6 Interface-Definition Die Schnittstelle eines Automatisierungs- oder COM-Objekts legen Sie im Gegensatz zu einer normalen Delphi-Klasse recht komfortabel an, es existiert ein eigener Assistent, den Sie über das Menü Ansicht|Typbibliothek öffnen:

HINWEIS: Auch den Hilfestring sollten Sie nicht vernachlässigen, wird dieser doch von vielen

Objekt-Browsern (z.B. in Visual Basic) angezeigt.

Eigenschaften Eigenschaften erstellen Sie zuerst mit dem TypeLibrary-Editor, der Ihnen ein fertiges Grundgerüst erzeugt. Delphi-Programmierer, die bereits Komponenten programmiert haben, werden an dieser Stelle etwas umdenken müssen, VB-Programmierern wird die Definition bekannt vorkommen. BEISPIEL: Eigenschaft Farbe (Lesen/Schreiben) type TGlobal = class(TAutoObject, IGlobal) protected function Get_Farbe: TColor; safecall; procedure Set_Farbe(Value: TColor); safecall; end;

610

Kapitel 12

OLE-Automation/ActiveX

function TGlobal.Get_Farbe: TColor; begin ... end; procedure TGlobal.Set_Farbe(Value: TColor); begin ... end;

Wie Sie sehen, kommen nicht mehr die Schlüsselwörter Read und Write, sondern lediglich eine Get_XYZ- bzw. eine Set_XYZ-Prozedur/Funktion zum Einsatz. Durch wahlweise Kombination der beiden Methoden können Sie ReadOnly- bzw. WriteOnly-Eigenschaften realisieren. Eine weitere Variante bietet sich mit der Referenzübergabe: type TGlobal = class(TAutoObject, IGlobal) protected procedure Set_MeinObject(var Value: Integer); safecall; ... procedure TGlobal.Set_MeinObject(var Value: Integer); begin ... end;

Da eine Referenz (Pointer) auf den eigentlichen Wert übergeben wird, können Sie direkt mit den Originaldaten arbeiten. HINWEIS: Beachten Sie, dass bei Out-of-Process-Servern ein hoher Aufwand nötig ist, um die

entsprechenden Daten (die Daten müssen temporär kopiert werden) bereitzustellen.

Methoden Bei Methoden erwartet Sie kein Neuland, die Definition erfolgt wie bei einer normalen DelphiKlasse: type TGlobal = class(TAutoObject, IGlobal) protected procedure Method1; safecall; end; procedure TGlobal.Method1; begin ... end;

Ob es sich um Funktionen oder Prozeduren handelt, entscheiden Sie. Wichtig ist lediglich, dass Sie das Grundgerüst mit dem TypeLibrary-Editor erstellen, da andernfalls keine Übereinstimmung mit der TypeLibrary (Interface) gegeben ist.

12.4 ActiveX-Code-Komponenten entwickeln

611

Aufzählungen Mit den Aufzählungen haben die ActiveX-Server wieder etwas Neues zu bieten, auch wenn der Begriff vielen Delphi-Programmierern bekannt vorkommen mag. Eigentlich muss Delphi an dieser Stelle passen, da ein entsprechendes Sprachkonstrukt nicht existiert. Als Notbehelf wurde die Verwendung von Konstanten genutzt: BEISPIEL: Auszug aus der MS-DAO-TypeLibrary (ein Typ für die Definition von Recordsets) { RecordsetTypeEnum } dbOpenTable = 1; dbOpenDynaset = 2; dbOpenSnapshot = 4;

Wie Sie sehen, kann Delphi dies nur mit einfachen Konstanten ohne jeden Zusammenhang umsetzen. Eine so "einfache" Sprache wie Visual Basic bietet an dieser Stelle einen echten Typ, der auch vom Compiler geprüft werden kann. BEISPIEL: VB-Realisierung Public Enum RecordsetType dbOpenTable = 1 dbOpenDynaset = 2 dbOpenSnapshot = 4 End Enum Dim xyz As RecordsetType

// Eine Variablendeklaration

12.4.7 Fehlerbehandlung Dass nun ausgerechnet die ActiveX-Server fehlerfrei sind, dürfte nicht zu erwarten sein. Prinzipiell bieten sich die gleichen Möglichkeiten, wie in Kapitel 5 beschrieben, an, einige Besonderheiten sind dennoch zu beachten. Zwei verschiedene Szenarien sind denkbar: ■ Der Fehler tritt aufgrund innerer Probleme im ActiveX-Server auf (Speichermangel, Dateizugriffe etc.). ■ Der Fehler ist die Folge einer Fehleingabe des Clientprogramms (Wertebereiche nicht beachtet, falscher Handle etc.). Grundsätzlich sollten Sie das Clientprogramm benachrichtigen. Dabei müssen Sie nicht auf die Microsoft-Methode zurückgreifen (einfach eine Dialogbox mit nichts sagendem Text anzeigen). Besser ist das Auslösen einer definierten Exception, die das Clientprogramm abfangen muss. Die eigentliche Fehlernummer und gegebenenfalls den Fehlertext können Sie über ein eigenes Objekt bereitstellen (z.B. ServerError). Sollte es sich um mehrere Fehler handeln, müssen Sie gegebenenfalls eine Errors-Collection erzeugen, d.h. eine Liste von Fehlermeldungen.

612

Kapitel 12

OLE-Automation/ActiveX

Dass Sie in die ActiveX-Serverdokumentation auch einen Fehlerkatalog aufnehmen, dürfte selbstverständlich sein. Allerdings sollten Sie nicht gleich an jeder Stelle Exceptions auslösen. Bei einem Methodenaufruf genügt auch ein Boole'scher Rückgabewert, der über Erfolg oder Misserfolg Auskunft gibt. Eigenschaften sollten, so weit es möglich ist, entsprechende Prüfungen in der Set-Methode vornehmen.

12.5 ActiveX-Controls Grundsätzlich werden ActiveX-Controls wie ein ActiveX-In-Process-Server entwickelt, der wesentliche Unterschied entsteht erst bei der Definition der Klassen. Bevor Sie sich jetzt sofort in die Arbeit stürzen, sollten Sie entscheiden, ob Sie ■ ein ActiveX-Control oder ■ ein ActiveX-Form entwickeln. Auch wenn auf den ersten Blick ein ActiveX-Form nicht geeignet scheint, sollten Sie bedenken, dass es hier wesentlich einfacher ist, zum Beispiel mehrere Komponenten in einem endgültigen "Control" zur Verfügung zu stellen. Im Gegensatz zu "einfachen" ActiveX-Controls lassen sich ActiveX-Forms weitgehend visuell entwickeln. Nicht zuletzt ist der Markt mit normalen ActiveX-Komponenten bereits total überschwemmt, was fehlt, sind hochkomplexe Controls, und die lassen sich nun einmal besser als ActiveX-Form entwickeln. Doch zurück zu den eigentlichen ActiveX-Controls.

12.5.1 Entwurf Ausgangspunkt ist, wie schon erwähnt, ein ActiveX-In-Process-Server, d.h. eine ActiveX-Bibliothek. In dieser Bibliothek können Sie beliebig viele ActiveX-Elemente (Borland-Jargon für ActiveX-Controls) unterbringen. Wählen Sie also über Datei|Neu|Weitere... in der Objektgalerie "ActiveX-Element", so erscheint folgender Experte:

12.5 ActiveX-Controls

613

Neben einem Vorfahrtyp, den Sie wie bei einer VCL-Komponente auswählen (siehe Kapitel 11), müssen Sie einen Namen sowie einige Optionen festlegen. Die Auswahl der Option "DesignLizenz" hat zur Folge, dass der Endanwender über eine LIC-Datei verfügen muss, um Ihr ActiveXControl in eine Entwicklungsumgebung zu laden. Für das reine Ausführen ist diese Datei nicht notwendig. Mit der Option "Info-Fenster" wird Ihrem Control automatisch ein "About"-Dialog hinzugefügt, den Sie eigenen Bedürfnissen anpassen können. Nachdem der Experte mit seiner Arbeit fertig ist, werden Sie mit einer fast unüberschaubaren Flut von Quelltexten eingedeckt, ohne dass dieses Control mehr könnte als sein VCL-Vorfahre (vom About-Dialog einmal abgesehen). Der Aufwand wird lediglich getrieben, um die Delphi-Methoden auf das ActiveX-Interface abzubilden. Die folgende Abbildung zeigt die TypeLibrary für einen einfachen VCL-Button.

Möchten Sie einzelne Eigenschaften entfernen, können Sie diese einfach in der TypeLibrary löschen. Gleiches trifft auf Methoden und Ereignisse zu. Prinzipiell gilt für ActiveX-Controls das Gleiche wie für die ActiveX-Server. Allerdings wollen wir an dieser Stelle noch einmal detailliert auf das Thema "Eigenschaften" eingehen, da diese bei ActiveX eine "Sonderbehandlung" erwarten.

614

Kapitel 12

OLE-Automation/ActiveX

12.5.2 Eigenschaften Die reine Definition der Ereignisprozeduren Get_XYZ und Set_XYZ stellt den Programmierer vor kein allzu großes Hindernis. Eine Grundüberlegung haben wir allerdings bisher vernachlässigt: Was passiert mit den in der Entwicklungsumgebung eingestellten Werten (Properties), nachdem die EXE compiliert bzw. das Anwendungsprogramm gestartet wurde? Die Antwort dürfte recht kurz ausfallen: nichts! Die Werte wurden nicht dauerhaft gespeichert (nur in einer Variablen) und können deshalb auch nicht wiederhergestellt werden. Bei den VCLKomponenten und den zugehörigen Eigenschaften bestand dieses Problem nicht, Delphi hatte dem Programmierer die Arbeit weitgehend abgenommen. Hier bei ActiveX müssen wir schon selbst "Hand anlegen". Ein kleines Beispiel zeigt, wie es geht. BEISPIEL: Erzeugt wird ein ActiveX-Control, das von der VCL-Komponente TPanel abgeleitet wird. Einzige

Aufgabe ist die Anzeige der aktuellen Uhrzeit. Dazu wird eine Eigenschaft ShowTime (Boolean) erzeugt. Das vom Experten erzeugte Grundgerüst (in Auszügen): unit PanelImpl1; interface uses Windows, ActiveX, Classes, Controls, Graphics, Menus, Forms, StdCtrls, ComServ, StdVCL, AXCtrls, ax1_TLB, ExtCtrls; type TPanelX = class(TActiveXControl, IPanelX) ... protected function Get_Showtime: WordBool; safecall; procedure Set_Showtime(Value: WordBool); safecall; end; function TPanelX.Get_Showtime: WordBool; begin end; procedure TPanelX.Set_Showtime(Value: WordBool); begin end; ...

Unsere erste Erweiterung gilt der Klassendefinition: TPanelX = class(TActiveXControl, IPanelX) private { Private-Deklarationen } ... FTime : TTimer; FOn : Boolean; procedure OnTimerTick(Sender: TObject); procedure SaveToStream(const Stream: IStream); override; procedure LoadFromStream(const Stream: IStream); override;

12.5 ActiveX-Controls

615

protected ...

Nachfolgend müssen wir uns um die Initialisierung des Timers und die Ereignisprozedur kümmern: procedure TPanelX.InitializeControl; begin FDelphiControl := Control as TPanel; FDelphiControl.OnClick := ClickEvent; FDelphiControl.OnDblClick := DblClickEvent; FDelphiControl.OnResize := ResizeEvent; fTime := TTimer.Create(FDelphiControl); ftime.Enabled := False; ftime.Interval := 1000; ftime.OnTimer := OnTimerTick end; procedure TPanelX.OnTimerTick(Sender: TObject); begin FDelphiControl.Caption := TimeToStr(time) end;

Die eigentlichen Schnittstellen-Methoden für die Eigenschaft ShowTime: function TPanelX.Get_Showtime: WordBool; begin Result := ftime.Enabled end; procedure TPanelX.Set_Showtime(value: WordBool); begin ftime.Enabled := value; Fon := value end;

Belassen wir das Control beim bisherigen Stand, ist es ziemlich vergesslich, soll heißen, nach einem Start des Anwenderprogramms ist die Eigenschaft ShowTime immer False, egal was in der jeweiligen Entwicklungsumgebung eingestellt wurde. Abhilfe schaffen die beiden folgenden (erweiterten) Methoden, die dafür verantwortlich sind, alle Eigenschaftswerte zu speichern bzw. wiederherzustellen. Die von Ihnen definierten Eigenschaften müssen Sie an dieser Stelle sichern. procedure TPanelX.SaveToStream(const Stream: IStream); var i: Integer; begin inherited SaveToStream(stream); Stream.Write(@FOn,sizeof(Fon),@i) end;

616

Kapitel 12

OLE-Automation/ActiveX

Sichern können Sie eigentlich alles, was sich im Speicher befindet, Sie brauchen lediglich einen Pointer darauf sowie die Größe des Speicherobjekts. Über den dritten Parameter erhalten Sie eine Rückmeldung, wie viele Bytes geschrieben wurden. Die Methode hat auch Rückgabewerte, über die Sie verschiedene Fehler auswerten können: Konstante

Beschreibung

S_OK

Alles OK

STG_E_MEDIUMFULL

Festplatte voll

STG_E_ACCESSDENIED

Zugriffsrechte reichen nicht aus

STG_E_CANTSAVE

Daten konnten nicht gespeichert werden

STG_E_INVALIDPOINTER

Zeiger sind ungültig

STG_E_WRITEFAULT

Fehler beim Schreiben

Beim Zurücklesen der Daten müssen Sie natürlich die gleiche Reihenfolge wie beim Schreiben verwenden: procedure TPanelX.LoadFromStream(const Stream: IStream); var i: Integer; begin inherited LoadFromStream(stream); Stream.read(@FOn,sizeof(Fon),@i); set_showtime(fon) end;

HINWEIS: Nach dem Einlesen der gespeicherten Werte müssen Sie diese natürlich auch noch

dem Control zuweisen, sonst passiert nichts. Bevor Sie lange suchen: Eigenschaften, die nur zur Laufzeit sichtbar sein sollen, können Sie mit Hilfe des TypeLibrary-Editors erzeugen. Setzen Sie einfach die Option "Non Browsable".

617

12.5 ActiveX-Controls

12.5.3 Einbinden von PropertyPages Wenn von Eigenschaften die Rede ist, dürfen im Zusammenhang mit ActiveX-Controls auch die PropertyPages nicht vergessen werden. Gedacht, um den Endanwender die Arbeit mit dem Control zu vereinfachen, bedeuten sie für den Programmierer erst einmal mehr Arbeit. Dank der vielen Assistenten ist diese Arbeit allerdings schnell erledigt. Wählen Sie einfach Datei| Neu|Eigenschaftenseite. Das Ergebnis ist ein nacktes Formular mit zwei Methoden. Fügen Sie die benötigten Controls hinzu, mit denen Sie die Eigenschaften einstellen möchten. BEISPIEL: Checkbox für unser simples TPanel

Um eine Verbindung zwischen ActiveX-Control und der PropertyPage herzustellen, müssen Sie die Methoden UpdatePropertyPage und UpdateObject überschreiben: Aktualisieren der Eigenschaftenseite: procedure TPropertyPage1.UpdatePropertyPage; begin checkbox1.Checked := OLEObject.ShowTime end;

Aktualisieren des Controls: procedure TPropertyPage1.UpdateObject; begin OLEObject.ShowTime:=checkbox1.Checked end;

HINWEIS: Falls Sie sich über das mysteriöse Objekt OLEObject wundern: Dabei handelt es sich

um Ihr ActiveX-Control. Die letzte Verbindung zwischen Eigenschaftenseite und ActiveX-Control stellen Sie mit der DefinePropertyPages-Methode Ihres ActiveX-Controls her: procedure TPanelX.DefinePropertyPages(DefinePropertyPage: TDefinePropertyPage); begin DefinePropertyPage(Class_PropertyPage1) end;

Registrieren Sie hier alle PropertyPages, die Sie bzw. die Ihr Control benötigt.

618

Kapitel 12

OLE-Automation/ActiveX

12.5.4 Ereignisse Mit dem TypeLibrary-Editor können Sie auch Ereignisse definieren. Allerdings müssen Sie diese nicht dem eigentlichen Interface, sondern dem XYZEvents-Interface hinzufügen:

Nach einer Ereignisprozedur werden Sie in der Implementierungs-Unit allerdings vergeblich Ausschau halten, fündig werden Sie erst in der TypeLibrary: IPanelXEvents = dispinterface ['{16575E12-05AE-11D1-A5F0-00804898FA90}'] ... procedure OnTimerRefresh; dispid 4; end; TPanelX = class(TOleControl) private ... FOnTimerRefresh: TNotifyEvent; ... published property OnTimerRefresh: TNotifyEvent read FOnTimerRefresh write FOnTimerRefresh; end;

Um das Ereignis auch auslösen zu können, müssen Sie etwas erfinderisch sein. Im ActiveX-Control greifen Sie über die private Variable FEvents (siehe obiges Event-Interface) auf das Ereignis zu. Ob die jeweilige Eigenschaft gebunden ist, erfahren Sie durch den Vergleich mit nil:

619

12.6 ActiveX-Forms

procedure TPanelX.OnTimerTick(Sender: TObject); begin FDelphiControl.caption := TimeToStr(time); if FEvents <> nil then FEvents.OnTimerRefresh end;

Damit dürften wir fast alle wesentlichen Themen rund um die ActiveX-Controls gestreift haben, wenden wir uns nun noch den ActiveX-Forms zu.

12.6 ActiveX-Forms Diese Komponenten sind nahe Verwandte der ActiveX-Controls. Das Grundkonzept geht allerdings von einer visuellen Entwicklung des ActiveX-Forms aus. Ausgangsbasis ist wieder ein In-ProcessServer, dem Sie die ActiveX-Forms hinzufügen können. HINWEIS: Bei ActiveX-Forms handelt es sich nicht um normale Nachfahren der TForm-Klasse,

sondern um Nachfahren von TActiveForm. Ein ActiveX-Form wird in anderen Entwicklungsumgebungen als ein OCX-Control eingebunden. Es kann nur innerhalb eines Formulars oder in einem Webbrowser dargestellt werden. Der Vorteil: ActiveX-Forms besitzen das gleiche COM-Interface wie ein ActiveX-Control (Eigenschaften, Methoden und Ereignisse), haben aber gleichzeitig die Möglichkeiten eines Formulars (mehrere Controls können in einem Form enthalten sein). Beispielsweise könnte ein derartiges Form ein StringGrid, eine Chart-Komponente sowie die nötigen Bedienelemente enthalten. Beim Erstellen des Controls erzeugt Delphi neben einem OCX-File auch gleich noch eine HTMLSeite, in die das ActiveX-Form eingebunden ist.

Einbinden in HTML-Seiten BEISPIEL: Eine automatisch erzeugte HTML-Datei

Delphi 7 ActiveX-Testseite

Die Delphi 7-Formulare und -Elemente sollten sich im unten stehenden Formular befinden.

---

620

Kapitel 12

OLE-Automation/ActiveX

Die Ansicht im MS Internet Explorer:

Sollten Sie beim Betrachten der Seite eine Fehlermeldung erhalten, dass möglicherweise Sicherheitsprobleme bestehen könnten, waren Sie übervorsichtig. Sie haben die höchste Sicherheitsstufe gewählt. Setzen Sie in diesem Fall unter "Optionen" den Sicherheitsgrad "Mittel":

12.7 Registrieren der ActiveX-Komponenten

621

Damit dürfte einer Anzeige im Browser nichts mehr im Weg stehen. Das Control sollten Sie bei der Verwendung innerhalb des Internets in ein CAB-File verpacken. Diese Optionen bietet Ihnen ebenfalls die Delphi-IDE (Menüpunkt Projekt|Optionen für die Distribution über das Web).

12.7 Registrieren der ActiveX-Komponenten Eigentlich ist an dieser Stelle nicht allzu viel zu sagen. Das Registrieren der ActiveX-Controls bzw. -Forms bzw. -Server läuft relativ problemlos ab. Allerdings müssen Sie die verschiedenen Typen von ActiveX-Komponenten auseinander halten. In-Process-Server (DLL oder OCX) müssen entweder mit der Delphi-Entwicklungsumgebung (Start|ActiveX-Server eintragen) oder einem eigenständigen Programm registriert werden. Dies kann zum Beispiel ein Installationsprogramm, wie Install-Shield, oder eine eigene Routine (siehe \\Delphi7\Demos\ActiveX\TregServ) übernehmen. HINWEIS: Vertreiben Sie die ActiveX-Komponente über eine Web-Page (CAB-File), wird die

Registrierung vom Internet Explorer vorgenommen. Etwas anders verhält es sich mit Out-of-Process-Servern. Diese lassen sich durch einen einfachen Aufruf registrieren. Möchte man vermeiden, dass die Anwendung geöffnet bleibt, kann der Parameter /regserver verwendet werden. Zum Entfernen der Registrierung verwenden Sie /unregserver.

Testen unter VB – ein heißer Tipp Testen Sie die ActiveX-Komponenten am besten mit Visual Basic 6. Tragen Sie dazu als Startparameter die VB-Entwicklungsumgebung ein (siehe Abbildung).

622

Kapitel 12

OLE-Automation/ActiveX

Vorteile eines Tests unter VB: ■ Sie können relativ einfach und vor allem schnell Instanzen der ActiveX-Klassen erzeugen, andererseits ist beim Einbinden von OCX-Controls nicht extra eine Schnittstellen-Unit nötig, der Test kann also sofort beginnen. ■ Läuft die Komponente mit VB, sind auch bei den Office-Produkten und anderen VBA-Anwendungen keine Probleme zu erwarten.

12.8 Zugriff auf .NET-Komponenten Die neue Microsoft .NET-Technologie ist heute in aller Munde. Zwar kann man mit Delphi 7 noch keine eigenen .NET-Komponenten entwickeln, wohl aber auf vorhandene .NET-Komponenten zugreifen1. Bevor wir aber zu den Details kommen, wollen wir einige notwendige Grundlagen erläutern.

12.8.1 Was ist eine .NET-Assembly? Das Microsoft .NET Framework und insbesondere die Common Language Runtime (CLR) stellen eine Laufzeitumgebung zur Verfügung, in welcher .NET-Komponenten, egal in welcher .NETSprache sie geschrieben wurden, problemlos zusammenarbeiten können. Ein .NET-Sprachcompiler erzeugt allerdings keinen nativen Code. Stattdessen wird der Quellcode in einen plattformneutralen Zwischencode in Microsoft Intermediate Language (MSIL oder kurz IL) compiliert, dem man es nicht mehr ansieht, von welcher .NET-Sprache (C#, VB.NET) er denn abstammt. Verschiedene miteinander verknüpfte IL-Codemodule bilden eine so genannte Assembly. Eine Assembly ist somit die Basiseinheit bei der Weitergabe von .NET-Anwendungen. Auf dem Zielrechner erledigt die CLR die folgenden Aktivitäten: ■ das Laden der Assembly, ■ das Übersetzen in nativen Maschinencode (mittels Just in Time-(JIT-)Compiler) und ■ das Ausführen des Codes. Eine Assembly kann aus einem oder mehreren Modulen bestehen und ist eine sich vollständig selbst beschreibende Einheit, sie enthält also sämtliche Informationen über die in ihr benutzten Datentypen, ihre Module und die Verknüpfungen zu anderen Assemblies.

Managed und Unmanaged Code Alle Anwendungen, die vollständig innerhalb der CLR laufen, werden als Managed Code (verwalteter Code) bezeichnet. Es gibt allerdings auch die Möglichkeit, aus der CLR heraus Unmanaged Code aufzurufen. Darunter versteht man Code, der zu Maschinencode compiliert wurde und der deshalb nicht direkt innerhalb der CLR ausgeführt werden kann.

1

Die .NET Interoperability zählt zu den wichtigsten neuen Features von Delphi 7.

12.8 Zugriff auf .NET-Komponenten

623

BEISPIEL: Durch so genanntes Platform Invoke (PInvoke) kann vom Managed Code aus auch auf die Win32-

API zugegriffen werden. Dieses Feature wurde so erweitert, dass auch COM-Objekte aufgerufen werden können. Die Fähigkeit der Zusammenarbeit zwischen Managed Code und COM-Objekten funktioniert aber auch in umgekehrter Richtung, d.h. dass .NET-Komponenten von Unmanaged Code (z.B. unsere Delphi-Applikation) benutzt werden können. Genau hier setzen die folgenden Überlegungen an.

12.8.2 Die Rolle der Typbibliotheken in .NET Für unsere Delphi-Anwendung funktionieren das Laden und der Zugriff auf .NET-Komponenten in der Regel genauso wie bei jedem anderen COM-Objekt. Sowohl COM als auch das .NET Framework besitzen einen Mechanismus, um Typ-Informationen nach außen hin als Typbibliothek sichtbar zu machen. Weil Typbibliotheken von den System-APIs geöffnet und gelesen werden, können sie z.B. auch nach Delphi importiert werden, um vom Vorteil der vTable-Bindung Gebrauch zu machen. In der .NET-Entwicklungsumgebung fungieren die Assemblies sowohl als Container für die IL als auch für die Typinformationen. Das .NET Framework enthält spezielle Klassen, die die in der Assembly enthaltenen Typen erkennen können. Wenn Sie vom Unmanaged Code aus auf eine .NET-Komponente zugreifen, benutzen Sie allerdings einen Proxy (COM Callable Wrapper bzw. CCW) und nicht die .NET-Komponente selbst. Dieser CCW-Mechanismus reicht in Verbindung mit dem selbst beschreibenden Assembly-Prinzip aus, um eine .NET-Komponente über Late Binding zu benutzen. Weil der Zugriff auf eine .NET-Komponente per Late Binding möglich ist, braucht nicht unbedingt eine Typbibliothek erzeugt zu werden. Lediglich die Assembly muss registriert sein. Tatsächlich sind Unmanaged Clients standardmäßig auf Late Binding beschränkt. In Abhängigkeit davon, wie die .NET-Komponente entworfen und aufgebaut wurde, werden Sie deshalb bei Inspektion der Typbibliothek oft nur ein "leeres" Klassen-Interface vorfinden. Solch eine Typbibliothek ist nutzlos, um Clients über vTable Binding anzusprechen, es geht nur Late Binding über das IDispatchInterface. BEISPIEL: Es wird das Late Binding zur ArrayList-Collection, die in der .NET-Assembly mscorlib.dll enthal-

ten ist, demonstriert. Die mscorlib-Assembly muss vor ihrer Benutzung registriert werden. Führen Sie dazu im .NET Framework-Verzeichnis folgendes Kommando aus: regasm mscorlib.dll

HINWEIS: Das komplette Beispiel finden Sie im Abschnitt 12.10.3!

Bemerkungen ■ Sie können das regasm-Tool falls erforderlich erneut dazu benutzen, wenn Sie die mscorlibmit der /u regasm-Option wieder aus der Registry entfernen wollen.

624

Kapitel 12

OLE-Automation/ActiveX

■ Benutzen Sie beim Registrieren nicht die /tlb-Option, denn das .NET Framework verfügt bereits über eine Typbibliothek für die mscorlib-Assembly, Sie brauchen deshalb keine neue zu generieren!

12.8.3 Zugriff auf selbst entwickelte .NET-Komponenten Unter COM ist die einzige Option die Schnittstellenvererbung. Im .NET Framework bleibt es hingegen Entscheidung des Entwicklers, ob er die Schnittstellen- oder die Implementierungsvererbung wählt. Dabei ist vor allem eines zu beachten: HINWEIS: Wenn die Entwickler nachträglich Methoden oder Eigenschaften zur Komponente

hinzufügen bzw. ändern, kann jeder COM-Client, der vom Layout des Interfaces abhängig ist, zum bösen Absturz gebracht werden! Sie als .NET-Komponentenentwickler dürfen selbst die Entscheidung treffen, ob Sie die Typinformationen trotz bekannter Risiken in eine Typbibliothek exportieren wollen. Realisiert werden kann dies durch Spezifizieren des ClassInterfaceAttribute. Dieses ist im System.Reflection.InteropServices-Namespace enthalten und kann die folgenden Werte der ClassInterfaceType-Enumeration annehmen: AutoDispatch (default), AutoDual und None. Was bedeuten diese drei Einstellungen? ■ Der AutoDispatch-Wert veranlasst, dass ein leeres Klassen-Interface generiert wird. Die Clients müssen demzufolge gezwungenermaßen über Late Binding zugreifen, was zu den bekannten Nachteilen (Performance!) führen kann. ■ Der AutoDual-Wert veranlasst das Abspeichern der Typinformation innerhalb der Klasse und auch der daraus abgeleiteten Klassen. Dieser übliche Weg wird immer dann gut funktionieren, wenn die .NET-Komponenten unter strenger Aufsicht weiterentwickelt werden. Anderenfalls kann es auch zu den oben erwähnten schlimmen Versionskonflikten führen, wenn disziplinlos an der Schnittstelle herumgedoktert wird. ■ Der Wert None unterdrückt das Generieren eines eigenen Klassen-Interface. Nur die Methoden, die in den abgeleiteten Schnittstellen implementiert wurden, können dann angesprochen werden. Für .NET-Komponenten, die von Unmanaged COM-Clients benutzt werden sollen, ist die reine Schnittstellenvererbung die bevorzugte Methode der Zusammenarbeit zwischen Managed und Unmanaged Code, denn auf diese Weise bleibt der COM-Client weitaus robuster gegenüber nachträglichen Änderungen der .NET- Komponente1.

Das AssemblyKeyFile-Attribut Dieses Attribut ist immer dann erforderlich, wenn die Komponente im Global Assembly Cache (GAC) verwaltet werden soll. Bei der Entwicklung der Komponente in einer .NET-Programmiersprache ist deshalb ein entsprechender Verweis in den Quellcode einzuarbeiten.

1

Das entspricht dem "heiligen" COM-Prinzip der Unantastbarkeit der Schnittstellen!

12.8 Zugriff auf .NET-Komponenten

625

BEISPIEL: Eine in C# entwickelte Komponente erhält des AssemblyKeyFile-Attribut. using using using using

System; System.Reflection; System.Runtime.InteropServices; System.Windows.Forms;

[assembly:AssemblyKeyFile("KeyFile.snk")] namespace NET_Test { ...

Wenn die Komponente im GAC eingerichtet werden soll, müssen wir als Erstes ein KeyFile (Schlüsseldatei) generieren, wozu wir das Strong Name-Tool des .NET Framework-SDK benutzen: sn -k KeyFile.snk

Das Kommando ist im gleichen Verzeichnis auszuführen, in dem sich auch der C#-Sourcecode befindet. HINWEIS: Falls sich die .NET-Assembly im selben Verzeichnis wie der Delphi-Client befindet,

kann auf das AssemblyKeyFile-Attribut auch verzichtet werden, da ein Strong Key nicht erforderlich ist!

Compilieren Als Nächstes wird der Code mit einem der .NET-Compiler übersetzt. BEISPIEL: Wir nehmen an, dass sich der C#-Quellcode in der Datei NETClasses.cs befindet. An der Komman-

dozeile wird der C#-Compiler dann wie folgt aufgerufen: csc /t:library Class1.cs

Als Ergebnis liegt die Assembly NETClasses.dll vor.

Registrieren Jede .NET-Assembly muss registriert werden, wozu das regasm-Tool zur Verfügung steht. Das Tool ähnelt in seinem Konzept tregsvr; es erzeugt Einträge in der Windows-Registry, so dass die Komponente von Unmanaged Clients aufgerufen werden kann. BEISPIEL: Die im Vorgängerbeispiel erzeugte .NET-Assembly wird (an der Kommandozeile) registriert. regasm /tlb NETClasses.dll

Die /tlb-Option bewirkt zwei Dinge: ■ Die Registry-Einträge für die Assembly werden erzeugt. ■ Alle Datentypen der Assembly werden in eine Typbibliothek exportiert, die ebenfalls registriert wird.

626

Kapitel 12

OLE-Automation/ActiveX

Installieren im Global Assembly Cache (GAC) Schließlich wird unter Benutzung des gacutil-Befehls die .NET-Komponente im GAC eingerichtet. BEISPIEL: Die -i Option zeigt an, dass die Assembly im GAC installiert wird. gacutil -i NETClasses.dll

HINWEIS: Der gacutil-Befehl muss jedes Mal ausgeführt werden, nachdem Sie eine neue Versi-

on der .NET-Komponente erzeugt haben. Wenn Sie später die Komponente wieder vom GAC entfernen wollen, müssen Sie den gacutilBefehl erneut bemühen, allerdings mit der -u-Option, lassen Sie dazu die .dll-Extension am Assembly-Namen weg! BEISPIEL: Deinstallieren gacutil -u NETClasses

Aufruf in Delphi Die Komponente wird von Delphi so wie jede andere COM-Komponente benutzt. BEISPIEL: Die in der Assembly NETClasses.dll enthaltene Komponente TmyKreis wird als Objekt myKreis1

instanziiert. uses NETClasses_TLB; ... var myKreis1: TmyKreis; myKreis1.Create(self); umf := myKreis1.kreisUmfang(rad); fl := myKreis1.kreisFlaeche(rad); myKreis1.Free;

// Typbibliothek referenzieren (vTable-Bindung!)

// Methodenaufruf // dto.

HINWEIS: Den kompletten Quellcode finden Sie im Praxisbeispiel 12.10.4. Dort lernen Sie

Schritt für Schritt, wie eine in C# geschriebene .NET-Komponente von Delphi importiert wird.

12.9 Lernbeispiele für Einsteiger 12.9.1 OLE-Automation mit Excel "In Excel ist doch bereits VBA integriert", werden Sie einwenden, "... wozu dann noch ein DelphiProgramm?" Das ist so weit richtig, aber die Programmierung von Oberflächen lässt sich in Delphi nach wie vor bedeutend sinnvoller realisieren. Ein weiteres wichtiges Anwendungsgebiet wäre das

12.9 Lernbeispiele für Einsteiger

627

Erstellen bzw. Bearbeiten von Datenbanken (SQL-Abfragen!) in Delphi mit nachfolgender statistischer Auswertung in Excel. Unser Beispielprogramm demonstriert den Zugriff auf ein Excel-Sheet sowie die Arbeit mit der OLEContainer-Komponente.

Oberfläche Für das Programm benötigen Sie neben diversen Buttons ein PageControl, ein StringGrid- und eine OLEContainer-Komponente. Das einzulagernde Objekt wird erst zur Laufzeit erzeugt, brechen Sie also den Dialog ab. Den weiteren Aufbau entnehmen Sie der folgenden Abbildung.

Das Datei-Menü enthält nur einen einzigen Menüpunkt (Beenden), da es lediglich dazu dient, bei einer Vor-Ort-Aktivierung des OLE-Objekts dessen Menüleiste aufzunehmen. Das StringGrid befindet sich auf der ersten, die OLEContainer-Komponente auf der zweiten Seite des PageControl.

Quelltext Hinter dem Button "Diagramm anzeigen" verbirgt sich folgender Code: procedure TForm1.BitBtn1Click(Sender: TObject); var zeile,spalte: Integer; var app: Variant; begin

Der Versuch, Excel als OLE-Automationsserver zu starten: try Excel := CreateOleObject('Excel.Application'); except

628

Kapitel 12

OLE-Automation/ActiveX

ShowMessage('Excel konnte nicht gestartet werden!'); Exit end;

Excel ist bei Verwendung als OLE-Server im Normalfall nicht sichtbar. Für den Test ist es im Allgemeinen sinnvoll, die Excel-Oberfläche anzuzeigen, um die Ergebnisse der Methodenaufrufe zu verfolgen. Die folgende Anweisung blendet die Oberfläche ein. Excel.Visible := True;

// für die Testphase sinnvoll

Einfügen einer Arbeitsmappe: Excel.Workbooks.Add;

Übernahme der Werte aus dem StringGrid in die einzelnen Zellen des Excel-Sheets: For zeile := 1 to 7 do for spalte := 1 to 3 do Excel.Cells[zeile, spalte].Value := stringgrid1.cells[spalte-1,zeile-1];

HINWEIS: Beachten Sie, dass die erste Zeile/Spalte im StringGrid den Index (0,0) hat, ein

Excel-Sheet beginnt bei (1,1). Ein neues Diagramm erstellen: Excel.Charts.Add; Excel.Charts[1].Activate;

Für die Parametrierung des Diagramms "missbrauchen" wir einfach den Diagramm-Assistenten: Excel.Charts[1].Chartwizard (excel.Worksheets['Tabelle1'].Range['A1:C6'], -4100, 4, 2, 1, 0, 2, 'Umsatz / Ertragsentwicklung 1999-2010', 'Jahr', 'Euro', '');

HINWEIS: Beachten Sie die eckigen Klammern! In VB- bzw. VBA-Beispielen finden Sie statt-

dessen die runden Klammern, die in Visual Βasic für Arrays verwendet werden.

Im nächsten Schritt kopieren wir das Ergebnis unserer Bemühungen in die Zwischenablage: Excel.Charts[1].ChartArea.Copy;

Ab sofort sind wir wieder mit Delphi-Objekten beschäftigt. Alles, was wir jetzt noch machen müssen, ist das Einfügen des OLE-Objekts aus der Zwischenablage in die OLEContainer-Komponente: OleContainer1.Paste;

Vergessen Sie nicht, den Speicher wieder aufzuräumen, Excel befindet sich zu diesem Zeitpunkt immer noch im Speicher. Wollen Sie den folgenden Dialog verhindern,

12.9 Lernbeispiele für Einsteiger

629

müssen Sie die Gespeichert-Eigenschaft der aktuellen Arbeitsmappe auf True setzen. Excel.ActiveWorkBook.Saved := True;

Excel beenden: Excel.Workbooks.Close;

Die Syntax für obige Aufrufe lässt sich einfach durch Aufzeichnen eines Excel-Makros bestimmen (Extras/Makro aufzeichnen). BEISPIEL: Für ein aufgezeichnetes Makro: Sub Makro1() Charts.Add ActiveChart.ChartType = xl3DColumnStacked ActiveChart.SetSourceData Source:=Sheets("Tabelle1").Range("A1:B8"), PlotBy _ :=xlColumns ActiveChart.Location Where:=xlLocationAsObject, Name:="Tabelle1" With ActiveChart .HasTitle = False .Axes(xlCategory).HasTitle = False .Axes(xlSeries).HasTitle = False .Axes(xlValue).HasTitle = False End With End Sub

Aus obiger Darstellung ergibt sich ein Problem: Wo bekommen Sie die Werte der Konstanten (z.B. xl3DSäulen) her? Für die Lösung bieten sich zwei Varianten an: 1. Öffnen Sie in Excel das Testfenster (Ansicht|Testfenster) und geben Sie den gesuchten Begriff

ein: (Die zurückgegebenen Werte können Sie in Delphi eintragen.)

630

Kapitel 12

OLE-Automation/ActiveX

2. Sie importieren die TypeLibrary von Excel (Projekt|Typbibliothek importieren) und nutzen die

dort aufgeführten Konstanten. Als letzten Schritt wollen wir das Diagramm ausdrucken. Gleichzeitig zeigt das Listing, wie Sie ein bestehendes OLE-Objekt als OLE-Automation-Server nutzen können. procedure TForm1.BitBtn2Click(Sender: TObject); var Excel: variant; begin OleContainer1.run; OleContainer1.DoVerb(ovOpen); Excel := OleContainer1.OleObject; Excel.Charts[1].PrintOut; Excel.Close; OleContainer1.Close end;

Hätten wir das Diagramm gleich beim Erstellen ausgedruckt, würde folgende Anweisung zum Drucken genügen: Excel.Charts[1].PrintOut;

So müssen wir erst umständlich den OLEContainer initialisieren, damit uns die Eigenschaft OLEObject ein gültiges Objekt zurückgibt.

Test Nach Programmstart sollten Sie zunächst die Dateneingabe vornehmen, d.h., einige Wertepaare in das Datengitter eingeben. Klicken Sie dann auf die "Diagramm"-Schaltfläche oder auf das "Diagramm"-Register.

12.9 Lernbeispiele für Einsteiger

631

Vor dem Drucken können Sie das Diagramm an Ihre Bedürfnisse anpassen. Klicken Sie dazu mit der rechten Maustaste auf den OLEContainer. Wählen Sie das Menü "Bearbeiten", und Sie können das Diagramm oder die Werte bearbeiten.

12.9.2 Word über OLE-Automation steuern Eines der "dankbarsten Opfer" für OLE-Automation ist nach wie vor Word für Windows. Unser kleines Beispielprogramm zeigt Ihnen, wie Sie aus einem Delphi-Programm heraus ein neues Word-Dokument erstellen, Kopf- und Fußzeilen einfügen und Daten übertragen (das Beispiel lässt sich problemlos so anpassen, dass die Daten statt aus den Eingabefeldern gleich aus einer Datenbank kommen).

Oberfläche Den Grundaufbau können Sie der folgenden Abbildung entnehmen:

In der Combobox finden sich drei Einträge: "1. Mahnung" ... "3. Mahnung".

Quelltext Grundlage für die Verbindung zu Word ist eine allgemeine Variable vom Typ Variant: uses comobj; var word : variant;

Der Ablauf ist mit wenigen Worten erklärt: Nach Initialisierung der Variablen mit CreateOLEObject können Sie alle Methoden des Word.Application-Objekts verwenden. Bevor Sie lange in der Online-Hilfe von Word herumstochern, ist es sinnvoller, ein Word-Makro aufzuzeichnen und dieses entsprechend zu modifizieren. Zum einen haben Sie gleich die korrekte Syntax, zum anderen sparen Sie sich jede Menge Arbeit. try word := CreateOleObject('Word.Application');

632

Kapitel 12

OLE-Automation/ActiveX

Bei Problemen kneifen wir an dieser Stelle: except ShowMessage('WORD konnte nicht gestartet werden!'); Exit end;

Word sichtbar machen (standardmäßig wird Word nicht angezeigt): word.Visible := True;

Ein neues Dokument erzeugen: word.Documents.Add; If word.ActiveWindow.View.SplitSpecial <> 0 Then word.ActiveWindow.Panes[2].Close; If (word.ActiveWindow.ActivePane.View.Type = 1) Or (word.ActiveWindow.ActivePane.View.Type = 2) Or (word.ActiveWindow.ActivePane.View.Type = 5) Then word.ActiveWindow.ActivePane.View.Type := 3;

HINWEIS: Wundern Sie sich bitte nicht über die verwendeten numerischen Werte. Wir haben

einfach die Konstanten durch die entsprechenden Werte ersetzt (VBA-Editor-Direktfenster). Kopfzeile erzeugen: word.ActiveWindow.ActivePane.View.SeekView := 9; word.Selection.Font.Name := 'Times New Roman'; word.Selection.Font.Size := 12; word.Selection.Font.Bold := True; word.Selection.ParagraphFormat.Alignment := 1; word.Selection.TypeText(Text:='Kohlenhandel Brikett-GmbH & Co.-KG. - Holzweg 16 - 54633 Steinhausen');

Fußzeile erzeugen: If word.Selection.HeaderFooter.IsHeader = True Then word.ActiveWindow.ActivePane.View.SeekView := 10 Else word.ActiveWindow.ActivePane.View.SeekView := 9; word.Selection.TypeText(Text:= 'Bankverbindung: Stadtsparkasse Steinhausen BLZ 123456789 KtoNr. 782972393243');

In den Textteil wechseln und Adresse eintragen: word.ActiveWindow.ActivePane.View.SeekView := 0; word.Selection.TypeText(Text:=Edit2.Text + ' ' + Edit1.Text); word.Selection.TypeParagraph; word.Selection.TypeText(Text:=Edit3.Text); word.Selection.TypeParagraph; word.Selection.TypeParagraph; word.Selection.Font.Name := 'Times New Roman'; word.Selection.font.Size := 12;

12.9 Lernbeispiele für Einsteiger

633

word.Selection.font.Bold := True; word.Selection.TypeText(Text:=Edit4.Text + ' ' + Edit5.Text); word.Selection.TypeParagraph; word.Selection.TypeParagraph; word.Selection.TypeParagraph; word.Selection.TypeParagraph; word.Selection.Font.Name := 'Arial'; word.Selection.Font.Size := 14; word.Selection.Font.Bold := True; word.Selection.TypeText(Text:=Combobox1.Text); word.Selection.TypeParagraph; word.Selection.TypeParagraph; word.Selection.TypeParagraph; word.Selection.Font.Name := 'Times New Roman'; word.Selection.Font.Size := 12; word.Selection.Font.Bold := True; If radiogroup1.itemindex= 0 Then word.Selection.TypeText(Text:='Sehr geehrter Herr ' + Edit1.Text) Else word.Selection.TypeText(Text:='Sehr geehrte Frau ' + Edit1.Text); end;

Test Starten Sie das Programm, füllen Sie die Maske aus und übertragen Sie die Daten in ein WordDokument!

634

Kapitel 12

OLE-Automation/ActiveX

12.10 Praxisbeispiele für Fortgeschrittene 12.10.1 OLE-Server registrieren Natürlich könnten Sie jetzt den Einwand bringen, der OLE-Server ließe sich doch viel einfacher über die Delphi-IDE ("Start|Active-X-Server eintragen...") oder über ein Setup-Programm installieren. Aber wozu mit Kanonen auf Spatzen schießen, wenn Sie diese Aufgabe Ihrem Programm selbst übertragen können? Kein großes Installationsprogramm, lediglich ein einziger Funktionsaufruf ist nötig. Hintergrund der Registrierung von In-Process-OLE-Servern sind die folgenden vier Funktionen, die in jeder OLE-DLL enthalten sind: ■ DllGetClassObject ■ DllCanUnloadNow ■ DllRegisterServer ■ DllUnregisterServer Wie sicher unschwer zu erkennen ist, dürfte die Funktion DllRegisterServer für unsere Aufgaben geeignet sein. Einziges Problem: Wir müssen die DLL dynamisch laden, da der Standort erst zur Laufzeit feststeht.

Oberfläche Ein Formular, darauf eine OpenDialog- und eine Edit-Komponente und ein Button – das sollte zum Testen genügen.

Quelltext Erzeugen Sie zunächst folgende Typdeklaration: type TDllRegisterServer = function: HResult;

Zum besseren Handling verpacken wir alles in eine Funktion, die im Erfolgsfall True zurückliefert. Übergeben müssen Sie lediglich den Namen (inkl. des kompletten Pfades) der DLL. function RegisterDLL(filename:string): Boolean; var handle: HInst; func : TDllRegisterServer; begin result := False; handle := LoadLibrary(PChar(fileName)); if handle <> 0 then begin try @func := GetProcAddress(handle,'DllRegisterServer'); func except Exit

12.10 Praxisbeispiele für Fortgeschrittene

635

end; FreeLibrary(handle); result := True end end;

Der Button "Registrieren": procedure TForm1.Button1Click(Sender: TObject); begin if RegisterDLL(Edit1.Text) then ShowMessage('DLL erfolgreich registriert!') else ShowMessage('Registrierung fehlgeschlagen!') end;

Der Dateidialog erlöst Sie von der Qual der Eingabe bandwurmförmiger Verzeichnisnamen und erscheint gleich zu Beginn: procedure TForm1.FormCreate(Sender: TObject); begin if OpenDialog1.Execute then Edit1.Text := OpenDialog1.FileName end;

Test Suchen Sie sich irgendeine ActiveX-DLL und versuchen Sie diese zu installieren.

Es macht nichts, wenn Sie die gleiche DLL mehrfach hintereinander registrieren.

12.10.2 Programmieren einer ActiveX-DLL für Visual Basic Im Unterschied zur klassischen DLL, die reine Funktionen/Prozeduren exportiert, ist eine ActiveXDLL eine COM-Komponente, sie exportiert also komplette Objekte mit deren Eigenschaften, Methoden und Ereignissen. Gegenüber einer ActiveX-EXE hat eine ActiveX-DLL keinen eigenen Prozess (ist also keine eigenständige Anwendung), sondern sie läuft (In-Process-Server) im Prozessraum des Clients. Der durch die direkte vTable-Bindung erreichte Performance-Gewinn dürfte

636

Kapitel 12

OLE-Automation/ActiveX

Grund genug sein, um – wo immer dies möglich ist – der ActiveX-DLL den Vorzug vor der -EXE zu geben. In dieser Demo wollen wir anhand einer ActiveX-DLL zeigen, wie wir unsere in Delphi programmierten Routinen für eigene und andere Programmentwicklungen (z.B. mit Visual Basic) verfügbar machen können. Unsere COM-Komponente soll eine ganz simple Aufgabe lösen, nämlich die Brutto- bzw. Nettowertberechnung. Dazu sind die folgenden Klassenmitglieder erforderlich: ■ mwst

Eigenschaft

■ brutto (nett)

Methode: brutto = netto * (1 + mwst)

■ netto( brutt)

Methode: netto = brutto / (1 + mwst)

Wir haben bewusst diese minimale Funktionalität gewählt, um nicht vom eigentlichen Problem, dem rein handwerklichen Erstellen einer ActiveX-DLL, abzulenken.

ActiveX-Bibliothek-Projekt erstellen Um COM-Komponenten innerhalb einer ActiveX-DLL zu erstellen, muss zunächst ein Projekt für eine ActiveX-Bibliothek geöffnet werden. Wählen Sie deshalb Datei|Neu|Weitere... und anschließend auf der "ActiveX"-Seite der Objektgalerie das Symbol "ActiveX-Bibliothek".

1.

2.

Es öffnet sich ein Codefenster mit dem Rahmencode eines ActiveX-DLL-Projekts: library Project2; uses ComServ; exports DllGetClassObject, DllCanUnloadNow, DllRegisterServer,

12.10 Praxisbeispiele für Fortgeschrittene

637

DllUnregisterServer; {$R *.RES} begin end.

Bereits hier erkennen Sie den Unterschied zur "normalen" DLL: Es wird als Grundfunktionalität bereits eine ganze Reihe von Methoden aus der Unit ComServ exportiert.

COM-Komponenten hinzufügen Zu unserer ActiveX-Bibliothek können nun eine oder mehrere COM-Komponenten hinzugefügt werden. Öffnen Sie wieder die "ActiveX"-Seite der Objektgalerie und wählen Sie diesmal "COMObjekt" (siehe obige Abbildung). Ungefragt drängt uns nun der COM-Objekt-Experte seine Dienste auf. Wie wir später sehen werden, erstellt er für uns eine Klassen-Unit und eine Typbibliothek (unter COM sind Schnittstelle und Implementierung immer streng voneinander getrennt).

Den Namen der Klasse lassen wir (mit Rücksicht auf die VB-Konvention) mit C beginnen (CBruttoNetto). Die Einstellung der Instanziierung ist für einen In-Process-Server ohne Bedeutung. Auf die Option "Typbibliothek einschließen" wollen wir nicht verzichten, denn dadurch können wir die Registrierung auf einem Fremdrechner vereinfachen, da die Typbibliothek nicht separat mitgegeben werden muss. "Schnittstelle als OLE-Automation" ist nicht erforderlich, denn wir wollen ein "echtes" COMObjekt.

638

Kapitel 12

OLE-Automation/ActiveX

Typbibliothekseditor Nach "OK" öffnet sich der Typbibliothekseditor. Dieses Tool könnte man auch als "Schnittstelleneditor" bezeichnen, besteht seine Aufgabe doch in der Erstellung einer COM-Schnittstelle (.TLBDatei) sowie in der Übertragung der Methodenrümpfe nach der Klassen-Unit Unit1. HINWEIS: Den Typbibliothekseditor bringen Sie auch später jederzeit über Ansicht|Typbiblio-

thek wieder zur Anzeige. Wir vergeben für die Bibliothek den vielsagenden Namen Allerlei sowie den Hilfestring Allerlei Bibliothek. Letzterer ist keinesfalls unwichtig, da Sie die Bibliothek nach ihrer Registrierung nicht unter ihrem Namen, sondern unter ihrem Hilfestring im Menü Projekt|Verweise... von Visual Basic wiederfinden werden. GUID und Versionsnummer werden automatisch generiert!

Eigenschaften hinzufügen Markieren Sie dann die Schnittstelle ICBruttoNetto im linken Fenster. Wie Sie sehen, hat sie den gleichen Namen wie die Klasse, nur mit vorangestelltem I. Jetzt können Sie mit der entsprechenden Schaltfläche (in der Werkzeugleiste) Eigenschaften hinzufügen: In der Registerkarte "Attribute" geben wir den Namen der Eigenschaft an (mwst). Beim Hinzufügen von Eigenschaften haben Sie die Auswahl zwischen verschiedenen Lese- und Schreibrechten:

12.10 Praxisbeispiele für Fortgeschrittene

639

Wir wählen den ersten Eintrag, wonach im linken Fenster die beiden Methoden für den Lese- und Schreibzugriff erscheinen. Nun müssen wir auf der "Parameter"-Seite den Rückgabetyp der Zugriffsmethode sowie etwaige Parameter eintragen. Die zahlreichen angebotenen Datentypen können für Verwirrung sorgen. Wer damit nicht zurechtkommt, sollte Tools|Umgebungsoptionen und dort Seite "Typbibliothek" wählen und als Schnittstellensprache Pascal anstatt IDL (Interface Definition Language) wählen:

Stellen Sie in der "Rückgabetyp"- bzw. "Typ"-Klappbox den entsprechenden IDL- bzw. PascalDatentyp ein. Dieser wird dann automatisch (innerhalb Unit1) in den entsprechenden Delphi-Typ umgewandelt. HINWEIS: Die "Typ"-Einstellung auf der "Attribute"-Seite entspricht dem "Rückgabetyp" auf

der Parameter"-Seite (wird automatisch angepasst). Beim Lesezugriff auf mwst brauchen in unserem Beispiel keine Parameter übergeben zu werden, als Rückgabetyp genügt in VB der Single-Datentyp. Entsprechend obiger Tabelle wählen Sie deshalb float:

640

Kapitel 12

OLE-Automation/ActiveX

Beim Schreibzugriff ist es genau umgekehrt, hier wird ein float-Parameter übergeben, ein Rückgabewert existiert nicht (void)1:

Methoden hinzufügen Mit der entsprechenden Schaltfläche werden die Methoden brutto und netto zur Schnittstelle hinzugefügt. Bezüglich der Kompatibilität der Datentypen wird auf obige Tabelle verwiesen. HINWEIS: Lassen Sie sich bei Währungen nicht vom angebotenen CURRENCY-Datentyp ver-

locken, sondern wählen Sie double! Falls Sie diesen Ratschlag ignorieren, funktioniert die ActiveX-DLL zwar zusammen mit einem Delphi-Programm, aber nicht unter Visual Basic!

Implementieren der Schnittstellenmitglieder Da wir mit Hilfe des Experten lediglich das Interface unserer COM-Komponente (Allerlei_TLP) sowie das Grundgerüst von Unit1 erstellt haben, müssen wir die Implementierung der Eigenschaften und Methoden (innerhalb Unit1) jetzt "zu Fuß" nachholen. Bevor es aber so weit ist, sollten wir in der Werkzeugleiste auf die Schaltfläche "Implementierung aktualisieren" klicken. Dabei werden die Definitionen der Prozeduren/Funktionen im Interfacebzw. Implementation-Abschnitt von Unit1 an die Schnittstellendefinitionen eingefügt bzw. angepasst. Öffnen Sie dann Unit1 und ergänzen Sie die im Folgenden unterstrichenen Anweisungen. interface uses Windows, ActiveX, Classes, ComObj, Allerlei_TLB, StdVcl; type TCBruttoNetto = class(TTypedComObject, ICBruttoNetto) mw: Single; protected function Get_mwst: Single; stdcall; procedure Set_mwst(Param1: Single); stdcall; function brutto(nett: Double): Double; stdcall; function netto(brutt: Double): Double; stdcall; end;

1

In C/C++ wird bekanntlich nicht zwischen Funktionen und Prozeduren unterschieden. Letztere sind ebenfalls Funktionen, allerdings mit dem Rückgabetyp void.

12.10 Praxisbeispiele für Fortgeschrittene

641

implementation uses ComServ; function TCBruttoNetto.Get_mwst: Single; begin Result := mw end; procedure TCBruttoNetto.Set_mwst(Param1: Single); begin mw := Param1 end; function TCBruttoNetto.brutto(nett: Double): Double; begin Result := nett * (1 + mw) end; function TCBruttoNetto.netto(brutt: Double): Double; begin Result := brutt / (1 + mw) end; initialization TTypedComObjectFactory.Create(ComServer, TCBruttoNetto, Class_CBruttoNetto, ciMultiInstance, tmApartment); end.

Das Verständnis dürfte Ihnen dann leicht fallen, wenn Sie bereits mit Klassen-Units vertraut sind.

Bemerkungen ■ Sie dürfen im Quellcode keine Änderungen per Hand vornehmen, die neuen Schnittstellen hinzufügen bzw. deren Definition verletzen! ■ Entfernen Sie eine Schnittstelle, so werden die entsprechenden Methoden in Unit1 leider nicht mit entfernt. Sie müssen Deklaration und Implementation per Hand löschen.

Compilieren, Registrieren Das Compilieren der ActiveX-Bibliothek geschieht nicht wie gewohnt mit F9, sondern mit ActiveX-Server eintragen über das Start-Menü. Auch ein Klick auf den Button "Typbibliothek registrieren" in der Werkzeugleiste des Typbibliothek-Editors führt zum gleichen Ergebnis:

642

Kapitel 12

OLE-Automation/ActiveX

Im Ergebnis finden Sie im aktuellen Verzeichnis die Dateien Project1.dll und Project1_TLB.dcu vor1. Außerdem sind etliche neue Einträge in der Windows-Registry hinzugekommen. Die registrierte COM-Komponente kann nun in andere Applikationen eingebunden werden.

Testen unter Delphi Bevor wir unsere ActiveX-DLL unter VB verwenden, empfiehlt sich ein Funktionstest unter Delphi. Öffnen Sie eine neue Delphi-Anwendung.

Oberfläche Sie brauchen zwei Editierfelder und eine RadioGroup, die mit dem Stringlisteneditor sehr schnell erstellt ist. Setzen Sie die ItemIndex-Eigenschaft auf 0, um den ersten Eintrag (16 % MWSt) zu aktivieren.

Quellcode Wir beschränken uns auf den implementation-Abschnitt: implementation

Zuerst ist die Typbibliothek einzubinden: uses Allerlei_TLB;

Die Objektvariable ... var obj: CBruttoNetto;

... und weitere Variablen: brutto, netto: Single; code: Integer;

Beim Laden des Formulars wird das Objekt instantiiert (das vorangestellte Co verweist auf die CoKlasse der Bibliothek), und die mwst-Eigenschaft sowie die anderen Variablen werden initialisiert: procedure TForm1.FormCreate(Sender: TObject); begin 1

Falls das Projekt noch nicht abgespeichert wurde, finden sich die Dateien im \Delphi\Bin-Verzeichnis.

12.10 Praxisbeispiele für Fortgeschrittene

obj := CoCBruttoNetto.Create; obj.Set_mwst(0.16); brutto := 11.6; netto := 10 end;

Da im obigen Code die direkte Eigenschaftszuweisung obj.mwst := 0.16;

nicht funktioniert, wird die entsprechende Zugriffsmethode obj.Set_mwst(0.16);

aufgerufen. Das macht aber nichts, da unter VB dieser "Schönheitsfehler" vergessen ist. Die MWSt wird geändert: procedure TForm1.RadioGroup1Click(Sender: TObject); begin case RadioGroup1.ItemIndex of 0: obj.Set_mwst(0.16); 1: obj.Set_mwst(0.07) end;

Der Bruttowert ist anzupassen: brutto := obj.brutto(netto); Edit1.Text := Format('%m',[brutto]) end;

Der Bruttowert wurde geändert: procedure TForm1.Edit1KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState); begin Val(Edit1.Text, brutto, code);

Netto ist neu anzuzeigen: netto := obj.netto(brutto); Edit2.Text := Format('%m',[netto]) end;

Der Nettowert wurde geändert: procedure TForm1.Edit2KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState); begin Val(Edit2.Text, netto, code);

Brutto neu anzeigen: brutto := obj.brutto(netto); Edit1.Text := Format('%m',[brutto]) end;

643

644

Kapitel 12

OLE-Automation/ActiveX

Falls beim Compilieren ein Fehler auftritt, ist mit Projekt|Typbibliothek importieren... zu überprüfen, ob auch die aktuelle Version der ActiveX-DLL referenziert wurde (evtl. die Allerlei_TLB.dcu ins Projektverzeichnis kopieren). HINWEIS: Die Funktionsfähigkeit unter Delphi ist noch lange kein Garant für das Funktionieren

der Komponente unter Visual Basic. Dies trifft insbesondere dann zu, wenn Sie sich nicht exakt an die Zuordnung der Datentypen gehalten haben.

Einbinden in Visual Basic 6 Erleichterung beim Visual Basic-Programmierer: Endlich wieder raus aus Delphi und zurück in die heimischen VB-Gefilde!

Oberfläche Diese entspricht der obigen Oberfläche für den Delphi-Testclient. Sowohl die beiden Textboxen als auch die zwei Optionsfelder werden als Steuerelementefeld realisiert. Setzen Sie die Value-Eigenschaft von Option1(0) auf True.

Quellcode Öffnen Sie ein neues Projekt und aktivieren Sie über das Menü Projekt|Verweise... die Allerlei Bibliothek (Sie erinnern sich, das war der Hilfestring, den wir im Typbibliothekseditor zugewiesen haben). Falls die Bibliothek nicht auffindbar ist, so wurde sie wahrscheinlich nicht richtig registriert. Dann müssen Sie noch einmal nach Delphi gehen und dort die Registrierung im Typbibliothekseditor nachholen (bzw. mit Regsvr32.exe per Hand erledigen).

Mitunter sammeln sich mehrere gleich lautende Einträge untereinander an, was auf frühere Versionen hindeutet, die teilweise nicht ordnungsgemäß deinstalliert wurden. HINWEIS: Achten Sie darauf, dass Sie immer die aktuelle Version der Bibliothek referenzieren!

Überprüfen Sie dazu auch die Pfadangabe im unteren Teil des Dialogfensters. Der nachfolgende Quellcode wurde weitestgehend analog zum obigen Delphi-Testbeispiel geschrieben, so dass es für den Umsteiger gute Vergleichsmöglichkeiten gibt. Option Explicit

12.10 Praxisbeispiele für Fortgeschrittene

645

Beim Referenzieren der Objektvariablen stellen Sie den Bibliotheksbezeichner Allerlei vor den Klassenbezeichner CBruttoNetto, wie er Ihnen durch die Intellisense angeboten wird. Private obj As Allerlei.CBruttoNetto

Da es sich um ein reines COM-Objekt handelt, wäre auch alternativ die Referenzierung der Schnittstelle möglich: Private obj as Allerlei.ICBruttoNetto

Die Schnittstelle ICBruttoNetto (siehe Delphi-Typbibliothekseditor) wird allerdings nicht durch die VB-Intellisense angeboten. Sonstige Deklarationen: Private brutto As Currency, netto As Currency

Instanziieren des Objekts und Initialisieren der Eigenschaft beim Laden des Formulars: Private Sub Form_Load() Set obj = New Allerlei.CBruttoNetto obj.mwst = 0.16 netto = 10 brutto = 11.6 End Sub

Mehrwertsteuer ändern: Private Sub Option1_Click(Index As Integer) Select Case Index Case 0: obj.mwst = 0.16 Case 1: obj.mwst = 0.07 End Select brutto = obj.brutto(netto) Text1(0).Text = Format$(brutto, "Currency") End Sub

Brutto oder Netto ändern: Private Sub Text1_KeyUp(Index As Integer, KeyCode As Integer, Shift As Integer) Select Case Index Case 0: brutto = Val(Text1(0).Text) netto = obj.netto(brutto) Text1(1).Text = Format$(netto, "Currency") Case 1: netto = Val(Text1(1).Text) brutto = obj.brutto(netto) Text1(0).Text = Format$(brutto, "Currency") End Select End Sub

Beim Vergleich der Delphi- und VB-Quelltexte stellen Sie erstaunt fest, dass VB 6 dabei gar nicht so schlecht abschneidet, eher das Gegenteil scheint der Fall zu sein.

646

Kapitel 12

OLE-Automation/ActiveX

Test Ein mehrfaches Hin und Her zwischen Delphi und VB wird sich nie ganz vermeiden lassen, da die anfängliche Funktionalität der ActiveX-DLL sicherlich noch verbesserungsbedürftig ist. Beachten Sie dabei Folgendes: VB vorher beenden bzw. Referenz auf die Bibliothek deaktivieren (sonst lässt sich der Server nicht entfernen). Unter Delphi entfernen Sie mit Start|ActiveX-Server austragen zunächst die vorhandene Registrierung, ehe Sie (nach vorgenommenen Änderungen) wieder Start| ActiveX-Server eintragen wählen und zu VB zurückkehren.

Bemerkungen ■ Fast zum Verwechseln ähnelt der COM-Objekt-Experte dem Automatisierungsobjekt-Experten. Der Unterschied: Letzterer spiegelt das klassische-OLE (aus der Zeit vor COM) wider und verwendet die IDispatch-Schnittstelle, Late Binding und ist deshalb (u.a. wegen InvokeMethode!) langsamer als reines COM, allerdings ist der Zugriff z.B. auch von "älteren" Sprachen aus, die COM nicht unterstützen (wie VB Script), möglich! ■ Eine Typbibliothek (= benutzerdefinierte Schnittstelle) wird nicht benötigt, allerdings funktioniert dann auch die Unterstützung zur Entwurfszeit (Intellisense) nicht. In VB entspricht das Dispatch-Interface dem Object-Datentyp.

12.10.3 Einbinden einer .NET-Komponente In Ergänzung zu den allgemeinen Ausführungen des Abschnitts 12.8 wollen wir den Zugriff auf die ArrayList-Komponente demonstrieren, die Bestandteil der mscorlib.dll-Assembly ist. HINWEIS: Als Voraussetzung für dieses Beispiel sollte das Microsoft .NET Framework auf

Ihrem PC installiert sein.

Assembly registrieren Wechseln Sie an der Kommandozeile in das Verzeichnis des Microsoft.NET Frameworks, in welchem sich die mscorlib.dll befindet, und führen Sie dort den Befehl regasm mscorlib.dll

aus.

647

12.10 Praxisbeispiele für Fortgeschrittene

Oberfläche

Quellcode uses ComObj; var dotNetArrList:Variant;

// Objektvariable

Start: procedure TForm1.Button1Click(Sender: TObject); var cap: Integer; item: Variant; i: Integer; begin

Das Objekt erzeugen: dotNetArrList := CreateOleObject('System.Collections.ArrayList');

Die Kapazität der ArrayList lesen: cap := dotNetArrList.Capacity; ListBox1.Items.Add('Kapazität der ArrayList: ' + IntToStr(cap));

Drei Einträge hinzufügen: dotNetArrList.Add('Das ist der erste Eintrag in die ArrayList!'); dotNetArrList.Add('Das ist der zweite Eintrag in die ArrayList!'); dotNetArrList.Add('Das ist der dritte Eintrag in die ArrayList!');

Alle Einträge lesen: for i := 0 to dotNetArrList.Count-1 do begin item := dotNetArrList.Item(i); ListBox1.Items.Add(item) end end;

648

Kapitel 12

OLE-Automation/ActiveX

Die Liste löschen: procedure TForm1.Button2Click(Sender: TObject); begin dotNetArrList.Clear; // alle Einträge entfernen ListBox1.Clear end;

Test

Bemerkungen ■ Falls wir, wie im Beispiel, die ArryaList mit einem parameterlosen Konstruktor aufrufen, kann sie standardmäßig 16 Einträge aufnehmen (Capacity = 16). Die Count-Eigenschaft hingegen entspricht der Anzahl der tatsächlich belegten Einträge.

12.10.4 Mit C# eine .NET-Komponente für Delphi entwickeln Mit Borland Delphi 7 können Sie noch keine eigenen .NET-Komponenten entwickeln. Falls auf Ihrem PC aber bereits das Microsoft .NET Framework installiert ist, können Sie einen der dort enthaltenen Kommandozeilen-Compiler (für C# oder Visual Basic) dazu benutzen. Damit Sie nicht unnötig abgelenkt werden, wollen wir das Beispiel bewusst einfach halten. Ziel ist die Entwicklung einer .NET-Assembly, welche die Klassen TmyKreis und TmyKugel bereitstellt. Beide Klassen exportieren entsprechende Methoden zur Berechnung von Umfang, Fläche, Oberfläche, Volumen und Gewicht.

Programmieren der Komponente (C#) Zum Schreiben des C#-Quellcodes genügt ein einfacher Texteditor wie z.B. Notepad: using System;using System.Reflection;using System.Runtime.InteropServices; namespace NET_Test { public interface kreisIF {

12.10 Praxisbeispiele für Fortgeschrittene

double kreisUmfang(double ra); double kreisFläche(double ra); }

Clients auf die implementierten Schnittstellen beschränken: [ClassInterface(ClassInterfaceType.None)]

Die Klassendeklaration: public class myKreis: kreisIF {

Die Klasse muss einen parameterlosen Konstruktor haben: public myKreis() {}

Methoden der Schnittstelle implementieren: public double kreisUmfang(double ra) { double umf = 2 * Math.PI * ra; return(umf); } public double kreisFläche(double ra) { double fl = Math.PI * ra * ra; return(fl); } }

Völlig analog verfahren wir mit der zweiten Klasse: public interface kugelIF { double kugelObfl(double ra); double kugelVol(double ra); double kugelGew(double ra, double sg); } [ClassInterface(ClassInterfaceType.None)] public class myKugel: kugelIF { public myKugel() {} public double kugelObfl(double ra) { double of = 4 * Math.PI * ra * ra; return(of); } public double kugelVol(double ra) { double vol = 4 / 3F * Math.PI * Math.Pow(ra, 3);

649

650

Kapitel 12

OLE-Automation/ActiveX

return(vol); } public double kugelGew(double ra, double sg) { double vol = 4 / 3F * Math.PI * Math.Pow(ra, 3); return(sg * vol); } } }

Speichern Sie die Textdatei als NETClasses1.cs im Projektverzeichnis ab.

Compilieren und Registrieren Als Nächstes wird der Code mit dem C#-Compiler (csc.exe) übersetzt. Wir nehmen an, dass sich der C#-Quellcode in der Datei Class1.cs befindet, und geben an der Kommandozeile folgenden Befehl ein: csc /t:library NETClasses1.cs

Als Ergebnis liegt die Assembly NETClasses1.dll vor. Diese muss vor ihrer Verwendung registriert werden, wozu wir das regasm-Tool benutzen. Das Tool ähnelt in seinem Konzept tregsvr; es erzeugt die notwendigen Einträge in der Windows-Registry, so dass die Komponente von Unmanaged Clients (unsere Delphi-Anwendung) aufgerufen werden kann. Geben Sie an der Kommandozeile ein: regasm /tlb NETClasses1.dll

Die /tlb-Option bewirkt zwei Dinge: ■ Die Registry-Einträge für die Assembly werden erzeugt. ■ Alle Datentypen der Assembly werden in eine Typbibliothek exportiert, die ebenfalls registriert wird. Haben Sie das Compilieren und Registrieren ordnungsgemäß ausgeführt, so ergibt sich der folgende Textbildschirm:

12.10 Praxisbeispiele für Fortgeschrittene

651

Im Projektverzeichnis finden Sie die folgenden Dateien vor:

Importieren in Delphi Ist die .NET-Assembly fertig gestellt und registriert, so ist das Einbinden in Delphi genauso einfach wie für jedes andere COM-Objekt: ■ Öffnen Sie ein Projekt und wählen Sie das Menü Projekt |Typbibliothek importieren. ■ Scrollen Sie durch die registrierten Typbibliotheken, um die .NET-Bibliothek aufzuspüren.

Wir wollen uns den Luxus erlauben und ein extra Package für die in der .NET-Assembly enthaltenen Komponenten erzeugen, welches wir zur "Beispiele"-Seite der Komponenten-Palette hinzufügen. Klicken Sie auf den "Installieren"-Button und entscheiden Sie sich für das Anlegen eines neuen Package:

652

Kapitel 12

OLE-Automation/ActiveX

Nach dem OK erscheint eine Zwischenabfrage, die Sie natürlich mit "Ja" beantworten. Klappt alles, so werden Sie durch die folgende Mitteilung erfreut:

Beide .NET-Komponenten können Sie nun auf der "Beispiele"-Seite der Komponentenpalette bewundern.

Oberfläche Um den Test überschaubar zu halten, beschränken wir uns auf eine Komponente myKreis, die wir auf das Startformular ziehen (nebst einigen weiteren Steuerelementen entsprechend der Abbildung):

12.10 Praxisbeispiele für Fortgeschrittene

653

Quellcode Der Beispielcode demonstriert, wie einfach die Methoden der .NET-Komponente aufgerufen werden können: procedure TForm1.Button1Click(Sender: TObject); // Berechnen var rad, umf, fl: Single; code: Integer; s : String; begin Val(Edit1.Text, rad, code); umf := myKreis1.kreisUmfang(rad); Str(umf:6:2, s); Label1.Caption := 'Der Umfang ist ' + s; fl := myKreis1.kreisFl_che(rad); Str(fl:6:2, s); Label2.Caption := 'Die Fläche ist ' + s; end;

Dank vorhandener Typbibliothek werden Sie beim Schreiben der Methodenaufrufe durch die Intellisense hervorragend unterstützt:

Test

654

Kapitel 12

OLE-Automation/ActiveX

Bemerkungen ■ Der Typbibliotheks-Importer erzeugt einen COM-Wrapper, so dass unser Delphi-Client über vtable- Binding auf die Komponente zugreifen kann. ■ Über die "Hinzufügen"-Schaltfläche der "Import"-Dialogbox ist es nicht möglich, die Typbibliothek einer .NET-Assembly korrekt zu registrieren. Sie müssen dazu immer das regasmTool (von der Kommandozeile aus) benutzen! ■ Wie Sie die .NET-Assembly gezielt im Global Assembly Cache (GAC) platzieren, wurde im Abschnitt 12.8 beschrieben.

13

Wissenschaft/Technik

Kapitel

13

Wissenschaft/Technik Lassen Sie sich vom Attribut "wissenschaftlich" nicht abschrecken, in diesem Kapitel werden nur einige Anregungen für mehr oder weniger komplexe praktische Problemlösungen vermittelt, die Ihnen Quelle für eigene Inspirationen sein sollen. Die einzelnen Beiträge stehen thematisch relativ lose nebeneinander und gehen in stark unterschiedlicher Weise ins Detail. Wir hoffen trotzdem, dass die getroffene "bunte" Auswahl auch etwas für Sie bieten wird. HINWEIS: Wem die folgenden Beiträge zu stressig sind bzw. "muffige Hörsaalatmosphäre" ver-

breiten, der sollte zunächst mit der leichter verdaulichen Kost im Praxisteil beginnen.

13.1 Sortieren Eine der wohl häufigsten Aufgaben für Computer ist das Sortieren, mit dem wir uns in diesem Abschnitt eingehender beschäftigen wollen. Unser Ziel ist die Entwicklung eines möglichst effizienten Sortieralgorithmus, der einen geringen Speicherbedarf aufweist und möglichst schnell ist.

13.1.1 Eine Testmenge erstellen Ausgangspunkt unserer Betrachtung ist ein eindimensionales, ungeordnetes statisches Array, z.B.: var Feld : array[1 .. 40] of Byte;

Von der Möglichkeit dynamischer Arrays werden wir ebenfalls Gebrauch machen: Die Übergabe von offenen Arrays an Funktionen bzw. Prozeduren. BEISPIEL: Innerhalb der Prozedur lassen sich über die Funktionen High und Low die Schranken des Arrays

bestimmen, damit sind auch die Grenzwerte für Schleifenvariablen festgelegt. procedure sort_shell (var a: array of word);

Zurück zum Sortieren: Für die Untersuchung verwenden wir die Routine Zufallszahlen, die das Array mit einer bestimmten Anzahl von zufälligen Werten (Word) füllt:

656

Kapitel 13

Wissenschaft/Technik

procedure zufallszahlen(var a : array of word); var bis,i: LongInt; begin bis := High(a); for i := 0 to bis do a[i] := Random(65000) end;

HINWEIS: Auf die Verwendung von Assembler-Code (bietet sich beim Datentyp Word eigent-

lich an) wurde bewusst verzichtet, um die Algorithmen mit wenig Aufwand auch für andere Datentypen nutzen zu können. HINWEIS: Alle beschriebenen Verfahren lassen sich mit relativ wenig Aufwand auf Pointer-

Listen etc. (siehe Kapitel 14) umschreiben. Arbeiten Sie mit Records, ist diese Vorgehensweise unbedingt zu empfehlen, da in diesem Fall nicht erst der komplette Record kopiert werden muss, sondern lediglich der Pointer neu gesetzt wird (wesentlich bessere Performance!).

13.1.2 Austauschverfahren (Exchange-Sort) Das Austauschverfahren ist eine der einfachsten und zugleich langsamsten Sortiermethoden. Beginnend mit dem ersten wird jedes weitere Element der Liste mit allen anderen Werten verglichen. Ist der Vergleichswert kleiner als der aktuelle Wert, werden beide ausgetauscht. ? A1 > A2,A3,A4...

? A0 > A1,A2,A3,A4...

A0

A1

A2

A3

A4

A5

A6

A0

A1

A2

A3

A4

A5

A6

Dieser Vorgang wird bis AN-1 fortgesetzt. Genaueres können Sie dem folgenden Programmablaufplan entnehmen. Die Realisierung des Sortieralgorithmus in Delphi: procedure sort_austausch (var a: array of Word); var bis,i,j : LongInt; h : Word; begin bis := High(a); for i := 0 to bis - 1 do for j := i + 1 to bis do If a[i] > a[j] then begin h := a[i]; a[i] := a[j]; a[j] := h end end;

657

13.1 Sortieren

Einen Test der Leistungsfähigkeit im Vergleich zu den anderen Verfahren finden Sie am Ende dieses Abschnitts. START

j=i+1

a(i) > a(j)

JA

a(i) mit a(j) tauschen NEIN JA JA

j=j+1

j ≤ Anzahl

NEIN

i=i+1

i ≤ Anzahl -1

NEIN

ENDE

13.1.3 Auswahlverfahren Das Auswahlverfahren ähnelt in seiner Arbeitsweise dem Austauschverfahren. Beginnend mit dem ersten Feldelement wird das Minimum gesucht, im Erfolgsfall werden die Werte getauscht. In dieser Vorgehensweise ist der Vorteil gegenüber dem Austauschverfahren zu sehen. Bei jedem Schleifendurchlauf wird maximal ein Wert getauscht. ? MIN(A1,A2,A3..))

? MIN(A0,A1,A2...)) A0

A1

A2

A3

A4

A5

A6

A0

A1

A2

A3

A4

A5

A6

Für die Ermittlung des Minimums verwendet das Programm eine Hilfsvariable vom Typ Word sowie einen Hilfsindex (Zeiger auf das jeweils kleinste Element).

658

Kapitel 13

START

h = a(i) k=i j=i+1

a(j) < h

JA

NEIN

h = a(j) k=j

JA JA

j=j+1

j ≤ Anzahl

NEIN

a(k) = a(i) a(i) = h i=i+1

i ≤ Anzahl -1

NEIN

ENDE

Die Umsetzung in Delphi bereitet keine weiteren Probleme: procedure sort_auswahl (var a: array of Word); var bis,i,j,k : LongInt; h : Word; begin bis := High(a); for i := 0 to bis - 1 do begin h := a[i]; k := i; for j := i + 1 to bis do if a[j] < h then begin h := a[j];

Wissenschaft/Technik

659

13.1 Sortieren

k := j end; a[k] := a[i]; a[i] := h end end;

Eine noch schnellere Variante des Auswahlverfahrens sortiert das gefundene Minimum in ein neues Feld ein. Diese Möglichkeit entspricht zwar dem menschlichen Vorgehen, zwei Punkte sprechen jedoch gegen dieses Verfahren: ■ Der Speicherbedarf verdoppelt sich durch das zweite benötigte Array. ■ Wir brauchen ein Kennzeichen für bereits einsortierte Werte ("abstreichen").

13.1.4 Bubble-Sort-Verfahren Dieses Verfahren ändert die bisherige Vorgehensweise dahingehend, dass der jeweils größere zweier benachbarter Werte durch das gesamte Array "geschoben" wird. Aus diesem Vorgang resultiert die Bezeichnung "Bubble-Sort", die Maxima steigen wie Blasen (Bubbles) zu ihren jeweiligen Positionen auf. max max max max max max

A0

A1 min

A2 min

A3 min

A4 min min

A5

max max max max max

A6

A0

min

A1 min

A2 min

A3 min

A4

A5

A6

min min

Dieser Vorgang wird so lange wiederholt, bis das Minimum im ersten Feld steht. Was so kompliziert aussieht, ist auch entsprechend langsam. Der Bubble-Sort-Algorithmus zählt deshalb mit zu den Schlusslichtern, wenn es um Ausführungsgeschwindigkeit geht. Der Algorithmus ist nur vollständigkeitshalber aufgeführt, von der Anwendung für "normale" Applikationen wird abgeraten (Ausnahmen siehe Abschnittsende). procedure sort_bubble (var a: array of Word); var bis,i : LongInt; h : Word; begin bis := High(a); repeat for i := 0 to bis - 1 do if a[i] > a[i + 1] then begin h := a[i]; a[i] := a[i + 1]; a[i + 1] := h end;

660

Kapitel 13

Wissenschaft/Technik

Dec(bis) until bis = 1 end;

Eine Mutante des Bubble-Sort, der Shake-Sort, wechselt während der Bearbeitung die Sortierrichtung, d. h., das Minimum wird an den Anfang geschoben. Was für Vorteile soll das bringen? Für Sortiervorgänge im Arbeitsspeicher spielt die obige Vorgehensweise keine Rolle, werden die Daten jedoch auf einer Festplatte oder einem Magnetband sortiert, lassen sich die Positionierungen der Schreib-/Leseköpfe auf diese Art und Weise minimieren. Da in diesem Fall die mittlere Zugriffszeit der Festplatte die Geschwindigkeit des Sortiervorgangs bestimmt, ist eine Optimierung an dieser Stelle besonders wichtig. Und damit können Sie sich denken, in welchen Bereichen auch der Bubble-Sort-Algorithmus sinnvoll einsetzbar wäre. START

a(i)>a(i+1)

NEIN JA

JA

i=i+1

i ≤ Anzahl-1

NEIN

Anzahl = Anzahl-1

Anzahl > 1

NEIN

ENDE

JA

h = a(i) a(i) = a(i + 1) a(i + 1) = h

661

13.1 Sortieren

13.1.5 Shell-Sort-Verfahren Die Geschwindigkeitsvorteile werden mit einer etwas aufwändigeren Programmierung bezahlt. Der Ansatz ist anders als bisher. Das Array der Länge N wird halbiert, danach vergleicht man die Werte A0 und AN/2, A1 und AN/2+1, ... miteinander. Das Maximum wird in die zweite Hälfte verschoben.

max

A0

A1

A2

A3

A4

A5

A6

A7

A0

A1

A2

A3

A4

A5

A6

A7

A0

A1

A2

A3

A4

A5

A6

A7

In einem zweiten Durchlauf werden die Intervalle halbiert, es erfolgt ein erneuter Vergleich. Der Ablauf wiederholt sich so lange, bis die Intervallgröße einem Feldelement entspricht und die jeweils benachbarten Werte verglichen werden: procedure sort_shell (var a: array of Word); var bis,i,j,k : LongInt; h : Word; begin bis := High(a); k := bis shr 1; // div 2 while k > 0 do begin for i := 0 to bis - k do begin j := i; while (j >= 0) And (a[j] > a[j + k]) do begin h := a[j]; a[j]:= a[j + k]; a[j + k] := h; If j > k then Dec(j,k) else j := 0 end end; k := k shr 1 // div 2 end end;

662

Kapitel 13

Wissenschaft/Technik

START k = Anzahl \ 2

k>0

NEIN

JA

j=i

j>=0 a(j) > a(j + k) JA

JA

h = a(j) a(j) = a(j + k) a(j + k) = h j=j-k

i=i+1

i ≤ Anzahl - k

NEIN

k=k\2

ENDE

13.1.6 Auswerten von Testergebnissen Die Ergebnisse einer Leistungsanalyse der einzelnen Algorithmen können Sie dem folgenden Diagramm entnehmen, das den Zeitbedarf für das Sortieren von jeweils 1000 Werten widerspiegelt. Es ist nicht auszuschließen, dass eine Realisierung der Sortierverfahren mit einer anderen Sprache zu abweichenden Ergebnissen führt. Die Ursachen sind unterschiedliche Ausführungszeiten für Vergleiche bzw. Zuweisungen. Je nachdem, ob eine Routine mehr Vergleiche oder Zuweisungen enthält, werden sich die Diagrammdaten ändern.

663

13.1 Sortieren

500

400

t(ms)

300

200

100

0

Austausch

Auswahl

Bubblesort

Shellsort

Fazit: Offensichtlich zählt der ShellSort-Algorithmus zu den optimalen Sortierverfahren für die üblichen Einsatzgebiete, zumal der Programmieraufwand relativ gering ist. Das zugrunde liegende Testprogramm wird im folgenden Abschnitt beschrieben.

13.1.7 Testprogramm Das folgende kleine Beispielprogramm vergleicht einzelne Sortieralgorithmen miteinander.

Oberfläche Auf das Startformular platzieren Sie eine ListBox, vier Buttons und vier Labels, so dass sich zur Laufzeit etwa die folgende Ansicht ergibt:

664

Kapitel 13

Wissenschaft/Technik

Programmierung Wir beschränken uns auf die Wiedergabe des implementation-Abschnitts von Unit1: Zunächst ist die Testmenge bereitzustellen (siehe 13.1.1): var testarray : array[0 .. 30000] of Word; procedure zufallsZahlen(var a : array of Word); var bis,i: LongInt; begin bis := High(a); for i := 0 to bis do a[i] := Random(65000) end; procedure listeFuellen(var a : array of Word); var bis,i: LongInt; begin Form1.Listbox1.Items.Clear; bis := High(a); for i := 0 to bis do Form1.Listbox1.Items.Add(IntToStr(a[i])) end;

Nun folgt der Code für die einzelnen Sortierroutinen, z.B. für den Shell-Sort (siehe 16.1.5): procedure sort_shell (var a: array of Word); ... end;

// Shell-Sort

Der Aufruf: procedure TForm1.Button4Click(Sender: TObject); // Aufruf des Shell-Sort var von,bis : LongInt; begin zufallsZahlen(testArray); von := getTickCount; sort_shell(testArray); bis := GetTickCount; listeFuellen(testArray); Label4.Caption := intToStr(bis-von) + ' ms' end;

HINWEIS: Den kompletten Quellcode finden Sie auf der Buch-CD.

Test Starten Sie das Programm und klicken Sie nacheinander die vier Buttons, um die vier Verfahren miteinander zu vergleichen. Nach Abschluss eines Sortiervorgangs wird im jeweiligen Label das Messergebnis angezeigt.

665

13.2 Suchen

13.2 Suchen Neben dem Sortieren ist das Suchen in Listen und Arrays ein häufiges Problem. Bei der Suche können wir entweder nach MuP1 oder mit entsprechenden Algorithmen vorgehen.

13.2.1 Lineares Durchsuchen Eine zwar immer funktionierende, aber auch ebenso langsame Methode ist das lineare Durchsuchen des gesamten Arrays (sequenzielle Suche): Function search (was : Word; wo: array of Word) : LongInt; var i: LongInt; begin for i := 0 to High(wo) if was = wo[i] then begin search = i + 1; Exit; end; search := 0 end;

Der Nachteil ist offensichtlich: Im "schlimmsten" Fall werden alle Werte geprüft. Die mittlere Anzahl der Versuche berechnet sich zu High/2.

13.2.2 Durchsuchen sortierter Datenfelder Oft sucht man aber Daten in sortierten Arrays. In diesem Fall liegt in der Sortierreihenfolge schon eine gewisse Information über die Lage eines Wertes. Nehmen wir eine Stichprobe aus der Mitte des Feldes, lassen sich drei Fälle unterscheiden: ■ Wir haben Glück, es ist der gesuchte Wert. ■ Der Stichprobenwert ist größer als der gesuchte Wert. ■ Der Stichprobenwert ist kleiner als der gesuchte Wert. Der Hinweis, dass wir im ersten Fall die Suche sofort abbrechen können, erübrigt sich. Im zweiten Fall muss der gesuchte Wert zwischen Stichprobe und Feldanfang, im dritten Fall zwischen Stichprobe und Feldende liegen. Durch erneutes Teilen des Intervalls und erneuten Vergleich lässt sich der gesuchte Wert eingrenzen. Wir können natürlich auch Pech haben, der gesuchte Wert existiert überhaupt nicht. Mit n Schritten werden 2n Werte erfasst, d.h., zehn Vergleichsschritte genügen für die Suche in 1024 Werten. Function search_sort (was : Word; wo : array of Word) : LongInt; { Diese Funktion liefert die Position in der Liste +1. Ist der Rückgabewert 0, dann wurde das

1

Methode des unbekümmerten Probierens

666

Kapitel 13

Wissenschaft/Technik

Element nicht gefunden. Die Funktion ist für sortierte Listen optimiert, für ungeordnete Listen verwenden Sie Search. } var i,mi,le,ri : LongInt; begin le := 0; ri := High(wo); repeat mi := (le + ri) div 2; if was < wo[mi] then ri := mi - 1 else le := mi + 1; until (wo[mi] = was) or (le > ri); if wo[mi] = was then search_sort := mi + 1 else search_sort := 0 end;

Test Ein Vergleich der Algorithmen ist mit dem auf der Buch-CD enthaltenen Testprogramm möglich. HINWEIS: Beachten Sie, dass Sie vor Aufruf von Search-Sort auf "Sortierte Liste erstellen"

klicken müssen.

667

13.3 Gauss-Algorithmus

Wie leider aus der Abbildung nicht ersichtlich ist, zeigt der Vergleich beider Algorithmen drastische Unterschiede in den Ausführungszeiten. Beim sequenziellen Suchen steigt die benötigte Zeit proportional zur Feldgröße an, beachten Sie jedoch, dass diese Ergebnisse nur für sortierte Felder gelten.

13.3 Gauss-Algorithmus Dieser Beitrag soll am Beispiel eines Lösungsprogramms für (physikalisch reale) lineare Gleichungssysteme zeigen, wie ein mathematischer Algorithmus schrittweise in eine Delphi-Applikation umzusetzen ist.

13.3.1 Theoretische Grundlagen Das Lösen linearer Gleichungssysteme (GLS) ist eine zentrale Aufgabenstellung der numerischen Mathematik. Jeder Taschenrechner, der das Prädikat "wissenschaftlich" für sich in Anspruch nimmt, sollte über ein entsprechendes Programm1 verfügen, wobei aber die obere Grenze meist bei acht bis zwölf Unbekannten liegt.

Das "Drei-Brüder"-Beispiel Beginnen wir statt vieler Worte lieber mit einem konkreten Beispiel für ein Gleichungssystem mit drei Unbekannten: Drei Brüder bringen es gemeinsam auf ein Alter von 155 Jahren. Der älteste wurde ein Jahr vor dem mittleren Bruder geboren und drei Jahre vor dem jüngsten. Wie alt ist jeder der drei? Aufstellen des GLS: x1 + x2 + x3

= 155

x1 - x2

= 1

x1 - x3 = 3 Lösen des GLS: Wir unterstellen Ihnen, dass Sie ein solches GLS mit drei Unbekannten noch ganz locker per Hand ausrechnen können, indem Sie z.B. die zweite und die dritte Gleichung nach x2 bzw. x3 auflösen und in die erste einsetzen: x1 + x1 - 1 + x1 - 3 = 155 womit Sie zunächst das Alter des ältesten Bruders: 3x1 = 159 x1 = 53 ermitteln und dann schnell zu den übrigen Lösungen kommen: 1

Leider gilt dies nicht für den "wissenschaftlichen" Windows-Taschenrechner.

668

Kapitel 13

Wissenschaft/Technik

x2 = 52 x3 = 50 Natürlich gibt es weitaus sinnvollere und vor allem umfangreichere Anwendungsbeispiele als obiges, und mit wachsender Anzahl von Unbekannten werden Sie allein durch intuitives Herangehen nicht mehr zum Ziel kommen. Reaktivieren Sie also Ihre Schulkenntnisse und entsinnen Sie sich an den Gauss-Algorithmus und seine verschiedenen Modifikationen (Einsetzungs- oder Gleichsetzungsmethode etc.). In computergerechter Form ist der Gauss-Algorithmus auch heute noch die beste Methode zum Lösen linearer GLS. Doch ehe wir dazu kommen, wollen wir eine solide Ausgangsbasis schaffen, indem wir bereits für das Aufstellen des GLS eine systematische Vorgehensweise empfehlen, die Sie im folgenden Abschnitt kennen lernen.

Abspeichern in Matrizenform In allgemeiner Form lässt sich ein lineares GLS mit n Unbekannten wie folgt notieren: a11x1 + a12x2 + .... + a1NxN = b1 a21x1 + a22x2 + .... + a2NxN = b2 ... aN1x1 + aN2x2 + .... + a1NxN = bN oder abgekürzt in Vektorform: A.x = b Wir sollten es uns aber im Computerzeitalter angewöhnen, dieses Problem (und andere ähnliche mathematische Zusammenhänge) möglichst gleich in Matrizenform niederzuschreiben: 1 2 3 ... N

1 a11 a21 a31 ... aN1

2 a12 a22 a32 ... aN2

3 a13 a23 a33 ... aNN

... ... ... ... ... ...

N a1N a2N a3N ... aNN

x1 x2 x3 ... xN

*

b1 b2 b3 ... bN

=

Die linke Seite (Koeffizientenmatrix A) kann unter Delphi in einem zweidimensionalen, der Lösungsvektor X und die rechte Seite B in jeweils einem eindimensionalen Array abgespeichert werden. Wie Sie sehen, wächst der Speicherplatzbedarf etwa quadratisch mit der Anzahl der Unbekannten. BEISPIEL: Obiges "Drei-Brüder"-Beispiel sieht in Matrizenform folgendermaßen aus:

1 1 1

1 -1 0

1 0 -1

*

x1 x2 x3

=

155 1 3

669

13.3 Gauss-Algorithmus

Programmablaufplan des Gauss-Algorithmus Wie Sie am folgenden Programmablaufplan (PAP) erkennen, lässt sich der Gauss-Algorithmus in zwei Zyklen unterteilen: ■ Elimination ■ Rücksubstitution Eingabe der Ordnung N Laden der Koeffizientenmatrix A(N,N) Laden der rechten Seite B(N)

Eingabe des Gleichungssystems

Start

Beginn des Gauss-Algorithmus Laden des Schrittzählers

k=N i=1 B(i) = B(i) -

Laden des Zeilenzählers Umformen der rechten Seite

B(k).A(i,k)/A(k,k) j=1

A(i,j) = A(i,j) - A(i,k).A(k,j)/A(k,k) Elimination

j = j+1 j=k?

nein

i = i+1 i=k?

Letzte Zeile erreicht ?

nein

Erniedrigen des Schrittzählers Letzter Reduktionsschritt ? Laden des Zeilenzählers Laden des Spaltenzählers

i=1 j=1

j = j+1 nein

B(i) = B(i)/A(i,i)

Rücksubstitution

B(i) = B(i) - B(j).A(i,j) j = i+1 ?

i = i+1 i = n+1 ?

Erhöhen des Zeilenzählers

nein

k=k-1 k=1?

Laden des Spaltenzählers Umformen der Koeffizientenmatrix Erhöhendes Spaltenzählers Letzte Spalte erreicht ?

nein Stop

Ausgabe der Lösung

Berechnung der Lösung Erhöhen des Spaltenzählers Prüfen des Spaltenzählers Korrigieren der Lösung Erhöhen des Zeilenzählers Letzte Zeile erreicht ? Ende des Gauss-Algorithmus Ausgabe der rechten Seite B(N)

670

Kapitel 13

Wissenschaft/Technik

Aufgrund seiner drei ineinander verschachtelten Schleifen verbraucht der Eliminationszyklus die meiste Rechenzeit. Schritt für Schritt wird eine Unbekannte nach der anderen eliminiert, und das Gleichungssystem (Restmatrix) schrumpft zusammen, bis es die Ordnung 1 erreicht hat und der Wert für x1 ermittelt werden kann. Die Rücksubstitution nutzt die bereits berechneten Werte von x, um sie schrittweise in das nächsthöhere Zwischengleichungssystem einzusetzen, aus welchem sich dann ein weiteres x direkt ermitteln lässt. Dabei wird die rechte Seite B mit der Lösung überschrieben, so dass Letztere keinen extra Speicherbereich benötigt. Kritisch ist die Division durch das Hauptdiagonalelement A(k,k). Es darf nicht null sein, da sonst das Programm unweigerlich "abstürzt". Sie können ein solches Debakel aber vermeiden, wenn Sie vorher die Reihenfolge der Gleichungen so umordnen, dass alle Hauptdiagonalelemente einen Wert ungleich null besitzen.

13.3.2 Ein einfaches Lösungsprogramm Wir wollen zunächst jeglichen überflüssigen Schnickschnack weglassen und uns auf die Implementierung des puren Gauss-Algorithmus gemäß des abgebildeten PAP konzentrieren. Folgerichtig werden wir die Aufwendungen für die Bedienoberfläche auf ein absolutes Minimum beschränken, wobei wir uns auf die einfachsten Ein- und Ausgabemöglichkeiten, die Delphi zur Verfügung stellt, besinnen: die InputBox und die MessageBox.

Bedienoberfläche Das Wenige, was wir an Komponenten noch brauchen, sind vier normale Buttons und ein SpinButton:

Den SpinEdit-Button finden Sie auf der "Beispiele"-Seite der Komponentenpalette.

13.3 Gauss-Algorithmus

671

Quelltext unit Unit1; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, Spin; type TForm1 = class(TForm) Button1: TButton; Button2: TButton; Button3: TButton; Button4: TButton; SpinEdit1: TSpinEdit; Label1: TLabel; procedure allgemeinEvent(Sender: TObject); end; var Form1: TForm1;

Im Interface-Abschnitt dürfte Ihnen die Ereignismethode allgemeinEvent auffallen. Wir müssen sie dort selbst eintragen! implementation {$R *.DFM} const Nmax = 10; // max. Anzahl der Unbekannten var N: Integer = 1; // Anzahl der Unbekannten A: array[1..Nmax, 1..Nmax] of Single; // Koeffizienten links B: array[1..Nmax] of Single; // Koeffizienten rechts

Was nun folgt, ist das Herzstück unseres Programms, gewissermaßen die 1:1-Umsetzung des PAP: procedure gauss1; var i,j,k : Integer; // Schleifenzähler begin // Eliminations-Zyklus: for k := N downto 2 do begin for i := 1 to k - 1 do begin B[i] := B[i] - B[k] * A[i,k] / A[k,k]; for j := 1 to k - 1 do begin A[i,j] := A[i,j] - A[i,k] * A[k,j] / A[k,k] end end end; // Rücksubstitutions-Zyklus: for i := 1 to N do begin for j := 1 to i - 1 do begin

672

Kapitel 13

Wissenschaft/Technik

B[i] := B[i] - B[j] * A[i,j] end; B[i] := B[i] / A[i,i] end end;

Die nach Abarbeitung des Gauss-Algorithmus im B-Array enthaltene Lösung wird zunächst aufbereitet und formatiert, ehe sie in der MessageBox zur Anzeige kommt: procedure anzeigen; // zeigt die Lösung an var s, s1:string; i:Integer; begin s := 'Lösung:' + #13; for i:= 1 to N do begin Str(B[i]:6:3, s1); s := s + 'X' + IntToStr(i) + ' = ' + s1 + #13 end; ShowMessage(s) end;

Der folgende allgemeine Event-Handler ersetzt die standardmäßig von Delphi angebotenen einzelnen Ereignisprozeduren. Das erscheint zwar zunächst etwas ungewöhnlich, aber man lernt schnell die gesteigerte Übersicht zu schätzen, da alle auszuwertenden Ereignisse in einer einzigen Prozedur zusammengefasst werden können: procedure TForm1.allgemeinEvent(Sender: TObject); // verarbeitet alle Ereignisse var s:string; i, j, code: Integer; // nur für Fehlercode bei Val-Funktion begin if Sender = Button1 then // OnClick: Eingabe der Koeffizientenmatrix for i:=1 to N do for j:=1 to N do begin Str(A[i,j]:6:3, s); if InputQuery('Koeffizientenmatrix eingeben!', 'A['+IntToStr(i)+','+IntToStr(j)+']', s) then Val (s, A[i,j], code) else break end; if Sender = Button2 then // OnClick: Eingabe der rechten Seite for i:=1 to N do begin Str(B[i]:6:3, s); if InputQuery('Rechte Seite eingeben!','B['+IntToStr(i)+']', s) then Val (s, B[i], code) else break // OnClick: Abbruch end; if Sender = Button3 then // OnClick: Lösen begin gauss1; anzeigen end;

13.3 Gauss-Algorithmus

673

if Sender = SpinEdit1 then // OnChange: Anzahl Unbekannter ändern N := SpinEdit1.Value; if Sender = Form1 then // OnCreate: Programmstart begin SpinEdit1.MinValue := 1; SpinEdit1.MaxValue := Nmax end; if Sender = Button4 then Close // OnClick: Beenden end;

Vergessen Sie nicht, die allgemeinEvent-Ereignismethode über die "Ereignisse"-Seite des Objektinspektors den entsprechenden Ereignissen (OnClick für alle vier Buttons, OnChange für SpinEdit1, OnCreate für Form1) zuzuweisen!

Test Was liegt näher, als das bereits arg strapazierte "Drei-Brüder-Beispiel" noch einmal aufzuwärmen? Stellen Sie die SpinBox zunächst auf den Wert 3 ein und geben Sie dann die neun Koeffizienten für die Matrix und die drei Koeffizienten für die rechte Seite ein:

Die Lösung bestätigt die Funktionsfähigkeit des Algorithmus:

Bemerkungen ■ Kontrolldurchlauf ist möglich (nur mit OK bestätigen). ■ Lösung ist auch in InputBox (rechte Seite) einzusehen. ■ Kein wiederholtes Klicken auf Lösen erlaubt, da sich die ursprünglichen Inhalte von A und B geändert haben! ■ Hauptdiagonalelemente müssen ungleich null sein (siehe nächster Abschnitt).

674

Kapitel 13

Wissenschaft/Technik

13.3.3 Kritik am einfachen Gauss-Algorithmus Obige Version des Gauss-Algorithmus erläutert zwar auf anschauliche Weise das mathematische Prinzip, hat aber mehrere Unzulänglichkeiten, die einem effektiven praktischen Einsatz im Wege stehen.

Keine Pivotisierung? Von diesem entscheidenden Mangel überzeugen Sie sich am besten selbst anhand des folgenden Beispiels (GLS mit fünf Unbekannten): 0 1 2 -1 3

2 -1 0 1 2

0 -1 2 1 2

1 0 1 1 -2

2 1 -1 1 0

*

x1 x2 x3 x4 x5

=

2 -2 4 2 -8

Nachdem Sie es endlich geschafft haben, alle 25 Koeffizienten nacheinander fehlerfrei einzugeben, und erwartungsfroh auf "Lösen" klicken, werden Sie durch eine böse Überraschung um die Früchte Ihrer Arbeit betrogen1:

Auf die konkrete Ursache des Übels werden Sie im Quelltextfenster hingewiesen:

1

Wie so oft, machen uns auch hier die "Nullen" das Leben schwer.

675

13.3 Gauss-Algorithmus

Über das lokale Menü Fehlersuche|Auswerten/Ändern... (rechte Maustaste!) können Sie sich davon überzeugen, dass das Element A[k,k] tatsächlich null ist:

In unserem Fall handelt es sich um das erste Hauptdiagonalelement der Koeffizientenmatrix: A[1,1] = 0. Um das Gleichungssystem trotzdem lösen zu können, müssen Sie die Reihenfolge der Gleichungen so umordnen, dass kein einziges Hauptdiagonalelement null ist. Dies erreichen Sie z.B. durch Vertauschen der ersten mit der letzten Gleichung: 3 1 2 -1 0

2 -1 0 1 2

2 -1 2 1 0

-2 0 1 1 1

0 1 -1 1 2

*

x1 x2 x3 x4 x5

=

-8 -2 4 2 2

Nach erneuter Eingabe ist jetzt das GLS lösbar, und der Gauss-Algorithmus liefert folgende "glatten" Werte: x1 = 0

x2 = 1

x3 = -1

x4 = 4

x5 = -2

Natürlich ist es unzumutbar, jedes Mal vor der Eingabe eines GLS dessen Hauptdiagonalelemente zu sichten und gegebenenfalls die Reihenfolge der Gleichungen "per Hand" zu ändern. Diese Aufgabe muss ein "ordentlicher" Gauss-Algorithmus selbst vornehmen, man nennt so etwas im Fachjargon "Pivotisierung". Dabei wird die Reihenfolge der Gleichungen zu Beginn eines jeden Eliminationsschrittes automatisch neu bestimmt, so dass immer die Gleichung mit dem betragsgrößten Hauptdiagonalelement an die erste Position rückt. Man vermeidet damit nicht nur die gefürchtete Gleitkommadivision durch null, sondern erreicht darüber hinaus auch ein Lösen des GLS mit höchstmöglicher Genauigkeit.

676

Kapitel 13

Wissenschaft/Technik

Speicherplatzverschwendung? Die maximale Anzahl der Unbekannten hatten wir im obigen Programm auf Nmax = 10 begrenzt. Beide Arrays A und B, in denen die Koeffizienten bzw. die Lösung des GLS abgespeichert werden, haben demnach feste Dimensionen. Es ist nicht möglich, größere GLS zu lösen, ohne Quelltextänderungen vornehmen zu müssen (Nmax) und erneut zu compilieren. Setzen wir aber von vornherein ein großes Nmax an (z. B. Nmax = 100), dann bedeutet dies wohl in der Mehrzahl der Fälle eine grandiose Speicherplatzverschwendung (circa 10.000 Felder), denn der Bedarf an Speicherplatz wächst etwa quadratisch mit der Anzahl der Unbekannten, und im Regelfall wird nur ein Bruchteil davon benötigt. Als "richtige" Programmierer geben wir uns mit solch einer Situation aber nicht zufrieden, sondern suchen nach einer Möglichkeit, wie wir die Größe der benötigten Arrays dynamisch anpassen können.

Primitive Bedienoberfläche? Hier müssen wir resigniert beipflichten, denn angesichts des spartanischen Outfits und der mittelalterlichen Dialogführung wäre dieser Vorwurf kaum zu entkräften. Sie sehen im folgenden Abschnitt selbst, dass es unter Windows weitaus attraktivere Möglichkeiten für einen effektiven Benutzerdialog gibt als mittels Input- und MessageBox.

13.4 Numerische Integration Zur Beschreibung analoger Systeme im Zeitbereich und deren Simulation durch numerische Methoden muss die Integration durch eine Summation und die Differentation durch die Bildung des Differenzenquotienten approximiert werden. Dazu bieten sich nachfolgende Möglichkeiten an.

13.4.1 Rechteckapproximation Die Bezeichnung Rechteckapproximation resultiert aus dem rechteckförmigen Verlauf der Ausgangsgröße. Grundlage dieses Verfahrens ist eine Näherung der Differentation durch einen Differenzenquotienten: (Rückwärtsdifferenz) oder (Vorwärtsdifferenz) Die Bezeichnung Vorwärts-/Rückwärtsdifferenz bezieht sich auf die benötigten Wertepaare. Bei der Rückwärtsdifferenz findet der aktuelle sowie der vorhergehende Wert Verwendung. Am Beispiel eines Tiefpassgliedes 1. Ordnung soll das Erstellen eines mathematischen Algorithmus demonstriert werden.

677

13.4 Numerische Integration

Ausgangspunkt ist die Differentialgleichung des Übertragungsgliedes: Gleichung I mit

Wird ∆t durch TA ersetzt und die Bedingung TA ≤ 0,1 ⋅ TX (Tx kleinste Zeitkonstante der Übertragungsfunktion) eingehalten, lässt sich folgende Vereinfachung nutzen: Gleichung II Nach dem Einsetzen von Gleichung II in Gleichung I und der Umformung nach X A erhält man folgende Beziehung: Gleichung III Mit dieser Formel lässt sich für alle diskreten Zeitpunkte n*TA der Ausgangswert des Systems bestimmen. Dabei wird immer auf den vorhergehenden Wert zurückgegriffen. Da für diese Art der Simulation keine "negativen Zeiten" existieren, werden die Anfangswerte wie folgt definiert: XE = 0 ; für t < 0 XA = 0 ; für t < 0 Folgende Grafik zeigt den prinzipiellen Verlauf (in %) des Ausgangssignals X A in Abhängigkeit von der Zeit:

678

Kapitel 13

Wissenschaft/Technik

Deutlich erkennbar sind Abweichungen gegenüber dem realen Verhalten, besonders bei starker Änderung der Ausgangsgröße. Eine Verbesserung lässt sich durch eine Verkleinerung der Tastzeit (Schrittweite) erreichen, dem steht jedoch ein erhöhter Rechenaufwand gegenüber. Ein weiteres Problem ist eine scheinbare Laufzeit (Phasenverschiebung), die zwischen dem Verlauf x(t) und dem Verlauf x (mittlerer Verlauf der diskreten Größe) auftritt. Diese "Laufzeit" ist eine Funktion der Tastzeit:

TL =

1 TA . 2

Die Ursache für dieses "Laufzeitverhalten" ist in der Realisierung mittels Abtast- und Halteglied zu sehen. Bei Stabilitätsuntersuchungen an diskreten Regelkreisen sollte deshalb die Laufzeitwirkung des diskreten Übertragungsgliedes berücksichtigt werden.

13.4.2 Beispiel zur Rechteckapproximation Ein RC-Tiefpassglied wird zum Zeitpunkt t = 0 mit einer Sprungfunktion (Gleichspannungsquelle E) beaufschlagt:

t=0 E=1V

R = 100 Ohm C = 1µF

U(t)

Für die Zeitkonstante des Systems gilt: TX = RC = 100VA-110-6AsV-1 = 10-4s = 0.1ms.

679

13.4 Numerische Integration

Für die Tastzeit (im Folgenden als Schrittweite bezeichnet) nimmt man einen etwa um den Faktor 10 kleineren Wert: TA = 0.1*TX = 0.01 ms Die mit XE und XA korrespondierenden physikalischen Größen sind die Eingangsspannung E und die Ausgangsspannung U(t). Da ein Einschwingvorgang erster Ordnung nach etwa dem zehnfachen Wert seiner Zeitkonstante als abgeschlossen betrachtet werden kann, wird als Endzeit angesetzt: TE = 1 ms

Programmablaufplan Start

Eingabe: R = 100 Ω C = 0,000001F

uk = 0 t=0 Integrationsschleife

1 1 + ⋅ uk u= R C 1 C + R dt JA

uk = u

t < te

NEIN

Stopp

Quellcode Auf dem Formular befinden sich ein Button und ein StringGrid. procedure TForm1.Button1Click(Sender: TObject); var u,uk,t, te,dt,R,C : Double;

680

Kapitel 13

z : LongInt; s : string; begin R := 100; // 100 Ohm C := 0.000001; // 1 Mikrofarad te := 0.001; // 1 Millisekunde dt := 0.00001; // Schrittweite = 0.01 ms uk := 0; // entspricht Vorgängerwert t := 0; z := 1; StringGrid1.RowCount := Round(te / dt); repeat u := (1 / R + C / dt * uk) / (1 / R + C / dt); Str(t:10:6,s); stringGrid1.Cells[0,z] := s; Str(u:6:3,s); stringGrid1.Cells[1,z] := s; uk := u; // Speichern Vorgängerwert t := t + dt; // Zeitinkrement Inc(z) until t >= te end; procedure TForm1.FormCreate(Sender: TObject); begin stringGrid1.Cells[0,0] := 'Zeit (sek)'; stringGrid1.Cells[1,0] := ' U (Volt)'; stringGrid1.ColCount := 2 end;

Test

Wissenschaft/Technik

13.4 Numerische Integration

681

13.4.3 Weitere Integrationsverfahren Die Rechteckapproximation ist auch als Implizite Euler'sche Rechteckregel in der Literatur bekannt. Sie wird durch folgende Eigenschaften charakterisiert: ■ hohe numerische Stabilität (Vorteil) ■ hoher Diskretisierungsfehler (Nachteil) Der Diskretisierungsfehler ist ein Verfahrensfehler, er lässt sich durch eine Erhöhung der Stellenzahl (z.B. durch Verwendung von Double- anstelle von Single-Zahlen) nicht verringern! Um den Diskretisierungsfehler zu senken, ist eine Verkleinerung der Schrittweite notwendig. Eine automatische Schrittweitensteuerung wird im folgenden Abschnitt beschrieben, die nähere Beleuchtung der Zusammenhänge zwischen numerischer Stabilität und Diskretisierungsfehler würde allerdings den Rahmen dieses Buches weit sprengen und ist Sache der Spezialliteratur. Ohne Probleme dürften Eingeweihte nun in der Lage sein, nach dem oben beschriebenen Schema weitere Integrationsverfahren höherer Ordnung, wie z.B. die Trapezregel, auszuprobieren. Für Interessenten sei noch Folgendes hinzugefügt: Hohe numerische Stabilitätseigenschaften sind besonders für die Analyse nichtlinearer Systeme, wie man sie z.B. bei der Netzwerkanalyse elektrischer Schaltungen antrifft, von ausschlaggebender Bedeutung. Hier versagen selbst solche in der Literatur hochgelobten Integrationsverfahren wie das nach Runge Kutta. Trotz des sehr geringen Diskretisierungsfehlers, den dieses Verfahren im stabilen Bereich bringt, kann es bei Anwendung einer automatischen Schrittweitensteuerung "total aus dem Ruder" laufen, wenn – bedingt durch ungünstige Kennlinienverläufe und Zeitkonstanten – der instabile Bereich erreicht wird.

13.4.4 Automatische Schrittweitensteuerung Wenn der lineare Verlauf einer beliebigen Funktion y = f(x) grafisch dargestellt werden soll, steht man immer vor der Frage: "Wie groß soll der Abstand ∆x zwischen den einzelnen Punkten (Schrittweite) denn nun gewählt werden, damit eine realitätsgetreue Grafik entsteht?" Nimmt man eine sehr kleine Schrittweite ∆x, so bedeutet dies im Allgemeinen eine enorme Verschwendung an Rechenzeit, da Pixel mehrfach an die gleiche Stelle gesetzt werden. Eine zu große Schrittweite hingegen ergibt eine ungenaue Darstellung mit diskontinuierlichen Übergängen (Zacken). Hat man es nun mit einer Funktion zu tun, die nur in einem kleinen Teilbereich starken Änderungen unterliegt, so muss man sich zwangsläufig mit der Wahl von ∆x an diesem "extremen" Abschnitt orientieren, obwohl für den übrigen Teil der Funktion ein weitaus größerer Abstand zwischen den zu verbindenden Punkten genügen würde. Ideal wäre es deshalb, wenn in den Bereichen mit starker Kurvenkrümmung ∆x klein ist und sich in den Abschnitten mit gleichmäßiger Steigung automatisch so vergrößern würde, dass nach dem Prinzip "so genau wie nötig" auch hier ein hinreichend "glatter" Verlauf gewährleistet ist. Diesen Wunsch kann eine automatische Schrittweitensteuerung erfüllen, die eigentlich bei keinem anspruchsvolleren Funktionsplot-Programm fehlen sollte. Sie beruht auf dem Vergleich eines Vorhersagewertes (Prädiktor) mit einem Korrekturwert (Korrektor).

682

Kapitel 13

Wissenschaft/Technik

Ohne tiefer in dieses interessante Gebiet der numerischen Mathematik einzudringen, wollen wir uns im Folgenden mit einem Prädiktor-Korrektor-Verfahren erster Ordnung begnügen. P(3) P(2)

Y

∆Y>ε

∆Y<ε K(2)

K(3)

K(1)

K(0)

0

H0 5 H0

H0

1

2 1

4

2H0 3 2

3

4

X

Die ersten beiden Schritte werden mit der Startschrittweite H0 durchgeführt. Das ist die so genannte Anlaufrechnung. Liegen die beiden Korrektorwerte K(0) und K(1) vor, kann erstmalig ein Prädiktor P(2) ermittelt werden. Entsprechend der expliziten Euler-Formel berechnet er sich aus der Verlängerung der durch K(0) und K(1) führenden Geraden bis zum Punkt x = 2H0. Nach Beendigung des zweiten Schritts ist erstmalig ein Prädiktor-Korrektor-Vergleich möglich. Dies entspricht der Fragestellung: Wie groß ist die Abweichung des vorhergesagten Wertes vom tatsächlich ermittelten Ergebnis? Dazu bildet man den Differenzbetrag beider Werte ∆Y = |P(2) - K(2)| und vergleicht ihn mit der vorgegebenen Fehlerschranke ε. Im Fallbeispiel nach obiger Abbildung liegt ∆Y unterhalb ε, die Schrittweite H kann deshalb auf das Doppelte der Startschrittweite vergrößert werden. Wie aber der Prädiktor-Korrektor-Vergleich P(3) - K(3) zeigt, war dies eine voreilige Entscheidung, und die Automatik muss den Schritt zurücknehmen und mit der alten Schrittweite H0 wiederholen. Allgemein wird in Abhängigkeit vom Vergleichsergebnis zwischen drei Fällen unterschieden: ■ ∆Y < 0.5 ε H kann verdoppelt werden, der neue Prädiktor ist P(n+1) = 3K(n) - 2K(n-1) ■ ∆Y > εDer Schritt muss mit halbierter Schrittweite wiederholt werden.Der alte Prädiktor ist auf die Hälfte zu kürzen: P(n+1) = (P(n) + K(n-1))/2 ■ 0.5 ε < ∆Y < εH wird beibehalten. Der neue Prädiktor ist P (n+1) = 2K(n) - K(n-1).Durch diese Bedingung schafft man einen gewissen "Toleranzschlauch", durch den vermieden wird, dass sich H nach jedem Schritt ändert. Bei hinreichend konstanter Krümmung der Funktion kann deshalb über ein längeres Intervall die gleiche Schrittweite benutzt werden.

683

13.4 Numerische Integration

Grenzbedingungen Die Schrittweite H darf sich nur zwischen den vom Anwender zu definierenden Grenzen Hmin und Hmax verändern. falsch!

Hmax > ∆X

∆X richtig!

Hmax < ∆X

Hmin

Hmin

Für die Festlegung von Hmin und Hmax gelten folgende Gesichtspunkte: ■ Um ein "Aussteigen" der Schrittautomatik bei sprunghaften Änderungen des Funktionswerts zu vermeiden, muss bei Erreichen von Hmin auf ein weiteres Halbieren von H verzichtet werden. Trotz der dadurch bewirkten Verletzung der Fehlerschranke ε ist mit dem nächsten Schritt fortzufahren. Praktisch bedeutet dies eine Approximation (Annäherung) des unendlich steilen Anstiegs durch eine Rampe (gestrichelte Linie in folgender Abbildung, unten). ■ Hmax sollte nicht größer gewählt werden wie der größte zu erwartende "Einbruch" ∆X im Funktionsverlauf. Andernfalls kann es passieren, dass ein solches "Loch" einfach nicht erfasst und ein glatter Verlauf vorgetäuscht wird (siehe folgende Abbildung, oben). Die praktische Umsetzung des Verfahrens nebst ausgiebigen Experimentiermöglichkeiten zur Thematik "Schrittweitensteuerung" finden Sie im Praxisteil dieses Kapitels ("Numerische Integration").

13.4.5 Beispiel Am Beispiel für die Sprungantwort eines RC-Tiefpassgliedes können Sie ein einfaches Integrationsverfahren erster Ordnung (Euler'sche Rechteckregel) testen. Gewissermaßen als Clou bietet sich die Möglichkeit, die Integration mit oder ohne automatische Schrittweitensteuerung durchzuführen.

684

Kapitel 13

Wissenschaft/Technik

Oberfläche Orientieren Sie sich an der folgenden Abbildung. Das Schaltbild wurde als Bitmap-Grafik eingefügt und dient lediglich der Illustration. In der PaintBox (dort, wo jetzt noch gähnende Leere klafft) werden zur Laufzeit das Koordinatensystem und natürlich auch die Kurve erzeugt. Auf eine Skalenbemaßung wurde verzichtet, um den Quelltext nicht unnötig aufzublähen. Eine "Nachrüstung" dürfte jedoch keine großen Schwierigkeiten bereiten.

Quelltext Die Initialisierungen: procedure TForm1.FormCreate(Sender: TObject); begin x1 := 0; y1 := Paintbox1.ClientHeight; x2 := Paintbox1.ClientWidth; y2 := 0; te := Val(edit3.text) / 1000; sx := (x2 - x1) / te; sy := (y1 - y2) / 1; end;

Wird Button1 (links) betätigt, sollen die Zeichenfläche gelöscht, die Grundparameter bestimmt und das Funktionsdiagramm ausgegeben werden: procedure TForm1.Button1Click(Sender: TObject); var t1 : LongInt; begin Paintbox1.Refresh;

13.4 Numerische Integration

Paintbox1.Canvas.pen.color := clBlack; Paintbox1.Canvas.MoveTo(0,0); Paintbox1.Canvas.LineTo(0,Paintbox1.ClientHeight-1); Paintbox1.Canvas.LineTo(Paintbox1.ClientWidth,Paintbox1.ClientHeight-1); te := Val(Edit3.Text) / 1000; dt := Val(Edit4.Text) / 1000; R := Val(Edit1.Text) * 1000; C := Val(Edit2.Text) * 0.000001; sx := (x2 - x1) / te ; sy := (y1 - y2) / 1; t1 := getTickCount; drawCurve; Label3.Caption := 'benötigte Zeit: ' + IntToStr(getTickCount-t1) + ' ms' end;

Die benötigte Zeit (in ms) bestimmen wir über die GetTickCount-Funktion. Es folgt die eigentliche Berechnung nebst grafischer Darstellung. procedure drawCurve; // Eintragen der Zeitfunktion // benötigte globale Parameter: // te = Endzeit // sx,sy = Anzeigeempfindlichkeit in x- und y-Richtung // dt = Startschrittweite var x,y : Single; sz : Integer; // Schrittzähler t : Single; // lfd. Zeit sa : Boolean; e,dtma,dtmi : Single; // Parameter für SW-Automatik up : Single; // Prädiktor u,uk : Single; // aktueller u. gespeicherter Korrektor du : Single; // Prädiktor-Korrektor-Differenz label ma1,ma2,ma3,ma4,ma5; begin // Parameter für Schrittautomatik initialisieren: if Form1.RadioGroup1.ItemIndex = 0 then sa := False else sa := True; if sa then Form1.Paintbox1.Canvas.Pen.Color:= clRed else Form1.Paintbox1.Canvas.Pen.Color:= clBlack; e := 0.0001; // Fehlerschranke = 1/1000 U-Einheit dtma := 100 * dt; // maximale SW dtmi := 0.01 * dt; // minimale SW ma1: // Zeitschleife initialisieren: sz := 0; t := 0; uk := 0; up := 0; ma2: // Einsprung Zeitschleife // Berechnen x- und y-Koordinate als Funktion der Zeit: u := (1 / R + C / dt * uk) / (1 / R + C / dt); // RC-Tiefpass inc(sz); // Schrittzähler erhöhen if Not sa then Goto ma4; // ohne SW-Automatik sofort zur Ausgabe if sz = 1 then Goto ma4; // ersten Punkt sofort ausgeben if sz = 2 then Goto ma3; // erstmals Prädiktor berechnen du := Abs(up - u); // Prädiktor-Korrektor-Differenz if du > e then begin // Verletzung der Fehlerschranke

685

686

Kapitel 13

Wissenschaft/Technik

if t dt if

(dt / 2) < dtmi then Goto ma3; // konstante SW := t - dt; // Schritt zurücknehmen := dt / 2; // SW halbieren sz = 3 then begin // zu große Startschrittweite form1.paintbox1.Refresh; Goto ma1; // zurück zum Anfang end; up := (up + uk) / 2; // Prädiktor kürzen Goto ma5; // ohne Ausgabe zum nächsten Schritt end; if (du > 0.5 * e) Or (2 * dt > dtma) then Goto ma3; // weiter mit konst. SW dt := 2 * dt; // SW verdoppeln up := 3 * u - 2 * uk; // neuer Prädiktor ma4: uk := u; // Korrektor speichern X := x1 + sx * t; Y := y2 + sy * u; // Umrechnung in Grafikkoordinaten if sz = 1 then Form1.Paintbox1.Canvas.MoveTo(Round(X)*10,Form1.Paintbox1.ClientHeight - Round(Y)); with Form1.Paintbox1 do begin if Form1.Checkbox1.Checked then Canvas.LineTo(Round(X),ClientHeight-Round(Y)) else // Linie/Punkt auf x,y ausgeben Canvas.Pixels[Round(X),ClientHeight-Round(y)]:= Form1.Paintbox1.Canvas.Pen.Color; end; if t >= te then begin MessageBeep(0); Exit; end; ma5: t := t + dt; // Zeit inkrementieren Goto ma2; // Schleife ma3: up := 2 * u - uk; // neuer Prädiktor (konstante SW) Goto ma4; end;

Lassen Sie sich von den "bösen" Goto-Anweisungen nicht abschrecken – der Zweck heiligt die Mittel, und die Programmierung hat sich dadurch erheblich vereinfacht!

Test Nach Programmstart betätigen Sie die "Diagramm"-Taste, welche gleichzeitig eine Löschfunktion erfüllt.

13.5 Berechnungen mit einer Datenbank

687

Besonders drastisch wirkt sich der Vorteil der Schrittautomatik bei Vergrößerung von dt aus. Die Automatik schaltet automatisch die Startschrittweite zurück, bis die Fehlerschranke unterboten ist. Wenn Sie den Schrittzähler (sz) am Ende anzeigen, erhalten Sie einen eindrucksvollen Beweis vom Geschwindigkeits- und Genauigkeitsvorzug der Schrittweitenautomatik. Experimentieren Sie mit den Werten für die Fehlerschranke sowie für maximale und minimale Schrittweite (e, dtma, dtmi), und erkunden Sie die Auswirkungen auf Geschwindigkeit und Genauigkeit der numerischen Integration!

13.5 Berechnungen mit einer Datenbank Typisch für relationale Datenbanken ist, dass in bestimmten Tabellen Fremdschlüssel enthalten sind, die auf die Primärschlüssel anderer Tabellen verweisen, in welchen dann die so genannten Detaildaten gespeichert sind. Das Verknüpfen von Tabellen gehört deshalb zum A und O des Delphi-Programmierers. Aber auch ohne SQL-Kenntnisse bietet Ihnen Delphi dafür eine schon fast verwirrende Anzahl von Möglichkeiten. Ein bemerkenswertes Feature ist z.B. das Hinzufügen so genannter berechneter Felder. Das vorliegende "hochwissenschaftliche" Anwendungsbeispiel beleuchtet das dafür notwendige Handwerkszeug, zu dem auch noch der Umgang mit LookupKomponenten und Lookup-Feldern gehört. Gegenstand ist eine durchaus interessante praktische Problemstellung: In einer Datenbank sollen Fahrten von einem Ort zu einem anderen gespeichert werden. Dabei soll die Entfernung zwischen beiden Orten angezeigt und alle inzwischen angefallenen Fahrtenkilometer aufsummiert werden. Wie man leicht sieht, handelt es sich hier um die Basisvariante eines sehr einfachen Fahrtenbuches.

688

Kapitel 13

Wissenschaft/Technik

13.5.1 Datenbank erstellen Die Datenbankstruktur können Sie am einfachsten mit Paradox oder mit dem zu Delphi mitgelieferten Programm Datenbankoberfläche erstellen. Unsere Datenbank besteht aus nur zwei Tabellen: Fahrten.db Feldname Nr Start Ziel

Orte.db Feldname Nr Ort Xkm Ykm

Typ Zähler (+) Integer lang (I) Integer lang (I)

Typ Zähler (+) Alpha (A) Integer lang (I) Integer lang (I)

Die beiden Fremdschlüssel Start und Ziel von Fahrten.db verweisen auf den Primärschlüssel Nr von Orte.db, diese Tabelle enthält die Detaildatensätze. Damit die Orte unabhängig von der Eingabereihenfolge immer alphabetisch geordnet erscheinen, erhält das Feld Ort einen Sekundärindex. Wie dabei vorzugehen ist, erfahren Sie im Praxisteil des Kapitels 9, "Ändern der Sortierfolge einer Tabelle"). Für die Kilometerangaben Xkm und Ykm genügen Integerzahlen. Beide Felder bezeichnen die Entfernung von einem festen Standort (die Heimatgarage des Fahrzeugs) zu dem jeweiligen Ort in West-Ost-Richtung (Xkm) und in Süd-Nord-Richtung (Ykm). In der folgenden Abbildung ist die Stadt Altenburg der feste Standort (Koordinatenursprung).

Altenburg Xkm=0, Ykm=0 -100 -250

Frankfurt a.M. Xkm=-250, Ykm=-100

Bevor Sie mit dem Datenbankentwurf beginnen, legen Sie ein neues Verzeichnis an, in welches Sie dann später beide Tabellen abspeichern. Weisen Sie diesem Verzeichnis einen Alias (z.B. Fahrtenbuch) zu.

689

13.5 Berechnungen mit einer Datenbank

13.5.2 Bedienoberfläche DataSource1 Panel1

Table1

DataSource2 Panel2

Table2

DBLookupComboBox1

DBLookupComboBox2

DBNavigator1

DBNavigator2 Button3 Button2

Wir bringen die Eingabemasken für beide Tabellen auf einem gemeinsamen Formular unter. Wie Sie sehen, sind die Komponenten auf zwei exakt gleich großen Panels gruppiert. Das hat seinen praktischen Grund: Später (vor dem endgültigen Compilieren) wollen wir beide Panels übereinander schieben, durch Ändern der Visible-Eigenschaft (zur Laufzeit) bringen wir dann das jeweils gewünschte Panel in den Vordergrund.

13.5.3 Anbinden der datensensitiven Komponenten Das Prinzip der Bound-Controls wird in 9.1.5 ("Komponenten für Datenzugriff und Datensteuerung") ausführlich erklärt, einen Einstieg vermittelt das Einführungsbeispiel 9.2.

Tabelle Orte.db Weisen Sie im Objektinspektor die Eigenschaften in folgender Reihenfolge zu: Komponente Eigenschaft

Wert

Bemerkung

Table1

DatabaseName

Fahrtenbuch

entsprechend Alias

TableName

Orte.db

Name der Tabelle

Active

True

stellt Verbindung zur Datenbank her

690

Kapitel 13

Wissenschaft/Technik

Komponente Eigenschaft

Wert

Bemerkung

DataSource1

Table1

Tabelle Orte.db

DBNavigator1 DataSource

DataSource1

navigiert durch die Tabelle

DBText1

DataSource

DataSource1

Datensatznummer anzeigen (ReadOnly)

DataField

Nr

DBEdit1

DataSource

DataSource1

DataField

Ort

DataSource

DataSource1

DataField

Xkm

DataSource

DataSource1

DataField

Ykm

DBEdit2 DBEdit3

DataSet

Ort anzeigen Xkm anzeigen Ykm anzeigen

Tabelle Fahrten.db Weisen Sie im Objektinspektor die Eigenschaften in folgender Reihenfolge zu: Komponente

Eigenschaft

Wert

Bemerkung

Table2

DatabaseName

Fahrtenbuch

entsprechend Alias

TableName

Fahrten.db

Name der Tabelle

Active

True

stellt Verbindung zur Datenbank her

DataSource2

DataSet

Table2

Tabelle Fahrten.db

DBNavigator2

DataSource

DataSource2

navigiert durch die Tabelle

DBText3

DataSource

DataSource2

Datensatznummer anzeigen (ReadOnly)

DataField

Nr

DataSource

DataSource2

DataField

Entfernung

berechnetes Feld Entfernung anzeigen (später ergänzen, s.u.!)

DataSource2

primäre Datenquelle

Start

Fremdschlüssel zur Detaildatenquelle

ListSource

DataSource1

Datenquelle der Detailtabelle

KeyField

Nr

Primärschlüssel der Detailtabelle

ListField

Ort

anzuzeigendes Detailfeld

DataSource2

siehe DBLookupComboBox1

DBText2

DBLookupCombo- DataSource Box1 DataField

DBLookupCombo- DataSource Box2 DataField

Ziel

ListSource

DataSource1

KeyField

Nr

ListField

Ort

13.5 Berechnungen mit einer Datenbank

691

Test 1 Es empfiehlt sich eine schrittweise Inbetriebnahme des Programms in drei Etappen. Zunächst testen wir die Funktionsfähigkeit unter Verzicht auf die Anzeige von Entfernung und Gesamtstrecke. Bevor Sie mit dem Eintragen von Fahrten beginnen, sollten Sie einige Datensätze in die Tabelle Orte.db eingeben.

Hinzufügen von vier Lookup-Feldern zur Tabelle Fahrten.db Wie können wir beim Scrollen durch Fahrten.db (Table2) die Entfernung zwischen den beiden Orten anzeigen? Um diese Aufgabe zu lösen, brauchen wir zunächst die Werte der Felder Xkm und Ykm von Start- und Zielort, diese allerdings sind in Table1 gespeichert. Um den Zugriff zu ermöglichen, müssen so genannte persistente Feldobjekte zu Table2 hinzugefügt werden, die dann über ihre Fremdschlüssel mit Table1 verknüpft werden. 1. Doppelklicken Sie auf Table2, es öffnet sich ein kleines Fenster, der so genannte Feldeditor. 2. Klicken Sie mit der rechten Maustaste hinein, wählen Sie im Kontextmenü den Eintrag Felder hinzufügen und klicken Sie den OK-Button. Im Feldeditor erscheinen jetzt alle Tabellenfelder aus Fahrten.db:

Im Objektinspektor können Sie nun die Eigenschaften und Ereignisse dieser persistenten Feldobjekte mit den Namen Table2Nr, Table2Start und Table2Ziel begutachten. 3. Klicken Sie wieder mit der rechten Maustaste auf den Feldeditor und wählen Sie im Kontextmenü den Eintrag Neues Feld. Nehmen Sie in dem sich öffnenden Dialogfenster die folgenden Eintragungen vor (Reihenfolge von links oben nach rechts unten):

692

Kapitel 13

Wissenschaft/Technik

4. Nach dem OK sehen Sie, dass der Feldeditor Zuwachs bekommen hat. Die Eigenschaften des Neuankömmlings können Sie sich im Objektinspektor betrachten und falls erforderlich auch dort editieren. Die folgende Abbildung weist speziell auf die Lookup-Eigenschaften hin. Die zur Erklärung hinzugefügten Bezeichner entsprechen denen im obigen Dialogfenster "Neues Feld".

Typ

Feldtyp Name Schlüsselfeld Datensatz LookupSchlüssel Ergebnisfeld Komponente

5. Fügen Sie nun auf die gleiche Weise die Lookup-Felder yStart, xZiel und yZiel hinzu. Schließlich beinhaltet unser Table2-Objekt insgesamt sieben persistente Feldobjekte, von denen vier Lookup-Felder sind: Table2 Feldobjekt

Typ

Table2Nr

TInteger

Table2Start

TInteger

Table2Ziel

TInteger

Table2xStart

TInteger

Table2yStart

TInteger

Table2xZiel

TInteger

Table2yZiel

TInteger

Table2Entfernung

TInteger

13.5 Berechnungen mit einer Datenbank

693

Die persistenten Feldobjekte (in obiger Zusammenstellung fett gedruckt) sind in der realen Tabelle Fahrten.db nicht enthalten, sie werden von Delphi hinzugefügt und verschwinden demzufolge nach der Beendigung des Programms wieder. Halt, da ist ja in obiger Zusammenstellung noch ein weiteres persistentes Feldobjekt enthalten: Table2Entfernung! Näheres dazu im folgenden Abschnitt.

Hinzufügen eines berechneten Feldes zur Tabelle Fahrten.db Die Entfernung (Luftlinie) zwischen Start und Ziel ergibt sich nach dem Lehrsatz des Pythagoras wie folgt: entfernung := Sqrt(dx2 + dy2) Dabei sind dx und dy die Koordinatendifferenzen zwischen Start- und Zielort: dx := xZiel - xStart dy := yZiel - yStart Um die Entfernung für jeden Datensatz zu speichern, muss ein weiteres persistentes Feldobjekt zu Table2 hinzugefügt werden. Die Vorgehensweise entspricht der beim Hinzufügen von LookupFeldern, nur dass Sie diesmal als Feldtyp die Option "Berechnet" einstellen:

Lookup-Definitionen entfallen hier, denn die Werte berechneter Felder werden meist im OnCalcFields-Event des jeweiligen Table-Objekts ermittelt. Schreiben Sie also bitte den folgenden EventHandler: procedure TForm1.Table2CalcFields(DataSet: TDataSet); var dx,dy: Single; begin dx := Table2xStart.Value-Table2xZiel.Value; dy := Table2yStart.Value-Table2yZiel.Value; Table2Entfernung.Value := Trunc(Sqrt(dx*dx + dy*dy)) end;

694

Kapitel 13

Wissenschaft/Technik

Test 2 Vergessen Sie vor dem Programmstart nicht, die Anzeigekomponente DBText2 an das berechnete Feld Entfernung anzubinden: DataSource = DataSource2, DataField = Entfernung. Nun können Sie sich durch die Fahrteneinträge klicken und dabei gleichzeitig die Entfernungsanzeige beobachten.

Berechnen der Gesamtstrecke Um die Gesamtstrecke zu ermitteln, müssen die Felder Entfernung aus allen Datensätzen von Table2 addiert werden. Das Resultat ist ein ganz normaler Wert (also kein berechnetes Datenbankfeld) und braucht demzufolge auch in keiner DBText-Komponente angezeigt zu werden, ein Label (Label10) genügt. Für das Berechnen der Gesamtstrecke fügen wir der Klassendeklaration von TForm1 eine neue Methode hinzu: type TForm1 = class(TForm) ... private function berechneSumme: String; ...

// neue (private) Methode hinzugefügt

Nun zum Implementation-Abschnitt von TForm1: Da beim Berechnen der Gesamtsumme alle Datensätze der Tabelle Fahrten.db durchlaufen werden, müssen wir uns vorher die aktuelle Position des Datensatzzeigers merken, um uns nach Abschluss der Berechnung wieder an die gleiche Stelle zurückzubewegen: var pos: TBookmark;

// Lesezeichen

Die Implementation unserer neu hinzugefügten Formularmethode: function TForm1.berechneSumme; var sum: Integer; begin sum := 0; with Table2 do begin pos := GetBookmark; // Lesezeichen setzen DisableControls; // Komponenten von Table2 abkoppeln First; while not EOF do begin sum := sum + Table2Entfernung.Value; Next end; GotoBookmark(pos); // Zurücksetzen auf Lesezeichen EnableControls // Komponenten wieder an Table2 ankoppeln end; result := IntToStr(sum) // Ergebnis wird als Zeichenkette geliefert end;

695

13.5 Berechnungen mit einer Datenbank

Um das zeitfressende "Mitwandern" der DB-Komponenten während des Durchlaufens der Tabelle zu verhindern, wurden die Methoden DisableControls und EnableControl eingesetzt. Das Berechnen der Gesamtstrecke im OnCalcField-Event ist nicht zu empfehlen, da durch die häufigen Aufrufe die Geschwindigkeit enorm leiden würde, warum? OnCalcEvent wird z.B. auch beim ganz normalen Weiterbewegen zum nächsten Datensatz ausgelöst, die Gesamtstrecke bleibt aber unverändert. Besser ist es, die Ereignisse OnCreate, AfterPost und AfterDelete zu verwenden, die lediglich beim Programmstart und Verändern, Hinzufügen bzw. Löschen von Datensätzen auftreten, also nur dann, wenn sich die Gesamtstrecke tatsächlich geändert hat: procedure TForm1.FormCreate(Sender: TObject); begin Label10.Caption := berechneSumme end;

// bei Programmstart

procedure TForm1.Table2AfterPost(DataSet: TDataSet); begin Label10.Caption := berechneSumme end;

// nach Abspeichern

procedure TForm1.Table2AfterDelete(DataSet: TDataSet); // nach Löschen begin Label10.Caption := berechneSumme end;

Die folgenden Prozeduren sind rein kosmetischer Natur, sie dienen lediglich dem Ein- bzw. Ausblenden von Panel2: procedure TForm1.Button2Click(Sender: TObject); // Orte editieren begin Panel2.Visible := False end; procedure TForm1.Button3Click(Sender: TObject); // Zurück zur Fahrten-Eingabe begin Panel2.Visible:=True end;

Test 3 Bevor Sie das Projekt endgültig compilieren: Übereinanderschieben von Panel2 auf Panel1 und Verkleinern von Form1 (BorderStyle=bsSingle). Sie werden mit Freude feststellen, dass diese kleine Applikation nun endlich zufrieden stellend funktioniert und dabei ganz ohne SQL auskommt. Die Anzeige der Gesamtstrecke wird erst dann aktualisiert, wenn der neue bzw. geänderte Datensatz tatsächlich in Fahrten.db abgespeichert wird oder nachdem ein Datensatz gelöscht wurde.

696

Kapitel 13

Wissenschaft/Technik

Löschen Sie eine Fahrt, so verschwindet auch deren Primärschlüssel (Nr) auf Nimmerwiedersehen. Wundern Sie sich also später nicht, wenn die laufende Nummernfolge der Fahrten Lücken aufweist. Analoges gilt auch für die Orte, wobei deren Durchnummerierung sowieso durch die alphabetische Sortierfolge außer Kraft gesetzt ist.

Bemerkungen ■ Der Einsteiger sollte sich an folgende Bedienroutinen beim Editieren von Datenzugriffskomponenten gewöhnen: Einmal auf Table-Objekt klicken: Eigenschaften des Table-Objekts werden im Objektinspektor angezeigt. Doppelt auf Table-Objekt klicken: Feldeditor wird aufgerufen, und die Eigenschaften des dort angeklickten persistenten Feldobjekts werden im Objektinspektor angezeigt. ■ AutoCalc = False für Table2 erhöht die Geschwindigkeit, da die Berechnung weniger oft erfolgt (siehe Online-Hilfe). ■ Anstatt beider Panels können Sie auch ein TabControl verwenden. ■ Wenn Sie später die Datenbank umstrukturieren und neue Felder zu einer Tabelle hinzufügen, die mit persistenten Feldobjekten arbeitet, so müssen Sie unter Delphi diese neuen Felder ebenfalls als persistente Feldobjekte hinzufügen, ansonsten stehen sie nicht zur Verfügung. ■ Persistente Felder lassen sich nicht über SQL abfragen. ■ Um die realen Straßenkilometer annähernd zu bestimmen, sollten Sie etwa 30 % zur Luftlinie hinzuschlagen. ■ Eine Möglichkeit, die Koordinateneinträge für die Orte zu vereinfachen, wäre eine LandkartenBitmap, wo die Orte mit der Maus nur angeklickt zu werden brauchen.

697

13.6 Lernbeispiele für Einsteiger

13.6 Lernbeispiele für Einsteiger 13.6.1 Mit physikalischen Maßeinheiten formatieren Auswahl und Umrechnen von physikalischen Maßeinheiten ist höchst lästig und eine häufige Fehlerquelle. Dabei ist es egal, ob Sie mit Papier und Bleistift oder mit einem normalen Taschenrechner hantieren. Wie viel Liter Wasser passen beispielsweise in einen kugelförmigen Behälter mit 0,85 m Durchmesser oder wievielmal ist die Erdoberfläche größer als die des Mondes? Die Lösung für solche oder ähnliche Fragen finden Sie im vorliegenden Beispiel. Es zeigt einen Weg, wie die zu einer Zahl passende Maßeinheit automatisch ermittelt werden kann, und bietet außerdem wichtige Hinweise für die Verwendung der Format-Funktion.

Oberfläche Wie Sie der Abbildung am Ende des Beispiels entnehmen können, brauchen Sie im Wesentlichen eine Textbox (Edit1) für die Eingabe des Kugel-Radius, eine Schaltfläche (Button1) für das Auslösen der Berechnung sowie ein Anzeigefeld (Label1).

Quelltext Auch hier beziehen wir uns nur auf den interessanten Teil der Formular-Unit, auf den Implementation-Abschnitt: var fk: Double; // Maßstabsfaktor me: String; // Maßstabseinheit wert: Double; code: Integer;

Die folgende Prozedur sucht, in Abhängigkeit von der Größe des Radius, eine geeignete Maßeinheit sowie den entsprechenden Umrechnungsfaktor aus: procedure setRadius(radius: Double); begin if radius >= 500 then begin fk := 0.001; me := 'Kilometer' end else if radius >= 0.5 then begin fk := 1; me := 'Meter' end else if radius >= 0.005 then begin fk := 100; me := 'Zentimeter' end else if radius >= 0.0005 then begin fk := 1000; me := 'Millimeter' end else if radius >= 5e-7 then begin fk := 1e6; me := 'Mikrometer' end else ShowMessage('zu klein!!!') end;

// Faktor und Maßeinheit bestimmen // für Himmelskörper etc.

// für alle möglichen Bälle

// für Staubkörnchen

698

Kapitel 13

Wissenschaft/Technik

Der Button "Berechnen": procedure TForm1.Button1Click(Sender: TObject); var fstr: String; begin Val(Edit1.Text, wert, code); setRadius(wert); wert := wert * fk;

Der im Label angezeigte Formatstring wird stückweise aus drei Bestandteilen zusammengesetzt: fstr := Format('Der Radius beträgt %.3f '+ me + '!' + #13,[wert]); wert := wert * wert; fstr := fstr + Format('Die Oberfläche beträgt %.2n Quadrat-'+ me + '!' + #13,[4 * Pi * wert]); wert := wert * Sqrt(wert); fstr := fstr + Format('Das Volumen beträgt %.3n Kubik-'+ me +'!'+ #13,[4/3 * Pi * wert]); Label1.Caption := fstr // Anzeige end;

Test Grundsätzlich ist der Radius in der Maßeinheit "Meter" einzugeben. Das folgende Berechnungsbeispiel analysiert einen alten Bekannten, den Mond:

Experimentieren Sie auch einmal mit kleinen Staubkörnchen, benutzen Sie dazu für die Eingabe das wissenschaftliche Format, z.B. 6.365e-6 m.

13.6 Lernbeispiele für Einsteiger

699

Bemerkungen ■ Der Zeilenumbruch im Label wird durch Einfügen von #13 in den Formatstring erzeugt. ■ Wenn Sie anstatt f- oder n- den g-Datentyp nehmen, wird die jeweils kürzeste Zahlendarstellung gewählt. ■ Um die versehentliche Eingabe eines Dezimalkommas (anstatt eines Dezimalpunktes) zu korrigieren, fügen Sie den folgenden Event-Handler hinzu: procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char); begin if Key = ',' then Key:= '.' end;

13.6.2 Zahlen konvertieren Dieses Progrämmchen dient zur eleganten Umrechnung von Dezimal-, Hexadezimal- und Binärzahlen. Außerdem wird dabei demonstriert, wie unter Delphi so genannte "gleitende" Berechnungen durchgeführt werden können. "Gleitend" soll hier bedeuten, dass auf eine "Ergebnistaste" (entsprechend der "="-Taste eines normalen Taschenrechners) verzichtet werden kann, da das Ergebnis sofort aktualisiert wird, wenn sich eine Eingangsgröße geändert hat. Ein Unterschied zwischen Einund Ausgabefeldern existiert nicht mehr.

Oberfläche Auf dem Startformular sind lediglich drei Textfelder (Edit1, Edit2 und Edit3) erforderlich, in welche Dezimal-, Hexadezimal und Binärzahlen ein- und ausgegeben werden.

Quelltext Der implementation-Abschnitt von Unit1: var zahl: LongInt;

Umwandeln Integer in Binär: function intToBinary(value:LongInt; digits: Byte): string; var i : Byte; mask : LongInt; begin SetLength(result,digits); for i := 0 to digits-1 do begin mask := 1 shl i; if (mask and value) = mask then result[digits-i]:= '1' else result[digits-i]:= '0' end; end;

700

Kapitel 13

Wissenschaft/Technik

Umwandeln Binär in Integer: function binaryToInt(value:string): LongInt; var i, len : Byte; begin result := 0; len := Length(value); for i := len downto 1 do if value[i] = '1' then result := result or (1 shl (len-i)) end;

Der Aufrufcode besteht aus Vereinfachungsgründen aus nur einem einzigen Event-Handler, der auf das OnChange-Ereignis aller drei Editierfelder reagiert. Schreiben Sie zunächst wie gewohnt diesen Event-Handler für Edit1 und stellen Sie dann im Objektinspektor auch das OnChange-Ereignis von Edit2 und Edit3 auf EditChange ein: procedure TForm1.EditChange(Sender: TObject); begin if Sender = Edit1 then try // Dezimalzahl geändert zahl := StrToInt(Edit1.Text); Edit2.Text := '$'+IntToHex(zahl,0); // Hexzahl anzeigen Edit3.Text := intToBinary(zahl, 32) // Binärzahl anzeigen except end; if Sender = Edit2 then // Hexzahl geändert try zahl := StrToInt(Edit2.Text); Edit1.Text := IntToStr(zahl); // Dezimalzahl anzeigen Edit3.Text := intToBinary(zahl, 32) // Binärzahl anzeigen except end; if Sender = Edit3 then // Binärzahl geändert try zahl := binaryToInt(Edit3.Text); Edit1.Text := IntToStr(zahl); // Dezimalzahl anzeigen Edit2.Text := '$' + IntToHex(zahl,0); // Hexzahl anzeigen except end end;

Um die unvermeidlichen Konvertierungsfehler zu umgehen, wurden alle Umrechnungen in tryexcept-Blöcken eingeschlossen (siehe Hinweis unten).

Test Sie können nun in ein beliebiges Feld eine Zahl eingeben. Falls eine Umrechnung möglich ist, wird das Ergebnis sofort in den anderen Feldern sichtbar.

13.7 Praxisbeispiele für Fortgeschrittene

701

HINWEIS: Falls es beim Austesten in der Entwicklungsumgebung trotz der try-except-Kapse-

lung zu Fehlermeldungen kommt, müssen Sie im Menü Tools|Debugger-Optionen auf der Seite "Sprach-Exceptions" das Häkchen bei "Bei Delphi-Exceptions stoppen" wegnehmen. Für das spätere Ausführen der EXE-Datei (d.h. außerhalb der DelphiIDE) hat diese Einstellung allerdings keine Bedeutung mehr.

Bemerkungen ■ Beachten Sie, dass die Zahlenbereiche nicht unbegrenzt sind (max. 32 Bit). ■ Eine Hexadezimalzahl wird in Object Pascal immer mit einem Dollarzeichen ($) eingeleitet. So wird eine Verwechslung mit Dezimalzahlen vermieden.

13.7 Praxisbeispiele für Fortgeschrittene 13.7.1 Rechnen mit komplexen Zahlen Im vorliegenden Praxisbeispiel wollen wir uns eine Unit schaffen, die für das Rechnen mit komplexen Zahlen zu gebrauchen ist. Sie soll neben einem komplexen Datentyp die Funktionen für Addition, Multiplikation und Division zur Verfügung stellen. Eine detaillierte Erläuterung der zugrunde liegenden mathematischen Algorithmen ist hier nicht vorgesehen und würde nur vom eigentlichen Anliegen ablenken1.

Quelltext für Unit erstellen Unmittelbar nach dem Start von Delphi klicken wir den Menüpunkt Datei|Neu..., wählen Unit und sehen ein Fenster mit einem sehr mageren Rahmencode für eine Unit namens Unit2 vor uns: In den Interface-Abschnitt tragen wir die Typdeklaration für TKomplex sowie die Kopfzeilen für die mit diesem Datentyp operierenden komplexen Funktionen addK, multK und divK ein. Nur diese insgesamt vier Bibliothekselemente sollen für den späteren Nutzer der Unit "sichtbar" sein. unit Unit2; interface

1

// Komplexe Grundrechenoperationen

Komplexe Zahlen sind wesentlicher Bestandteil der Elektrotechnik (Wechselstromlehre).

702

Kapitel 13

Wissenschaft/Technik

type // Datentyp für komplexe Zahl in kartesischen Koordinaten TKomplex = record re, im : Single; // Real- und Imaginärteil end; function addK(a,b: TKomplex): TKomplex; // Addition kompl. Z. function multK(a,b: TKomplex): TKomplex; // Multiplikation kompl. Z. function divK(a,b: TKomplex): TKomplex; // Division kompl. Z.

Im implementation-Abschnitt werden die drei Funktionen mit Leben erfüllt. Für die Notation der Kopfzeilen findet die Kurzform1 Verwendung: implementation var kx: TKomplex;

// interne Zwischenvariable

Addition: function addK; begin kx.re := a.re + b.re; kx.im := a.im + b.im; result := kx end;

Multiplikation: function multK; begin kx.re := a.re*b.re - a.im*b.im; kx.im := a.re*b.im+a.im*b.re; result := kx end;

Division: function divK; begin kx.re := (a.re*b.re+a.im*b.im)/(b.re*b.re+b.im*b.im); kx.im := (a.im*b.re-a.re*b.im)/(b.re*b.re+b.im*b.im); result := kx end; end.

HINWEIS: Falls Ihnen bei einem eventuellen Neustart des Projekts die Unit2 verloren gegangen

sein sollte, können Sie diese über den Menüpunkt Ansicht|Units... (Strg+F12) wieder herbeizaubern.

1

Dabei wird die Parameterleiste einfach weggelassen.

703

13.7 Praxisbeispiele für Fortgeschrittene

Oberfläche für Testprogramm Um uns von der Funktionsfähigkeit der Unit2 zu überzeugen, brauchen wir ein kleines Testprogramm, das die Ein- und Ausgabe von komplexen Zahlen und die Auswahl der Rechenoperation ermöglicht. Wir benutzen dazu das bereits vorhandene Startformular Form1, auf das wir sechs Editierfelder (Edit1 ... Edit6), eine Gruppe von drei RadioButtons (RadioButton1 ... RadioButton3) und einen Schalter (Button1) platzieren:

Setzen Sie ReadOnly für Edit3 und Edit6 auf True, da wir diese Felder nur zur Ergebnisanzeige brauchen.

Quelltext für Testprogramm Im folgenden Implementationsteil von Unit1 wird Unit2 eingebunden und reger Gebrauch von den zur Verfügung gestellten Sprachelementen (TKomplex, addK, multK, divK) gemacht. Die Ausgabeformatierung erfolgt mit insgesamt acht Stellen, davon zwei nach dem Dezimaltrenner. uses Unit2; var code: Integer; zk1, zk2, zk3: TKomplex;

// Unit2 einbinden! // komplexe Zwischenvariablen

Die folgende Prozedur ist die entscheidende Routine: procedure displayResult; // Berechnung und Anzeige var s: string; begin with Form1 do begin Val(Edit1.Text, zk1.re, code); Val(Edit4.Text, zk1.im, code); Val(Edit2.Text, zk2.re, code); Val(Edit5.Text, zk2.im, code); if RadioButton1.Checked then zk3:= addK(zk1, zk2); if RadioButton2.Checked then zk3:= multK(zk1, zk2); if RadioButton3.Checked then if (zk2.re <> 0) or (zk2.im <> 0) then zk3:= divK(zk1, zk2); Str(zk3.re:8:2,s); Edit3.Text:= s; // Anzeige Realteil Str(zk3.im:8:2,s); Edit6.Text:= s // Anzeige Imaginärteil

704

Kapitel 13

Wissenschaft/Technik

end end;

Nun zu den Event-Handlern: procedure TForm1.FormCreate; // Formular laden begin Edit1.Text:= '1'; Edit2.Text:= '1'; Edit3.Text:= '2'; Edit4.Text:= '1'; Edit5.Text:= '1'; Edit6.Text:= '2' end;

Für das OnClick-Event der RadioButtons wurden, genauso wie für OnKeyPress und OnKeyUp der Editierfelder, jeweils gemeinsame Ereignisbehandlungen geschrieben: procedure TForm1.ClickRadioB; begin displayResult end;

// Wechsel des Operators

procedure TForm1.EditKeyPress; // Komma in Dezimalpunkt verwandeln begin if key = ',' then key:= '.' end; procedure TForm1.EditKeyUp; begin displayResult end;

// Eingabe

Die Prozedur displayResult ist keine Methode von Form1. Sie muss deshalb an den Anfang des Implementation-Teils gesetzt werden, damit sie noch vor den Methoden, die sie aufrufen, deklariert ist (sonst erfolgt Compiler-Fehlermeldung!).

Test Starten Sie das Programm und überzeugen Sie sich von der Funktionsfähigkeit der Unit2. Eine Ergebnistaste brauchen Sie nicht – das Resultat wird sofort nach jeder Tastatureingabe aktualisiert. Wenn als Beispiel die Aufgabe (2.5 + 3j) / (-2 + j) gelöst werden soll, erhalten Sie als Ergebnis die komplexe Zahl -0.4 -1.7j. Sie brauchen sich auch nicht mehr darum zu kümmern, ob Sie als Dezimaltrenner Komma oder Punkt verwenden. Wie von Geisterhand wird jede Kommaeingabe in einen Punkt umgewandelt.

13.7 Praxisbeispiele für Fortgeschrittene

705

Bemerkungen ■ Wenn die Unit2 getestet ist und zufrieden stellend funktioniert, sollten Sie ihr einen aussagekräftigeren Namen geben, z.B. Komplex. ■ Wie wäre es mit einer "standesgemäßen" objektorientierten Lösung? Sie müssten dazu in der Unit eine Klasse definieren, welche die Rechenoperationen als Methoden bereitstellt.

13.7.2 Kreuzprodukt von Vektoren (OOP-Beispiel) Nichts lässt das von Selbstzweifeln zernagte Herz eines Mathe-Lehrers höher schlagen als ein gutes Demoprogramm, mit dem er (fernab des Verdachts jedweder Spielerei) seinen Schülern anschaulich abstraktes Wissen vermitteln kann. Auch manch gelangweilter Schüler erwacht aus seiner Lethargie, wenn der Lehrer glaubhaft machen kann, dass er alles selbst programmiert hat. Gleich mehrere Fliegen werden mit einer Klappe geschlagen: ■ Verständnis der naturwissenschaftlichen Zusammenhänge1, ■ Aufstieg in die "höheren" Regionen der OOP, ■ und last but not least: Spaß! Es soll nicht bestritten werden, dass ein hartnäckiger OOP-Muffel auch mit herkömmlicher Programmierung schnell zu einer funktionsfähigen Applikation kommen kann. Im Ergebnis einer solchen Hauruck-Aktion findet sich der gesamte Quellcode meist in einer einzigen Unit (der des Formulars) wieder und wird (zumindest für den Nachfolger des gefeuerten Muffels) nicht mehr überschaubar sein, was die Wiederverwendbarkeit, die Erweiterbarkeit und Pflege der Applikation in Frage stellt. HINWEIS: OOP ist kein Selbstzweck, sondern dient vor allem dem Ziel, übersichtlichen,

wiederverwendbaren und erweiterbaren Code zu schreiben. Als Beispiel dient das Thema "Kreuzprodukt von Vektoren".

Etwas Theorie Ohne weiter in die Theorie abzuschweifen, soll nur so viel vorausgesetzt werden: Der resultierende Vektor des Kreuzprodukts steht immer senkrecht auf der durch A und B aufgespannten Ebene, C = A x B Wenn A = A.x + A.y und B = B.x + B.y 1

Das Kreuzprodukt von Vektoren ist keine abstrakte mathematische Angelegenheit, sondern wird z.B. in der Physik bzw. Elektrotechnik (Feldtheorie) umfassend angewendet.

706

Kapitel 13

Wissenschaft/Technik

dann ist seine Länge: |C| = A.x * B.y – A.y * B.x Der mathematische Hintergrund stellt also keine besondere Hürde dar, die Hauptschwierigkeit liegt, wie Sie sehen werden, in der optischen Gestaltung (Grafikprogrammierung).

Sorgfältige Planung ist wichtig Von unserem Programm sollten wir bereits zu Beginn eine möglichst konkrete Vorstellung entwickeln:

Das einzige Formular soll ein dreidimensionales Koordinatensystem (Achsen x, y, z) anzeigen. Die beiden Vektoren a und b sollen sich mit der Maus per Drag& Drop in Richtung und Länge verändern lassen. Das von ihnen aufgespannte Parallelogramm soll ebenfalls angezeigt werden. Der Ergebnisvektor (bzw. das Kreuzprodukt) axb liegt fest auf der z-Achse und ändert seine Länge in Abhängigkeit von a und b (bzw. proportional zur Fläche des Parallelogramms). Nachdem man sich eine möglichst genaue Vorstellung von der angestrebten optischen Präsentation gemacht hat, kommt die entscheidende Frage: Welche Objekte sind vorhanden, und wie kann ich sie am besten in Klassen aufteilen? Bedenken Sie dabei immer: Objekte mit gleichen oder ähnlichen Eigenschaften sollten zusammengefasst und einer Klasse zugeordnet werden.

707

13.7 Praxisbeispiele für Fortgeschrittene

Das Klassendiagramm liefert den Bauplan Ein einfaches Klassendiagramm besteht aus drei Abschnitten: ■ Name der Klasse (oben) ■ Auflistung der Eigenschaften (Mitte) ■ Auflistung der Methoden (unten) Werfen Sie einen Blick auf den obigen Screenshot, so können Sie Pfeil-Objekte in drei unterschiedlichen Klassenzugehörigkeiten feststellen: ■ unbewegliche Achsen x, y, z ■ mit der Maus frei zu bewegende Vektoren a und b ■ längenveränderlicher Ergebnisvektor für das Kreuzprodukt c = axb Das im Folgenden dargestellte Klassendiagramm enthält einen Lösungsvorschlag, wie man diese drei Pfeil-Objekte von drei verschiedenen Klassen (TPfeil, TVektor und TKreuzprodukt) ableiten kann. Dabei sind TVektor und TKreuzprodukt Nachkommen von TPfeil, erben also sämtliche Eigenschaften und Methoden. TPfeil X Y angle erzeugen zeichnen

// x-Koordinate der Pfeilspitze // y-Koordinate ... // Winkel // initialisiert Pfeil // zeichnet verdrehten Pfeil

TVektor zustand anfassen ziehen loslassen

// Status beim Ziehen/Loslassen // Maus-Anfassoperation // Maus-Ziehoperation // Maus-Loslassoperation

TKreuzprodukt mf kp

// Maßstabsfaktor für Grafik // Kreuzprodukt (Zahlenwert)

berechnen // berechnet Kreuzprodukt zeichneParallelogramm // füllt Fläche

Wir wollen das Projekt in vier Etappen realisieren, die systematisch aufeinander aufbauen.

708

Kapitel 13

Wissenschaft/Technik

Etappe 1 In dieser Etappe soll die Klasse TPfeil entworfen werden. Aus dieser Klasse werden wir drei Instanzen (Pfeil-Objekte) ableiten und zum Zeichnen des Koordinatensystems benutzen. Besondere Schwierigkeiten: ■ Ein dreidimensionales Koordinatensystem wird zweidimensional dargestellt. Die z-Achse muss also "verdreht" werden. ■ Die Pfeilspitzen sollen sich beim Drehen nicht verzerren. ■ In weiser Voraussicht auf spätere "bewegte" Pfeile sollte der XOR-Zeichenmodus Verwendung finden.

Pfeil-Unit Fügen Sie dem Projekt eine Unit hinzu, die Sie in Pfeil umbenennen. unit Pfeil; interface uses Forms, Graphics; type TPfeil = class(TObject) // Klassendeklaration private x1, y1, // Anfangspunkt ... x2, y2, // Endpunkt des Pfeils ps : Single; // Länge der Pfeilspitzen frm : TForm; // Zeichenformular col : TColor; // Farbe ld : Integer; // Liniendicke name: string; procedure setAngle(alf: Single); function getX: Single; function getY: Single; procedure setX(dx: Single); procedure setY(dy: Single); public constructor erzeugen(xa,ya: Single; f: TForm; xb,yb: Single; cl: TColor; l, p: Integer; nam:string); property angle: Single write setAngle; // setzt x2, y2 bei übergebenem Winkel property x: Single read getX write setX; // relative x-Koordinate property y: Single read getY write setY; // dto. y procedure zeichnen; // zeichnet Pfeil end;

Der implementation-Abschnitt: constructor TPfeil.erzeugen; begin x1:=xa; y1:=ya;

709

13.7 Praxisbeispiele für Fortgeschrittene

frm:=f; x2:=x1+xb; y2:=y1-yb; col:= cl; ld:=l; ps:=p; name:=nam; end;

Zugriffsmethoden für Eigenschaften: procedure TPfeil.setAngle; // verdreht Pfeil um Winkel alf im Uhrzeigersinn var pl: Single; begin pl := Sqrt((x*x + y*y)); // Länge des Pfeils x2 := x1 + pl * Sin(alf); y2 := y1 - pl * Cos(alf) end; function TPfeil.getX; begin Result := x2-x1 end;

// liest relative Koordinate x

procedure TPfeil.setX; begin x2 := x1 + dx end;

// schreibt relative Koordinate x

function TPfeil.getY; begin Result := y2-y1 end;

// liest relative Koordinate y

procedure TPfeil.setY; begin y2 := y1 + dy end;

// schreibt relative Koordinate y

Zeichnen eines gedrehten Pfeils: procedure TPfeil.zeichnen; var pl, // Länge des Pfeils si, co: Single; // Sinus u. Kosinus des Drehwinkels

Hilfsfunktionen (allgemein für beliebige Symbole verwendbar): function tX(dx, dy: Single): Integer; // transformiert x-Koordinate begin Result := Round(x1 + dx*co + dy*si) end; function tY(dx, dy: Single): Integer; // transformiert y-Koordinate begin Result := Round(y1 + dy*co - dx*si) end; procedure dwp(dx, dy: Single); // setzt Zeichenstift auf transformierte Position begin frm.Canvas.MoveTo(tX(dx,dy), tY(dx,dy)) end; procedure dwl(dx, dy: Single); // zieht Linie zur transf. Position begin frm.Canvas.LineTo(tX(dx,dy), tY(dx,dy)) end; procedure dwt(dx, dy: Single; s:string); begin

// schreibt Text an transf. Position

710

Kapitel 13

frm.Canvas.TextOut(tX(dx,dy), tY(dx,dy), s) end;

Hauptprogramm: begin with frm.Canvas do begin Pen.Color:= frm.Color xor col; // XOR-Zeichnungsmodus Pen.Width:=ld; // Stiftstärke

Pfeilschaft zeichnen: MoveTo(Round(x1),Round(y1)); LineTo(Round(x2),Round(y2)) end;

// Stift auf Anfangspunkt setzen // Linie zum Endpunkt ziehen

Pfeilspitze verzerrungsfrei zeichnen (relativ aufwändig): pl := Sqrt((x*x + y*y)); if pl=0 then pl:=0.1; si := -y/pl; co := x/pl; dwp(pl-ps, ps/2); dwl(pl,0); dwl(pl-ps,-ps/2); dwt(pl+2*ps, -ps, name) end; end.

// // // // // //

Länge des Pfeils Gleitkommaüberlauf vermeiden Sinus und Kosinus berechnen Anfangspunkt der Pfeilspitze setzen obere Linie ziehen dto. untere Linie

// Pfeil beschriften

Form-Unit in Etappe 1 Es genügt die Wiedergabe des implementation-Abschnitts: uses Pfeil; var achseX, achseY, achseZ: TPfeil; // Achssystem x0, y0: Single; // Koordinatenursprung procedure TForm1.FormCreate(Sender: TObject); begin Color := clWhite; Canvas.Pen.Mode := pmXOR; x0 := ClientWidth/2; y0 := ClientHeight/2; // Koordinatensystem zeichnen: // Achslänge=200, Linienstärke=1, Pfeilspitze=6 achseX := TPfeil.erzeugen(x0, y0, Form1, 200, 0, clBlack, 1, 6, 'x'); achseY := TPfeil.erzeugen(x0, y0, Form1, 0, 200, clBlack, 1, 6, 'y'); achseZ := TPfeil.erzeugen(x0, y0, Form1, 200, 0, clBlack, 1, 6, 'z'); achseZ.angle := 5/4*Pi // Verdrehen der z-Achse end;

Wissenschaft/Technik

13.7 Praxisbeispiele für Fortgeschrittene

711

procedure TForm1.FormPaint(Sender: TObject); begin achseX.zeichnen; achseY.zeichnen; achseZ.zeichnen end;

Test der Etappe 1 Achten Sie besonders auf die Darstellung der Pfeilspitzen, auch bei der z-Achse sollten sie unverzerrt sein.

Etappe 2 In dieser Etappe werden wir unserem Projekt die Klasse TVektor hinzufügen, denn diese brauchen wir für die zwei "beweglichen" Vektoren a und b. Als Nachkomme von TPfeil fügt sie dem "Erbmaterial" neue Drag & Drop-Eigenschaften und -Methoden hinzu. Besondere Schwierigkeiten: ■ Animation ohne Verletzen des Hintergrundes und ohne Flackern ■ Beschriftung der Vektoren ■ "Anfassen" der Pfeilspitzen

712

Kapitel 13

Wissenschaft/Technik

Vektor-Unit unit Vektor; interface uses Pfeil; type TVektor = class(TPfeil) // TVektor ist Nachkomme von TPfeil private z: Integer; // Zustand (0 = "normal", 1 = "gezogen") public property zustand: Integer read z write z; // Ziehoperationen mit Maus: procedure anfassen(x,y: Integer); procedure ziehen(x,y: Integer); procedure loslassen; end; implementation

Die folgende Methode testet, ob der Mausklick die Pfeilspitze trifft: procedure TVektor.anfassen; const d=6; // Kantenlänge für sensibles Viereck begin if (x>x2-d) and (x<x2+d) and (y>y2-d) and (y
x2 und y2 stammen aus dem protected-Abschnitt von TPfeil! end;

Beim Ziehen erlaubt der XOR-Zeichenmodus ein Löschen durch Überzeichnen: procedure TVektor.ziehen; begin if z = 1 then begin zeichnen; x2:=x; y2:=y; zeichnen; end end;

// // // //

kein Zeichnen im Zustand "Normal" alten Pfeil löschen durch Überzeichnen Endpunkt des Pfeils verändern Pfeil neu zeichnen

Das Loslassen führt zurück zum Anfangszustand: procedure TVektor.loslassen; begin z:=0 end; end.

Form-Unit in Etappe 2 Es werden nur die Änderungen/Ergänzungen angegeben. In der Typdeklaration sind zwei Methoden zur Beschriftung der Vektoren hinzuzufügen:

13.7 Praxisbeispiele für Fortgeschrittene

type TForm1 = class(TForm) ... procedure labelA; procedure labelB; end; implementation uses ..., Vektor; var ..., A, B: TVektor;

// Klassen-Unit hinzufügen //zwei drehbare Vektoren hinzufügen

procedure TForm1.FormCreate(Sender: TObject); begin ...

Vektoren erzeugen und initialisieren: A := TVektor.erzeugen(x0, y0, Form1, 100, 0, clBlue, 3,10, ''); A.zustand := 0; labelA; B := TVektor.erzeugen(x0, y0, Form1, 0, 100, clLime, 3,10, ''); B.zustand := 0; labelB end;

Methoden zur Beschriftung hinzufügen: procedure TForm1.labelA; begin Label1.Left := Round(x0+A.x+5); Label1.Top:= Round(y0+A.y+5) end; procedure TForm1.labelB; begin Label2.Left := Round(x0+B.x+5); Label2.Top:= Round(y0+B.y+5) end;

Drei Event-Handler für Drag & Drop-Operationen besetzen: procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin A.anfassen(X,Y); B.anfassen(X,Y) end; procedure TForm1.FormMouseMove(Sender: TObject; Shift: TShiftState; X,Y: Integer); begin if (A.zustand=1) then begin A.ziehen(X,Y);

713

714

Kapitel 13

Wissenschaft/Technik

labelA end; if (B.zustand=1) then begin B.ziehen(X,Y); labelB end end; procedure TForm1.FormMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin A.loslassen; B.loslassen end;

OnFormPaint-Event-Handler ergänzen: procedure TForm1.FormPaint(Sender: TObject); begin ... A.zeichnen; B.zeichnen end;

Test von Etappe 2 Fassen Sie die Pfeilspitzen a oder b mit der Maus an und ziehen Sie sie an neue Positionen.

715

13.7 Praxisbeispiele für Fortgeschrittene

Etappe 3 Nun soll als letzte die Klasse TKreuzProd realisiert werden. Aufgabe ist die Berechnung und grafische Anzeige des Kreuzprodukts. Die Klasse ist laut Klassendiagramm ebenfalls Nachkomme von TPfeil. Besondere Schwierigkeiten: ■ Da das Kreuzprodukt relativ große Zahlenwerte annehmen kann, ist ein geeigneter Maßstabsfaktor für die grafische Anzeige zu finden. ■ Die Vektoren a und b sind an die Methode berechnen als Parameter zu übergeben.

Kreuzprodukt-Unit unit Kreuzprodukt; interface uses Pfeil, Vektor, Graphics, Forms; type TKreuzProd = class(TPfeil) // Nachkomme von TPfeil private public procedure berechnen(xp,yp: Integer; A,B: TVektor); end; implementation procedure TKreuzProd.berechnen; const m=100; // Maßstabsfaktor var axb: Single; // Kreuzprodukt begin zeichnen; A.ziehen(xp, yp); B.ziehen(xp, yp); axb := -A.x * B.y + x := axb/m; // y := 0; if axb > 0 then angle := 5/4*Pi else angle := 1/4*Pi; zeichnen end; end.

// ändert A, B und C!

// löscht C-Vektor // verändert und zeichnet A-Vektor neu // dto. für B-Vektor A.y * B.x; // KP berechnen KP für Anzeige m-fach verkleinern

// in negative z-Richtung drehen // in positive z-Richtung " // zeichnet neuen C-Vektor

716

Kapitel 13

Wissenschaft/Technik

Form-Unit in Etappe 3 Auch hier wollen wir nur auf die erforderlichen Ergänzungen/Änderungen hinweisen: Der Typdefinition von TForm1 ist eine Prozedur zur Beschriftung des Kreuzprodukt-Vektors hinzuzufügen: procedure labelC;

Der implementation-Abschnitt: uses ..., Kreuzprodukt; var: ..., C: TKreuzProd;

Im OnCreate-Event von Form1 muss der Vektor C hinzugefügt und initialisiert werden: C := TKreuzProd.erzeugen(x0, y0, Form1, 100, 0, clRed, 3,10, ''); C.angle := 5/4*Pi; labelC

Auch hier wird mangels geeigneter Alternative die Beschriftung mit Labels realisiert: procedure TForm1.labelC; begin Label3.Left := Round(x0+C.x+5); Label3.Top:= Round(y0+C.y+5) end;

Der OnMouseMove-Event-Handler hat sich grundlegend geändert: procedure TForm1.FormMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer); begin if (A.zustand=1) or (B.zustand=1) then begin C.berechnen(x,y, A, B); // berechnet und zeichnet A,B und C labelA; labelB; labelC end end;

Im OnPaint-Event-Handler ergänzen Sie: C.zeichnen

Test von Etappe 3 Das Programm besitzt bereits jetzt schon seine Grundfunktionalität. Ziehen Sie an a oder b, ändert sich auch axb.

13.7 Praxisbeispiele für Fortgeschrittene

717

Etappe 4 Für diese Etappe brauchen wir keine neue Klasse, wir müssen aber die bereits vorhandene Klasse TKreuzprodukt um die Methode zeichneParallelogramm ergänzen. Die Fläche des durch a und b aufgespannten Parallelogramms entspricht mathematisch exakt dem Kreuzprodukt. Besondere Schwierigkeiten: ■ Realisierung des "bewegten" Parallelogramms ohne lästigen Flackereffekt ■ zahlenmäßige Anzeige der Vektorkoordinaten

Ergänzungen in Kreuzprodukt-Unit Die folgende Methode zeichnet das durch die Vektoren A und B aufgespannte Parallelogramm: procedure TKreuzProd.zeichneParallelogramm (A, B: TVektor); var xa,ya,xb,yb,xc,yc,xd,yd: Integer; begin xa:=Round(x1+A.x); ya:=Round(y1+A.y); xb:=Round(x1+A.x+B.x); yb:=Round(y1+A.y+B.y); xc:=Round(x1+B.x); yc:=Round(y1+B.y); xd:=Round(x1); yd:=Round(y1); with frm.Canvas do begin Pen.Color := frm.Color xor clYellow; Brush.Color := clYellow xor frm.Color;

718

Kapitel 13

Wissenschaft/Technik

Polygon([Point(xa,ya),Point(xb,yb),Point(xc,yc), Point(xd,yd)]) end end;

Außer dem Hinzufügen obiger Methode sind noch einige wenige kleinere Änderungen erforderlich, über die Sie sich bitte in der Buch-CD informieren. Das Gleiche trifft für die Formular-Unit zu.

Test von Etappe 4 Endlich ist es geschafft (siehe Screenshot am Anfang des Beitrags)! Der mathematisch interessierte Leser kann jetzt "hochinteressante" Erkundungen durchführen, z.B. ■ Kommutativgesetz gilt beim Kreuzprodukt nicht, denn AxB <> BxA, ■ wenn Fläche des Parallelogramms verschwindend ist, so ist auch das Kreuzprodukt 0, ■ ein rechter Winkel zwischen A und B ergibt maximales Kreuzprodukt, ■ haben A und B entgegengesetzte Richtung, so ergibt sich unabhängig von deren Größe immer das Kreuzprodukt 0.

14

Datenstrukturen

Kapitel

14

Datenstrukturen Zeichenketten (Strings) und dynamische Arrays gehören mit zu den wichtigsten Datenstrukturen von Delphi. Dieses Kapitel dürfte deshalb für den fortgeschrittenen Programmierer eine willkommene Ergänzung zu den grundlegenden Ausführungen des Sprachkapitels 2 sein1.

14.1 Strings, Strings, Strings Ging es, was die Verwendung von Strings betrifft, bei den älteren Delphi- bzw. Pascal-Versionen noch recht übersichtlich zu, hielten ab Delphi-Version 2 einige Neuerungen Einzug, die beim Einbzw. Umsteiger für Konfusion sorgen könnten. Unterscheiden sollten Sie zwischen folgenden Typen: ■ Short String Der altbekannte Stringtyp mit max. 255 Zeichen, ein Längenbyte befindet sich am Anfang des Strings. ■ Long StringDer neue Standard-String kann max. 2 Gigabyte2 speichern. Long Strings sind zuweisungskompatibel mit dem von der API verwendeten PChar-Stringtyp. Dies trifft allerdings nur bei der direkten Zuweisung (a := b) zu. Bei der Übergabe von Funktionsparametern müssen Sie eine explizite Typumwandlung mit PChar(...) vornehmen. ■ Nullterminierter String (PChar)Vertreter dieser Gattung finden Sie häufig bei der Arbeit mit API-Funktionen. Die Verwendung ist im Vergleich mit den "normalen" Strings etwas umständlicher, geht es jedoch um die schnelle Verarbeitung von Zeichenketten mit Hilfe von Pointern, sind PChar-Strings die erste Wahl. ■ Unicode-Strings (WideChar)Jedes Zeichen des Strings wird mit 2 Bytes beschrieben, auf diese Weise lassen sich bis zu 65536 Zeichen codieren. Den Unicode-Zeichen dürfte im Laufe der Zeit eine immer größere Bedeutung zukommen.

1

Einsteiger sollten sich derlei schwer verdauliche Kost vorerst nicht zumuten.

2

An dieser Stelle sollten Sie auch einen Blick für die verfügbaren Computer-Ressourcen übrig haben.

720

Kapitel 14

Datenstrukturen

Die folgende Skizze zeigt die Unterschiede: Längenbyte

Short String

6

A

B

C

D

E

F

D

E

F

#0

Pointer

PChar

A

B

C

Pointer (Bei Konvertierung in PChar)

Long String

Referenzzähler

Längen-DWORD

A

B

C

D

E

F

#0

Pointer

Unicode

A

B

C

D

E

F

#0

1Byte

Durch die standardmäßige Verwendung von Long Strings ist ein bisher gern genutztes Feature nicht mehr verfügbar: Der Zugriff auf das Längenbyte mit string[0]. Als Alternative bietet sich entweder die Definition eines Short Strings oder die Funktion Length an. Soll die Länge des Strings beeinflusst werden, kann die Funktion SetLength verwendet werden. BEISPIEL: Verwendung der neuen Long Strings var s : String; // automatisch handelt es ... s := '1234567'; // Length(s) ---> SetLength(s,3); // Length(s) ---> SetLength(s,10); // Length(s) --->

sich um einen Long String 7, s = '1234567' 3, s = '123' + #0 10, s = '123' + #0

14.1.1 API-Zugriff mit PChar Wer bisher schon viel mit API-Funktionen programmiert hat, wird auch unweigerlich mit dem Datentyp PChar in Berührung gekommen sein. Leider war das Handling etwas gewöhnungsbedürftig, was zu den abenteuerlichsten Konstruktionen führte, um dennoch mit Pascal-Strings arbeiten zu können. Var s : String; s := 'Hallo' + user; s := s + #0 Messagebox(0, @s[1], ...

14.2 Dynamische Speicherverwaltung

721

Darauf können Sie verzichten. Ein LongString lässt sich ohne Probleme in ein PChar umwandeln (umgekehrt ebenfalls). Var s : String; ... s := 'Hallo' + user; Messagebox(0, PChar(s), ...

14.1.2 Unicode-Zeichensatz Ganz nebenbei wird auch noch ein neuer Zeichensatz eingeführt (Unicode), der statt einem zwei Byte für jedes Zeichen verwendet. Dadurch wird es möglich, bis zu 65536 verschiedene Zeichen darzustellen. Delphi arbeitet standardmäßig jedoch nach wie vor mit dem guten alten ANSI-Zeichensatz. Ein Blick in die Unit Windows zeigt jedoch, dass Sie problemlos auch den neuen WideChar-Zeichensatz verwenden können. Dazu wurden alle API-Funktionen, die Strings als Parameter erwarten, in drei Versionen eingebunden: function MoveFileA(lpExistingFileName, lpNewFileName: PAnsiChar): BOOL; stdcall; function MoveFileW(lpExistingFileName, lpNewFileName: PWideChar): BOOL; stdcall; function MoveFile(lpExistingFileName, lpNewFileName: PChar): BOOL; stdcall;

Die Variante 1 verwendet explizit den ANSI-Zeichensatz, Variante 2 den Unicode-Zeichensatz. Variante 3 (Standard) verwendet in der aktuellen Delphi-Version den ANSI-Zeichensatz, was jedoch nicht heißt, dass spätere Versionen nicht auch Unicode-Zeichen unterstützen. An dieser Stelle wollen wir nicht darauf verzichten, Ihnen ein neues Feature der Long Strings vorzustellen. Arbeiten Sie mit zwei Strings und weisen Sie den einen String dem anderen zu, wird lediglich eine Referenz (Zeiger) kopiert, der Inhalt des Strings wird nicht kopiert. Erst eine Veränderung an einem der beiden Strings führt dazu, dass auch eine physische Kopie erstellt wird. Für die Verwaltung der einzelnen Referenzen ist der Referenzzähler zuständig. var s1,s2 : String; begin s1 := 'Hallo'; // ein String s2 := s1; // ein String + neue Referenz darauf s2[4] := 'i'; // zwei Strings, da S2 verändert wird!!!!! ...

Beispiele für die Verwendung von Strings finden Sie im Praxisteil des Kapitels.

14.2 Dynamische Speicherverwaltung Stichwörter wie Pointer, GetMem, ReAlloc, FreeMem etc. verursachen vielen Programmierern immer noch Unbehagen, obwohl es dazu eigentlich kaum einen Grund gibt. Zugegeben, die Arbeit mit dynamischen Strukturen ist etwas gewöhnungsbedürftiger als mit statischen Arrays, andererseits sind dynamische Strukturen in vielen Fällen schneller, flexibler, und (man mag es im 32-Bit-

722

Kapitel 14

Datenstrukturen

Windows-Zeitalter mit seinen fast unbegrenzten Adressräumen kaum noch erwähnen) sie benötigen weniger Speicherplatz. Sicher können Sie in Ihrem Programm genügend Speicher reservieren, wenn Sie nur ein paar Daten ablegen wollen. Beispielsweise ist folgende Array-Definition in einem 32-Bit-Programm kein Problem mehr: var x : array[1..1000000] of Integer;

Allerdings sollten Sie sich überlegen, ob das pauschale Reservieren mehrerer MByte gerechtfertigt ist, wenn tatsächlich nur 100 KByte benötigt werden.

14.2.1 Pointer Voraussetzung für die Verwaltung dynamischer Strukturen im Speicher sind so genannte Zeiger bzw. Pointer. Im Unterschied zu anderen Variablen werden mit Zeigern nicht Werte, sondern lediglich Speicheradressen verwaltet. Wollen Sie statt der Adresse den Wert der Speicherstelle ermitteln, auf die der Pointer zeigt, müssen Sie den Zeiger erst dereferenzieren. Das alles hört sich mächtig umständlich und kompliziert an, ein kleines Beispielprogramm soll deshalb für mehr Klarheit sorgen. var A : ^Byte; B : Byte;

// Zeiger auf ein Byte deklarieren // eine normale Bytevariable deklarieren

Der Variablen B wird der Wert 230 zugewiesen: B := 230;

Der Zeigervariablen A wird die Adresse der Variablen B zugewiesen: A := @B;

Statt obiger Anweisung können Sie auch die Funktion Addr verwenden, die einen Pointer auf das übergebene Objekt (Variable, Prozedur etc.) zurückgibt. Variable B (Byte)

Wert: Adresse:

...

230

0012FBDAh

0012FBDBh

Variable A (Pointer)

0012FBDBh 0012FBDCh

0012FBDDh

0012FBDEh

... 0012FBDFh

0012FBE0h

Wollen Sie den Wert der Variablen B in einem Label ausgeben, könnten Sie jetzt alternativ folgende Anweisungen verwenden: Label1.Caption := Format('Wert von B : %d',[B]);

oder Label1.Caption := Format('Wert von B : %d',[A^]);

723

14.2 Dynamische Speicherverwaltung

In der zweiten Zeile wird die Variable A dereferenziert und damit der Wert von B ausgegeben. Soll B ein neuer Wert zugewiesen werden, können Sie dies wie gewohnt mit B := 127;

oder mit A^ := 127;

tun.

Zeigertypen Bei der Arbeit mit Zeigern müssen Sie zwischen zwei Arten unterscheiden: ■ untypisierte Pointer ■ typisierte Pointer Eine Variante von typisierten Pointern haben Sie im vorhergehenden Beispiel bereits kennen gelernt, A wurde als Pointer auf ein Byte bzw. als Byte-Pointer deklariert. Auf die gleiche Art und Weise könnten Sie auch Pointer auf Integer, Word oder andere Datentypen erzeugen. Eine besonders interessante Variante von typisierten Pointern sind die Zeiger auf Record-Strukturen, auf die wir in den nächsten Abschnitten noch detailliert eingehen werden. Untypisierte Pointer stellen eine universellere Variante von Pointern dar, sie können auf beliebige Objekte zeigen. Allerdings hat dies zur Folge, dass sich derartige Pointer nicht ganz so einfach dereferenzieren lassen wie die typisierten Zeiger. var A : Pointer; B : Byte; ... B := 230;

// untypisierten Zeiger deklarieren // eine normale Bytevariable deklarieren

Der Zeigervariablen A wird die Adresse der Variablen B zugewiesen: A := @B;

Der folgende Versuch, mit "^" die Pointer-Variable zu dereferenzieren, wird fehlschlagen, da dem Compiler nicht bekannt ist, auf welchen Datentyp der Zeiger gerichtet ist, d.h., wie die Adresse zu interpretieren ist. label1.caption := Format('Wert von B : %d',[A^]);

// Fehler

Abhilfe schafft ein Typisieren des Zeigers: label1.caption := Format('Wert von B : %d',[Byte(A^)]);

Auch die Zuweisung muss mit einer Typisierung verbunden sein: Byte(A^):= 17;

724

Kapitel 14

Datenstrukturen

Für selbst definierte Datentypen bieten sich somit die beiden folgenden Varianten an: type TAdresse = record Name Vorname Strasse Plz Ort end;

: : : : :

string[20]; string[20]; string[30]; string[5]; string[30];

Variablendeklaration: var A : Pointer; B : ^TAdresse; C : TAdresse;

// untypisierten Zeiger deklarieren // typisierten Zeiger deklarieren // normale Variable

Das Füllen des Records: c.Name c.Vorname c.Strasse c.plz c.ort

:= := := := :=

'Mayer'; 'Hans'; 'Lindenallee 5'; '45455'; 'Waltershausen';

Zuweisen der Pointer: A := @C; B := @C;

Ab jetzt sind die Gemeinsamkeiten vorbei. Während Sie über einen typisierten Pointer ohne Probleme auch die einzelnen Felder des Records zuweisen können, b^.Vorname := 'Otto';

ist bei einem untypisierten Record erst eine Typisierung notwendig: TAdresse(A^).Vorname:= 'Otto';

Welchen Vorteil hat denn nun ein untypisierter Zeiger, wenn der Zugriff mit so hohem Aufwand verbunden ist? Zum einen ist es mit untypisierten Zeigern möglich, Referenzen auf gänzlich verschiedene Objekte zu speichern, zum anderen können Sie mit einem untypisierten Zeiger auch einzelne Bytes auslesen. Möchten Sie beispielsweise das Längen-Byte des ersten Feldes im Record ermitteln, genügt bei einem untypisierten Zeiger folgender Aufruf: laenge := Byte(A^);

statt laenge := B^.Name[0];

725

14.2 Dynamische Speicherverwaltung

Insbesondere bei numerischen Variablen vereinfacht sich der Zugriff dadurch wesentlich (z.B. Auslesen einzelner Bytes aus einem Integerwert).

NIL-Pointer Im Zusammenhang mit der Verwendung von Zeigern werden Sie fast immer mit der Zeigerkonstanten nil konfrontiert. Weisen Sie einem Pointer diesen Wert zu, zeigt dieser auf "Nichts". If Zeigervariable = nil then Exit;

Dynamische Variablen In den bisherigen Beispielen hatten wir die Pointer lediglich dazu verwendet, auf eine statische Variable zu zeigen. Es ist jedoch ebenfalls möglich, mit New eine dynamische Variable zu erzeugen, die durch die Pointer-Variable referenziert wird. BEISPIEL: Typdeklaration von TAdresse (siehe vorhergehendes Beispiel). var adresse : TAdresse; New(adresse); adresse^.Name adresse^.Vorname adresse^.Strasse adresse^.plz adresse^.ort label1.caption

:= := := := := :=

// eine dyn. Variable wird erzeugt (zeiger auf adresse) 'Mayer'; 'Hans'; 'Lindenallee 5'; '45455'; 'Waltershausen'; adresse^.name;

HINWEIS: Dynamisch erzeugte Variablen müssen Sie mit Dispose wieder freigeben. Dispose(adresse);

Erzeugen von Speicherblöcken Benötigen Sie mehr als nur eine dynamische Variable, können Sie sich mit GetMem einen ganzen Speicherbereich reservieren, der durch den Zeiger referenziert wird. var p : ^Byte; ... GetMem(p,1000); BlockRead(F, p^, 1000); ... FreeMem(p);

// Speicher reservieren // Füllen des Speichers aus einer Datei // Speicher wieder freigeben

Pointer-Arithmetik Zum Schluss wollen wir noch auf eine wichtige Eigenschaft von typisierten Pointern eingehen, nämlich die Möglichkeit, Pointer zu inkrementieren bzw. zu dekrementieren.

726

Kapitel 14

Datenstrukturen

BEISPIEL: Anlegen eines Byte-Arrays, das mit Werten initialisiert ist. var puffer : array[0..9] of Byte = (10,11,12,13,14,15,16,17,18,19); p : ^Byte; // typisierte Zeigervariable ...

Zuweisen der Array-Adresse: p := @puffer;

Anzeige der ersten Arrayzelle (puffer[0]): label1.caption := IntToStr(p^);

Anzeige der zweiten Arrayzelle (puffer[1]): inc(p); label2.caption := IntToStr(p^);

Anzeige der fünften Arrayzelle (puffer[4]): inc(p,3); label3.caption := IntToStr(p^); end;

Natürlich können Sie den Pointer auch mit Dec dekrementieren. Wenn Sie jetzt hoffen, das war es zu Pointern, müssen wir Sie enttäuschen. In den folgenden Abschnitten werden wir die Zeiger für das Erstellen von dynamischen Datenstrukturen nutzen, es wird also alles noch viel schlimmer. Um die Sache allerdings nicht gar zu theoretisch und unübersichtlich abzuhandeln, werden wir für alle im Folgenden vorgestellten Datenstrukturen das gleiche Beispiel wählen. Dies hat zum einen den Vorteil, dass Sie sich nicht jedes Mal mit einer neuen Aufgabenstellung beschäftigen müssen, zum anderen bietet sich Ihnen damit die Möglichkeit, die einzelnen Verfahren objektiv miteinander zu vergleichen (Aufwand, Übersichtlichkeit etc.). Ausgangspunkt ist eine Textdatei mit Namen, die zusammen mit einer Nummer im Speicher verwaltet werden soll. Der grundsätzliche Record-Aufbau könnte wie folgt aussehen: TType = record nr inhalt end;

: Integer; : string

Weiterhin soll eine Möglichkeit bestehen, die Daten anzuzeigen. Dazu werden wir die Funktionalität des Datenbank-Navigators nachempfinden. HINWEIS: Die oben genannten Beispiele finden Sie auch auf der Buch-CD.

727

14.2 Dynamische Speicherverwaltung

14.2.2 Verkettete Listen Das Erzeugen dynamischer Variablen hatten wir bereits im letzten Abschnitt kurz vorgestellt, in einer mit New erzeugten Variablen konnten Sie beliebige Daten speichern. Allerdings war dieses Verfahren auf eine einzige Variable eingeschränkt, für die oben genannte Aufgabenstellung werden aber n Speicherzellen benötigt. Gehen wir davon aus, dass ein Name maximal 20 Zeichen lang ist (21 Byte) und dass zusätzlich eine Integervariable gespeichert werden soll (4 Byte), dann zeigt sich schnell, dass wir mit einem statischen Array nicht sehr weit kommen. Definieren wir beispielsweise ein Array mit 10.000 Elementen, benötigt dieses in jedem Fall 250.000 Byte. Eine erste Lösung könnte die Verwaltung von dynamischen Variablen in einem Array sein. Statt in jeder Arrayzelle den kompletten Record zu speichern (25 Byte), könnten wir Zeiger (4 Byte) verwenden. Pointer-Array

Speicher

1

...

2

Mayer,1

3

Müller,2

4

10000

NIL

Lehmann,3

...

...

NIL

Type TDaten = record nr inhalt end; PDaten = ^TDaten;

: Integer; : string[20];

var puffer : array[0..10000] of PDaten; ... New(Daten); // dynamische Variable erzeugen // Füllen der Struktur // Daten^.Inhalt := ...; // Daten^.nr := ...; puffer[0] := daten; // Speichern im Array

Der spätere Zugriff kann zum Beispiel mit label1.caption := puffer[0]^.inhalt;

erfolgen.

728

Kapitel 14

Datenstrukturen

Die Verwendung eines Zeiger-Arrays ist zwar recht komfortabel (Sie können weiterhin die ArrayElemente über den Index ansprechen), die Speicherverschwendung wird allerdings kaum reduziert (Minimum 40.000 Byte für die Zeiger plus 25 Byte für jeden Datensatz). Der Ausweg kann nur eine vollständige dynamische Verwaltung sein.

Einfach verkettete Listen Der Begriff "Einfach" soll hier nicht den Aufwand bzw. den Anspruch des Verfahrens beschreiben, sondern nur den Grundgedanken. Einfach verkettete Listen können wegen ihres Aufbaus nur in einer Richtung durchlaufen werden. Die folgende Skizze zeigt das Prinzip: Nr Name Nächster

Nr Name Nächster

Nr Name Nächster

NIL

Jeder Datensatz wird um ein zusätzliches Element (Pointer) erweitert, das auf den folgenden Datensatz zeigt. Mit Hilfe dieser Zeiger ist es später möglich, sich von einem zum anderen Datensatz zu "bewegen". Das Überspringen von Datensätzen bzw. das Durchlaufen der Liste in umgekehrter Reihenfolge ist nicht möglich. Wie sieht nun die Realisierung in Pascal aus? type PKnoten = ^TKnoten; TKnoten

= record nr : Integer; inhalt : string; next : PKnoten; end;

Neben den beiden Feldern Nr und Inhalt finden Sie ein Feld Next, das einen typisierten Pointertyp darstellt. Erwähnenswert ist noch der Typ des Feldes Inhalt. Insbesondere im Hinblick auf die weiteren Verfahren sei festgestellt, dass es sich um einen dynamischen Stringtyp (Long String) handelt, es wird also kein Speicher durch eine festgelegte Stringgröße verschwendet. Für die weitere Arbeit brauchen wir zusätzlich zwei Variablen: var Root, Knoten : PKnoten;

Mit der Variablen Root ist es möglich, den Anfang der Kette dauerhaft zu speichern. (Wie sollten wir sonst jemals zum Anfang der Kette zurückkehren?) Die Variable Knoten wird den jeweils aktuellen Datensatz repräsentieren. Wie schon erwähnt, hat die Arbeit mit dynamischen Variablen auch einen Nachteil: Für die Ordnung im Speicher sind Sie als Programmierer zuständig, Ihre Variablen müssen Sie selbst wieder

729

14.2 Dynamische Speicherverwaltung

aus dem Speicher holen. Um unnötige Probleme mit den Beispielprogrammen zu vermeiden, werden wir sowohl die Initialisierung als auch die Deinitialisierung in Ereignissen unterbringen. Initialisierung: procedure TForm1.FormCreate(Sender: TObject); begin New(root); // Erzeugen der dynamischen Variablen Root Knoten := root; // gleichzeitig aktueller Satz with knoten^ do // füllen der Struktur begin nr := 0; inhalt := ''; next := nil; // Wichtig!!!!!!!!!!!!!!!!! end end;

Bei obigen Anweisungen kommt es vor allem auf die Vorbelegung des Next-Pointers an. Nur über den Wert in dieser Variablen können wir feststellen, ob wir uns am Ende der Liste befinden (besonders beim Deinitialisieren wichtig). Die Ordnung auf dem Heap stellen wir mit dem FormClose-Ereignis wieder her: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin Knoten := Root; while Knoten^.Next <> NIL do begin Root:= Knoten; Knoten := Root^.Next; Dispose(Root); end; Dispose(Knoten); end;

Die While-Schleife wird so lange durchlaufen, wie der Next-Pointer nicht ins Leere zeigt (nil). Innerhalb der Schleife werden die Elemente schrittweise wieder aus dem Speicher entfernt. Dabei müssen wir allerdings aufpassen, dass wir uns nicht "den Boden unter den Füßen wegziehen". Das soll heißen, dass wir keinesfalls die Variable löschen dürfen, bevor wir nicht den Pointer auf das nächste Element ermittelt haben. Nun kommen wir zur eigentlichen Routine, mit der die Liste im Speicher aufgebaut wird. procedure DateiEinlesen; var f : textfile; s : string; neuerKnoten : PKnoten; i : Integer; begin

// wir nur temporär benötigt

730

Kapitel 14

Datenstrukturen

Öffnen der Datei mit Fehlerbehandlung: AssignFile(f,'..\daten.dat'); {$i-} Reset(f); {$i+} if ioresult <> 0 then begin ShowMessage('Datei konnte nicht gefunden werden!'); Exit; end; i := 0;

Für jeden Datensatz: while not eof(f) do begin readln(f,s);

Erzeugen einer neuen dynamischen Variablen: new(neuerKnoten);

In den sich schon in der Liste befindlichen Datensatz tragen wir jetzt den Pointer auf den neuen Datensatz sowie die Daten aus der Textdatei ein: with knoten^ do begin next := neuerKnoten; inhalt := s; nr := i end;

Danach machen wir den neuen Datensatz zum aktuellen: knoten := neuerKnoten;

Der Zeiger auf das nächste Element ist erst einmal nil: knoten^.next := nil; Inc(i); end; CloseFile(f);

Nach dem Durchlaufen aller Zeilen setzen wir den Satzzeiger auf das erste Element der Liste: knoten := root; Anzeige; end;

In der Anzeigeroutine ist lediglich der aktuelle Zeiger zu dereferenzieren: procedure Anzeige; begin with knoten^ do begin form1.edit1.text := inttostr(nr); form1.edit2.text := inhalt end end;

731

14.2 Dynamische Speicherverwaltung

Das war auch schon fast alles, bleibt nur noch das "Bewegen" in der Liste. Auf den jeweils nächsten Datensatz wechseln wir, indem dem Pointer Knoten das Feld Next (d.h. der Pointer auf das nächste Element) zugewiesen wird. procedure TForm1.Button3Click(Sender: TObject); begin if knoten.next^.next <> nil then knoten := knoten^.next; Anzeige end;

Die If-Bedingung bedarf sicherlich einer Erklärung. Statt den Inhalt von Next auf nil zu prüfen, überprüfen wir das Feld Next im folgenden Datensatz. Die Ursache ist ein leerer Datensatz am Ende unserer Liste, der dadurch entstanden ist, dass wir bereits im Create-Ereignis einen neuen Datensatz angelegt haben. Durch Umstellen könnten wir auch auf diesen Datensatz verzichten (siehe Ringpuffer). 503 Skiba Nächster

504 Gretschel Nächster

505 NIL

Ist z.B. der 503. Datensatz der aktuelle, testen wir, ob im nächsten Datensatz ein Nil-Pointer auftritt. Nur wenn das nicht der Fall ist, wechseln wir den aktuellen Datensatz. Für den 504. Datensatz ist die Bedingung False, wir werden den Satzzeiger also nicht verändern. Nicht ganz so kompliziert ist der Wechsel auf den ersten Listeneintrag: procedure TForm1.Button2Click(Sender: TObject); begin knoten:= root; Anzeige end;

Damit hätten wir auch schon den Nachteil dieses Verfahrens vorgestellt: Die absolute Positionierung und das Durchlaufen der Liste in umgekehrter Reihenfolge ist nicht bzw. nur umständlich und damit langsam möglich. Eine absolute Positionierung könnten Sie nur erreichen, wenn Sie den Zeiger auf Root zurücksetzen und in einer Schleife die entsprechende Anzahl von Elementen durchlaufen. Das Problem, auch den vorhergehenden Datensatz zu erreichen, können wir durch die Verwendung einer doppelt verketteten Liste lösen. Geht es darum, Daten zu sortieren, kann eine verkettete Liste ihre Vorteile gegenüber einem statischen Array voll ausspielen. Stellen Sie sich vor, in eine bestehende Liste soll ein neuer Datensatz eingefügt werden. Bei einer Pointerliste sind lediglich zwei Zeiger zu verändern, Daten müssen (im Gegensatz zu einer statischen Liste) nicht kopiert werden.

732

Kapitel 14

Nr Name Nächster

Nr Name Nächster

Datenstrukturen

Nr Name Nächster

Nr Name Nächster Ähnlich einfach ist das Löschen einzelner Elemente: Nr Name Nächster

Nr Name Nächster

Nr Name Nächster

Alles, was Sie machen müssen, ist die Übernahme des Pointers aus dem zu löschenden Element in seinen Vorgänger. Natürlich muss auch das Element selbst mit Dispose wieder freigegeben werden. BEISPIEL: Löschen des Elements mit der Nummer 13 var hilfs : Pointer; begin knoten:= root; while (knoten.next^.next <> nil)and(knoten.next^.nr <> 13) do knoten := knoten.next; if knoten.next^.nr = 13 then begin hilfs := knoten.next^.next; Dispose(knoten.next); knoten.next := hilfs; end end;

Doppelt verkettete Listen Gegenüber dem vorherigen Verfahren sind nur geringste Änderungen nötig. Jeder Datensatz wird um einen weiteren Pointer erweitert, der auf den jeweiligen Vorgänger zeigt. NIL

Nr Name Nächster Vorgänger

Nr Name Nächster Vorgänger

Nr Name Nächster Vorgänger

NIL

14.2 Dynamische Speicherverwaltung

733

Während bei der Initialisierung der zweite Pointer ebenfalls auf nil gesetzt werden muss, procedure TForm1.FormCreate(Sender: TObject); begin New(root); Knoten := root; with knoten^ do begin nr := 0; inhalt := ''; next := nil; previous := nil end end;

unterscheidet sich die Deinitialisierung nicht von der einfach verketteten Liste. Eine wesentliche Erweiterung ist allerdings beim Einlesen der Daten vorzunehmen, die Anweisung ist unterstrichen: procedure DateiEinlesen; var f : textFile; s : string; neuerKnoten : PKnoten; i : integer; begin AssignFile(f,'..\daten.dat'); {$i-} Reset(f); {$i+} if ioresult <> 0 then begin ShowMessage('Datei konnte nicht gefunden werden!'); Exit end; i := 0; while not eof(f) do begin readln(f,s); new(neuerKnoten); with knoten^ do begin next := neuerKnoten; inhalt := s; nr := i end; NeuerKnoten^.previous := knoten; knoten := neuerKnoten; knoten^.next := nil; inc(i) end; CloseFile(f);

734

Kapitel 14

Datenstrukturen

Last := knoten.previous; knoten := root; Anzeige end;

Ganz nebenbei merken wir uns auch gleich noch das Ende der Liste im Pointer Last. Wechsel auf den nächsten Datensatz: if knoten.next^.next <> nil then knoten := knoten^.next;

Wechsel auf den vorhergehenden Datensatz: if knoten.previous <> nil then knoten := knoten^.previous;

Wechseln zum letzten Datensatz: knoten:= last;

Wie Sie sehen, ist die Programmierung von Pointerlisten zwar aufwändiger als mit einem statischen Array, die Vorteile dürften allerdings überwiegen. Im Folgenden wollen wir Ihnen noch einen Spezialfall vorstellen:

Ringpuffer Auch bei einem Ringpuffer handelt es sich um eine ganz normal verkettete Liste (es kann sich sowohl um einfach als auch um doppelt verkettete Listen handeln), mit dem Unterschied, dass diese Liste weder einen Anfang noch ein Ende aufweist. Der letzte Pointer zeigt auf das erste Listenelement. Nr Name Nächster

Nr Name Nächster

Nr Name Nächster

Wozu brauchen wir nun dieses Konstrukt? Stellen Sie sich vor, ein Messgerät liefert einen ununterbrochenen Strom von Messwerten (5 Mal pro Sekunde), und dieser Wert soll auf dem Bildschirm angezeigt werden. Bedingt durch Messfehler ist es nötig, den Mittelwert zu bilden. Hier tritt nun ein Problem auf: Für eine Mittelwertbildung müsste die Summe der Einzelmesswerte durch deren Anzahl geteilt werden. Da es sich jedoch um einen kontinuierlichen Datenstrom handelt, müssen wir uns auf eine bestimmte Anzahl von Messwerten beschränken. Das Verfahren wird "Gleitende Mittelwertbildung" genannt, es werden beispielsweise nur die letzten zehn Messwerte in die Rechnung einbezogen (Summe/10). Die programmtechnische Umsetzung mit einem Ringpuffer ist denkbar einfach. In den aktuellen Datensatz wird der neue Wert eingetragen (der Pointer bleibt unverändert), danach kann die Liste einmal komplett durchlaufen werden (Berechnung). Zum Schluss wird der nächste

735

14.2 Dynamische Speicherverwaltung

Datensatz ausgewählt. Dieser Vorgang kann endlos wiederholt werden, es sind jeweils die letzten n Werte gespeichert.

Neuer Wert

1. Schritt

Summieren

Neuer Datensatz

2. Schritt

3. Schritt

Ein weiteres Anwendungsgebiet findet sich in der digitalen Regelungstechnik, wo es darum geht, Signale um bestimmte Zeiträume zu verzögern (so genannte Laufzeit- bzw. Totzeitglieder)1. Doch zurück zu unserem Beispiel, wo wir uns auf das Einlesen der ersten zehn Datensätze beschränken. Testen Sie das Programm, werden Sie feststellen, dass nach dem zehnten der erste Datensatz wieder auftaucht. procedure DateiEinlesen; var f : textfile; s : string; oldKnoten : PKnoten; i : integer; begin oldknoten := nil; assignfile(f,'..\daten.dat'); {$i-} reset(f); {$i+} if ioresult <> 0 then begin showmessage('Datei konnte nicht gefunden werden!'); exit; end; i := 1; while (not eof(f)) and (i<=10) do begin readln(f,s); new(Knoten); with knoten^ do begin next := nil; inhalt := s;

1

Der Puffer wird vorinitialisiert mit N=TL/TA-Elementen (TA-Abtastzeit, TL-Laufzeit), danach kann der alte Wert gelesen werden, die Zelle wird beschrieben, und der Zeiger wird um ein Element weiterbewegt.

736

Kapitel 14

Datenstrukturen

nr := i; end; if oldknoten <> nil then oldknoten^.next := knoten else root := knoten; oldknoten := knoten; inc(i); end; closefile(f);

Der letzte Knoten zeigt wieder auf den Anfang der Liste. knoten^.next := root; knoten := root; Anzeige; end;

Im Code wird diesmal nicht mit einer vorinitialisierten Liste gearbeitet, der leere Datensatz am Ende der Liste entfällt dadurch (siehe einfach verkettete Liste).

Binäre Bäume Auf diese Spezialform, bei der es sich eigentlich nicht um Listen, sondern um ganze Bäume handelt, wollen wir nicht detailliert eingehen. Die folgende Grafik zeigt lediglich das Grundprinzip, wie Daten in solchen Bäumen gespeichert werden können: Links Rechts Daten Links Rechts Daten

Links Rechts Daten

Links Rechts Daten

Links Rechts Daten Derartige Strukturen werden zum Beispiel zum schnellen Sortieren von Daten verwendet, beim Einordnen neuer Elemente sind nur wenige Vergleiche nötig, um die neue Position festzulegen. Allerdings haben die Informatiker es geschafft, auch aus diesem Thema eine Wissenschaft zu machen. So gibt es unter anderem Algorithmen, mit denen der Baum neu "zentriert" werden kann, um eine ungleichmäßige Baumtiefe zu vermeiden. Damit schließen wir das Thema "Zeigerlisten" vorerst ab.

14.2 Dynamische Speicherverwaltung

737

14.2.3 Arbeiten mit TList-Objekten Nach dem vorangegangenen Exkurs in die Untiefen von Pascal werden wir jetzt eine objektorientierte Lösung für unser Problem suchen.

Dynamische Variablen Mit dem TList-Objekt bietet sich die Möglichkeit, Aufgaben, die wir bisher mit der Pointerliste realisiert haben, in ein Objekt zu verlagern. Für das Erzeugen der dynamischen Variablen sind Sie zwar nach wie vor verantwortlich (das Objekt kennt nur Zeiger, keine Records), das Speichern übernimmt jedoch das Objekt. Erster Schritt ist die Definition unseres Records sowie eines Pointertyps: type PDaten = ^TDaten; TDaten = record nr : Integer; inhalt : String; end;

Definition des Listen-Objekts sowie einer Pointer-Variablen, die wir für das Erstellen von neuen Datensätzen benötigen: var Liste : TList; Daten : PDaten; ListIndex : Integer;

Objekte müssen mit Create erstellt werden procedure TForm1.FormCreate(Sender: TObject); begin Liste := TList.Create; end;

und sollten zum Schluss auch wieder freigegeben werden: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin Liste.Free; end;

Die schon bekannte Funktion zum Einlesen der Daten: procedure DateiEinlesen; var f : textfile; s : String[20]; i : Integer; begin assignfile(f,'..\daten.dat'); {$i-} reset(f); {$i+}

738

Kapitel 14

Datenstrukturen

if ioresult <> 0 then begin showmessage('Datei konnte nicht gefunden werden!'); exit; end; i := 0; while not eof(f) do begin readln(f,s);

An dieser Stelle erzeugen wir eine dynamische Variable New(Daten);

und füllen die einzelnen Felder: Daten^.nr := i; Daten^.inhalt := s;

Mit der Add-Methode übergeben Sie diese Variable an das List-Objekt: Liste.Add(Daten); inc(i); end; closefile(f); form1.trackbar1.max := i-1; listindex := 0; Anzeige; end;

Bei der Anzeige muss natürlich der Zeiger dereferenziert und typisiert werden. Die Typisierung erfolgt mit Hilfe des PDaten-Typs: procedure Anzeige; begin with PDaten(Liste.Items[listindex])^ do begin form1.edit5.text := inttostr(nr); form1.edit6.text := inhalt; end; end;

Die einzelnen Zellen der Liste werden über einen Index angesprochen, den wir uns in der Variablen ListIndex merken. Wechsel auf erstes Element der Liste: listindex := 0;

Vorhergehendes Element: if listindex > 0 then dec(listindex);

Nächstes Element: if listindex < Liste.Count-1 then inc(listindex);

739

14.2 Dynamische Speicherverwaltung

Letztes Element: listindex := Liste.count-1;

Beliebiges Element: listindex := trackbar1.position;

Wie Sie sehen, ist die Programmierung mit dem TList-Objekt recht komfortabel. Sie werden von fast allen Aufgaben entlastet, lediglich die dynamischen Variablen müssen Sie noch selbst erstellen.

Weitere Methoden Im Unterschied zu den Pointerlisten aus den vorhergehenden Abschnitten bietet ein TList-Objekt einen ganzen Satz von Methoden, mit denen Sie die Liste verwalten können. Methode

Bemerkung

Add

... dynamische Variable oder Objekt an die Liste anhängen.

Clear

... Liste löschen.

Delete

... löscht das durch Index bezeichnete Objekt.

Pack

... löscht alle Elemente mit NIL-Zeiger.

Exchange

... tauscht zwei Elemente miteinander aus.

Insert

... fügt ein Element in die Liste ein.

Remove

... löscht ein Element (Parameter ist der Pointer).

Sort

... sortiert die Liste.

Auf die Methode Sort wollen wir noch einmal getrennt eingehen, da Sie für den Aufruf eine Funktion mit folgendem Aufbau erstellen müssen: function vergleich(Item1, Item2: begin if PKnotenList(Item1)^.inhalt if PKnotenList(Item1)^.inhalt if PKnotenList(Item1)^.inhalt end;

Pointer): Integer; > PKnotenList(Item2)^.inhalt then result := 1; < PKnotenList(Item2)^.inhalt then result := -1; = PKnotenList(Item2)^.inhalt then result := 0;

Übergabewerte sind zwei Elemente der Liste bzw. die Pointer darauf. Ihre Funktion bestimmt nun, wie die beiden Elemente miteinander verglichen werden (welches Feld genutzt wird). Ist Item1 größer als Item2, ist der Rückgabewert positiv, andernfalls negativ. Sind beide Elemente gleich, gibt die Funktion null zurück. Im obigen Listing ist der Vergleich etwas umständlich, da es sich um Zeichenketten handelt. Sollten Sie numerische Werte miteinander vergleichen, genügt die folgende Anweisung: function vergleich(Item1, Item2: Pointer): Integer; begin result := PKnotenList(Item1)^.inhalt - PKnotenList(Item2)^.inhalt; end;

740

Kapitel 14

Datenstrukturen

An die Methode Sort können Sie nun Ihre Funktion übergeben: procedure TForm1.Button1Click(Sender: TObject); begin liste.sort(vergleich) end;

Objektvariablen Statt nur einfacher dynamischer Variablen können Sie auch ganze Objekte an die Liste übergeben. BEISPIEL: Zeigerliste für Objekte type TMyList = class nr : integer; inhalt : String; constructor Create(i:integer); end;

// Klasse erzeugen

... var Liste : TList;

Das Überschreiben des Konstruktors ist nicht unbedingt nötig, es vereinfacht jedoch das spätere Einfügen von Objekten in die Liste, da wir so keine separate Instanz der Klasse erzeugen müssen. constructor TMyList.Create(i:integer, s : String); begin inherited Create; nr := i; inhalt := s; end;

Das folgende Aufruf-Beispiel zeigt, dass wir das von der Create-Methode zurückgegebene Objekt gleich an die Add-Methode weitergeben können: Liste.Add(TMyList.Create(10,'Mayer'))

Spätere Versuche, die Daten aus der Liste auszulesen, erfordern natürlich wieder eine Typisierung: label1.caption := TMylist(Liste[index]).inhalt

Das TList-Objekt eignet sich hervorragend für das Speichern von Zusatzinformationen in einer TreeView-Komponente. Weisen Sie einfach die Einträge der Liste (Pointertyp) der Data-Eigenschaft (ebenfalls ein Pointer) von Treeview zu. Beim späteren Abruf der Informationen genügt folgende Anweisung: label1.caption := TMylist(TreeView1.Selected.data).inhalt

14.2 Dynamische Speicherverwaltung

741

14.2.4 Memory-Streams Im Unterschied zu den bisherigen Verfahren erinnert die Verwendung von Memory-Streams stark an eine typisierte Datei. Wer noch nicht mit Streams gearbeitet hat, sollte sich aus diesem Grund erst einmal Abschnitt 7.5 durchlesen.

TMemoryStream Der Datenrecord erfährt eine wesentliche Einschränkung: Statt einer variablen Stringlänge verwenden wir einen festen ShortString. Der Grund ergibt sich aus dem Prinzip des Streams, in den zwar beliebige Daten geschrieben werden können, beim Lesen muss allerdings die Größe bekannt sein. Der Ausweg wäre eine geänderte Record-Struktur mit einem Längenfeld, aber so weit wollen wir es an dieser Stelle nicht treiben. type TStreamKnoten

= record nr : Integer; inhalt : string[20]; end;

Das Stream-Objekt: var mstream : TMemoryStream; Streamknoten : TStreamknoten;

Der weitere Ablauf ist wie bei einer typisierten Datei organisiert. Nach dem Schreiben der Records können diese gezielt wieder ausgelesen werden, wenn der Satzzeiger entsprechend positioniert wird. Streams können zwar nicht auf BOF bzw. EOF getestet werden, mit den beiden Eigenschaften Position und Size haben Sie jedoch auch dieses Problem im Griff. Geschrieben wird, wie nicht anders zu erwarten ist, mit Write, gelesen wird mit Read. Der einzige Unterschied zu einer normalen Datei ist der "Datenträger", denn Memory-Streams werden im Arbeitsspeicher abgelegt. procedure DateiEinlesen; var f : textfile; s : String[20]; i : Integer; begin mStream := TMemoryStream.Create; AssignFile(f,'..\daten.dat'); {$i-} reset(f); {$i+} if ioResult <> 0 then begin ShowMessage('Datei konnte nicht gefunden werden!'); Exit; end; i := 0; while not eof(f) do begin readln(f,s); Streamknoten.inhalt := s; Streamknoten.nr := i; mStream.Write(Streamknoten,SizeOf(Streamknoten)); Inc(i);

742

Kapitel 14

Datenstrukturen

end; CloseFile(f); mStream.position := 0; mStream.read(Streamknoten,sizeof(streamknoten)); AnzeigeStream; end;

Die Anzeige eines Datensatzes: procedure AnzeigeStream; begin with Streamknoten do begin Form1.Edit3.Text := IntTostr(nr); end end;

Form1.Edit4.Text := inhalt

Wie Sie vielleicht schon bemerkt haben, wird in der Prozedur nicht direkt mit dem Stream gearbeitet, sondern lediglich der Inhalt der Variablen Streamknoten ausgegeben. Der Grund ist das Verhalten der Methode Read, die bei jedem Lesevorgang auch die Position des Satzzeigers verändert (wie in einer normalen Datei). Die folgenden Beispiele zeigen, wie Sie den Satzzeiger positionieren. Erster Datensatz: mStream.Position := 0; mStream.Read(Streamknoten,SizeOf(Streamknoten));

Vorhergehender Datensatz (relativ zum aktuellen): if mStream.position-2*sizeof(Streamknoten) >= 0 then begin mStream.Seek(-2*sizeof(Streamknoten),soFromCurrent); mStream.Read(Streamknoten,SizeOf(Streamknoten)) end;

Nächster Datensatz: if mStream.Position < mStream.Size then mStream.Read(Streamknoten,SizeOf(Streamknoten));

Letzter Datensatz: mStream.Position := mStream.Size - SizeOf(Streamknoten); mStream.Read(Streamknoten,SizeOf(Streamknoten));

Der Clou an der Sache ist die Möglichkeit, mit einer Anweisung die komplette Liste in einer echten Datei zu speichern. mStream.SaveToFile('c:\daten.dat');

Beim Laden dieser Datei brauchen Sie nur die Methode LoadFromFile aufzurufen, einfacher kann man es eigentlich nicht haben.

743

14.2 Dynamische Speicherverwaltung

TCustomMemoryStream Sicher ist auch Ihnen das etwas umständliche Verändern des Satzzeigers aufgestoßen, was daraus resultiert, dass Read den Zeiger verändert. Abhilfe können Sie durch eine kleine Variation des obigen Programms schaffen. Statt eines TMemoryStream-Objekts erstellen Sie einfach ein TCustomMemory-Objekt, das mit Memory über eine recht interessante Eigenschaft verfügt. Da ein Stream lediglich als Zeichenstrom im Speicher abgelegt ist, lassen sich nicht nur mit der Methode Read Daten auslesen, sondern Sie können auch direkt mit Pointern arbeiten. Den Pointer auf den Anfang des Streams erhalten Sie über die Eigenschaft Memory. Erzeugen Sie jetzt einen typisierten Pointer, können Sie mit diesem problemlos Datensätze aus dem Stream auslesen oder auch schreiben, unabhängig von der Position des Satzzeigers. var mstream : TCustomMemoryStream; Streamknoten : TStreamknoten; zeiger : ^TStreamknoten;

// der Pointer

Zuweisen des Zeigers und Positionieren auf den 5. Datensatz: zeiger := mstream.memory; inc(zeiger,4);

Auslesen der Daten: edit3.text := inttostr(zeiger^.nr); edit4.text := zeiger^.inhalt;

Für das Anhängen neuer Datensätze sollten Sie unbedingt die Methode Write verwenden. Weiterhin müssen Sie sich beim Lesen bzw. Schreiben auf die Größe des Streams beschränken, andernfalls erhalten Sie eine Fehlermeldung:

Damit wären wir auch schon wieder bei den Pointern angelangt. Für alle, die immer noch nicht genug haben, folgt noch eine weitere Variante, Daten dynamisch zu speichern.

14.2.5 Dynamische Arrays Die am Anfang des Abschnitts vorgestellten Pointerlisten hatten einen wesentlichen Nachteil: Die wahlfreie Positionierung war relativ umständlich. Mit dem im Folgenden vorgestellten Verfahren können Sie jeden Record über einen Index ansprechen, fast wie bei einem statischen Array. Trotzdem handelt es sich um eine dynamische Struktur, es wird nur so viel Speicher reserviert, wie unbedingt nötig ist.

744

Kapitel 14

Datenstrukturen

HINWEIS: Mehr über die dynamischen Arrays von Delphi erfahren Sie im Kapitel 2.

Memory-Arrays Eine Einschränkung sollte allerdings nicht vergessen werden: Die Recordgröße muss konstant sein, variable Strings sind also nicht zulässig. Die Definition des Records: type

TDat = record nr : Integer; inhalt : String[20]; end;

Ein Array-Typ (die Voraussetzung für das spätere Positionieren über den Index): TDatA = array[0..0] of TDat; var memdat : ^TDatA; anzahl, nummer : integer;

Am Programmende sorgen wir dafür, dass der gesamte belegte Speicher wieder freigegeben wird: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin ReallocMem(memdat,0); end;

Füllen des Arrays: procedure DateiEinlesen; var f : textfile; s : String[20]; i : Integer; begin assignfile(f,'..\daten.dat'); {$i-} reset(f); {$i+} if ioresult <> 0 then begin showmessage('Datei konnte nicht gefunden werden!'); exit; end; i := 0; while not eof(f) do begin readln(f,s);

Reservieren von zusätzlichem Speicher: ReallocMem(memdat,(i+1) * sizeof(TDat));

14.3 Lernbeispiele für Einsteiger

745

Das Array wird gefüllt: memdat^[i].nr := i; memdat^[i].inhalt := s; inc(i); end; closefile(f); form1.trackbar2.max := i-1; anzahl := i-1; nummer := 0; Anzeige end;

Anzeigen eines Datensatzes: procedure Anzeige; begin with Memdat^[nummer] do begin form1.edit7.text := inttostr(nr); form1.edit8.text := inhalt; end end;

Die Anweisungen zum Positionieren des Satzzeigers brauchen wir Ihnen sicher nicht vorzustellen, Sie müssen lediglich den Index innerhalb des Arrays ändern. Abgesehen von der Einschränkung auf eine feste Recordgröße dürfte das oben genannte Verfahren wohl eine der optimalen Möglichkeiten zum dynamischen Speichern bieten. Insbesondere der Zugriff über den Index macht es möglich, bisherige Algorithmen, die auf statischen Arrays basierten, schnell umzustellen.

14.3 Lernbeispiele für Einsteiger 14.3.1 Zerlegen von Strings Ein häufig auftretendes Problem des Programmierers ist das Zerlegen von Zeichenketten in ihre Bestandteile (String-Tokenizer). Nicht zuletzt müssen sich auch die höheren Programmiersprachen (inkl. SQL) damit herumschlagen, wenn es darum geht, den Quelltext zu interpretieren bzw. zu compilieren. Die folgende Demo erläutert das Prinzip am Beispiel eines normalen Eintrags in ein Fahrtenbuch, wo es darum geht, die einzelnen Stationen der Fahrstrecke, den Reisezweck und die geschäftlichen, privaten und zwischen Wohnort und Arbeitsstelle gefahrenen Kilometer aus einem einzigen String herauszufiltern. Endgültige Klarheit dürfte die folgende Abbildung schaffen.

746

Kapitel 14

Datenstrukturen

Oberfläche Ein Editierfeld nimmt den Eingabestring auf, die Ausgabe der "zerpflückten" Informationen erfolgt in sechs Labels.

Quelltext der Unit stringRoutinen2 Grundlage ist die ziemlich komplexe Funktion decodeRoute, die von der separaten Unit stringRoutinen2 exportiert wird. unit stringRoutinen2; interface uses SysUtils;

// wegen Stringfunktionen

Die Funktion decodeRoute liefert die decodierten Daten in einer wie folgt strukturierten Variablen zurück: type TRoute = record AOrt, BOrt, COrt: string[20]; Zweck: string[50]; kmGe, kmPr, kmWA: Integer end; function decodeRoute(s:string):TRoute; implementation var route: TRoute;

DecodeRoute baut auf lokalen Funktionen und Prozeduren auf, die sich auf das Herausfiltern einer bestimmten Teilinformation (Fahrtroute, Reisezweck, gefahrene Kilometer) beschränken. Vorerst aber eine reine Hilfsfunktion, die das lästige Leerzeichen-Problem vom Tisch wischt:

747

14.3 Lernbeispiele für Einsteiger

function deleteFirstLastLZ(st:string):string; // entfernt vor- und nachstehende LZ var a, z: Integer; begin Result:=''; if st <> '' then // natürlich darf es kein Leerstring sein! begin // alle vorstehenden LZ entfernen: // besonders tückisch ist der Fall, wenn String nur aus LZ besteht! a:=1; while st[a] = ' ' do begin Delete(st,a,1); if st= '' then Exit end; // alle nachstehenden LZ entfernen: z:=Length(st); while st[z] = ' ' do begin Delete(st,z,1); Dec(z) end; Result := st end end;

Das Decodieren der Fahrtroute: function decodeRoute; var i: Integer; anz: Integer;

// Positionszähler im String // Zeichenanzahl

procedure fahrtRoute; var ort:string; function selOrt:string; // selektiert einen Ort begin ort:=''; Inc(i); while (s[i] <> '-') and (s[i] <> '/') do begin ort := ort + s[i]; Inc(i); if i>anz then Break end; ort := deleteFirstLastLZ(ort); // entfernt vor- und nachstehende LZ Result := ort end; begin route.AOrt := selOrt; // Startort feststellen if s[i] <> '-' then Exit; // Route besteht aus nur einer Ortsangabe route.BOrt := selOrt; // zweiten Ort feststellen if s[i] <> '-' then // Ort ist bereits Zielort => vertauschen begin route.COrt := route.BOrt; route.BOrt :=''; Exit end; route.COrt:= selOrt // Zielort feststellen end;

Das Herausfiltern des Reisezwecks: procedure reiseZweck; var zweck: string; begin if s[i] <> '/' then Exit; zweck:=''; Inc(i);

748

Kapitel 14

Datenstrukturen

if i > anz then Exit; while s[i] <> '/' do begin zweck := zweck + s[i]; Inc(i); if i>anz then begin Dec(i); Break end end; route.Zweck := DeleteFirstLastLZ(zweck) end;

Das Ermitteln der gefahrenen Kilometer: procedure gefahreneKm; var gesch, priv, wa: string; function detectNumber: string; // liefert nächste Zeichenfolge nach LZ-Folge var st:string; begin st:=''; repeat Inc(i) until (s[i] <> ' ') or (i > anz); // hält an nächster Ziffer if i > anz then begin Result := ''; Exit end; // falls keine gefunden repeat st := st + s[i]; Inc(i) until (s[i] = ' ') or (i > anz); Result := st end; begin gesch := detectNumber; // geschäftliche km if gesch <> '' then route.kmGe := StrToInt(gesch) else Exit; priv := detectNumber; // private km if priv <> '' then route.kmPr := StrToInt(priv) else Exit; wa := detectNumber; // km Wohnort-Arbeit if WA <> '' then route.kmWA := StrToInt(wa) end;

Nach all diesen Vorarbeiten kann's jetzt endlich zur Sache gehen: begin // Hauptroutine von decodeRoute! with route do // Rückgabewerte initialisieren begin AOrt:=''; BOrt:=''; COrt:=''; Zweck :=''; kmGe:=0; kmPr:=0; kmWA:=0 end; Result := route; if s <> '' then begin // nur wenn Übergabeparameter kein Leerstring ist i := 0; anz := Length(s); // Anfangsparameter setzen if (s[i+1] = '-') or (s[i+1] = '/') then Exit; // unzulässige erste Zeichen // String zerpflücken: if i < anz then fahrtRoute; if i < anz then reiseZweck; if i < anz then gefahreneKm end; Result := route end; end.

749

14.3 Lernbeispiele für Einsteiger

Quelltext Unit1 Da der relevante Code in die Unit stringRoutinen ausgelagert wurde, kann sich Unit1 auf ihre eigentlichen Aufgaben, die Verwaltung der Benutzerschnittstelle, konzentrieren. Im implementation-Abschnitt fügen Sie lediglich Folgendes hinzu: uses stringRoutinen2; var route: TRoute; procedure TForm1.Button1Click(Sender: TObject); begin route:=decodeRoute(Edit1.Text); Label10.Caption := route.AOrt; Label11.Caption := route.BOrt; Label12.Caption := route.COrt; Label13.Caption := route.Zweck; Label14.Caption := IntToStr(route.kmGe); Label15.Caption := IntToStr(route.kmPr); Label16.Caption := IntToStr(route.kmWA) end;

// Zerpflücken

Test Starten Sie das Programm und überzeugen Sie sich von seiner Wirksamkeit. Achten Sie darauf, dass die einzelnen Stationen der Reiseroute stets durch einen waagerechten Strich (-) voneinander zu trennen sind, während zwischen den gefahrenen Kilometern mindestens ein Leerzeichen zu stehen hat. Reiseroute, Bemerkungen und gefahrene Kilometer sind durch einen Frontslash (/) zu separieren.

750

Kapitel 14

Datenstrukturen

14.3.2 Zum Unterschied zwischen PChar und String Dem Object Pascal-Einsteiger fällt naturgemäß das Verständnis der Pointer-Philosophie besonders schwer. Deshalb soll im Folgenden der Unterschied zwischen String- und PChar-Datentyp an einem Beispiel nahe gebracht werden. Da Letztere durch das Zeichen #0 begrenzt werden, sind sie auch unter dem Begriff nullterminierte Strings bekannt. Dieses Grundverständnis ist auch eine Voraussetzung für die spätere DLL-Programmierung und die Arbeit mit API-Funktionen. Ziel dieser Demo ist es, den Inhalt eines Editierfeldes nach Groß- und Kleinbuchstaben zu durchsuchen, wobei das Problem einmal mit dem string- und einmal mit dem PChar-Datentyp gelöst wird.

Oberfläche Auf dem Startformular platzieren Sie ein Editierfeld, zwei RadioButtons und zwei Schaltflächen, so dass sich etwa folgender Anblick bietet:

Quelltext Der gesamte Quellcode befindet sich im implementation-Abschnitt von unit1. Die beiden folgenden Funktionen erwarten als Übergabeparameter ein einzelnes Zeichen (Char-Datentyp): function isUpper(c:Char): Boolean; // testet auf Großbuchstaben begin result := c in ['A'..'Z','Ä','Ö','Ü'] end; function isLower(c:Char): Boolean; // testet auf Kleinbuchstaben begin result := c in ['a'..'z','ä','ö','ü','ß'] end;

HINWEIS: Die Funktionen isUpper und isLower finden Sie neben anderen Hilfsfunktionen in

der Unit hFunc auf der Buch-CD. Sie können sich deshalb deren Eintippen sparen, wenn Sie diese Unit über die uses-Klausel am Anfang des Implementation-Abschnitts einbinden. Jetzt kommt der interessante Teil. Der folgenden Prozedur wird ein Pascal-String übergeben, der in einzelne Zeichen "zerschnitten" wird, um diese dann mit obigen Funktionen zu testen: procedure stringGB(s: string); var i: Word;

14.3 Lernbeispiele für Einsteiger

751

z: Char; begin for i := 1 to Length(s) do begin z := s[i]; if isUpper(z) then ShowMessage(z + ' ist ein Großbuchstabe!') end end;

Das gleiche Problem löst mit weniger Aufwand die nächste Prozedur, der allerdings ein PCharDatentyp zu übergeben ist: procedure pCharGB(p: PChar); begin while (p^ <> #0) do begin if isUpper(p^) then ShowMessage(p^ + ' ist ein Großbuchstabe!'); Inc(p) // weiter zum nächsten Zeichen end end;

Die beiden noch fehlenden Prozeduren stringZugriffKB und pCharZugriffKB sind analog programmiert, auf ihre Wiedergabe kann deshalb hier verzichtet werden (siehe Buch-CD). Beim folgenden Aufruf der beiden string-Funktionen genügt die direkte Übergabe des Inhalts von Edit1, während bei den pChar-Funktionen vorher der Inhalt von Edit1 mittels der PChar-Standardfunktion in einen Zeiger auf einen nullterminierten String verwandelt werden muss: procedure TForm1.Button1Click(Sender: TObject); // Großbuchstaben begin if RadioButton1.Checked then stringGB(Edit1.Text) else pCharGB(PChar(Edit1.Text)) end; procedure TForm1.Button2Click(Sender: TObject); // Kleinbuchstaben begin if RadioButton1.Checked then stringKB(Edit1.Text) else pCharKB(PChar(Edit1.Text)) end;

Test Die Anzeige der gefundenen Groß- bzw. Kleinbuchstaben erfolgt der Einfachheit halber in nacheinander sich öffnenden Meldungsfenstern.

752

Kapitel 14

Datenstrukturen

Sie werden feststellen, dass beide Programmiervarianten absolut das Gleiche leisten und nach außen nicht zu unterscheiden sind. Der fortgeschrittene Programmierer wird allerdings die elegantere und schnellere PChar-Realisierung bevorzugen, während der Einsteiger mit den Pascal-Strings weniger Verständigungsprobleme haben dürfte.

14.4 Praxisbeispiele für Fortgeschrittene 14.4.1 Zweidimensionales Array auf dem Heap (Unit-Version) Obwohl in Delphi mittlerweile auch "echte" dynamische Arrays auf relativ unkomplizierte Weise möglich sind (siehe 2.4.3), kann der versierte Programmierer auch eigene dynamische Datenstrukturen entwickeln, die auf dem reichlich vorhandenen Stapelspeicher (Heap) abgelegt werden. Der dabei erzielbare Performance-Gewinn ist nicht zu unterschätzen. Grundlegende Ausführungen zu dieser Thematik sind im Abschnitt 14.2.5 dieses Kapitels enthalten. Obwohl die einzelnen Felder eindimensional hintereinander abgelegt werden, ist ein quasi zweidimensionaler Zugriff nach einfacher Umrechnung möglich. Das vorliegende Beispiel bezieht sich auf eine klassische Programmiervariante mittels einer Unit.

Quellcode Unit dynVarAr Insgesamt brauchen wir vier Routinen: ■ Dimensionieren des Arrays ■ Schreibzugriff ■ Lesezugriff ■ Freigeben des Arrays Um eine leichte Wiederverwendbarkeit zu ermöglichen, verpacken wir den Code in eine separate Unit. Fügen Sie über Datei|Neu... das Gerüst einer leeren Unit hinzu, der Sie den Namen dynVarAr geben und in die Sie folgenden Quelltext eintragen: unit dynVarAr;

In den interface-Abschnitt tragen wir die Köpfe der zu exportierenden Prozeduren/Funktionen ein: interface procedure procedure procedure function

dimArray (z,s:Integer); freeArray; wrA(i,j:Integer; w:Integer); rdA(i,j:Integer):Integer;

// Schreibzugriff (i = Zeile, j = Spalte) // Lesezugriff

Wir beschränken uns auf ein zweidimensionales dynamisches Integer-Array, das wir wie folgt implementieren:

753

14.4 Praxisbeispiele für Fortgeschrittene

implementation

Auf ein Feld dieses Datentyps soll der Pointer zeigen: type dArray = array[1..1] of Integer;

Der Pointer: var dA: ^dArray; imax, jmax: Integer;

// imax = Zeilenzahl, jmax = Spaltenzahl

Nun zur Implementierung der zu exportierenden Prozeduren/Funktionen: procedure dimArray; // Speicherplatz reservieren begin jmax := j; imax := i; GetMem(dA, SizeOf(dA^[1])* zmax * smax) end; procedure freeArray; // Speicher wieder freigeben begin FreeMem(dA,SizeOf(dA^[1])* imax * jmax) end; procedure wrA; // Schreibzugriff auf Zeile i und Spalte j begin dA^[(i-1)* jmax + j] := w end; function rdA; // Lesezugriff auf Zeile i und Spalte j begin Result := dA^[(i-1)* jmax + j] end;

Zu Beginn soll das kleinstmögliche Array initialisiert werden (1 Zeile, 1 Spalte): initialization imax:=1; jmax:=1; dimArray(1,1) end.

Vergessen Sie nicht, die Unit exakt unter ihrem Namen dynVarAr abzuspeichern!

Oberfläche Zum Austesten unserer dynamischen Arrays verwenden wir eine Oberfläche, die zur Laufzeit etwa folgenden Anblick bieten soll:

754

Kapitel 14

Datenstrukturen

Mit den RadioButtons stellen wir die gewünschte Zeilen- und Spaltenanzahl ein, die in obiger Abbildung sieben bzw. acht beträgt.

Quellcode Formular-Unit Zum Austesten unserer Unit dynVarAr fügen wir dem Implementation-Abschnitt der Formular-Unit (Unit1) folgenden Code hinzu: uses dynVarAr;

// Einbinden der Unit

var imax, jmax: Integer;

Das Füllen des Arrays mit Beispieldaten (der Einfachheit halber nehmen wir dafür den Zeilen- und Spaltenindex): procedure writeArray; var i,j,z: Integer; begin for i := 1 to imax do for j := 1 to jmax do begin z := StrToInt(IntToStr(i) + IntToStr(j)); wrA(i,j,z) // Schreibzugriff auf das Array end end;

755

14.4 Praxisbeispiele für Fortgeschrittene

Das Anzeigen des Array-Inhalts: procedure displayArray; var i,j,z: Integer; begin Form1.Refresh; for i := 1 to imax do for j := 1 to jmax do begin z := rdA(i,j); // Lesezugriff auf das Array Form1.Canvas.TextOut(40+j*40, 50 + i*25, IntToStr(z)) end end;

Das passiert beim Ändern der Dimension: procedure TForm1.RadioButtonClick(Sender: TObject); begin freeArray; // Speicherplatz freigeben

Die maximale Spaltenzahl setzen: if Sender = RadioButton1 then jmax := 1; if Sender = RadioButton2 then jmax := 2;

und so weiter ... if Sender = RadioButton9 then jmax := 9;

Nun die maximale Zeilenzahl: if Sender = RadioButton10 then smax := 1; if Sender = RadioButton10 then smax := 2;

und so weiter ... if Sender = RadioButton18 then smax := 9;

Übrigens: Im Beispiel 14.4.2 wird auch gezeigt, wie Sie obige monströse Routine durch Einsatz einer RadioGroup drastisch vereinfachen können. Nun kann das neue Array dimensioniert, gefüllt und angezeigt werden: dimArray(smax,jmax); writeArray; displayArray end;

// Speicherplatz belegen

Der Start: procedure TForm1.FormCreate(Sender: TObject); begin imax:=1; jmax:=1 end;

756

Kapitel 14

Datenstrukturen

Test Starten Sie das Programm und stellen Sie durch Klick auf die RadioButtons die Dimensionen des dynamischen Arrays ein. Es wird jeweils immer nur so viel Speicher belegt, wie er der aktuellen Größe des angezeigten Arrays entspricht.

Bemerkungen ■ Der Aufbau des Arrays mit Variant-Datentypen würde zwar das Abspeichern unterschiedlichster Datentypen gestatten, bedeutet allerdings eine erhebliche Speicherplatzverschwendung. Es wird deshalb empfohlen, lieber mit konkreten Datentypen wie Integer oder Single zu arbeiten. ■ Das Modifizieren des Quelltextes für andere Array-Dimensionen (ein-, drei-, vierdimensional) dürfte für den routinierten Programmierer kein Thema sein. ■ Eine verbesserte Programmversion erwartet Sie im nachfolgenden Beispiel.

14.4.2 Zweidimensionales Array auf dem Heap (OOP-Version) HINWEIS: Ein Lernerfolg für dieses Beispiel ist an zwei Voraussetzungen gebunden:

1. Das Vorgängerbeispiel 14.4.1 wurde vollständig verstanden. 2. OOP-Grundkenntnisse (Kapitel 6) sind ausreichend vorhanden. Das Vorgängerbeispiel hat mittlerweile die sechste Auflage dieses Buchs überlebt. Nach wie vor bietet es eine gute Einführung in die Arbeit mit Pointern und dynamischen Speichervariablen. Trotzdem ist der Zugriff auf die einzelnen Felder des Arrays gewöhnungsbedürftig. Wäre es nicht viel besser, anstatt z := rdA(i,j);

// Lesezugriff

oder wrA(i,j,z);

// Schreibzugriff

die üblichen Notationen z := A[i, j];

oder A[i, j] := z;

zu verwenden? Lassen Sie uns deshalb ein Objekt definieren, das den Lese- und Schreibzugriff als Eigenschaft kapselt und die gewünschten Daten nach außen auf die gewohnte Weise zugänglich macht!

14.4 Praxisbeispiele für Fortgeschrittene

757

Oberfläche Diese entspricht nur rein äußerlich dem Vorgängerbeispiel. Im Sinne einer längst überfälligen Vereinfachung werden wir die 18 RadioButtons durch je eine RadioGroup für die horizontalen und vertikalen Einstellungen ersetzen. Weisen Sie der Items-Eigenschaft im Stringlisten-Editor die Werte 1 bis 9 zu und setzen Sie ItemIndex = 0. Bei der horizontalen RadioGroup setzen Sie Columns = 9 , die vertikale verbleibt auf ihrem Standardwert (Columns = 1).

Klassen-Unit Beim Vergleich des Quelltextes mit der gleichnamigen Unit des Vorgängerbeispiels werden Ihnen viele Analogien auffallen. So sind z.B. die ehemaligen Funktionen/Prozeduren zu Methoden der Klasse TMatrix2 geworden. unit dynVarAr; interface type TIntArray = array[1..1] of Integer; TMatrix2 = class(TObject) private imax, jmax: Integer; pA: ^TIntArray; function rdA(i,j:Integer):Integer; procedure wrA(i,j:Integer; w:Integer); function rangeOKi(i: Integer): Boolean; // Bereichsüberprüfung i function rangeOKj(j: Integer): Boolean; // Bereichsüberprüfung j public constructor Create(im, jm: Integer); destructor Destroy; override; property A[i, j: Integer]: Integer read rdA write wrA; // !!! end; implementation uses SysUtils;

Für die Fehlerbehandlung (bei Bereichsüberschreitungen) brauchen wir diese "intelligente" Konstante (siehe Test): const errTxt = 'Index (%d) ist größer als %d !';

Konstruktor und Destruktor kapseln das Erzeugen/Entfernen von Objekten: constructor TMatrix2.Create; // dyn. Speicher reservieren begin inherited Create; imax := im; jmax := jm; GetMem(pA, SizeOf(Integer)* imax * jmax)

758

Kapitel 14

Datenstrukturen

end; destructor TMatrix2.Destroy; // dyn. Speicher wieder freigeben begin FreeMem(pA,SizeOf(Integer)* imax * jmax) end;

Diese beiden folgenden privaten Methoden (Rückgabewert Boolean) überprüfen die Bereichsgrenzen: function TMatrix2.rangeOKi; begin Result := (i > 0) and (i <= imax); if not Result then raise ERangeError.CreateFmt(errTxt, [i, imax]) end; function TMatrix2.rangeOKj; begin Result := (j > 0) and (j <= jmax); if not Result then raise ERangeError.CreateFmt(errTxt, [j, jmax]) end;

Schließlich die Zugriffsprozeduren für die Property A[i, j] : procedure TMatrix2.wrA; // Schreibzugriff begin if rangeOKi(i) and rangeOkj(j) then pA^[(i-1)* jmax + j] := w end; function TMatrix2.rdA; // Lesezugriff begin if rangeOKi(i) and rangeOkj(j) then Result := pA^[(i-1)* jmax + j] else Result := 0 end; end.

Unit zum Testen der Klasse In der Beispielanwendung wird ein Objekt mtrx als Instanz der Klasse TMatrix2 benutzt. Es genügt die Wiedergabe des implementation-Abschnitts: uses dynVarAr; var mtrx: TMatrix2; imax, jmax: Integer;

// Objektreferenz // max. Zeilen- bzw. Spaltenanzahl

Wir brauchen zwei Hilfsprozeduren zur Demonstration des Lese- und Schreibzugriffs.

14.4 Praxisbeispiele für Fortgeschrittene

759

1. Das Array wird mit Beispieldaten gefüllt: procedure writeArray; var i,j,z: Integer; begin for i := 1 to imax do for j := 1 to jmax do begin z := StrToInt(IntToStr(i) + IntToStr(j)); mtrx.A[i,j] := z // Schreibzugriff end end;

2. Das Array wird wieder ausgelesen: procedure displayArray; var i,j,z: Integer; begin Form1.Refresh; begin for i := 1 to imax do for j := 1 to jmax do begin z := mtrx.A[i,j]; // Lesezugriff Form1.Canvas.TextOut(40+j*40, 55 + i*28, IntToStr(z)) end end end;

Nun zu den beiden Event-Handlern: 1. Bei Programmstart steht ein minimales Array mit einer Zeile und einer Spalte zur Verfügung: procedure TForm1.FormCreate(Sender: TObject); begin imax := 1; jmax := 1; mtrx := TMatrix2.Create(imax, jmax) // Anfangsobjekt erzeugen end;

2. Das Ändern der Zeilen- und Spaltenanzahl der Matrix: procedure TForm1.RadioGroupClick(Sender: TObject); begin mtrx.Free; // altes Objekt freigeben! if Sender = RadioGroup1 then jmax := RadioGroup1.ItemIndex+1; if Sender = RadioGroup2 then imax := RadioGroup2.ItemIndex+1; mtrx := TMatrix2.Create(imax,jmax); // neues Objekt erzeugen! writeArray; displayArray end;

760

Kapitel 14

Datenstrukturen

Wie Sie sehen, haben wir für beide RadioGroups einen gemeinsamen OnClick-Event-Handler verwendet. Korrigieren Sie deshalb den Bezeichner (RadioGroupClick anstatt RadioGroup1Click/ RadioGroup2Click) in der Typdeklaration TForm1 und auf der "Ereignis-Seite" des Objektinspektors!

Test Sie werden keinerlei Unterschiede zum Vorgängerbeispiel feststellen. Wenn Sie aber bewusst eine Bereichsüberschreitung provozieren, z.B. wenn Sie eine Anweisung mtrx.A[11, 20] := ....

in den Quelltext einfügen, so würde folgende Fehlermeldung erscheinen:

Beim genauen Hinsehen entdecken Sie hier den Text aus der Konstanten errTxt.

Bemerkungen ■ Es bedarf minimaler Änderungen, um die Klasse an andere Dimensionen (ein-, drei-, vierdimensional) oder Datentypen (Double, String, ...) anzupassen. ■ Eine nach den Prinzipien dieses Beispiels konstruierte Klasse zum Lösen linearer Gleichungssysteme finden Sie unter 16.4 (Mathematikprogramm GAUSS2).

15

Erweitere Grafikprogrammierung

Kapitel

15

Erweitere Grafikprogrammierung Dieses Kapitel hält einiges für den Grafikprofi bereit, was im Kapitel 7 keinen Platz mehr gefunden hätte. Sie erfahren, wie man ■ auf das GDI (Graphical Device Interface) von Windows zugreift, ■ Bitmaps manipuliert und ■ 3-D-Vektorgrafiken programmiert. Empfehlenswert sind Grundkenntnisse im Aufruf von API-Funktionen (siehe Kapitel 10).

15.1 GDI-Programmierung Mittelpunkt des folgenden Abschnitts ist die Grafikprogrammierung unter Windows mit Hilfe des GDI. Sie werden vielleicht einwenden, dass Borland den Anspruch erhebt, das Windows-GDI mit dem Canvas-Objekt zu kapseln. Dies aber ist nur teilweise richtig, denn Windows hat noch wesentlich mehr zu bieten, als es die wenigen Methoden und Eigenschaften des Canvas-Objekts vermuten lassen. Insbesondere Programmierer, die Aufgabenstellungen in wissenschaftlich technischen Bereichen realisieren müssen, finden eine breit gefächerte Palette von Grafikfunktionen, deren Vielfalt schon verwirrend ist. Der folgende Abschnitt kann aus diesem Grund auch nur einen ersten Überblick geben, im Rezeptbuch finden Sie detaillierte Beispiele zu den angesprochenen Themen. HINWEIS: Bevor Sie an einigen "nicht funktionierenden" Beispielprogrammen verzweifeln,

sollten Sie in der Win 32-Help-Datei nachschlagen, ob die relevante Funktion von Ihrem Betriebssystem überhaupt unterstützt wird (QuickInfo). Was die Sache so kompliziert macht, ist die Tatsache, dass Sie eine Funktion zwar ohne Laufzeitfehler aufrufen können, es passiert allerdings nichts. Insbesondere die erweiterten Möglichkeiten in Bezug auf Koordinatensysteme etc. werden in Windows 95/98/ME nicht oder nur teilweise unterstützt1.

1

Wir haben zwar versucht, wo immer es geht, die entsprechenden Funktionen zu kennzeichnen, sollte ein Beispielprogramm trotzdem bei Ihnen nicht laufen, suchen Sie die Ursache bitte zuerst in der verwendeten Windows-Version.

762

Kapitel 15

Erweitere Grafikprogrammierung

Für die Grafikprogrammierung bietet Delphi einige recht interessante Ansätze. So werden unter anderem große Teile des Windows-GDI in einem Objekt der Klasse TCanvas gekapselt. Statt einzelner Grafikfunktionen bietet ein Canvas eine Reihe von Methoden und Eigenschaften für die Grafikausgabe. Neben folgenden Objekten bzw. Klassen ■ Formulare (TForm), ■ TImage-Komponenten, ■ TPaintbox-Komponenten, ■ Drucker (Printer), ■ TBitmap, TMetafile, TIcon verfügen auch einige andere Komponenten (z.B. ListBox, ComboBox etc.) über ein Canvas-Objekt. Die folgende Abbildung zeigt die für die Grafikausgabe wichtigsten Klassen mit den dazugehörigen Canvas-Objekten. TForm

TPaintbox

Canvas

TImage

Canvas

TPrinter

Canvas

Canvas

TBitmap Canvas

TMetafile TMetafileCanvas

Picture Bitmap Canvas

HINWEIS: Die Klasse TMetafile ist nur mit einer gestrichelten Linie mit einem TMetafile-

Canvas-Objekt verbunden, der Grund dafür wird in Abschnitt 15.1.3 (Metafiles) detailliert erläutert.

15.1.1 Arbeiten mit dem GDI Am Anfang war das Handle Wenn Sie schon in der GDI-Help-Datei geschmökert haben, werden Sie dort auch auf den Begriff des Handle gestoßen sein. Was also ist ein Handle? Mit Handle wird eine Nummer (Typ Integer) bezeichnet, mit der ein Formular oder eine Komponente eindeutig gekennzeichnet ist. Jedes Fenster bzw. (fast) jede Komponente in Delphi verfügt

763

15.1 GDI-Programmierung

über diese Eigenschaft. Das Handle wird jedoch nicht durch Ihre Anwendung, sondern durch Windows direkt vergeben. Neben dem Handle finden Sie noch die Bezeichnung Gerätekontext (DC) bzw. Handle auf den Gerätekontext (HDC). Dieser Gerätekontext ist die Schnittstelle zwischen Ihrem Anwendungsprogramm und den eigentlichen Ausgabegeräten wie Bildschirm, Fenster, Drucker etc. Der Kontext eines Gerätes beinhaltet nicht nur alle Informationen, Eigenschaften und Attribute, sondern auch die Funktionen, um dieses Gerät anzusprechen. Daraus folgt auch der prinzipielle Ablauf beim Arbeiten mit den GDI-Funktionen: ■ Anlegen eines Gerätekontextes ■ Anlegen von Objekten ■ Zuweisen der neuen Objekte ■ Grafikausgaben (mit obigen Objekten) ■ Wiederherstellen der Ursprungsobjekte ■ Zerstören der neuen Objekte ■ Freigabe bzw. Schließen des Gerätekontextes BEISPIEL: Grafikausgabe über einen Gerätekontext var dc : HDC; hp,ho : HPen; ... dc := GetDC(Handle); hp := CreatePen(0, 10, 0); ho := SelectObject(dc, hp); LineTo(dc, 220,210); SelectObject(dc, ho); DeleteObject(hp); ReleaseDC(Handle,dc);

// // // // // // //

Anlegen DC Anlegen neues Objekt (Stift) Auswählen Objekt Grafikausgabe Wiederherstellen Objekt Löschen Objekt Löschen DC

HINWEIS: Beachten Sie, dass Sie keine aktiven Objekte löschen können bzw. sollten. Aus die-

sem Grund muss vor dem Aufruf von DeleteObject auch das alte Objekt mit SelectObject wiederhergestellt werden.

Gerätekontext (Device Context Types) In Delphi führen zwei verschiedene Wege zum HDC. Zum einen können Sie den von Delphi bereitgestellten Handle (Canvas.Handle)1 verwenden, zum anderen können Sie auch einen eigenen DC erzeugen.

1

An dieser Stelle Vorsicht: Bei Form.Handle handelt es sich nicht um einen HDC, sondern um einen "normalen" Handle. Nur Canvas.Handle beschreibt einen Handle auf den DC.

764

Kapitel 15

Erweitere Grafikprogrammierung

Auf die Frage, welche Variante denn zu bevorzugen ist, lässt sich keine allgemein gültige Antwort geben. Einerseits ist die Arbeit mit Delphi-Handles recht komfortabel und sicher (Sie vergessen nie das Löschen des DC!), andererseits kommen Sie in bestimmten Fällen nicht um die Definition eines eigenen DCs herum. Dies könnte zum Beispiel dann der Fall sein, wenn Sie einen DC brauchen, den Delphi nicht zur Verfügung stellt (Screen), oder wenn Sie mit einigen bestimmten GDIFunktionen arbeiten. Letzteres Argument wollen wir etwas näher betrachten, probieren Sie dazu die beiden folgenden Codefragmente aus. BEISPIEL: Variante 1 var dc : HDC; procedure TForm1.Button1Click(Sender: TObject); begin dc := Canvas.Handle; Rectangle(dc, 100, 100, 150, 200); end;

BEISPIEL: Variante 2 var dc : HDC; procedure TForm1.Button1Click(Sender: TObject); begin dc := Canvas.Handle; end; procedure TForm1.Button2Click(Sender: TObject); begin Rectangle(dc, 100, 100, 150, 200); end;

Im ersten Beispiel wird erwartungsgemäß ein Rechteck auf dem Formular gezeichnet, wenn Sie auf Button1 klicken. Im zweiten Beispiel müsste nach dem Druck auf Button1 (Speichern des HDC in der Variablen dc) und nachfolgendem Druck auf Button2 (GDI-Grafikausgabe) ebenfalls ein Rechteck erscheinen. In einigen Fällen passiert allerdings nichts, Delphi "vergisst" einfach den DC bzw. generiert einen neuen, der mit dem gespeicherten nicht mehr übereinstimmt. Diese Besonderheit können Sie nur umgehen, wenn Sie sich einen eigenen DC erzeugen. Doch bevor es so weit ist, wollen wir uns die verschiedenen DC-Typen einmal genauer ansehen. Windows unterstützt vier verschiedene Typen von Gerätekontexten. Deren Beschreibung bzw. Verwendung finden Sie in der folgenden Tabelle: Gerätekontext Beschreibung

Display

Ausgaben auf dem Bildschirm, d.h. Fenster, Controls oder Screen Erzeugen mit GetDC, GetDCEx oder BeginPaint Löschen mit ReleaseDC oder EndPaint

765

15.1 GDI-Programmierung

Gerätekontext Beschreibung

Printer

Drucker/Plotter der verschiedenen Typen Erzeugen mit CreateDC Löschen mit DeleteDC

Memory

Speicherabbilder von Bitmaps. Diese sind nicht sichtbar, können aber das Ziel von Grafikausgaben sein. Erzeugen mit CreateCompatibleDC Löschen mit DeleteDC

Information

... dient lediglich der Informationsgewinnung, es können keine Grafikausgaben vorgenommen werden (GetDeviceCaps) Erzeugen mit CreateIC Löschen mit DeleteDC

HINWEIS: Jede Menge Beispiele zu diesem Thema finden Sie im Kochbuchteil!

15.1.2 Koordinatensysteme und Abbildungsmodi Bisher sind Sie unter Delphi wahrscheinlich nur mit dem Canvas-eigenen Koordinatensystem in Berührung gekommen, dessen Nullpunkt sich in der linken oberen Ecke befindet. Positive x-Werte werden nach rechts, positive y-Werte nach unten abgetragen. Die Einheit in diesem Koordinatensystem ist das Pixel. 0,0

+X

+Y

Leider hat die ganze Sache einen wesentlichen Haken: Da der Drucker über das gleiche CanvasObjekt gesteuert wird, erfolgt auch dort die Ausgabe in Pixeln. Dass die Ausgabe einer 100 Pixel langen Linie auf einem 300-dpi-Drucker zu einem anderen Ergebnis führt als auf einem 600-dpiDrucker, dürfte klar sein. Von einer geräteunabhängigen Ausgabe kann in diesem Zusammenhang wohl nicht mehr gesprochen werden. Wer diesem Missstand abhelfen will, kommt um die Verwendung der Funktion SetMapMode nicht herum, mit der Sie einem Ausgabegerät bzw. dessen DC ein neues Koordinatensystem bzw. einen anderen Abbildungsmodus zuweisen können.

766

Kapitel 15

Erweitere Grafikprogrammierung

Für die Druckausgabe ist insbesondere der Abbildungsmodus MM_LOMETRIC interessant, in dem Sie unabhängig von der Druckerauflösung mit Millimetern arbeiten können. BEISPIEL: Drucken eines 10 cm großen Rechtecks Printer.BeginDoc; SetMapMode(Printer.handle,MM_LOMETRIC); Printer.Canvas.Rectangle(100,100,1100,1100); Printer.EndDoc;

Die folgende Tabelle listet die zulässigen SetMapMode-Konstanten auf. Typ

Beschreibung

MM_ANISOTROPIC

Virtuelle Einheiten werden in willkürliche Einheiten mit willkürlich skalierten Achsen umgewandelt. Das Setzen des Abbildungsmodus verändert die aktuellen Fenster- und Grafikfenster-Einstellungen nicht. Zum Ändern der Einheiten für Orientierung und Skalierung sollte Ihre Anwendung die Funktionen SetWindowExt und SetViewportExt benutzen.

MM_HIENGLISH

Jede virtuelle Einheit wird in 0.001 Zoll umgewandelt. Positive x sind rechts, positive y oben. Beachten Sie, dass es bei diesem Abbildungsmodus sehr schnell zu Wertebereichsüberschreitungen kommen kann.

MM_HIMETRIC

Eine virtuelle Einheit wird in 0.01 Millimeter umgewandelt. Positive x sind rechts, positive y oben.

MM_ISOTROPIC

Virtuelle Einheiten werden in willkürliche Einheiten mit gleich skalierten Achsen umgewandelt, d.h., eine Einheit auf der x-Achse entspricht einer Einheit auf der y-Achse. Um die gewünschten Einheiten und die Achsenorientierungen zu bestimmen, müssen Sie die Funktionen SetWindowExt und SetViewportExt benutzen.

MM_LOENGLISH

Jede virtuelle Einheit wird in 0.01 Zoll umgewandelt. Positive x sind rechts, positive y oben.

MM_LOMETRIC

Eine virtuelle Einheit wird in 0.1 Millimeter umgewandelt. Positive x sind rechts, positive y oben.

MM_TEXT

Eine virtuelle Einheit wird in einen (1) Geräte-Bildpunkt gewandelt. Positive x sind rechts, positive y unten.

MM_TWIPS

Eine virtuelle Einheit wird in 1/20 Punkt umgewandelt. Da 1 Punkt gleich 1/72 Zoll ist, entspricht ein Twip 1/1440 Zoll. Positive x sind rechts, positive y oben.

Wie Sie der Tabelle entnehmen können, stimmt der Modus MM_TEXT mit dem Delphi-Koordinatensystem überein. Für die Ausgabe auf dem Bildschirm sind die Modi MM_ANISOTROPIC und MM_ISOTROPIC interessant, können Sie doch damit beliebige Koordinatensysteme realisieren. Allerdings ist der Modus MM_ISOTROPIC dahingehend eingeschränkt, dass x- und y-Achse im gleichen Maßstab skaliert werden, die Abbildung also proportional vergrößert bzw. verkleinert wird.

15.1 GDI-Programmierung

767

Die Funktionen SetWindowExtEx und SetViewportExtEx brauchen Sie für die Auswahl der Skalierungsfaktoren. BEISPIEL: Eine technische Zeichnung mit den virtuellen Abmessungen 4000 x 4000 soll in den Clientbereich

eines Formulars skaliert werden. SetMapMode(Canvas.Handle,MM_ISOTROPIC); SetWindowExtEx(Canvas.Handle,4000,4000,nil); SetViewportExtEx(Canvas.Handle,Clientwidth,Clientheight,nil);

Nach der Auswahl des Abbildungsmodus (natürlich verwenden wir MM_ISOTROPIC, die Zeichnung soll ja nicht verzerrt werden) übergeben wir der Funktion SetWindowExtEx die virtuellen Maximalabmessungen unseres neuen Fensters. Die Größe des Viewports entspricht den realen Innenabmessungen des Formulars (ClientWidth, ClientHeight). Alle weiteren Grafikausgaben (Text, Linien etc.) werden jetzt so skaliert, als ob das Fenster eine Innenabmessung von 4000 x 4000 Pixel hätte. Möchten Sie positive y-Werte nach oben abtragen, können Sie auch folgende Zuweisung für SetViewportExtEx verwenden: SetViewportExtEx(Canvas.Handle,Clientwidth,-Clientheight,nil);

Mit Hilfe der Funktion SetWindowOrgEx ist es weiterhin möglich, den Nullpunkt des Koordinatensystems beliebig zu verschieben, Sie brauchen bei späteren Grafikausgaben also nicht extra einen Offset zu addieren. BEISPIEL: Zeichnen einer Sinuskurve im Bereich 0 ... 2π. Die Funktion soll so skaliert werden, dass der

Clientbereich unabhängig von der Formulargröße voll genutzt wird. const max = Round(2*PI*100); var n : integer; begin SetMapMode(Canvas.Handle,mm_anisotropic); SetWindowExtEx(Canvas.Handle,max,200,nil); // Kippen des Koordinatensystems SetViewportExtEx(Canvas.Handle,Clientwidth,-Clientheight,nil); SetWindowOrgEx(Canvas.Handle,0,100,nil); // Verschiebung Nullpunkt Canvas.Moveto(0,0); for n := 0 to max do canvas.lineto(n,round(100*sin(n/100))); end;

Mit den oben genannten Funktionen ist lediglich eine Verschiebung bzw. eine Skalierung möglich. Wem das nicht reicht, der findet eine weitere GDI-Funktion, die alle mathematisch relevanten Transformationen vornehmen kann. Die Rede ist von SetWorldTransform, mit der Sie Verschiebungen, Skalierungen, Rotationen, Spiegelungen und Scherungen realisieren können. HINWEIS: Windows 95/98/ME-Programmierer müssen an dieser Stelle leider passen, lediglich

Windows NT/2000/XP bietet dieses Feature.

768

Kapitel 15

Erweitere Grafikprogrammierung

Übergabewerte an die Funktion sind der Gerätekontext und eine Strukturvariable vom Typ XFORM: TXForm = packed record eM11: Single; eM12: Single; eM21: Single; eM22: Single; eDx: Single; eDy: Single; end;

Bevor es jedoch so weit ist, dass Sie Koordinatentransformationen vornehmen können, müssen Sie den erweiterten Grafikmodus mit SetGraphicsMode aktiviert haben. BEISPIEL: Aktivieren des erweiterten Grafikmodus SetGraphicsMode(Canvas.Handle, GM_ADVANCED); ...

Wie Sie die einzelnen Elemente von TXForm verwenden, sollen die folgenden Skizzen und Formeln verdeutlichen:

Translation x' = x + dx y' = y + dy

... als Transformationsmatrix: 1 0

0 1

0 0

dx dy 1

Skalierung x' = x ⋅ dx y' = y ⋅ dy

... als Transformationsmatrix: dx 0 0 0 dy 0 0 0 1

769

15.1 GDI-Programmierung

Rotation x' = (x ⋅ cos A) − (y ⋅ sin A) y' = (y ⋅ sin A) − (y ⋅ cos A)

... als Transformationsmatrix: cos A

sin A

0

− sin A cos A 0 0

0

1

Scherung x' = x + (sx ⋅ y) y' = y + (sy ⋅ x)

... als Transformationsmatrix: 1

sx 0

sy 0

1 0

0 1

Alle obigen Formeln lassen sich in folgender Weise zusammenfassen: x' = x ⋅ em12 + y ⋅ em21 + edx y' = x ⋅ em12 + y ⋅ em22 + edy

bzw. als Transformationsmatrix: em11 em12 0 em21 em22 0 edx

edy

1

Natürlich müssen Sie Drehung, Skalierung und vielleicht noch die Verschiebung nicht mit einem Mal setzen. Verwenden Sie einfach die Funktion ModifyWorldTransform, mit der Sie das bisherige Koordinatensystem modifizieren. Sie müssen lediglich angeben, wie die neue Transformationsmatrix mit der bisherigen verknüpft wird: Parameter

Bedeutung

MWT_IDENTITY

Ersetzen der bisherigen Transformationsmatrix mit der neuen.

MWT_LEFTMULTIPLY

Die neue Matrix ist der linke Faktor, die alte Matrix der rechte Faktor.

MWT_RIGHTMULTIPLY

Die neue Matrix ist der rechte Faktor, die alte Matrix der linke Faktor.

770

Kapitel 15

Erweitere Grafikprogrammierung

15.1.3 Zeichenwerkzeuge und Objekte Für die Ausgabe von Grafiken (dazu zählt auch Text!) unterstützt Windows verschiedene grafische Objekte: ■ Stifte (Pen) ■ Pinsel (Brush) ■ Bitmaps ■ Paletten ■ Schriftarten (Font) ■ Regionen (Region) ■ Paths In den folgenden Abschnitten wollen wir kurz auf die wichtigsten Möglichkeiten und Funktionen eingehen, zahlreiche Rezepte im Kochbuchteil zeigen am Beispiel, wie Sie die Funktionen richtig einsetzen.

Erzeugen und Parametrieren der Objekte Bis auf wenige Ausnahmen müssen Sie alle oben genannten Objekte erst erzeugen (CreatePen, CreateBrush etc.), bevor Sie diese nutzen können. Eine dieser Ausnahmen ist die Verwendung der Delphi-Objekte zum Parametrieren. BEISPIEL: Rechteck mit der Linienstärke 10 zeichnen. Diese wird über das Pen-Objekt eingestellt. Canvas.Pen.Width := 10; Rectangle(Canvas.Handle, 10,10,100,100)

Wenn Sie nicht den Delphi-Gerätekontext (Canvas.Handle) verwenden, sondern einen neuen DC erzeugen, ist obige Vorgehensweise nicht mehr zulässig. In diesem Fall müssen Sie entweder ein Objekt mit CreatePen etc. erzeugen, oder Sie nutzen die Tatsache aus, dass Delphi einen Handle auf seine Objekte bereitstellt. var HPold DC begin DC := HPold :=

: HPen; : HDC; GetDC(handle); SelectObject(DC, Canvas.Pen.Handle)

// neuen DC erzeugen // Delphi-Pen übernehmen

Nach diesen Anweisungen können Sie mit dem Delphi-Pen arbeiten. Beachten Sie jedoch, dass Sie diesen Stift weder löschen (DeleteObject) noch über die Delphi-Eigenschaften ändern dürfen (das Handle ist sonst ungültig). Sie sollten lediglich den vorhergehenden Stift wiederherstellen (dazu brauchen wir die Variable vom Typ HPen): SelectObject(DC, Hpold);

15.1 GDI-Programmierung

771

Natürlich haben Sie auf diese Weise nur Zugriff auf Optionen, die Delphi als Eigenschaften zur Verfügung stellt. Einen Font, der um 10° gedreht ist, können Sie so nicht erzeugen, dazu fehlt die Eigenschaft Angle. Das Erzeugen mit CreatePen, CreateFont etc. erfordert etwas mehr Arbeit. Neben dem Erstellen des neuen Objekts müssen Sie sich auch noch um das Sichern der bisherigen Objekte kümmern. Selbst erstellte Objekte sollten wieder gelöscht werden, sonst werden wertvolle Systemressourcen verschwendet. BEISPIEL: Erzeugen eines neuen Schrifttyps (Font-Objekt) var hfont, fontold : Integer; dc : HDC; begin dc := GetDC(Handle); hfont := CreateFont(-10, 0, 100, 0, fw_normal, 0, 0, 0, 1, 4, $10, 2, 4, 'Arial'); fontold := SelectObject(dc,hfont); ... TextOut(dc,10,10,'Test',4); ... SelectObject(dc, fontold); // Zurücksetzen Font DeleteObject(hfont); // Löschen Font end;

Das Zurücksetzen und Löschen des Objekts können Sie auch mit einer Anweisung realisieren, DeleteObject(SelectObject(dc, fontold);

da der Rückgabewert der Funktion SelectObject der bisher gültige Handle ist. HINWEIS: Eine letzte Variante, Objekte zu erzeugen, bietet sich mit der Funktion GetStock-

Object, über die bereits vordefinierte System-Objekte abgerufen werden können. Diese Objekte brauchen nicht gelöscht zu werden.

Stift (Pen) Das Windows-GDI verwendet Stifte zum Zeichnen von Umrissen grafischer Primitive, d.h. von Linien, Kreisen etc. Ab Win 32 wird zwischen zwei Grundtypen von Stiften unterschieden: ■ Cosmetic Pens ■ Geometric Pens Während der erste Typ nur über die Attribute Width, Style und Color verfügt, bietet der zweite Typ bedeutend mehr. Allerdings hat dieses Mehr natürlich auch seinen Preis: Grafikausgaben mit Geometric Pens sind meist wesentlich langsamer als Ausgaben mit einem Cosmetic Pen.

772

Kapitel 15

Erweitere Grafikprogrammierung

Die folgende Abbildung demonstriert einige Möglichkeiten der beiden Stifttypen:

Delphi selbst bzw. die Unit Graphics setzt für die TPen-Objekte standardmäßig Cosmetic Pens ein, der Wechsel zu einem Geometric Pen ist jedoch problemlos möglich. Für das Erstellen von Pens bieten sich mit CreatePen und ExtCreatePen zwei Funktionen, von denen allerdings nur die zweite wirklich interessant ist, können doch alle Optionen von CreatePen auch über das Canvas-Objekt eingestellt werden. SYNTAX:

function ExtCreatePen(PenStyle : DWORD; Width: DWORD;const Brush: TLogBrush; StyleCount: DWORD; Style: Pointer): HPEN;

Die folgenden Abbildungen sollen Ihnen helfen, sich bei der Vielzahl der Optionen zurechtzufinden. Der Parameter PenStyle ist die Summe (OR-Verknüpfung) der folgenden Attribut-Konstanten. Je Gruppe ist nur eine Konstante zulässig. PS_GEOMETRIC + PS_DASH + PS_ENDCAP_ROUND + PS_JOIN_ROUND

Die beiden Konstanten für die Auswahl des Stifttyps: ■ PS_GEOMETRIC ■ PS_COSMETIC Mit den folgenden Konstanten beeinflussen Sie beim Geometric Pen die Form der Linienenden:

773

15.1 GDI-Programmierung

Die folgenden Linientypen sind ab Linienstärke 2 nur mit einem Geometric Pen realisierbar:

Für das Zeichnen von Ecken können ebenfalls drei verschiedene Modi gesetzt werden:

HINWEIS: Unter Windows 95/98 werden nicht alle Attribute korrekt dargestellt.

Der Parameter Width bestimmt die Stärke der Linie. Etwas aufwändiger ist da schon die Zuweisung der Brush-Option. Die Struktur im Einzelnen: TLogBrush = packed record lbStyle: UINT; lbColor: COLORREF; lbHatch: Longint; end;

Für lbStyle können Sie eine der folgenden Konstanten verwenden: Konstante

Beschreibung

BS_SOLID

gefüllte Linie

BS_HATCHED

Linie mit Füllmuster

774

Kapitel 15

Erweitere Grafikprogrammierung

Konstante

Beschreibung

BS_HOLLOW, BS_NULL

leere Linie

BS_PATTERN

Linie mit Bitmap als Füllmuster

HINWEIS: Beachten Sie, dass der obige Brush nur zum Füllen der Linie verwendet wird, es han-

delt sich nicht um den eigentlichen Brush, mit dem Figuren (Kreis, Rechteck etc.) gefüllt werden. Ist lbStyle auf BS_HATCHED festgelegt, können Sie mit lbHatch eines der folgenden Muster auswählen:

Wie Sie auch Linien erzeugen können, die mit Bitmaps gefüllt sind, zeigt Ihnen der folgende Abschnitt, der detailliert auf die Verwendung von Pinseln eingeht.

Die Parameter StyleCount und Style können Sie für nutzerdefinierte Linientypen verwenden. Ein solcher Typ wird mit einem DWORD-Array beschrieben. StyleCount gibt die Anzahl der DWORDWerte an, Style ist das eigentliche DWORD-Array. BEISPIEL: Nutzerdefinierter Linientyp var muster : array[0..3] of DWORD; begin muster[0] :=1; // Länge 1. Linie muster[1] :=20; // Länge 1. Leerstelle

15.1 GDI-Programmierung

775

muster[2] :=10; // Länge 2. Linie muster[3] :=40; // Länge 2. Leerstelle newpen := ExtCreatePen(PS_GEOMETRIC + PS_USERSTYLE + ... , 4, @muster);

erzeugt folgendes Muster:

HINWEIS: Beachten Sie, dass die Konstante PS_USERSTYLE von Ihnen zu setzen ist.

Pinsel (Brush) Im Gegensatz zum Stift dient der Pinsel zum Füllen von Flächen und Hintergründen. Die Pinselart beschränkt sich allerdings nicht auf die verfügbaren Farben, sondern schließt auch Muster und Bitmaps ein. Windows unterscheidet vier verschiedene Pinseltypen: ■ einfarbige Pinsel (Solid Brush) ■ vordefinierte Pinsel (Stock Brush) ■ Pinsel mit Muster (Hatch Brush) ■ Pinsel mit Bitmap (Pattern Brush) Solid Brush Im Prinzip handelt es sich bei einem Solid Brush auch um einen Bitmap-Pinsel, besteht er doch aus einer einfarbigen 8x8-Bitmap. Für den Programmierer stellt sich jedoch nur die Frage nach der Pinselfarbe, die als COLORREF-Wert an die Funktion CreateSolidBrush übergeben wird. BEISPIEL: Erzeugen und Zuweisen eines roten Pinsels var c : ColorRef; hb : HBrush; begin c := 255; hb := CreateSolidBrush(c); SelectObject(canvas.handle, hb);

Bevor Sie sich jetzt den Kopf darüber zerbrechen, wie Sie mühsam einen Farbwert ausrechnen, verwenden Sie einfach die Funktion RGB, deren Rückgabewert ein COLORREF-Wert ist. Übergeben werden die Intensitäten von Rot, Grün und Blau als Byte-Werte. Wollen Sie eine Füllfarbe erzeugen, die in der 16-Farben-Palette von Delphi vordefiniert ist, können Sie auch die Konstanten clBlack...clWhite verwenden.

776

Kapitel 15

Erweitere Grafikprogrammierung

HINWEIS: Von Ihnen erzeugte Solid-Brushs sind nach Gebrauch wieder zu löschen.

Stock Brush Windows stellt für häufig wiederkehrende Aufgaben zwei Gruppen vordefinierter Pinsel zur Verfügung. Während die erste Gruppe aus sieben verschiedenen Graustufen bzw. leeren Pinseln besteht, die Sie mit GetStockObject abrufen können, bietet das User-Interface weitere 21 Pinsel, die den Systemfarben entsprechen. Die Handles können Sie mit GetSysColorBrush ermitteln.

BEISPIEL: Hellgrau gefülltes Rechteck zeichnen var hb : HBrush; begin hb := SelectObject(canvas.handle,GetStockObject(LTGRAY_BRUSH)); rectangle(canvas.handle,10,10,100,100); SelectObject(canvas.handle,hb); end;

Hatch Brush Für das Zeichnen von einfachen Schraffuren bietet sich die Verwendung von Hatch-Brushs an. Folgende sechs Typen sind von Windows vordefiniert:

Zum Abrufen der Handles verwenden Sie die Funktion CreateHatchBrush.

15.1 GDI-Programmierung

777

Pattern Brush Wem die bisherigen Möglichkeiten noch nicht ausreichen, der dürfte spätestens bei den PatternBrushs fündig werden.

Alles, was Sie brauchen, ist eine Bitmap bzw. das entsprechende Handle (HBitmap). Für dieses Handle bieten sich in Delphi drei wesentliche Quellen an: ■ Image-Komponente ■ ImageList-Komponente ■ TBitmap-Objekt BEISPIEL: Image-Komponente var newhb, hb : HBrush; begin newhb := CreatePatternBrush(Image1.Picture.Bitmap.Handle) hb := SelectObject(canvas.handle,newhb); ellipse(canvas.handle,10,10,100,100); SelectObject(canvas.handle,hb); ...

BEISPIEL: ImageList-Komponente var hb : HBrush; bm : TBitmap; begin bm := TBitmap.Create; imagelist1.getBitmap(0,bm); hb := SelectObject(canvas.handle,CreatePatternBrush(bm.handle));

Bei einer ImageList ist das direkte Abrufen des Bitmap-Handles nicht möglich (die Methode GetImageBitmap liefert lediglich einen Handle auf die gesamte ImageList-Bitmap). Wir müssen den Umweg über ein TBitmap-Objekt gehen. Die Abbildung zeigt das Resultat:

778

Kapitel 15

Erweitere Grafikprogrammierung

BEISPIEL: Laden aus einer Datei var hb : HBrush; bm : TBitmap; begin bm := TBitmap.Create; bm.LoadFromFile('c:\temp\test.bmp'); hb := SelectObject(canvas.handle,CreatePatternbrush(bm.handle));

Auch in diesem Beispiel müssen wir den Umweg über ein TBitmap-Objekt wählen, um die Datei mit der Methode LoadFromFile zur Laufzeit laden zu können. Beachten Sie, dass im Normalfall das Muster immer in der linken oberen Ecke beginnt. Möchten Sie eine Musterverschiebung erreichen, müssen Sie mit der Funktion SetBrushOrgEx einen neuen "Nullpunkt" setzen:

Bitmaps Eine Bitmap besteht neben dem Speicherabbild (Array aller Pixel) aus einem Header, der Größe und Auflösung beschreibt, sowie einer Palette. Windows unterstützt zwei Arten von Bitmaps:

779

15.1 GDI-Programmierung

■ geräteabhängige (DDBs1) ■ geräteunabhängige (DIBs2) Bei geräteabhängigen Bitmaps wird die Grafik so im Arbeitsspeicher abgelegt, wie es das Ausgabegerät erfordert. Im Unterschied dazu werden geräteunabhängige Bitmaps in einem fest definierten Format abgelegt, also unabhängig vom Ausgabegerät. An dieser Stelle wollen wir nicht weiter auf die Arbeit mit den Systemfunktionen eingehen, bietet doch Delphi im Zusammenhang mit Bitmaps fast schon alles, was der Programmierer so braucht. Bis auf eine Ausnahme: Wollen Sie Screenshots von einzelnen Fenstern bzw. vom gesamten Screen erzeugen, müssen Sie sich zwangsläufig mit dem internen Aufbau von Bitmaps beschäftigen. Der Einwand, mit der Methode GetFormImage könnte ebenfalls ein Formular-Screenshot erzeugt werden, kann so nicht gelten. Die damit erzeugte Bitmap umfasst lediglich den Clientbereich des Formulars, nicht die gesamte sichtbare Fläche inklusive Kopfzeile und Menü. BEISPIEL: Screenshot var ScreenDC, CompDC : HDC; ScreenBitmap : HBitmap; h : THandle;

Erzeugen eines Bildschirm-Gerätekontextes ScreenDC

:= GetDC(0);

sowie eines dazu kompatiblen Gerätekontextes: CompDC

:= CreateCompatibleDC(ScreenDC);

Entsprechend der Bildschirmgröße wird eine kompatible Bitmap erzeugt ScreenBitmap := CreateCompatibleBitmap(ScreenDC, GetDeviceCaps(ScreenDC, HORZRES), GetDeviceCaps(ScreenDC, VERTRES));

und dem neuen Gerätekontext zugewiesen: h := SelectObject(CompDC, ScreenBitmap);

Erst jetzt können wir mit BitBlt den Inhalt des Bildschirm-DCs in den Hilfs-DC übertragen. Doch vorher blenden wir das aktuelle Fenster aus: Self.Hide; BitBlt(CompDC,0,0,GetDeviceCaps(ScreenDC, HORZRES), GetDeviceCaps(ScreenDC, VERTRES),ScreenDC,0,0,SRCCOPY);

Formular wieder einblenden Self.show;

1

Device-Dependent Bitmap

2

Device-Independent Bitmap

780

Kapitel 15

Erweitere Grafikprogrammierung

und Bitmap in das Formular kopieren: BitBlt(canvas.handle,0,0,clientwidth,clientheight,compDC,0,0,SRCCOPY);

Wer schon einmal im Win 32-SDK geblättert hat, dürfte ein ähnliches Beispiel gefunden haben, allerdings mit einem Unterschied, den die folgende Abbildung zeigt.

Zu sehen ist der Speicherbedarf der Anwendung bei mehrmaligem Aufruf der obigen Funktion. Nach einigen Aufrufen geht nichts mehr. Die Ursache ist ein ebenso trivialer wie gern gemachter Fehler: Erzeugte Ressourcen wurden nicht oder nur teilweise wieder freigegeben. Aus diesem Grund müssen Sie unbedingt noch die folgenden Zeilen an das obige Listing anhängen: DeleteObject(SelectObject(CompDC,h)); DeleteDC(CompDC); ReleaseDC(0,ScreenDC);

// Löschen der Speicher-Bitmap // Löschen DC // Löschen DC

Wollen Sie die Bitmap für die weitere Bearbeitung einem TBitmap-Objekt zuweisen, können Sie folgenden Aufruf verwenden: var B : TBitmap; B := TBitmap.Create; B.Width := Screen.Width; B.Height := Screen.Height; BitBlt(B.Canvas.Handle,0,0, Screen.Width, Screen.Height,compDC,0,0,SRCCOPY); ...

Einzelheiten zu den DCs sind in folgender Tabelle zusammengefasst: Gerätekontext

Quellcode

DC gesamtes Fenster

dc := GetWindowDC(Handle); ... ReleaseDC(0,dc);

DC Clientbereich des Fensters

dc := GetDC(Handle); ... ReleaseDC(Handle,dc);

DC Bildschirm

dc := GetDC(0); ... ReleaseDC(0,dc); // oder dc:=CreateDC('DISPLAY','0','0','0'); ... DeleteDC(dc);

15.1 GDI-Programmierung

781

Das Speichern von Bitmaps ist eigentlich ein relativ aufwändiges Unterfangen. Doch darüber brauchen Sie sich in Delphi kaum Sorgen zu machen. Mit den beiden Methoden SaveToFile bzw. LoadFromFile haben Sie sowohl das Speichern als auch das Laden von Bitmaps aus einer Datei bestens im Griff.

Metafiles (WMF) Ein Metafile ist prinzipiell eine aufgezeichnete Folge von GDI-Funktionen mit den entsprechenden Parametern. Da die meisten GDI-Funktionen vektororientiert arbeiten, kann man von einem vektororientierten Grafikformat sprechen. Im Gegensatz zum Bitmap-Format werden also keine Informationen über einzelne Pixel gespeichert, sondern lediglich Daten über die einzelnen Grafikfunktionen wie Kreise, Linien, gefüllte Flächen etc. Einzige Ausnahme sind eingelagerte Bitmaps, diesen Fall wollen wir jedoch hier außer Acht lassen. Die Bezeichnung "Metafile" deutet eigentlich mehr auf eine Datei hin, es kann sich jedoch auch nur um ein Speicherobjekt handeln. Für uns ist im Weiteren die "nichtflüchtige" Form des Metafiles, d.h. die Metadatei, interessant. Dieses Format eignet sich aufgrund seiner Verbreitung gut für den Import und Export von Grafiken. In diesem Zusammenhang werden Sie auch schon mit dem wohl wesentlichsten Problem von Metadateien konfrontiert: Leider sind Metafile und Metafile nicht dasselbe. Sollten Sie bereits den (erfolglosen) Versuch unternommen haben, eine mit GDI-Funktionen angelegte Metadatei in Word für Windows oder in ein anderes Programm zu importieren, werden Sie wahrscheinlich über folgende Fehlermeldung gestolpert sein:

Die Ursache für obiges befremdliches Verhalten ist ein Unterschied im WMF-Format. Microsoft hatte unter 16-Bit-Windows mit dem Metafile-Format einen entsprechenden Datei-Header eingeführt, der jedoch noch einige Unzulänglichkeiten aufwies. Insbesondere fehlten Informationen über Größe und Position. typedef struct tagMETAHEADER { WORD mtType; WORD mtHeaderSize; WORD mtVersion; DWORD mtSize; WORD mtNoObjects; DWORD mtMaxRecord; WORD mtNoParameters; } METAHEADER;

782

Kapitel 15

Erweitere Grafikprogrammierung

Diesem Missstand wurde mit dem Aldus Placeable Metafile-Format abgeholfen. Dieses Format entspricht zu 100 % dem Microsoft-Format, weist jedoch einen zusätzlichen Header von 22 Byte auf. Wie sieht nun dieser Header aus? Das SDK (Software Development Kit) gibt Aufschluss: typedef struct { DWORD key; HANDLE hmf; RECT bbox; WORD inch; DWORD reserved; WORD checksum; } METAFILEHEADER;

Der Aufbau im Detail: Position

Bedeutung

0-3

Kennsignatur (0xD7, 0xCD, 0xC6, 0x9A)

4-5

nicht verwendet (0)

6-13

RECT-Struktur (links, oben, rechts, unten)

14-15

Umrechnungsfaktor für die verwendeten Einheiten

16-19

nicht verwendet (0)

20-21

Prüfsumme über den Header

Finden Sie in Programmen einen Importfilter für das WMF-Format, so ist im Allgemeinen das Aldus-Format gemeint. Mit Win 32 führt Microsoft nun noch ein neues Metafile-Format ein: Enhanced Metafiles. Dieses Format enthält im Header folgende Informationen: ■ Größe des Metafiles in Byte ■ Größe des Bildes in Geräteeinheiten ■ Größe des Bildes in 0,01 mm ■ Anzahl der Records ■ Offset einer zusätzlichen Beschreibung ■ die Größe einer optionalen Palette ■ die Auflösung des Originalausgabegeräts in Pixeln ■ die Auflösung des Originalausgabegeräts in mm ■ eine optionale Beschreibung Enhanced Metafiles ermöglichen eine echte Geräteunabhängigkeit. Alles, was nötig ist, um die Grafik originalgetreu auf einem anderen Gerät wiederzugeben, wird mitgespeichert. Zusätzlich

783

15.1 GDI-Programmierung

können in diesem Format auch die neuen Win 32-GDI-Befehle Verwendung finden (Koordinatensysteme, Bézierkurven, Pens etc.). Was sich so gut anhört, hat allerdings einen kleinen, aber nicht unwesentlichen Haken: Es gibt mit einigen der aktuell verbreiteten Grafikprogramme Probleme, diese Dateien zu laden. Wollen Sie Anwendungen schreiben, deren Grafiken importiert werden können, sollten Sie vorläufig besser beim Aldus-WMF-Format bleiben. Und damit sind wir schon beim Thema angelangt: Wie bei fast allen GDI-Funktionen führen auch hier zwei verschiedene Wege zum Ziel: ■ direkter Aufruf der GDI-Funktionen oder ■ Verwendung von Delphi-Methoden Im vorliegenden Fall wollen wir den Delphi-Methoden den Vorzug geben, nehmen uns diese doch eines der größten Probleme ab: das Speichern im Aldus-Metafile-Format. Wichtigstes Objekt für die weitere Arbeit ist eine TMetafile-Instanz, die ein Enhanced Metafile kapselt. Dieses erstellen Sie wie jedes andere Objekt durch Aufruf des Konstruktors Create. Der weitere Ablauf weicht allerdings von bisherigen Grafikobjekten (Form, Canvas etc.) ab. Ein Metafile kann erst nach dem Abschluss der letzten Zeichenoperation verwendet werden. Aus diesem Grund wird auch kein direkter Canvas zur Verfügung gestellt, sondern es muss ein Objekt vom Typ TMetafileCanvas quasi als Puffer zwischengeschaltet werden. Nachdem die Ausgabe im TMetafileCanvas-Objekt vorgenommen und das Objekt mit Free freigegeben wurde, können Sie das Metafile-Objekt benutzen (speichern, kopieren etc.). var WMF : TMetafile; begin WMF := TMetafile.Create; with TMetafileCanvas.Create(WMF, 0) do try TextOut(10,10,'hello world'); finally Free end;

// // //

Erzeugen des Metafile-Objekts Ausgabe-Canvas erzeugen ... Grafikoperationen

Danach kann das Metafile zum Beispiel gespeichert, WMF.SaveToFile('c:\test1.wmf');

in ein Formular kopiert Canvas.Draw(150,0,WMF);

oder in die Zwischenablage kopiert werden: Clipboard.Assign(wmf);

Zu allem Überfluss kann ein Metafile auch noch in ein anderes Metafile kopiert werden. Auf das Ziel-Metafile können Sie allerdings wieder nur mit einem TMetafileCanvas-Objekt zugreifen: var WMF, WMF1 : TMetafile;

784

Kapitel 15

Erweitere Grafikprogrammierung

begin WMF := TMetafile.Create; WMF1 := TMetafile.Create;

Zeichnen im 1. Metafile-Objekt : with TMetafileCanvas.Create(WMF, 0) do try TextOut(10,10,'hello world'); finally Free end;

Kopieren des 1. in das 2. Metafile: with TMetafileCanvas.Create(WMF1, 0) do try Draw(0,0,WMF); finally Free end;

Soll das Objekt als Enhanced Metafile gespeichert werden, ist es empfehlenswert, den Konstruktor CreateWithComment statt Create zu verwenden. In diesem Fall übergeben Sie neben dem TMetafile-Objekt und dem Referenz-DC auch ein Copyright und einen Kommentar, die beide in der Datei mitgespeichert werden. var WMF : TMetafile; begin WMF := TMetafile.Create; with TMetafileCanvas.CreateWithComment(WMF, 0,'DoKo', 'Anlagenskizze A17') do try TextOut(10,10,'hello world'); finally Free end; WMF.SaveToFile('c:\test1.emf');

HINWEIS: Delphi speichert Metafiles standardmäßig als Enhanced Metafile, geben Sie aber

beim Speichern die Extension "WMF" an oder setzen Sie die Eigenschaft Enhanced auf False, wird im Aldus-Metafile-Format gespeichert. Vielleicht haben Sie sich schon Gedanken über den Parameter "Referenz-DC" gemacht? Der Sinn ist schnell gefunden, wenn Sie sich die Informationen ansehen, die im Datei-Header eines Metafiles gespeichert werden. Unter anderem finden sich dort Werte für Größe, Auflösung etc. Im Quellcode der Unit Graphics entdecken Sie auch die interne Abfrage der Eigenschaften: RefDC := ReferenceDevice; if ReferenceDevice = 0 then RefDC := GetDC(0); ... FMetafile.MMWidth := GetDeviceCaps(RefDC, HORZSIZE) * 100

15.1 GDI-Programmierung

785

... FMetafile.MMHeight := GetDeviceCaps(RefDC, VERTSIZE) * 100 ...

Dieser Referenz-DC liefert also auch gleich die Abmessungen für das Metafile. Möchten Sie eine maßstabsgerechte WMF-Grafik erstellen, ist die Standard-Einstellung unbrauchbar, Sie müssen mit der Funktion SetMapMode nachhelfen. BEISPIEL: Sie möchten eine Grafik speichern, die genau 10 x 10 cm groß ist und ein 5 x 5 cm großes Recht-

eck enthält. var WMF : TMetafile; begin WMF := TMetafile.Create; wmf.mmheight := 10000; wmf.mmwidth := 10000; with TMetafileCanvas.Create(WMF, 0) do try SetMapMode(handle,MM_HIMETRIC); SetWindowOrgEx(handle,0,10000,nil); rectangle(0,0,5000,5000); finally Free end; WMF.SaveToFile('c:\test1.wmf');

Die äußeren Abmessungen der Grafik setzen Sie mit MMHeight und MMWidth. Bei den recht großen Koordinaten handelt es sich um Angaben in der Maßeinheit 1/100 mm. Mit SetMapMode wechseln wir in den Abbildungsmodus MM_HIMETRIC, also ebenfalls 1/100 mm. SetWindowOrgEx sorgt dafür, dass der Nullpunkt in die linke untere Ecke verschoben wird und wir ein mathematisch korrektes Koordinatensystem erhalten. Ein bereits als Datei vorliegendes Metafile kann mit der Methode LoadFromFile geladen werden. Die Anzeige ist zum Beispiel über die Draw-Methode möglich. Eine zweite Variante bietet sich mit der Image-Komponente. BEISPIEL: Laden und Anzeigen einer WMF-Grafik var WMF : TMetafile; begin WMF := TMetafile.Create; WMF.LoadFromFile('c:\test1.wmf'); Canvas.Draw(0,0,wmf);

Schriftarten (Fonts) Über Schriftarten und die zugehörigen Windows-Funktionen ließe sich ein eigenes Buch schreiben. Aus diesem Grund werden wir uns auf die relevanten Funktionen beschränken, ein aufschlussreiches Beispielprogramm zum Experimentieren finden Sie imKochbuchteil.

786

Kapitel 15

Erweitere Grafikprogrammierung

Dreh- und Angelpunkt ist (wie auch bei den bisherigen Objekten) ein Handle. Dieses erhalten Sie über die Funktion CreateFont. Alle wichtigen Schriftoptionen wie Höhe, Typ, Winkel etc. werden über diese Funktion eingestellt. SYNTAX:

function CreateFont(Height, Width, Escapement, Orientaion, Weight: Integer; Italic, Underline, StrikeOut, CharSet, OutputPrecision, ClipPrecision, Quality,PitchAndFamily: DWORD; FaceName: PChar): HFONT;

Die Funktionsparameter im Einzelnen: Height ... ist die Schrifthöhe in den gerade aktiven Einheiten. Wird für die Schriftgröße kein Wert angegeben, verwendet Windows eine Standardgröße (z.B. 10 Punkte). Das Vorzeichen entscheidet über die Verwendung des Wertes als Zeichenhöhe (-) oder Zellhöhe (+). Die Abbildung zeigt das Ergebnis bei Height gleich -50 bzw. +50:

Width ... bezeichnet die durchschnittliche Zeichenbreite, ist sie null (0), wird die günstigste Schrift durch das System gewählt:

Beachten Sie, dass ein Verkleinern der Schrift den Wert für Width nicht verändert, die Zeichen bleiben also immer gleich breit! Escapement ... ist der Drehwinkel der Textzeile in 1/10 Grad (in Bezug auf die x-Achse).

An dieser Stelle eine kleine Einschränkung: Es lassen sich nur TrueType-Schriftarten drehen, was aber kein Problem darstellen sollte.

787

15.1 GDI-Programmierung

Orientation ... gibt den Drehwinkel jedes einzelnen Zeichens an (in 1/10 Grad in Bezug auf die x-Achse). Dieser Wert wird vom GDI ignoriert. Weight ... ist die Schriftstärke. Werte zwischen 100 (dünn) und 900 (extra breit) in 100er-Schritten sind gültig.

Die wichtigsten Konstanten zur Schriftstärke: Konstante

Wert

FW_THIN

100

FW_EXTRALIGHT

200

FW_LIGHT

300

FW_NORMAL

400

FW_SEMIBOLD

600

FW_BOLD

700

FW_EXTRABOLD

800

Bemerkung

... entspricht Font.Bold = False ... entspricht Font.Bold = True

Italic, Underline, StrikeOut ... bezeichnen kursiven, unterstrichenen bzw. durchgestrichenen Text:

CharSet ... ist der Zeichensatz, verwenden können Sie die folgenden Werte, von denen ANSI und OEM sicher am interessantesten sind: Konstante

Wert

Bemerkung

ANSI_CHARSET

0

Windows-Standardzeichensatz

DEFAULT_CHARSET

1

SYMBOL_CHARSET

2

SHIFTJIS_CHARSET

128

788

Kapitel 15

Konstante

Wert

HANGEUL_CHARSET

129

CHINESEBIG5_CHARSET

136

OEM_CHARSET

255

Erweitere Grafikprogrammierung

Bemerkung

zusätzliche Zeichen, die im DOS-Zeichensatz vorkommen (z.B. für ein Terminalprogramm)

OutputPrecision ... bezieht sich auf die Ausgabegenauigkeit: Konstante

Bemerkung

OUT_DEFAULT_PRECIS OUT_STRING_PRECIS OUT_CHARACTER_PRECIS OUT_STROKE_PRECIS OUT_TT_PRECIS

Sollten TrueType- und Rasterfont vorhanden sein, wird der TrueType-Font gewählt.

OUT_DEVICE_PRECIS OUT_RASTER_PRECIS OUT_TT_ONLY_PRECIS

Es werden nur TrueType-Fonts verwendet.

ClipPrecision ... spezifiziert die Genauigkeit des Clippings, wenn sich Zeichen außerhalb des Clipping-Bereichs befinden: Konstante

CLIP_DEFAULT_PRECIS CLIP_CHARACTER_PRECIS CLIP_STROKE_PRECIS CLIP_MASK CLIP_LH_ANGLES CLIP_TT_ALWAYS CLIP_EMBEDDED

Quality ... entscheidet über die Ausgabequalität. Diese Eigenschaft ist im Wesentlichen nur bei Rasterschriftarten interessant.

789

15.1 GDI-Programmierung

Konstante

Beschreibung

DEFAULT_QUALITY

Das Aussehen des Fonts ist egal.

DRAFT_QUALITY

Das Aussehen des Fonts ist weniger wichtig. Für GDI-Rasterfonts ist die Skalierung eingeschaltet.

PROOF_QUALITY

Die Zeichenqualität der Schrift ist wichtiger als die exakte Einhaltung der Schriftattribute. GDI-Rasterfonts werden nicht skaliert.

BEISPIEL: DEFAULT_QUALITY und PROOF_QUALITY von MS Sans Serif, Height = 50

PitchAndFamily ... gibt Zeichenabstand und Schriftherkunft an: Konstante

Bemerkung

DEFAULT_PITCH

... normaler Zeichenabstand wird beibehalten.

FIXED_PITCH

... fester Zeichenabstand.

VARIABLE_PITCH

... variabler Zeichenabstand.

Mit den Werten der folgenden Tabelle können Sie unter anderem bestimmen, ob Zeichen mit oder ohne Serifen dargestellt werden. Konstante

Bemerkung

FF_DONTCARE

Herkunft egal oder unbekannt.

FF_ROMAN

z.B. Times Roman oder Century Schoolbook, mit Serifen:

FF_SWISS

z.B. Helvetica oder Swiss, ohne Serifen:

FF_MODERN

mit oder ohne Serifen, konstanter Zeichenabstand, z.B. Pica, Elite oder Courier:

790

Kapitel 15

Konstante

Bemerkung

FF_SCRIPT

Handschriften, z.B. Script:

FF_DECORATIVE

z.B. Old English oder Fraktur:

Erweitere Grafikprogrammierung

HINWEIS: Die Werte beider Tabellen können mit dem OR-Operator verknüpft werden. BEISPIEL: Für den (noch) Schriftunkundigen

Facename ... bezeichnet den Namen der Schriftart. Ist der Font nicht vorhanden, wird versucht, eine Schrift zu finden, die oben genannten Parameter aufweist. Texthintergrund Neben den Einstellungen über CreateFont ist auch eine weitere Funktion von Interesse, mit der Sie bestimmen, ob der Text durchsichtig oder mit Hintergrund gezeichnet wird: SetBkMode. Übergabewerte sind der DC und eine der folgenden Konstanten:

SetBkMode(canvas.handle,TRANSPARENT);

791

15.1 GDI-Programmierung

Textausrichtung Wer bereits unter DOS programmiert hat, wird vielleicht die nicht proportionalen Fonts vermissen, mit denen sich Texte bzw. Tabellen problemlos formatieren ließen. Zum rechtsbündigen Ausrichten genügte es, entsprechend viele Leerzeichen in den Ausgabestring einzufügen. Leider funktioniert diese Methode nur noch mit Fonts wie "Courier" etc. Die folgende Abbildung zeigt das Resultat bei gleicher Anzahl von Leerzeichen vor den Ausgabestrings:

Abhilfe schafft die Funktion SetTextAlign, mit der Sie den Einfügepunkt (Koordinaten von TextOut) bestimmen können. TA_TOP

TA_BASELINE

TA_BOTTOM

TA_LEFT

TA_CENTER

TA_RIGHT

Durch die Addition der Konstanten bestimmen Sie sowohl die horizontale als auch die vertikale Position des Einfügepunktes. BEISPIEL: Ausrichtung über die linke untere Ecke SetTextAlign(Canvas.Handle,TA_LEFT + TA_BOTTOM);

Zeichenabstand Eine letzte Variante zur Textformatierung möchten wir Ihnen mit der Funktion SetTextCharacterExtra vorstellen, mit der Sie den Abstand der einzelnen Buchstaben eines Ausgabestrings variieren können.

792

Kapitel 15

Erweitere Grafikprogrammierung

Übergeben Sie neben dem DC die Pixelzahl, um die Sie die Zeichen zueinander verschieben wollen. Textabmessungen Die Texthöhe in Pixeln bestimmen Sie mit Font.Height:

Font.Height

In einigen Fällen ist es allerdings günstiger, die Texthöhe in Punkten anzugeben. Verwenden Sie dazu die Eigenschaft Font.Size. Der Zusammenhang zwischen Height und Size:

Haben Sie beispielsweise einen String s := 'Rotationswinkel 27°';

und möchten Sie diesen an der Position P(50,50) zentriert ausgeben, brauchen Sie Informationen darüber, wie hoch und wie breit der auszugebende Text ist. Zwei Methoden sind in diesem Zusammenhang interessant: Canvas.TextWidth() und Canvas.TextHeight(). Während TextHeight im Allgemeinen der Schrifthöhe in Pixeln entspricht, ist TextWidth von der Anzahl der Buchstaben und der Schriftart abhängig. Die Ausgabeposition berechnet sich zu: s := 'Rotationswinkel 27°'; Canvas.TextOut(x - Canvas.TextWidth(s) div 2, y, s);

Wem das zu umständlich ist und wer bereits Erfahrung mit der GDI-Programmierung hat, kann mit der Funktion SetTextAlign das gleiche Resultat erreichen.

Textausgabe mit DrawText Bei dieser GDI-Funktion handelt es sich wohl um die leistungsfähigste Variante für Textausgaben. Neben der Beschränkung auf ein Ausgaberechteck können Sie auch die Textausrichtung (links, zentriert, rechts, oben, unten) beeinflussen. DrawText berücksichtigt weiterhin Zeilenumbrüche und Tabulatoren. Optional können auch Zeilenumbrüche erzwungen werden. SYNTAX:

function DrawText(hDC: HDC; lpString: PChar; nCount: Integer; var lpRect: TRect; uFormat: UINT): Integer;

BEISPIEL: Mehrzeilige Textausgabe mit DrawText var r : TRect; p : PChar;

793

15.1 GDI-Programmierung

Initialisieren des Ausgaberechtecks: procedure TForm1.FormCreate(Sender: TObject); begin r := Bounds(0,0,memo1.clientwidth,memo1.clientheight); end;

Löschen des Hintergrunds und Textausgabe: p := PChar(memo1.text); paintbox1.canvas.FillRect(r); DrawText(paintbox1.canvas.handle, p, length(p), r, DT_LEFT + DT_EXPANDTABS + DT_WORDBREAK); ...

Die wichtigsten DrawText-Konstanten: Konstante

Beschreibung

DT_BOTTOM

... Text wird am unteren Rand ausgerichtet (nur mit DT_SINGLELINE).

DT_CALCRECT

... berechnet lediglich die Höhe des Ausgabetextes, keine Textausgabe!

DT_CENTER

... Text wird horizontal zentriert.

DT_EXPANDTABS

... Tabulatoren werden mit acht Leerzeichen dargestellt.

DT_LEFT

... Text wird linksbündig ausgerichtet.

DT_NOPREFIX

... unterdrückt die Interpretation von "&" als Formatierung (Unterstreichen eines Zeichens).

DT_RIGHT

... Text wird rechtsbündig ausgerichtet.

DT_SINGLELINE

... einzeilige Ausgabe, Zeilenumbrüche werden ignoriert.

DT_TABSTOP

... Vorgabe der Anzahl von Leerzeichen pro Tab. Der Wert wird in Bits 15-8 übergeben. Beispiel: Festlegen der Tabs var tabwidth : word; Tabwidth := shl 8; DrawText(paintbox1.canvas.handle, p,length(p),r,DT_TABSTOP+tabwidth);

DT_TOP

... Text wird am oberen Rand ausgerichtet (nur mit DT_SINGLELINE).

DT_VCENTER

... Text wird vertikal zentriert (nur mit DT_SINGLELINE).

DT_WORDBREAK

... automatischer Zeilenumbruch, wenn der Text nicht in die Zeile passt.

Textausgabe mit TextRect TextRect begrenzt, im Gegensatz zur TextOut-Funktion, die Text-Ausgabefläche auf ein Rechteck, dessen Maße Sie in einer Variablen vom Typ TRect übergeben.

794 SYNTAX:

Kapitel 15

Erweitere Grafikprogrammierung

TextRect(Rect: TRect; X, Y: Integer; const Text: string);

Die Abbildung zeigt den Einfluss der einzelnen Parameter:

Top

Y

Left X

Bottom

Right var rec : TRect; begin rec.Left := 30; rec.Top := 30; rec.Right := 320; rec.Bottom := 150; canvas.font.color := clred; canvas.TextRect(Rec,0,30,'Hallo User'); end;

Bézierkurven Für einfache Zeichnungen dürften die bisherigen Zeichenfunktionen ausreichen, kompliziertere Gebilde bekommen Sie mit der Bézierfunktion in den Griff. Wie bei einer "normalen" Linie übergeben Sie Anfangs- und Endpunkt, zusätzlich jedoch noch zwei Stützpunkte, mit denen die Linie wie ein Gummiband "gezogen" werden kann. SYNTAX:

function PolyBezier(DC: HDC; const Points; Count: DWORD): BOOL; stdcall;

x2,y2 x4,y4 x1,y1

x3,y3

var punkte: array [0..3] of TPoint; punkte[0].X := 4;

795

15.1 GDI-Programmierung

punkte[0].Y := 4; punkte[1].X := 100; punkte[1].Y := 100; punkte[2].X := 150; punkte[2].Y := 120; punkte[3].X := 75; punkte[3].Y := 30; PolyBezier(image1.canvas.handle, punkte[0], 4);

Clipping (Regionen) In Ihren Delphi-Programmen sind Sie es gewohnt, dass Zeichenoperationen, die über den Clientbereich des Formulars bzw. der Komponente hinausgehen, einfach abgeschnitten werden. Damit haben Sie auch schon die einfachste Form von Clipping kennen gelernt. Für bestimmte visuelle Effekte ist es häufig wünschenswert, dass diese Ausgabebereiche nicht nur rechteckig, sondern zum Beispiel auch einmal rund sind. Die Abbildung zeigt das Ergebnis von Grafikausgaben in einer Region:

Das Erzeugen einer Region ist relativ simpel, mit CreateEllipticRgn bzw. CreateRectRgn definieren Sie die Funktion, das gewonnene Handle für die Region können Sie der Funktion SelectObject übergeben. var RHandle : THandle; begin RHandle := CreateEllipticRgn(10,20,100,110); SelectObject(canvas.handle,RHandle);

Sie werden sich vielleicht wundern, dass wir im Beispiel nicht den Rückgabewert von SelectObject gespeichert haben, wird dieser doch sonst immer zum Wiederherstellen der alten Einstellungen verwendet. Bei Regionen ist das etwas anders, der Rückgabewert ist nicht das Handle auf das bisher aktive Objekt, sondern lediglich eine Statusvariable: Konstante

Bemerkung

SIMPLEREGION

Region besteht aus einem Rechteck.

COMPLEXREGION

Region besteht aus mehr als einem Rechteck.

NULLREGION

Region ist leer.

796

Kapitel 15

Erweitere Grafikprogrammierung

Aus diesem Grund müssen wir uns für das Zurücksetzen der Region schon etwas anderes einfallen lassen. Am einfachsten ist das Erzeugen einer neuen Region, die den gesamten Clientbereich erfasst. var RH; RHnew : THandle; begin RH := CreateEllipticRgn(10,20,100,110); SelectObject(DC,RH); RHnew := CreateRectRgnIndirect(Clientrect); SelectObject(DC,RHnew); // Zurücksetzen der Region DeleteObject(RH); ...

Regionen können Sie aus Rechtecken, Ellipsen oder Polygonen zusammensetzen. Zusammensetzen bedeutet in diesem Fall nicht einfach nur die ODER-Verknüpfung, es sind auch weitere Variationen möglich. Verwenden Sie die Funktion CombineRgn, der Sie neben den zu kombinierenden Regionen auch den Modus übergeben. Der "Rückgabewert" ist eine neue Region, die Sie einem Ausgabegerätekontext mit SelectObject zuweisen können. R1Handle := CreateEllipticRgn(10,20,100,110); R2Handle := CreateEllipticRgn(100,95,200,195); CombineRgn(R3Handle,R1Handle,R2Handle,RGN_OR); SelectObject(canvas.handle,R3Handle);

// Oder Kombination

Die folgende Abbildung zeigt die verschiedenen Möglichkeiten bzw. die Konstanten für den Kombinationsmodus:

CombineRgn

RGN_AND

RGN_COPY

RGN_DIFF

RGN_OR

RGN_XOR

Neben dem Zeichnen, Invertieren (InvertRgn) und Umrahmen (FrameRgn) bieten sich Regionen noch für ein weiteres Aufgabengebiet an.

15.1 GDI-Programmierung

797

Nehmen wir an, Sie wollen ein Programm schreiben, bei dem sich auf einer Grafik so genannte "maussensitive" Flächen befinden. Diese Bereiche sollen nicht sichtbar sein und beliebige Formen aufweisen (Polygone, Kreise etc.). Über Delphi können Sie lediglich die aktuelle Mausposition abfragen (MouseDown, MouseMove). Ob sich die Maus in einem der Bereiche befindet, wissen Sie nicht. Mit Hilfe einer Region und der Funktion PtInRegion ist das kein Problem. procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); var RH : Thandle; begin RH := CreateEllipticRgn(10,20,100,110); if PtInRegion(rh,x,y) then beep; end;

Natürlich könnten Sie den Test auch beim Verschieben des Mauscursors ausführen.

Clipping (Paths) Ein Path erfüllt ähnliche Aufgaben wie eine Region, grafische Ausgaben können auf einen bestimmten Bereich eingeschränkt werden. Die Übereinstimmungen gehen sogar so weit, dass eine Region aus einem Path erzeugt werden kann. Paths können das Ergebnis beliebiger Grafikausgaben (inklusive Bézierkurven, Polygonen, Texten) sein. Die Definition ist relativ einfach: Sie rufen BeginPath auf, zeichnen mit diversen GDI-Funktionen den Path und beenden die Definition mit EndPath. Grafikoperationen zwischen BeginPath und EndPath sind nicht auf dem Bildschirm bzw. Ausgabegerät sichtbar! dc := canvas.handle; TextOut(dc, 10, 10, 'Test', 4); BeginPath(dc); TextOut(dc, 180, 180, 'Test', 4); EndPath(dc); SelectClipPath(dc, RGN_COPY);

Ist der Path definiert, kann er z.B. zum Clipping benutzt werden (SelectClipPath). Alle folgenden Zeichenaktionen sind nur innerhalb des Path sichtbar. BEISPIEL: Ein Path besteht aus dem Text "Test", und das Fenster wird mit horizontalen und vertikalen Linien

bzw. einer Bitmap gefüllt.

798

Kapitel 15

Erweitere Grafikprogrammierung

An dieser Stelle wollen wir kurz auf eine Besonderheit eingehen, die auf den ersten Blick wohl nicht ganz einsichtig ist. Verwenden Sie eine Textausgabe zur Definition von Paths, erhalten Sie im Normalfall nur den Texthintergrund (siehe Abbildung). Abhilfe schaffen Sie mit der Funktion SetBkMode, mit der Sie in den Transparent-Modus schalten:

15.2 Erweiterte Bitmap-Manipulation Möchten Sie Grafiken nicht nur anzeigen, sondern auch verändern, bietet sich auf den ersten Blick die Pixels-Eigenschaft an. Dieses Array ermöglicht den Zugriff auf die einzelnen Bildpunkte, es ist demnach auch kein Problem, zum Beispiel eine Farbe durch eine andere auszutauschen. Doch wer bereits erste Schritte auf diesem Gebiet unternommen hat, wird schnell enttäuscht. Das Auslesen und Setzen der einzelnen Punkte verbraucht so viel Zeit, dass es wohl kaum einem Programmnutzer zumutbar ist, es sei denn, man möchte ihn ärgern. BEISPIEL: Drehen einer Bitmap (in Image1) um 90° procedure TForm1.Button1Click(Sender: TObject); var x,y : integer; begin image2.height := image1.Canvas.ClipRect.Right; image2.width := image1.Canvas.ClipRect.Bottom; for x := Image1.Canvas.ClipRect.Left to Image1.Canvas.ClipRect.Right do for y := Image1.Canvas.ClipRect.Top to Image1.Canvas.ClipRect.Bottom do begin Image2.Canvas.Pixels[y,Image1.Canvas.ClipRect.Right-x-1] := Image1.Canvas.Pixels[x,y]; application.ProcessMessages; end; end;

Als Alternative bietet sich dem begeisterten GDI-Programmierer die Arbeit mit den Device Independent Bitmaps (DIB) an. Doch die Verwendung der entsprechenden Funktionen erfordert nicht nur eine genaue Kenntnis des GDI, sondern auch unnötigen Schreibaufwand, muss doch die DIB wieder in das Bitmap-Format zurückgewandelt werden. Vom zusätzlichen Speicherverbrauch wollen wir an dieser Stelle gar nicht sprechen. Die praktikable und auch empfehlenswerte Lösung heißt ScanLine. Dabei handelt es sich um eine Eigenschaft des Bitmap-Objektes.

15.2 Erweiterte Bitmap-Manipulation

SYNTAX:

799

ScanLine[Row: Integer]: Pointer;

HINWEIS: Bevor Sie sich mit den folgenden Abschnitten beschäftigen, sollten Sie sich mit der

Programmierung von Pointern vertraut gemacht haben (siehe Kapitel 14).

15.2.1 Grundlagen Auch wenn es auf den ersten Blick so scheinen mag, ScanLine ist kein direkter Ersatz für die Pixels-Eigenschaft. Der Grund ist schnell aus der Syntax zu entnehmen: Sie erhalten lediglich einen Pointer auf die Daten einer gewählten Bitmap-Zeile. Wie diese Daten aufgebaut sind, wie viele Spalten und Zeilen es gibt, wird nicht von der Funktion berücksichtigt. Ein Fehler bei der Arbeit mit dieser Funktion führt meist zu einem Programmabsturz.

Worauf zeigt der Pointer? Ganz allgemein kann gesagt werden: auf das erste Byte der gewählten Zeile. Wie diese Zeile in sich aufgebaut ist und aus wie vielen Bytes sie besteht, wird durch das Bitmap-Format bestimmt. Delphi unterstützt folgende Bitmap-Formate: Format

Beschreibung

1 Bit/Pixel

Schwarz-/Weiß-Bilder, bei denen jedes Pixel durch ein Bit dargestellt wird.

4 Bit/Pixel

Bilder mit 16 Farben, ein Byte stellt somit die Informationen für zwei benachbarte Pixel zur Verfügung.

8 Bit/Pixel

Bilder dieses Typs können 256 Farben darstellen. Damit entspricht ein Byte auch einem Pixel. Doch freuen Sie sich nicht zu früh, es handelt sich nicht um den direkten Farbwert, sondern nur um den Index in einer getrennt gespeicherten Farbpalette.

15 oder

Bei diesem Format werden mit jeweils 5 bzw. 6 Bit für die drei Grundfarben die Farbwerte dargestellt bzw. abgespeichert. Das interne Format:

16 Bit/Pixel

pf15bit: 0rrrrrgggggbbbbbpf16bit: rrrrrggggggbbbbb

Dass die Arbeit mit derart verschachtelten Daten nicht unbedingt einfach ist, dürfte schnell ersichtlich sein. 24 Bit/Pixel

Das Wunschformat jedes Grafikprogrammierers: Jeder Punkt wird mit drei Bytes (RGB) zu je 8 Bit dargestellt. Der Zugriff auf derartige Bitmaps ist problemlos realisierbar.

32 Bit/Pixel

Noch etwas schneller lassen sich 32-Bit-Bilder bearbeiten. Dies wird durch die bessere Speicherausrichtung (4 Byte) erreicht. Das vierte Byte hat zwar keine Bedeutung, kann aber für Transparenz-Informationen genutzt werden. Beachten Sie jedoch, dass derartige Bilder auch sehr groß werden können.

800

Kapitel 15

Erweitere Grafikprogrammierung

Wie bestimme ich die Anzahl der Spalten? Eigentlich müsste die Frage anders gestellt werden, da meist nicht die Anzahl der Bildpunkte, sondern die Anzahl der nötigen Bytes von Bedeutung ist. Die Pixelanzahl können Sie mit Bitmap.Width bestimmen, die Byteanzahl berechnet sich aus den jeweiligen Bildformaten, wie sie im vorhergehenden Abschnitt vorgestellt wurden. BEISPIEL: 32-Bit-Bild, Bitmap.Width = 300

4 * Bitmap.Width = 1200 Bytes/Zeile Doch Vorsicht: Ein 24-Bit-Bild mit einer Breite von 299 Pixeln hat nicht etwa 3 * Bitmap.Width = 897 Bytes/Zeile sondern ((3 * Bitmap.Width + 3) DIV 4 ) * 4 = 900 Bytes/Zeile HINWEIS: Die Bitmaps werden in jeder Zeile auf Vielfache von 4 Bytes aufgefüllt!

Wie bestimme ich die Anzahl der Zeilen? Diese Antwort ist schnell gegeben, über die Eigenschaft Bitmap.Height steht Ihnen direkt der Wert zur Verfügung. Aber auch hier lauert ein Fallstrick: Möchten Sie mit einem Byte-Pointer die einzelnen Pixel der Grafik durchlaufen, müssen Sie berücksichtigen, dass die Pixel in umgekehrter Reihenfolge im Speicher liegen, d.h., Sie müssen bei ScanLine[Bitmap.Height-1] beginnen. BEISPIEL: Alle Pixel der Grafik sollen auf Schwarz gesetzt werden (32-Bit-Bitmap). var x,y : Integer; p : PByte; begin Image1.Picture.Bitmap.PixelFormat := pf32bit; p := Image1.Picture.Bitmap.ScanLine[Image1.Picture.Bitmap.Height-1]; for y := 1 to (Image1.Picture.Bitmap.Height) do begin for x := 1 to (Image1.Picture.Bitmap.Width) * 4 do begin p^ :=255; Inc(p) end end end;

BEISPIEL: Nur die Farbe Blau soll zurückgesetzt werden: var x,y : Integer; p : PByte; begin Image1.Picture.Bitmap.PixelFormat := pf32bit; p := Image1.Picture.Bitmap.ScanLine[Image1.Picture.Bitmap.Height-1]; for y := 1 to (Image1.Picture.Bitmap.Height) do begin

15.2 Erweiterte Bitmap-Manipulation

801

for x := 1 to (Image1.Picture.Bitmap.Width) do begin p^ := 0; Inc(p,4) end end end;

Es geht auch so: var x,y : Integer; p : PRGBQuad; begin Image1.Picture.Bitmap.PixelFormat := pf32bit; p := Image1.Picture.Bitmap.ScanLine[Image1.Picture.Bitmap.Height-1]; for y := 1 to (Image1.Picture.Bitmap.Height) do begin for x := 1 to (Image1.Picture.Bitmap.Width) do begin p^.rgbBlue := 0; Inc(p) end end end;

Damit dürften Sie schon einen ersten Eindruck gewonnen haben, die folgenden Beispiele zeigen an verschiedenen Aufgabenstellungen die Möglichkeiten, die Ihnen mit ScanLine offen stehen. HINWEIS: Ein Testprogramm RGB für die folgenden Funktionen finden Sie auf der Buch-CD.

15.2.2 Spiegeln von Bitmaps Zu den Standardaufgaben jedes Grafikprogramms gehört das Spiegeln von Bitmaps um die vertikale oder die horizontale Achse. Beides kann mit relativ wenig Aufwand bewältigt werden. Um den Nutzen zu erhöhen, verpacken wir beide Routinen gleich in Prozeduren, damit haben Sie die Möglichkeit, diese in Ihre Programme zu übernehmen. Die beiden folgenden Routinen erwarten als Übergabewert eine 24-Bit-Bitmap: TRGBArray pRGBArray

= ARRAY[0..0] OF TRGBTriple; = ^TRGBArray;

procedure SpiegelnHorizontal(Bitmap:TBitmap); var i,j,w : Integer; RowIn,RowOut: pRGBArray; begin w := bitmap.width*sizeof(TRGBTriple); Getmem(rowin,w); for j := 0 to Bitmap.Height-1 do begin move(Bitmap.Scanline[j]^,rowin^,w); rowout := Bitmap.Scanline[j];

802

Kapitel 15

Erweitere Grafikprogrammierung

Wir tauschen einfach die Bytes innnerhalb einer Zeile, nachdem wir uns eine komplette Zeile im Array RowIn gesichert haben. for i := 0 to Bitmap.Width-1 do rowout[i] := rowin[Bitmap.Width-1-i]; end; bitmap.Assign(bitmap); Freemem(rowin); end; procedure SpiegelnVertikal(Bitmap : TBitmap); var j,w : Integer; help : TBitmap; begin help := TBitmap.Create; help.Width := Bitmap.Width; help.Height := Bitmap.Height; help.PixelFormat := Bitmap.PixelFormat; w := Bitmap.Width*sizeof(TRGBTriple); for j := 0 to Bitmap.Height-1 do

Mit Hilfe der Funktion Move können wir eine komplette Zeile kopieren: move(Bitmap.Scanline[j]^,Help.Scanline[Bitmap.Height - 1 - j]^,w); Bitmap.Assign(help); help.free end;

BEISPIEL: Der Aufruf ist selten simpel: image1.Picture.bitmap.PixelFormat := pf24bit; SpiegelnVertikal(image1.picture.bitmap)

15.2 Erweiterte Bitmap-Manipulation

803

15.2.3 Farbmanipulation Im Folgenden wollen wir uns damit beschäftigen, das Aussehen der Bilder, d.h. die einzelnen Farbwerte zu verändern.

Invertieren Eine der einfachsten Operationen ist das Invertieren der Bitmap, die einzelnen RGB-Werte brauchen nur negiert zu werden: procedure Invertieren(Bitmap:TBitmap); var i,j : Integer; Row : ^TRGBTriple; begin for j := 0 to Bitmap.Height-1 do begin row := Bitmap.Scanline[j]; for i := 0 to Bitmap.Width-1 do begin row^.rgbtred := not row^.rgbtred; row^.rgbtBlue := not row^.rgbtblue; row^.rgbtgreen := not row^.rgbtgreen; inc(row) end end; bitmap.Assign(bitmap) end;

Bei einem 32-Bit-RGB-Bild geht es sogar noch einfacher, wir invertieren gleich alle vier Bytes auf einen Schlag: procedure Invertieren32Bit(Bitmap:TBitmap); var i,j : Integer; P : PDWord; begin

Ermitteln des Pointers auf das erste Byte bzw. DWord: p := Bitmap.Scanline[Bitmap.Height-1]; for j := 1 to Bitmap.Height* Bitmap.Width do begin p^ := not p^; inc(p) end; bitmap.Assign(bitmap) end;

804

Kapitel 15

Erweitere Grafikprogrammierung

Graustufen Beim Umwandeln einer Farbgrafik in ein Graustufenbild werden die einzelnen Farben entsprechend ihrer Leuchtkraft bewertet und daraus ein Graustufenwert (8 Bit) berechnet. Dieser Wert wird nachfolgend allen drei Farbkanälen zugewiesen: procedure Graustufen(Bitmap:TBitmap); var i,j : Integer; Row : ^TRGBTriple; grau : byte; begin for j := 0 to Bitmap.Height-1 do begin row := Bitmap.Scanline[j]; for i := 0 to Bitmap.Width-1 do begin grau := (row^.rgbtred * 77 + row^.rgbtgreen * 151 + row^.rgbtblue * 28) div 256; row^.rgbtred := grau; row^.rgbtBlue := grau; row^.rgbtgreen := grau; inc(row) end end; bitmap.Assign(bitmap) end;

Heller/Dunkler Um ein Bild aufzuhellen oder dunkler zu machen, genügt es, dass zu jedem Wert eine Konstante addiert wird. Um Werteüberläufe zu verhindern, müssten wir entweder bei jedem Wert abfragen, ob das Berechnungsergebnis den Wertebereich (255) überschreitet, oder wir legen gleich ein Array an, in dem für jeden der möglichen 256 Werte der neue Wert gespeichert ist. Insbesondere bei großen

15.2 Erweiterte Bitmap-Manipulation

805

Bildern können Sie so wertvolle Sekunden gewinnen, da nur noch der Wert aus dem Array ausgelesen werden muss: procedure Helligkeit(Bitmap, // Ziel-Bitmap Original : TBitmap; // Original Value : integer); // Wert zw -240 ... + 240 var x,y : Integer; Ziel : ^TRGBTriple; Quelle : ^TRGBTriple; n : byte; ar : array[0..255] of byte; begin n := abs(value); if value > 0 then for x := 0 to 255 do if integer(x + n) > 255 then ar[x]:=255 else ar[x] := x + n else for x := 0 to 255 do if integer(x - n) < 0 then ar[x]:=0 else ar[x] := x - n; for y := 0 to Bitmap.Height-1 do begin Ziel := Bitmap.Scanline[y]; Quelle := Original.Scanline[y]; for x := 0 to (Bitmap.Width-1) do begin Ziel^.rgbtBlue := ar[Quelle^.rgbtBlue]; Ziel^.rgbtred := ar[Quelle^.rgbtred]; Ziel^.rgbtGreen := ar[Quelle^.rgbtGreen]; inc(Ziel); inc(quelle) end end end;

Übergeben Sie der Funktion einen positiven oder negativen Wert, um das Bild aufzuhellen oder abzudunkeln.

806

Kapitel 15

Erweitere Grafikprogrammierung

Kontrast Um den Kontrast eines Bildes zu erhöhen, normieren wir zunächst die Farbwerte, indem wir diese in einen Integerwert umwandeln und 128 abziehen. Den resultierenden Wert multiplizieren wir mit einem konstanten Faktor, nachfolgend wird die Normierung durch Addition von 128 wieder aufgehoben. Da wir die Gleitkomma-Operationen nicht für jeden Pixel ausführen möchten (Performance), verwenden wir wieder ein Array, in dem wir die Farbwerte vorberechnen. procedure Kontrast(Bitmap:TBitmap; value: byte); var x,y : Integer; Ziel, Quelle : ^TRGBTriple; n : byte; ar : array[0..255] of byte; k : integer; fak : single; begin fak := 1 + value /100; for x := 0 to 255 do begin k := Round((integer(x) - 128)*fak) + 128; if k > 255 then ar[x] := 255 else if k < 0 then ar[x] := 0 else ar[x] := k end; n := value; for y := 0 to Bitmap.Height-1 do begin Ziel := Bitmap.Scanline[y]; Quelle := Bitmap.Scanline[y]; for x := 0 to (Bitmap.Width-1) do begin Ziel^.rgbtred := ar[Quelle^.rgbtred]; Ziel^.rgbtblue := ar[Quelle^.rgbtblue]; Ziel^.rgbtgreen := ar[Quelle^.rgbtgreen]; inc(ziel); inc(quelle) end end end;

HINWEIS: Bei einem 32-Bit-Bild könnten Sie auch direkt einen Byte-Pointer verwenden.

807

15.2 Erweiterte Bitmap-Manipulation

15.2.4 Drehen von Bitmaps Geht es um das Drehen von Bitmaps, bieten sich zwei Varianten an, von denen die erste jedoch den Windows NT-Programmierern vorbehalten bleibt: ■ Verwendung der GDI-Funktion PlgBlt ■ Arbeiten mit ScanLine

Der leichte Weg (Windows NT/2000/XP) In die 32-Bit-API haben die Microsoft-Programmierer mit PlgBlt eine fertige Funktion integriert, die auch mit ihrer Performance durchaus überzeugen kann. Ihre Aufgabe als Programmierer besteht lediglich darin, die Positionen der drei Punkte P(1), P(2), P(3) zu berechnen. Neben einfachen Drehungen lassen sich auf diese Weise auch Verzerrungen realisieren. Sie berechnen einfach ein Trapez, in das die Grafik hineinskaliert werden soll. Die Abbildung zeigt das Grundprinzip: P(1)

P(2)

P(3)

Beachten Sie die Reihenfolge der Werte bei der Übergabe: ■ linke obere Ecke P(1) ■ rechte obere Ecke P(2) ■ linke untere Ecke P(3) Einige Variablen: var punkte : array[0..2] of TPoint; winkel : Double;

Die eigentliche Berechnung: procedure berechnePunkte; var si, co : double; begin

// der Drehwinkel

808

Kapitel 15

Erweitere Grafikprogrammierung

si := Sin(winkel); co := Cos(winkel);

Linke obere Ecke: punkte[0].x := ClientWidth div 2; punkte[0].y := ClientHeight div 2;

Rechte obere Ecke: punkte[1].x := Round(ClientWidth div 2 + image1.clientWidth * co); punkte[1].y := Round(ClientHeight div 2 + image1.clientWidth * si);

Linke untere Ecke: punkte[2].x := Round(ClientWidth div 2 - image1.clientHeight * si); punkte[2].y := Round(ClientHeight div 2 + image1.clientHeight * co) end;

Der Aufruf: winkel := - PI / 10; berechnePunkte; PlgBlt(canvas.handle, punkte[0], image1.picture.bitmap.canvas.handle, 0, 0, image1.ClientWidth, image1.ClientHeight,0,0,0);

Der schwere Weg (ScanLine) Alle, die nicht zu den glücklichen Windows NT/2000/XP-Besitzern zählen, müssen sich schon selbst um das Drehen der einzelnen Pixel kümmern. Die Autoren werden an dieser Stelle das Brett an der dünnsten Stelle bohren und lediglich eine Funktion zum Drehen um 90° vorstellen. HINWEIS: Um unnötige Berechnungen zu vermeiden, wandeln wir die Bitmap in eine 32-Bit-

Bitmap um. type TMyhelp = array[0..0] of TRGBQuad; procedure Drehen90Grad(Bitmap:TBitmap); var P : PRGBQuad; x,y,b,h : Integer; RowOut : ^TMyHelp; help : TBitmap; BEGIN Bitmap.PixelFormat := pf32bit; help := TBitmap.Create; help.PixelFormat := pf32bit;

Maße der Ziel-Bitmap bestimmen: b := bitmap.Height; h := bitmap.Width;

15.3 3-D-Vektorgrafik

809

help.Width := b; help.height := h;

Zeile für Zeile werden nun die Pixel "umgeschaufelt": for y := 0 to (h-1) do begin rowOut := help.ScanLine[y]; P := Bitmap.scanline[bitmap.height-1]; inc(p,y); for x := 0 to (b-1) do begin rowout[x] := p^ inc(p,h) end end;

Zum Schluss kopieren wir die Hilfs-Bitmap in die eigentliche Bitmap: bitmap.Assign(help) end;

Damit dürften Sie einen ersten Eindruck gewonnen haben, welche Möglichkeiten die ScanLineEigenschaft bietet. Das Internet hält auf diesem Gebiet genügend Stoff bereit, um ein komplettes Grafikprogramm zu schreiben, wir müssen uns an dieser Stelle leider etwas kürzer fassen.

15.3 3-D-Vektorgrafik Prinzipiell gelten für die 3-D-Vektorgrafik die Ausführungen zur 2-D-Vektorgrafik im Kapitel 7. Um aber bei der Menge der Koordinaten (jede Linie wird nicht durch vier, sondern durch sechs Werte repräsentiert!) noch halbwegs den Überblick zu behalten, müssen wir das 2-D-Konzept etwas abwandeln.

810

Kapitel 15

Erweitere Grafikprogrammierung

P1(x1,y1,z1) Y

Z y1

P2(x2,y2,z2) y2

z2

x1 x2

z1 X

Zunächst einige (3-D-) Ergänzungen zum Kapitel 7. Wie leicht zu erkennen ist, reicht die bisherige Darstellung eines Punktes mit zwei Koordinaten nicht aus. Zusätzlich zur x- und y-Koordinate müssen wir die z-Achse für die Tiefenwirkung verwenden. Wir wollen im Folgenden davon ausgehen, dass dieser Körper nur aus Linien besteht (so genanntes Drahtmodell), die Erweiterung der Algorithmen auf n-Ecke bzw. Kreise ist jederzeit möglich, würde jedoch den Rahmen dieses Kapitels sprengen. Ein Kreis muss durch seinen Mittelpunkt, den Radius und mindestens einen Raumpunkt, der auf dem Umfang liegt, definiert sein. Übrigens lässt sich auch ein Kreis als Vieleck (Polygon) auffassen, die Rechenzeit verkürzt sich dadurch erheblich! Ausgangspunkt für die weitere Arbeit ist die Suche nach einer sinnvollen Möglichkeit für das Speichern eines Körpers. Da sich in Delphi leider keine dynamischen Arrays anlegen lassen, müssen wir entweder ein festes Array vorgeben oder mit einer Pointerliste arbeiten. Grundlage des Körpers sind Linien, die durch Raumpunkte dargestellt werden. Jeder Raumpunkt besteht wiederum aus drei Koordinaten. Die Umsetzung in Object Pascal könnte wie folgt aussehen: type punktType = record x,y,z : Double; end; linienType = record a,b : PunktType; end; var figur1 : array [0 .. 24] of linienType;

Neben den Koordinateninformationen lassen sich auch Linientypen bzw. Farbwerte abspeichern, wir haben jedoch bewusst darauf verzichtet, um den Aufwand nicht unnötig zu erhöhen. Um die Körperkoordinaten ohne viel Aufwand eingeben zu können, wurde die Prozedur New_Line

15.3 3-D-Vektorgrafik

811

geschrieben. Vom Programm werden nur noch die Koordinatenwerte an die Prozedur übergeben, diese trägt die neuen Werte ein: procedure new_line(var k:array of linientype;x1,y1,z1,x2,y2,z2:Double); begin k[i].a.x := x1; k[i].a.y := y1; k[i].a.z := z1; k[i].b.x := x2; k[i].b.y := y2; k[i].b.z := z2; Inc(i) end;

Eine andere Möglichkeit wäre das Laden der Koordinaten aus einer Datei. Vor der weiteren Betrachtung bleiben zwei Fragen offen: ■ Welche Darstellungsform auf dem Bildschirm soll gewählt werden? ■ Wie sollen die Drehwinkel übergeben werden (relativ oder absolut)? Beginnen wir mit Punkt zwei. Um den Aufwand möglichst niedrig zu halten, werden wir die Drehwinkel als relative Koordinaten zum letzten Drehpunkt interpretieren1. Dieses Vorgehen bietet mehrere Vorteile: ■ Wir können die gleichen Algorithmen für die Rotation benutzen wie für die 2-D-Grafik. ■ Die Algorithmen sind nicht so komplex wie Algorithmen für die absolute Berechnung. ■ Wir benötigen weniger Arbeitsspeicher. Die letzte Aussage hört sich im Windows-Zeitalter etwas merkwürdig an, aber: Um auch das Letzte an Geschwindigkeit aus unserem Delphi-Programm herauszukitzeln, müssen wir statt der laufenden Berechnung von Cos() und Sin() auf vorbereitete Tabellen zugreifen. Da trigonometrische Funktionen nicht gerade schnell sind, lässt sich auf diese Art und Weise einiges an Rechenzeit einsparen. Kommen wir zum Thema Speicherplatz zurück: Für die absolute Positionierung auf 1/10° genau brauchen wir allein für die Sinus-Tabelle 360 * 10 Werte, und das im Double-Format (fast 30 KByte!). Für die inkrementelle Methode sieht das ganz anders aus. Wir können einfach ein paar sinnvolle Werte speichern, die häufig gebraucht werden, z.B. ±1/10°, ±1°, ±10°, ±90° etc. Sie sehen, der Aufwand ist bedeutend geringer! Wo viel Licht ist, da ist natürlich auch Schatten. Die inkrementelle Methode hat auch ihre Nachteile. Ein Problem ist beispielsweise, dass sich Berechnungsfehler immer weiter summieren können. Nach genügend vielen Rotationen/Skalierungen wird es Ihnen kaum gelingen, den Ursprungskörper wiederherzustellen. Dem kann jedoch mit dem Double-Format entgegengewirkt werden. Demgegenüber kommt die absolute Methode eventuell sogar mit Integer-Arithmetik aus. Wie gesagt, die Wahl der Methode sollten Sie von Ihrer jeweiligen Anwendung abhängig machen. Bleibt noch das Problem der Darstellung auf dem Bildschirm.

1

Im Programm besteht die Möglichkeit, den Körper um jeweils ± 1° zu drehen.

812

Kapitel 15

Erweitere Grafikprogrammierung

15.3.1 Darstellungsmöglichkeiten Für die Bildschirmdarstellung der 3-D-Koordinaten werden wir zwei verschiedene Verfahren verwenden:

Parallelprojektion Bei der Parallelprojektion, in diesem Fall der so genannten Kavaliersperspektive, bleibt die x-yEbene erhalten, z-Koordinaten werden in bestimmten Teilungsverhältnissen in der x-y-Ebene abgebildet. Y

X

Z

Diese Darstellungsform verzerrt zwar den Körper, da aber die Strecken-Teilungsverhältnisse erhalten bleiben, wird die Parallelperspektive in der Technik bevorzugt. Für unser Programm bedeutet das, dass x- und y-Koordinaten unverändert in die Betrachtung eingehen. Um die Darstellung nicht allzu sehr zu verzerren, werden wir den Neigungswinkel auf 18° reduzieren (Kavaliersperspektive 45°). Die z-Achse ist um 18° geneigt, zur x-Koordinate kommt also z/2 hinzu, zur yKoordinate z/10.

Zentralprojektion (Fluchtpunktperspektive) Die Zentralprojektion geht von einem Betrachterstandpunkt aus. Die Fluchtlinien Körperkante/ Betrachter werden in der Betrachtungsebene abgebildet:

Betrachtungsebene (Bildschirm)

Betrachter

813

15.3 3-D-Vektorgrafik

Durch diese Art der Darstellung entsteht ein Fluchtpunkt, der vom Betrachterstandpunkt abhängig ist.

Fluchtpunkt

Sie können diesen Effekt im Beispielprogramm nachvollziehen, indem Sie den Körper nach rechts/links verschieben und vergrößern/verkleinern. Damit sind wir auch schon bei der Umsetzung angelangt. Für die Zentralprojektion benötigen wir zusätzlich den Abstand des Betrachters. Nach dem Strahlensatz gilt:

Y-2D

Abstand

Y2 D =

Y-3D

z-Koordinate

Y3D ⋅ Abs tand Abs tand + Z

Entsprechendes ist natürlich auch für die x-Koordinate zutreffend. Unser zugehöriges DelphiProgramm: aa.x aa.y bb.x bb.y

:= := := :=

round(a.x * abstand / (abstand + a.z)) + links; round(-a.y * abstand / (abstand + a.z)) + oben; round(b.x * abstand / (abstand + b.z)) + links; round(-b.y * abstand / (abstand + b.z)) + oben;

HINWEIS: Bei ungünstigem Betrachterstandpunkt kann ein Laufzeitfehler "Division durch null"

auftreten! Fangen Sie diesen gegebenenfalls mit einem Try-Except-Block ab. Sowohl für die Parallel- als auch für die Zentralprojektion sind noch zusätzliche Koordinatentransformationen erforderlich, bevor die Grafik dargestellt werden kann.

814

Kapitel 15

Erweitere Grafikprogrammierung

Der Faktor -1 für die y-Koordinate kippt das fenstereigene Koordinatensystem in vertikaler Richtung. Mit folgenden Anweisungen wird der Offset für x- und y-Achse in die Mitte des Fensters verlegt: links := wohin.ClientWidth div 2; oben := wohin.ClientHeight div 2;

Wenden wir uns nun den eigentlichen Routinen für Translation, Streckung und Rotation zu:

15.3.2 Translation Die Translation oder Verschiebung ist nichts anderes als die Addition von Punktvektor und Verschiebungsvektor. Was sich so kompliziert anhört, ist relativ trivial. Jede Komponente des Punktvektors wird zu ihrem Verschiebungsvektor addiert: a.x := a.x + dx; a.y := a.y + dy; a.z := a.z + dz; Y

X

Z

Um den gesamten Körper zu bewegen, müssen natürlich alle Punkte verschoben werden. procedure translation (var k : array var anzahl,i:Integer; begin anzahl := High(k); for i := 0 To anzahl - 1 do with a.x := a.x + dx;a.y := a.y + b.x := b.x + dx;b.y := b.y + end end;

of linienType; dx,dy,dz :Integer);

k[i] do begin dy;a.z := a.z + dz; dy;b.z := b.z + dz

815

15.3 3-D-Vektorgrafik

15.3.3 Streckung/Skalierung Neben der Verschiebung kann ein Körper auch vergrößert, d.h. skaliert werden. Die Skalierung wird durch Multiplikation des Punktvektors mit einer Konstanten (dem Skalierungsfaktor) realisiert.

Je nachdem, ob der Skalierungsfaktor größer oder kleiner 1 ist, wird der Körper vergrößert oder verkleinert. procedure scalierung (var k: array of linienType; scal : Double); var anzahl,i : Integer; begin anzahl := High(k); for i := 0 To anzahl - 1 do with k[i] do begin a.x := a.x * scal; a.y := a.y * scal; a.z := a.z * scal; b.x := b.x * scal; b.y := b.y * scal; b.z := b.z * scal end end;

15.3.4 Rotation Die Programmierung eines Rotations-Algorithmus gestaltet sich naturgemäß schwieriger als für die Translation bzw. Skalierung. Um den Überblick nicht zu verlieren, führen wir folgende Notation ein: ■ Rotation um die x-Achse

α (alpha)

■ Rotation um die y-Achse

β (beta)

■ Rotation um die z-Achse

γ (gamma)

816

Kapitel 15

Erweitere Grafikprogrammierung

Y

X

Z

Für die Drehung um die einzelnen Achsen sind Transformationsmatrizen Ri gegeben:

R

1 0  =  0 cos α X   0 sin α

0   − sin α   cos α 

 cos β 

R = Y 

0  − sin β

0 sin β   1 0   0 cos β 

R

 cos γ  =  sin γ Z   0

− sin γ cos γ 0

0  0  1

Der neue Vektor bildet sich durch Multiplikation mit der entsprechenden Rotationsmatrix. Um unnötige Operationen zu vermeiden, werden die Matrizen aufgelöst und (soweit sinnvoll) berechnet (keine Multiplikationen mit null!). Die Prozedur Rotation erwartet als Parameter den zu drehenden Körper sowie die oben genannten Rotationswinkel. Im Programm sind nur Inkrementswinkel von -1°, 0°, +1° zulässig. Sie können die Anzahl der Winkel-Inkremente jedoch jederzeit in der Init-Prozedur ändern. procedure rotation (var k : array of linientype; alpha, beta, gamma :integer); var anzahl, i: Integer; ax,ay,az,bx,by,bz: Double; begin anzahl := High(k); For i := 0 To anzahl - 1 do with k[i] do begin if gamma <> 0 then begin ax := a.x; ay := a.y; bx := b.x; by := b.y; a.x := ax * Cost[gamma] - ay * Sint[gamma]; a.y := ax * Sint[gamma] + ay * Cost[gamma]; b.x := bx * Cost[gamma] - by * Sint[gamma]; b.y := bx * Sint[gamma] + by * Cost[gamma]; end; if alpha <> 0 then begin ay := a.y; az := a.z;

15.3 3-D-Vektorgrafik

817

by := b.y; bz := b.z; a.y := ay * Cost[alpha] - az * Sint[alpha]; a.z := ay * Sint[alpha] + az * Cost[alpha]; b.y := by * Cost[alpha] - bz * Sint[alpha]; b.z := by * Sint[alpha] + bz * Cost[alpha]; end; if beta <> 0 then begin az := a.z; ax := a.x; bx := b.x; bz := b.z; a.z := az * Cost[beta] - ax * Sint[beta]; b.z := bz * Cost[beta] - bx * Sint[beta]; a.x := az * Sint[beta] + ax * Cost[beta]; b.x := bz * Sint[beta] + bx * Cost[beta]; end; end;

Die Rotation wird nur ausgeführt, wenn ein Inkrement ungleich null vorliegt. Auf diese Weise sollen unnötige Berechnungen vermieden werden. Mit den vorgestellten Algorithmen können Sie den Körper bereits beliebig im Raum verschieben, drehen und skalieren. Sie können das Demo-Programm über die Cursortasten, die x-, y-, z- sowie die Plus-/Minustasten steuern. Mit SHIFT + (X/Y/Z) lässt sich die Rotationsrichtung verändern. Das Ergebnis kann sich schon sehen lassen, ein Problem bleibt allerdings die Geschwindigkeit. Bereits bei den wenigen Linien beginnt das Bild zu flackern. Um diesen Effekt auszuschließen, müsste das gesamte Bild im Hintergrund aufgebaut und erst dann auf den Screen kopiert werden.

HINWEIS: Das komplette 3-D-Grafikbeispiel finden Sie im Praxisteil unter 15.5.2.

818

Kapitel 15

Erweitere Grafikprogrammierung

15.4 Lernbeispiele für Einsteiger 15.4.1 Eine umrandete Fläche mit Farbe füllen Aus jedem pixelorientierten Zeichenprogramm kennen Sie die "Farbkanne", mit der Sie eine umrandete Fläche mit einer Farbe füllen können. Auch in Delphi gibt es eine entsprechende Methode. Wie Sie diese richtig einsetzen, zeigt das folgende Beispiel.

Oberfläche Für die Oberfläche wird lediglich ein Button benötigt. Das Formular ist das Ausgabeziel der Grafikoperationen, es hätte aber auch eine Paintbox sein können. Der folgende Screenshot zeigt die Laufzeitansicht.

Quelltext Zur Vorbereitung der Zeichenfläche verwenden wir den Button-Klick: procedure TForm1.Button1Click(Sender: TObject); var i : integer; begin Refresh; Canvas.Pen.Color := clBlack; for i := 1 to 50 do Canvas.LineTo(Round(ClientWidth * Random), Round(ClientHeight * Random)); Canvas.Pen.Color := clRed end;

Die Fülloperation wird mit Mausklick auf die Zeichenfläche eingeleitet. Da wir zum Füllen die Stiftfarbe verwenden wollen, müssen wir die Pinselfarbe kurzzeitig in einer Zwischenvariablen

15.4 Lernbeispiele für Einsteiger

819

sichern (vom Typ TColor). Die Farbe des aktuellen Punktes erhalten wir über die Pixels-Eigenschaft. procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); var help,farbe : TColor; begin with Canvas do begin Screen.Cursor := crHourglass; help := Brush.Color; Brush.Color:= Pen.Color; farbe:= Pixels[X,Y]; FloodFill(x,y, farbe, fssurface); Brush.Color := help; Screen.Cursor := crDefault end end;

Das Anzeigen der Sanduhr sollte bei Fülloperationen immer erfolgen, da diese teilweise recht lange dauern können (z.B. bei stark zergliederten Füllflächen). Das vorgestellte Verfahren füllt eine Fläche mit einheitlicher Farbe. Sie haben jedoch auch die Möglichkeit, eine Fläche zu füllen, die von einer vorgegebenen Farbe umrandet ist. Die Farben innerhalb der Fläche spielen dann keine Rolle. Legen Sie dazu den vierten Parameter von Floodfill auf fsBorder fest. In diesem Fall müssten Sie folgenden Aufruf verwenden: FloodFill(x,y, clBlack, fsBorder);

Test Mit dem Button "Muster" blenden Sie zunächst ein Zufallsmuster ein. Klicken Sie mit der Maus auf bestimmte Regionen und Sie können diese mit der "Farbkanne" füllen (siehe Abbildung oben).

15.4.2 Drag & Drop mit Grafikobjekten Eine nicht ganz triviale, aber häufig auftretende Aufgabe ist zu lösen: Mehrere grafische Objekte (z.B. Kreise, Rechtecke etc.) sind auf den Canvas eines Formulars zu zeichnen. Durch Anfassen mit der Maus und Ziehen (bei gedrückt gehaltener Taste) sollen diese Objekte verschoben oder in der Größe verändert werden. Sie kennen diese Funktionalität bereits zur Genüge aus eigener Erfahrung, denn viele professionelle Zeichenprogramme (auch die DelphiIDE!) arbeiten nach dem Drag & Drop-Prinzip. Als angehende Profis verzichten wir auf eine schnelle "Quick and Dirty"-Programmierung, weil diese (insbesondere bei vielen Objekten) mit ziemlicher Sicherheit im Chaos enden wird. Im vorliegenden Beispiel wird das Problem deshalb konsequent mit OOP-Mitteln gelöst, wobei wir uns auf drei Grafikobjekte vom Typ "Kreis" beschränken wollen.

820

Kapitel 15

Erweitere Grafikprogrammierung

Grundlagen Wir wissen zwar, dass viele Delphi-Komponenten Drag & Drop-Operationen unterstützen und dazu Ereignisse wie z.B. OnDragDro, OnDragOverp etc. besitzen (siehe auch Kapitel 4), aber in unserem Fall nützt das wenig, da wir auf keine vorgefertigten Delphi-Objekte zurückgreifen können, sondern diese von Grund auf neu erstellen müssen. Der folgende Zustandsüberführungsgraph zeigt das Grundprinzip: Start Objekt erzeugen

Z=0 Objekt anfassen nein

Objekt getroffen? ja

Objekt loslassen Z=1 Objekt an neuer Position zeichnen

Objekt ziehen Objekt an alter Position löschen

Ein grafisches Objekt hat zwei Zustände: ■ Z=0 ("Normal") ■ Z=1 ("Zeichenmodus") Der Übergang zwischen beiden Zuständen wird durch drei Ereignisse ausgelöst: ■ Objekt anfassen ■ Objekt ziehen ■ Objekt loslassen In Abhängigkeit vom aktuellen Zustand reagiert ein Objekt nur auf bestimmte Ereignisse. Außerdem ist der Übergang zum Folgezustand mitunter an bestimmte Bedingungen geknüpft, z.B. führt

821

15.4 Lernbeispiele für Einsteiger

das Ereignis Objekt anfassen nur dann von Z1 zu Z2, wenn man mit der Maus das Objekt richtig "getroffen" hat.

Oberfläche Ein leeres Formular!

Quellcode für Unit Kreis Fügen Sie über das Datei-Menü zum Projekt eine neue Unit hinzu. unit Kreis; interface uses Forms, Graphics;

Die Klassendeklaration: type TKreis = class(TObject) private

Im Unterschied zu obiger Zeichnung haben unsere "Kreis"-Objekte nicht zwei, sondern drei Zustände, die in einer Zustandsvariablen z gespeichert sind. Diese kann demnach die Werte 0 ("Normalzustand"), 1 ("Größe des Objekts verändern") und 2 ("Objekt verschieben") annehmen: z: Integer;

// Zustand (0, 1, 2)

Die weiteren Felder/Attribute des Objekts bedürfen wohl keiner extra Erläuterung: r: Integer; // Radius x0, y0: Integer; // Mittelpunktkoordinaten clr: TColor; // Farbe cvs: TCanvas; // Zeichenfläche dc: Integer; // Größe des Mittelkreuzes dr: Integer; // Randverbreiterung für bequemeres "Anfassen"

Die folgenden Methoden sind nach außen "sichtbar": public constructor erzeugen(x,y,rd: Integer; co: TColor; f: TForm); procedure zeichnen; procedure anfassen(x,y: Integer); procedure ziehen(x,y: Integer); procedure loslassen; end;

Nun zum implementation-Abschnitt. Im Konstruktor wird ein Objekt erzeugt und initialisiert, d.h. mit Anfangswerten gefüllt: constructor TKreis.erzeugen; begin z:=0; // Anfangszustand f.Color := clWhite;

822

Kapitel 15

Erweitere Grafikprogrammierung

x0:=x; y0:=y; r:=rd; cvs:= f.Canvas; cvs.Brush.Style := bsClear; // transparent (kein Füllmuster für Kreis) cvs.Pen.Mode := pmXOR; // XOR-Zeichenmodus clr:= co xor clWhite; // immer weißer Formularhintergrund dc := r div 10; dr := 3; zeichnen end;

Wie oben ersichtlich, wird im XOR-Zeichenmodus gearbeitet. Das bringt den Vorteil, dass sich Objekte durch doppeltes Überzeichnen einfach wieder löschen lassen (siehe Kap. 7). D.h., die folgende Methode zeichnen wird sowohl zum Zeichnen als auch zum Löschen des Objekts verwendet: procedure TKreis.zeichnen; begin with cvs do begin Pen.Color := clr; // Zeichenfarbe Ellipse(x0-r,y0-r,x0+r,y0+r); dc := r div 10; // Mittelkreuz anpassen MoveTo(x0-dc, y0); LineTo(x0+dc+1, y0); MoveTo(x0, y0-dc); LineTo(x0, y0+dc+1) end end;

Am aufwändigsten ist die anfassen-Methode, mit der eine Drag & Drop-Operation eingeleitet wird: procedure TKreis.anfassen;

Die Methode greift auf die zwei lokalen Funktionen randGetroffen und mitteGetroffen zurück. Die erste Hilfsfunktion testet, ob das übergebene Koordinatenpaar den Rand des Kreises trifft: function randGetroffen: Boolean; var q: Integer; // Hilfsvariable begin Result := False; q := (X-x0) * (X-x0) + (Y-y0) * (Y-y0); if (q > (r-dr) * (r-dr)) and (q < (r+dr) * (r+dr)) then Result := True; end;

Analog dazu prüft die folgende Hilfsfunktion, ob der Mittelpunkt des Kreises getroffen wird: function mitteGetroffen: Boolean; begin Result := False; if (X > (x0-dc)) and (X < (x0+dc+1)) and (Y > (y0-dc)) and (Y < (y0+dc+1)) then Result := True end;

Hier erfolgt der Aufruf: begin if randGetroffen then z := 1; if mitteGetroffen then z := 2 end;

// neuer Zustand "Radius verändern" // neuer Zustand "Kreis verschieben"

15.4 Lernbeispiele für Einsteiger

823

In der Ziehphase (Z=1 oder Z=2) wird das Grafikobjekt an alter Position gelöscht, dann werden die neuen Koordinaten bzw. Abmessungen ermittelt und damit das Objekt in neuer Größe bzw. Position gezeichnet: procedure TKreis.ziehen; var dx, dy: Single; begin if z = 0 then Exit; // kein Zeichnen im Zustand "Normal" zeichnen; // alten Kreis löschen durch Überzeichnen if z = 1 then begin // Größe verändern dx := (X-x0); dy := (Y-y0); r := Round(Sqrt(dx * dx + dy * dy)) end; if z=2 then begin // Kreis verschieben x0 := X; y0 := Y end; zeichnen // Kreis neu zeichnen end;

Das Loslassen des Objekts führt zurück zum initialen Zustand Z=1: procedure TKreis.loslassen; begin z:=0 end; end.

Quellcode für Unit1 Dank OOP gestaltet sich der Quellcode für unsere Formular-Unit knapp und übersichtlich. Es genügt, wenn wir uns auf die Wiedergabe des implementation-Abschnitts beschränken. Zu Beginn werden die Klassen-Unit eingebunden und drei Objektvariablen referenziert. uses Kreis; var kreis1, kreis2, kreis3: TKreis;

Beim Laden des Formulars werden die drei Kreisobjekte erzeugt und mit den gewünschten Anfangswerten gefüllt: procedure TForm1.FormCreate(Sender: TObject); begin kreis1 := TKreis.erzeugen(100, 200, 50, clRed, Form1); kreis2 := TKreis.erzeugen(300, 200, 50, clGreen, Form1); kreis3 := TKreis.erzeugen(200, 100, 50, clBlue, Form1); end;

Die folgenden drei Event-Handler realisieren den Grundzyklus "Anfassen", "Ziehen" und "Loslassen": Kreiselement anfassen: procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin

824

Kapitel 15

Erweitere Grafikprogrammierung

kreis1.anfassen(X,Y); kreis2.anfassen(X,Y); kreis3.anfassen(X,Y) end;

Kreiselement bei gedrückter Maustaste "ziehen": procedure TForm1.FormMouseMove(Sender: TObject; Shift: TShiftState; X,Y: Integer); begin kreis1.ziehen(X,Y); kreis2.ziehen(X,Y); kreis3.ziehen(X,Y) end;

Maustaste loslassen: procedure TForm1.FormMouseUp(Sender: TObject; Button: TMouseButton; TShiftState; X, Y: Integer); begin kreis1.loslassen; kreis2.loslassen; kreis3.loslassen; end;

Shift:

Damit nach einem Verdecken des Formulars die Objekte nicht verschwinden, macht sich folgende Programmergänzung erforderlich: procedure TForm1.FormPaint(Sender: TObject); // regeneriert Zeichnung begin kreis1.zeichnen; kreis2.zeichnen; kreis3.zeichnen end;

Test Fassen Sie die Objekte mit der Maus entweder am Mittelkreuz oder am Rand an und verschieben oder vergrößern/verkleinern Sie sie. Sieht es nach dem Start noch so aus,

... so kann sich wenig später schon folgendes Bild ergeben:

15.5 Praxisbeispiele für Fortgeschrittene

825

Bemerkungen ■ Die OOP-Grundlagen können Sie am besten mit dem"Autorennen" im Kapitel 6 erlernen. ■ Andere Figuren wie Rechtecke etc. lassen sich mittels Vererbung erzeugen. ■ Um den Quelltext überschaubar zu halten, wurde die Gestalt des Mauszeigers nicht geändert. Es dürfte aber kein Problem sein, die Cursor-Eigenschaft des Formulars an den aktuellen Zustand anzupassen. ■ Auch das "Einrahmen" mehrerer Objekte und anschließendes gemeinsames Manipulieren dürfte mit geringem zusätzlichen Aufwand machbar sein (siehe dazu Praxisbeispiel 7.5.2). ■ Auf der Buch-CD finden Sie zu Vergleichszwecken den Quellcode für eine konventionelle "Nicht-OOP"-Lösung, allerdings mit Beschränkung auf nur ein Objekt.

15.5 Praxisbeispiele für Fortgeschrittene 15.5.1 Programmieren einer Animation mit BitBlt Das Windows-GDI gibt dem ambitionierten "Spielfreak" mit der BitBlt-Funktion ein leistungsfähiges Instrument in die Hand, um zumindest zweidimensionale Grafikanimationen zu realisieren.

Grundlagen Den Eindruck einer fortlaufenden Bewegung des Sprites gewinnt man normalerweise durch folgende Technik:

826

Kapitel 15

Erweitere Grafikprogrammierung

■ Löschen des Sprites auf alter Position und Wiederherstellen des zerstörten Hintergrundes ■ Sichern des Hintergrundes, auf den das Sprite kopiert werden soll ■ Kopieren des Sprites auf seine neue Position Der Nachteil dieses Verfahrens ist das lästige Flackern, das durch das ständige Löschen hervorgerufen wird. Um die Defizite bezüglich Darstellungsqualität abzubauen, müssen die Zugriffe auf die Vordergrundgrafik auf das notwendige Minimum beschränkt werden. Zur Realisierung bedarf es einer Kopie des Hintergrundes (TBitmap). Infolgedessen kann das Eliminieren des Sprites entfallen, was beim obigen Verfahren unverzichtbar war, um auf die entsprechenden Bereiche des Hintergrundes zugreifen zu können. Der jeweilige Sektor wird jedoch nicht unmittelbar auf den Bildschirm projiziert, sondern zunächst von einem zusätzlichen TBitmapObjekt aufgenommen, das vorher mit Hilfe zweier Masken aufbereitet wurde. Der im Anschluss auf diesem Objekt generierte Sprite verschmilzt mit dem Untergrund zu einem kompletten Zwischenbild. Dieses wird auf die Bildschirmoberfläche kopiert.

Hilfsbitmap SRCCOPY Maske 1 SRCAND

Maske 2 SRCINVERT

SRCCOPY

Warum so kompliziert?

827

15.5 Praxisbeispiele für Fortgeschrittene

Unser Hauptproblem ist, dass der Sprite nicht rechteckig ist und aus diesem Grund nicht einfach mit SRCCOPY kopiert werden kann. Aus diesem Grund sind die "Klimmzüge" mit den zwei Masken erforderlich, die über geeignete AND- bzw. INVERT-Verknüpfungen mit einer HilfsBitmap quasi den Hintergrund "durchscheinen" lassen. Hier noch einmal eine Zusammenfassung aller in Frage kommenden Pixelverknüpfungen: Hilfs-Bitmap Verknüpfung

Maske 1

Ergebnis

Erklärung

Farbe (X)

AND

Weiß (1)

Farbe (X)

Untergrund

Farbe (X)

AND

Schwarz (0)

Schwarz (0)

Flugzeugschatten

Farbe (X)

INVERT (XOR)

Schwarz (0)

Farbe (X)

Untergrund

Schwarz (0)

INVERT (XOR)

Farbe (X)

Farbe (X)

Flugzeug

Oberfläche Auf der Oberfläche finden Sie neben zwei Buttons zum Starten und Beenden einen Schieberegler (die Notbremse für den Pentium) und zwei Image-Komponenten. Die eine nimmt beide Masken auf, die andere kapselt die Hintergrundgrafik. Beide Image-Komponenten sind zur Laufzeit nicht sichtbar. Schließlich brauchen wir noch eine (große) Paintbox für die eigentliche Grafikausgabe.

828

Kapitel 15

Erweitere Grafikprogrammierung

Quelltext Wir beschränken uns auf den Implementation-Abschnitt von Form1: var ok : Boolean;

Es geht los: procedure TForm1.SpeedButton1Click(Sender: TObject); var L : Integer; n : Integer; b : Single; z : TBitmap; begin

Gleich nach dem Start wird das Hintergrundbild in die Paintbox kopiert: BitBlt(PaintBox1.Canvas.Handle, 0, 0, PaintBox1.Width,Paintbox1.Height, Image1.Picture.Bitmap.Canvas.Handle, 0,0, SRCCOPY);

Eine Hilfs-Bitmap wird erzeugt: z := TBitmap.Create; z.Width := 33; z.Height:= 33; ok := True; while ok do begin

Etwas Rechenzeit verbrauchen und anderen Prozessen Zeit zum Reagieren geben: for n := 0 to Scrollbar1.Position do b := Sqrt(2345); Application.ProcessMessages; Inc(L);

Die eingangs beschriebenen Pixelverknüpfungen werden durchgeführt: BitBlt(z.Canvas.Handle, 0, 0, 33, 33, Image1.Picture.Bitmap.Canvas.Handle, L, L, SRCCOPY); BitBlt(z.Canvas.Handle, 1, 1, 32, 32, Image2.Picture.Bitmap.Canvas.Handle, 32, 0, SRCAND); BitBlt(z.Canvas.Handle, 1, 1, 32, 32, Image2.Picture.Bitmap.Canvas.Handle, 0, 0, SRCINVERT); BitBlt(Paintbox1.Canvas.Handle, L, L, 32, 32, z.Canvas.Handle, 0, 0, SRCCOPY); If L > 400 Then L:=0 end; z.Free end;

Die Flugschau beenden: procedure TForm1.SpeedButton2Click(Sender: TObject); begin ok := False end;

15.5 Praxisbeispiele für Fortgeschrittene

829

Test Wenn Sie einen schnellen PC haben, dann müssen Sie die "Bremse" ganz schön weit nach rechts stellen, damit Sie anstelle des rasenden Ufo ein Flugzeug erkennen können.

Bemerkungen ■ Heiligstes Motto des Grafikprogrammierers: "Nur keine Zeit verschwenden ...", deshalb möglichst alles mit BitBlt abwickeln, keine Grafikmethoden verwenden usw.! ■ Auf ProcessMessages können wir leider nicht verzichten, das Programm ließe sich sonst nicht stoppen.

15.5.2 Darstellen einer 3-D-Vektorgrafik Diese ziemlich umfangreiche Demo wird sich auf die Darstellung eines Drahtgittermodells beschränken, eigenen Erweiterungen steht jedoch nichts im Wege.

Oberfläche Für die Programmoberfläche brauchen wir zwei Fenster: eines zur Darstellung der Grafik, ein zweites für die Steuertasten. Die BorderStyle-Eigenschaft des Hauptfensters setzen Sie auf bsNone, die Color-Eigenschaft auf clBlack.

Damit wäre das erste Fenster bereits komplett, das zweite ist jedoch etwas aufwändiger. Den grundsätzlichen Aufbau können Sie der Abbildung entnehmen.

830

Kapitel 15

Erweitere Grafikprogrammierung

Quelltext Bei der Beschreibung des Quelltextes soll der Schwerpunkt auf den verwendeten Algorithmen liegen, d.h. auf den Prozeduren aus Unit3. Die Unit exportiert die folgenden Typen bzw. Prozeduren: unit Unit3; interface uses forms,graphics; const r = PI/180; type punkttype = record x,y,z : Double; end; punkttyp2 = record x,y :integer end; linientype = record a,b : Punkttype; aa,bb : punkttyp2; end; var gamma,beta,alpha : integer; scal,dx,dy,dz : double; sint,cost : array [-1 .. 1] of double; figur1 : array [0 .. 24] of linientype; abstand : double; procedure procedure procedure procedure procedure

init(wohin :tform); scalierung (var k: array of linientype; scal : Double); translation (var k : array of linientype; dx,dy,dz :integer); rotation (var k : array of linientype; alpha,beta,gamma :integer); darstellen (var k: array of linientype);

Für die Darstellung werden keine weiteren Units benötigt. Es genügt also, wenn Sie nur die obige Unit in Ihre eigenen Programme übernehmen. Kommen wir zu den Details: Mit New_Line fügen Sie dem Körper eine neue Linie hinzu, in diesem Fall figur1. Wie bei allen folgenden Prozeduren können Sie ein beliebig großes Array an diese übergeben, die Größe wird intern verwaltet. implementation var i,links,oben:integer; wo : tform; procedure new_line(var k:array of linientype;x1,y1,z1,x2,y2,z2:Double); begin k[i].a.x := x1; k[i].a.y := y1; k[i].a.z := z1; k[i].b.x := x2; k[i].b.y := y2;

15.5 Praxisbeispiele für Fortgeschrittene

831

k[i].b.z := z2; inc(i) end;

Beim Skalieren werden die Punktvektoren mit einem konstanten Faktor multipliziert. procedure scalierung (var k: array of linientype; scal : Double); var anzahl,i : integer; begin anzahl := high(k); For i := 0 To anzahl - 1 do with k[i] do begin a.x := a.x * scal; a.y := a.y * scal; a.z := a.z * scal; b.x := b.x * scal; b.y := b.y * scal; b.z := b.z * scal end end;

Wird ein Punkt verschoben, handelt es sich um eine Addition von Punkt- und Verschiebungsvektor: procedure translation (var k : array of linientype; dx,dy,dz :integer); var anzahl,i:integer; begin anzahl := high(k); For i := 0 To anzahl - 1 do with k[i] do begin a.x := a.x + dx; a.y := a.y + dy; a.z := a.z + dz; b.x := b.x + dx; b.y := b.y + dy; b.z := b.z + dz end end;

Die Rotation ist schon etwas aufwändiger. Wie bekannt, bildet sich der neue Vektor durch Multiplikation mit der entsprechenden Rotationsmatrix. Um unnötige Operationen zu vermeiden, werden die Matrizen aufgelöst und (soweit sinnvoll) berechnet (keine Multiplikationen mit null!). Für die Drehwinkel sind nur Werte von 0, -1, +1 zulässig. Grund ist die Verwendung einer Sinus- bzw. Cosinus-Tabelle, mit der Rechenzeit gespart werden soll. Wenn Sie diese Tabelle entsprechend erweitern, steht der Verwendung anderer Winkelinkremente nichts im Weg. procedure rotation (var k : array of linientype; alpha,beta,gamma :integer); { alpha-Rotation x-Achse beta-Rotation y-Achse gamma-Rotation z-Achse } var anzahl,i :integer; ax,ay,az,bx,by,bz :double; begin anzahl := high(k); for i := 0 to anzahl - 1 do with k[i] do begin if gamma <> 0 then begin ax := a.x; ay := a.y; bx := b.x; by := b.y; a.x := ax * Cost[gamma] - ay * Sint[gamma]; a.y := ax * Sint[gamma] + ay * Cost[gamma]; b.x := bx * Cost[gamma] - by * Sint[gamma]; b.y := bx * Sint[gamma] + by * Cost[gamma]

832

Kapitel 15

Erweitere Grafikprogrammierung

end; if alpha <> 0 then begin ay := a.y; az := a.z; by := b.y; bz := b.z; a.y := ay * Cost[alpha] - az * Sint[alpha]; a.z := ay * Sint[alpha] + az * Cost[alpha]; b.y := by * Cost[alpha] - bz * Sint[alpha]; b.z := by * Sint[alpha] + bz * Cost[alpha] end; if beta <> 0 then begin az := a.z; ax := a.x; bx := b.x; bz := b.z; a.z := az * Cost[beta] - ax * Sint[beta]; b.z := bz * Cost[beta] - bx * Sint[beta]; a.x := az * Sint[beta] + ax * Cost[beta]; b.x := bz * Sint[beta] + bx * Cost[beta] end end;

Damit sind schon alle benötigten Vektoroperationen implementiert, übrig bleibt die Darstellung des gesamten Körpers auf dem Bildschirm bzw. in einem Fenster. Im vorliegenden Beispiel haben wir uns für die Zentralperspektive entschieden, Sie können an dieser Stelle aber auch jede andere Darstellungsart verwenden. Für das Vernichten der alten Grafik bieten sich zwei Möglichkeiten an: Löschen des gesamten Fensters mit Refresh oder Löschen der einzelnen Linien durch Überzeichnen mit der Hintergrundfarbe. Die zweite Methode ist auf Grafikkarten mit Beschleuniger-Chip schneller, hat jedoch den Nachteil, dass das Bild flimmert. procedure darstellen (var k: array of linientype); var anzahl,i : integer; begin anzahl := high(k); wo.canvas.pen.color:=clblack; for i := 0 to anzahl - 1 do with k[i] do begin wo.canvas.moveto (aa.x,aa.y); wo.canvas.lineto (bb.x,bb.y) end; wo.canvas.pen.color:=cllime; for i := 0 to anzahl - 1 do with k[i] do begin aa.x := round(a.x * abstand / (abstand + a.z)) + links; aa.y := round(-a.y * abstand / (abstand + a.z)) + oben; bb.x := round(b.x * abstand / (abstand + b.z)) + links; bb.y := round(-b.y * abstand / (abstand + b.z)) + oben; wo.canvas.moveto (aa.x,aa.y); wo.canvas.lineto (bb.x,bb.y) end end;

Bisher haben wir nur von einem "Körper" gesprochen, jetzt müssen wir diesen genauer definieren:

15.5 Praxisbeispiele für Fortgeschrittene

833

procedure init(wohin :tform); begin i:=0; scal := 80; abstand := 1000; new_line( figur1, -2, 1, 2, 1, 1, 2); new_line( figur1, -2, 1, 2, -2, -1, 2); new_line( figur1, -2, -1, 2, 1, -1, 2); new_line( figur1, 1, -1, 2, 1, 1, 2); ... new_line( figur1, -0.5, 0.5, -1, -0.5, -1, -1); new_line( figur1, 0.5, 0.5, -1, 0.5, -1, -1);

Die Berechnung der Sinus- und Cosinus-Tabelle nehmen wir ebenfalls in der Init-Prozedur vor: for i := -1 to 1 do begin sint[i]:=sin(i*r*2); cost[i]:=cos(i*r*2) end; scalierung(figur1,scal); links := wohin.clientwidth div 2; oben := wohin.clientheight div 2; wo := wohin; wo.canvas.pen.color:=cllime end;

Für die Manipulation des Körpers brauchen wir auch die entsprechenden Steuertasten. Um den Überblick bei der Vielzahl der Funktionen nicht zu verlieren, setzt jede der Tasten beim Drücken die Variable befehl. Wird das MouseUp-Ereignis ausgelöst, erfolgt die erneute Darstellung. Auf diese Weise ist es leicht, die Steuerung des Körpers in einer Prozedur zusammenzufassen. unit Unit1; interface ... implementation uses unit2,unit3; {$R *.DFM} var form2 : TForm2; ok : boolean; befehl : integer; procedure TForm1.FormCreate(Sender: TObject); begin form2 := tform2.Create(Self); form2.Show; left := screen.width-width; top := screen.height-height end;

834

Kapitel 15

Erweitere Grafikprogrammierung

Da beide Fenster gleichzeitig angezeigt werden sollen, erzeugen wir Form2 in der Init-Prozedur von Form1. Würde nur die Anweisung Form2.Show ausgeführt, tritt ein Laufzeitfehler auf: Das Hauptformular Form1 ist noch nicht initialisiert, und es wird versucht, ein weiteres Fenster anzuzeigen. Auf die gezeigte Art umgehen wir dieses Problem. Im Projektfenster müssen Sie allerdings eine Änderung vornehmen: Form2 darf nicht mehr automatisch erzeugt werden, es genügt, wenn sie verfügbar ist, procedure TForm1.FormDestroy(Sender: TObject); begin form2.Free; end; procedure TForm1.Button3Click(Sender: TObject); begin ok := false; close end; procedure TForm1.BitBtn9MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin befehl:=9; end; procedure TForm1.BitBtn10MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin befehl:=10; end; procedure TForm1.BitBtn11MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin befehl:=11; end; procedure TForm1.BitBtn12MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin befehl:=12; end;

Beachten Sie, dass in der folgenden Endlosschleife mit application.processMessages

Rechenzeit freigegeben wird. Wenn Sie meinen, auf diese Zeile verzichten zu können, werden Sie eine böse Überraschung erleben: Ihre Anwendung lässt sich nicht mehr bedienen, denn die gesamte Rechenzeit wird für die Schleife verwendet. Eine andere Möglichkeit wäre die Verwendung von SpinButtons, die zyklisch ein Ereignis auslösen, solange die Taste gedrückt ist. Die obige Methode bringt jedoch die besten Ergebnisse. procedure TForm1.BitBtn13Click(Sender: TObject); begin ok := true; init(form2); darstellen(figur1); while ok do begin case befehl of 1 : scalierung(figur1,1.04); 2 : scalierung(figur1,0.96); 3 : rotation(figur1,0,1,0);

15.5 Praxisbeispiele für Fortgeschrittene

835

4 : rotation(figur1,0,-1,0); 5 : rotation(figur1,1,0,0); 6 : rotation(figur1,-1,0,0); 7 : rotation(figur1,0,0,1); 8 : rotation(figur1,0,0,-1); 9 : translation(figur1,0,1,0); 10 : translation(figur1,-2,0,0); 11 : translation(figur1,2,0,0); 12 : translation(figur1,0,-2,0); end; if befehl <> 0 then darstellen(figur1); Application.ProcessMessages end end;

Ergänzungen ■ In der vorliegenden Version flimmert das Bild teilweise beim Drehen bzw. Verschieben. Um diesen Effekt zu vermeiden, müsste das Bild komplett im Hintergrund aufgebaut und dann in den Vordergrund kopiert werden. Sie sollten dazu eine Paintbox sowie eine Hintergrund-Bitmap vom Typ TBitmap verwenden. ■ Ein weiteres Problem ist der Werteüberlauf beim Zoomen, dem Sie jedoch mit einer Fehlerbehandlung (Try ... Except...) begegnen können.

16

Applikationen

Kapitel

16

Applikationen 16.1 Einsteigerprogramm TEXTVERARBEITUNG Diese kleine Anwendung soll zwar kein ausgewachsenes Textverarbeitungsprogramm ersetzen, ist aber als Demo besonders gut für den Einsteiger geeignet. Dieser lernt an einem durchgängigen Beispiel wichtige Delphi-Elemente kennen, wie z.B. MDI-Fenster, Erzeugen und Entfernen von Formularen zur Laufzeit, Datei-, Drucker- und Fontdialoge, den Zugriff auf Textdateien, Menüentwurf, RichText-Komponente, Zwischenablage, Stringlisten ... Zur Vorbereitung empfiehlt sich insbesondere das Durcharbeiten des Kapitels 4 ("Formulare und Komponenten").

16.1.1 Bedienoberfläche Unsere Applikation besteht aus zwei Formularen, dem MDI-Rahmenfenster und einem Kindfenster. Letzteres wird erst zur Laufzeit hinzugefügt und kann sich beliebig oft vermehren.

MDI-Rahmenfenster Die FormStyle-Eigenschaft von Form1 setzen Sie auf fsMDIForm. Platzieren Sie eine MainMenuund eine OpenDialog-Komponente auf das Formular. Klicken Sie doppelt auf die MainMenu-Komponente und erstellen Sie im Menü-Editor die in der folgenden Abbildung gezeigten Einträge:

838

Kapitel 16

Applikationen

HINWEIS: Den Trennbalken innerhalb des Menüs erreichen Sie durch Eintrag eines einzelnen

"-"-Zeichens als Caption-Eigenschaft. Der Shortcut entsteht durch Voranstellen eines "&"-Zeichens.

MDI-Kindfenster Obwohl wir in unserer Applikation mit mehreren Dokumenten (MDI-Kindfenster) gleichzeitig arbeiten können, genügt es, wenn wir einen einzigen "Prototyp" entwerfen. Fügen Sie über Datei| Neues Formular ein weiteres Formular (Form2) hinzu. Dort findet eine RichEdit-Komponente ihren Platz, die nach Setzen der Align-Eigenschaft auf alClient das Fenster vollkommen ausfüllt:

Der Menüentwurf für die MainMenu-Komponente gestaltet sich etwas aufwändiger als der für das MDI-Rahmenfenster: Datei Neu Öffnen... Schließen Speichern Speichern als ... Drucken Drucker einrichten ... Beenden

Bearbeiten Ausschneiden Kopieren Einfügen Löschen Alles auswählen

Zeichen Links Rechts Zentriert Font ...

Fenster Nebeneinander Hintereinander

HINWEIS: Die Name-Eigenschaft von Menüobjekten wird standardmäßig aus der Caption-

Eigenschaft gebildet. Dabei werden aber Umlaute und "ß" unterdrückt, was sehr übel aussehen kann. Korrigieren Sie deshalb aus Übersichtlichkeitsgründen hier die Name-Eigenschaft im Objektinspektor. Die RichEdit-Komponente (auf der Seite "Win32") ähnelt der Memo-Komponente, ist aber weitaus leistungsfähiger, da sie quasi die Funktionalität eines vollständigen kleinen Textverarbeitungsprogramms zur Verfügung stellt.

16.1 Einsteigerprogramm TEXTVERARBEITUNG

839

Wie Sie sehen, ist auch noch ein ganzes Sammelsurium weiterer Komponenten erforderlich: PopUpMenu, SaveDialog, FontDialog, PrinterSetupDialog, PrintDialog (von links). Zwecks Definition des PopUp-Menüs doppelklicken Sie auf die Komponente und erstellen im Menü-Editor die folgenden Einträge:

Weisen Sie der PopUpMenu-Eigenschaft von Form2 die Komponente PopUpMenu1 zu! Setzen Sie außerdem die FormStyle-Eigenschft auf fsMDIChild. Und noch eine "Kleinigkeit" gilt es zu berücksichtigen: Da wir die Kindfenster (Dokumente) erst zur Laufzeit selbst hinzufügen bzw. entfernen wollen, müssen wir deren automatische Erstellung durch Delphi verhindern. Wählen Sie den Menüpunkt Projekt|Optionen... und verschieben Sie Form2 auf die rechte Seite:

16.1.2 Quelltext des MDI-Rahmenfensters Der Code ist im Handumdrehen erstellt und beschränkt sich auf die Definition von drei EventHandlern. HINWEIS: Um den Rahmencode der Event-Handler zu erhalten, klicken Sie im Entwurfsmodus

auf den entsprechenden Menüeintrag!

840

Kapitel 16

implementation uses Unit2; {$R *.DFM}

Applikationen

// Kindfenster-Unit einbinden!

Ein neues Kindfenster (Dokument) wird erzeugt: procedure TForm1.Neu1Click(Sender: TObject); begin TForm2.Create(Self) end;

// Datei|Neu // Konstruktor aufrufen

procedure TForm1.Oeffnen1Click(Sender: TObject); // Datei|Öffnen begin with OpenDialog1 do begin Filter := 'Text Files (*.txt)|*.txt|Alle Files(*.*)|*.*'; DefaultExt := 'txt'; if Execute then with TForm2.Create(Self) do dateiOeffnen(FileName) end end;

Die Methode dateiOeffnen wird von Unit2 zur Verfügung gestellt. procedure TForm1.Beenden1Click(Sender: TObject); begin Close end;

// Datei|Beenden

16.1.3 Quelltext der MDI-Kindfenster Klassendefinition und anderes Fügen Sie zur Klassendefinition von TForm2 folgende Ergänzungen in den privaten und den öffentlichen Abschnitt ein: private { Private-Deklarationen } pfad: string; // private Variable hinzufügen public { Public-Deklarationen } procedure dateiOeffnen(const dateiName: string); // öffentliche Methode hinzufügen end; var Form2: TForm2;

Wenn Sie ein neues Dokument öffnen, soll in der Titelleiste die Beschriftung "ohne Namen" stehen: const standardFileName = 'ohne Namen';

Nun zum Implementation-Abschnitt: implementation {$R *.DFM}

// Konstante hinzufügen

841

16.1 Einsteigerprogramm TEXTVERARBEITUNG

Neben der Unit des Rahmenfensters (Unit1) werden noch die Units für den Zugriff auf Zwischenablage und Drucker gebraucht: uses Clipbrd, Printers, Unit1;

// Units hinzufügen

Die von uns hinzugefügte Methode muss noch definiert werden: procedure TForm2.dateiOeffnen; begin Pfad := dateiName; Caption := ExtractFileName(dateiName); with RichEdit1 do begin Lines.LoadFromFile(pfad); // Datei => Anzeige SelStart := 0; Modified := False // es wurde noch nichts im Text verändert end end;

Kindfenster laden und schließen Das passiert beim Laden eines Dokuments: procedure TForm2.FormCreate(Sender: TObject); // neues Dokument begin pfad := StandardFileName; SaveDialog1.Filter := 'Text Files (*.txt)|*.txt|Alle Files(*.*)|*.*'; SaveDialog1.DefaultExt := 'txt' end;

Wenn Sie das Dokument schließen, sind OnCloseQuery und OnClose zu besetzen: procedure TForm2.FormCloseQuery(Sender: TObject; var CanClose: Boolean); const warnText = 'Änderungen speichern in %s?'; begin if RichEdit1.Modified then begin case MessageDlg(Format(warnText, [pfad]), mtConfirmation, [mbYes, mbNo, mbCancel], 0) of idYes: Speichern1Click(Self); idCancel: CanClose := False end end end; procedure TForm2.FormClose(Sender: TObject; var Action: TCloseAction); begin Action := caFree // Dokument wird gelöscht end;

842

Kapitel 16

Applikationen

Datei-Menü Das Menü des Rahmenfensters hat nur Bedeutung, wenn kein Dokument geladen ist. Ansonsten ist immer das Menü des aktiven Kindfensters zu sehen. Um die Datei-Event-Handler der Kindfenster zu besetzen, werden einfach die gleichnamigen Methoden des Rahmenfensters aufgerufen: procedure TForm2.Neu1Click(Sender: TObject); begin Form1.Neu1Click(Sender) end;

// Datei|Neu

procedure TForm2.Oeffnen1Click(Sender: TObject); // Datei|Öffnen begin Form1.Oeffnen1Click(Sender) end;

Nicht zu verwechseln mit dem Beenden der Applikation ist das Schließen eines einzelnen Dokuments: procedure TForm2.Schliessen1Click(Sender: TObject); begin Close end;

// Datei|Schließen

Dieser Vorgang löst dann die Ereignisse OnCloseQuery und OnClose aus (siehe oben). Wenden wir uns jetzt dem Speichern zu: procedure TForm2.Speichern1Click(Sender: TObject); // Datei|Speichern begin if pfad = StandardFileName then Speichernals1Click(Sender) // ruft Speichern als Event-Handler auf else begin RichEdit1.Lines.SaveToFile(pfad); // Text => Datei RichEdit1.Modified := False // Dirty-Flag zurücksetzen end end; procedure TForm2.Speichernals1Click(Sender: TObject); // Datei|Speichern als begin SaveDialog1.FileName := pfad; if SaveDialog1.Execute then begin pfad := SaveDialog1.FileName; Caption := ExtractFileName(pfad); Speichern1Click(Sender) // ruft Speichern-Event-Handler auf end end;

Beim Drucken nimmt uns die PrinterSetUpDialog-Komponente die ganze Arbeit ab: procedure TForm2.Druckereinrichten1Click(Sender: TObject); // Datei|Druckereinrichtung begin PrinterSetupDialog1.Execute end; procedure TForm2.Drucken1Click(Sender: TObject);

// Datei|Drucken

843

16.1 Einsteigerprogramm TEXTVERARBEITUNG

begin if PrintDialog1.Execute then RichEdit1.Print(pfad) end;

Das gesamte Programm wird beendet: procedure TForm2.Beenden1Click(Sender: TObject); begin Form1.Beenden1Click(Sender) end;

// Datei|Beenden

Bearbeiten-Menü Nun zur Arbeit mit dem Clipboard-Objekt: procedure TForm2.KopierenClick(Sender: TObject); begin RichEdit1.CopyToClipboard end;

// Bearbeiten|Kopieren

procedure TForm2.AusschneidenClick(Sender: TObject); // Bearbeiten|Ausschneiden begin RichEdit1.CutToClipboard end; procedure TForm2.Loeschen1Click(Sender: TObject); begin RichEdit1.ClearSelection end;

// Bearbeiten|Löschen

procedure TForm2.EinfuegenClick(Sender: TObject); // Bearbeiten|Einfügen begin RichEdit1.PasteFromClipboard end; procedure TForm2.Allesauswaehlen1Click(Sender: TObject); // Bearbeiten|Alle auswählen begin RichEdit1.SelectAll end;

Einige Funktionen des Bearbeiten-Menüs sollen auch über das PopUp-Menü ausführbar sein. Weisen Sie deshalb den PopUp-Einträgen im Objektinspektor die gleichnamigen Methoden des Hauptmenüs zu! Zur Steuerung der Menüanzeige ist ein zusätzlicher Event-Handler erforderlich: procedure TForm2.Bearbeiten1Click(Sender: TObject); // Bearbeiten var HasSelection: Boolean; begin Einfuegen1.Enabled := Clipboard.HasFormat(CF_TEXT); // nur Text kann eingefügt werden! Einfuegen2.Enabled := Einfuegen1.Enabled; // PopUp-Menü! HasSelection := RichEdit1.SelLength > 0; // True, wenn was selektiert ist

844

Kapitel 16

Ausschneiden1.Enabled := HasSelection; Ausschneiden2.Enabled := HasSelection; Kopieren1.Enabled := HasSelection; Kopieren2.Enabled := HasSelection; Loeschen1.Enabled := HasSelection end;

Applikationen

// PopUp-Menü // PopUp-Menü

Zeichen-Menü Nun zum Ausrichten der Zeilen. Die drei Menüeinträge "Links", "Rechts" und "Zentriert" benutzen einen gemeinsamen Event-Handler: procedure TForm2.AusrichtenClick(Sender: TObject); // Zeichen|Links, Rechts, Zentriert begin Links1.Checked := False; // Häkchen zurücksetzen Rechts1.Checked := False; Zentriert1.Checked := False; with Sender as TMenuItem do Checked := True; // Häkchen setzen with RichEdit1.Paragraph do if Links1.Checked then Alignment := taLeftJustify else if Rechts1.Checked then Alignment := taRightJustify else if Zentriert1.Checked then Alignment := taCenter end;

Der Zeilenumbruch: procedure TForm2.Zeilenumbruch1Click(Sender: TObject); begin with RichEdit1 do begin WordWrap := not WordWrap; if WordWrap then ScrollBars := ssVertical else ScrollBars := ssBoth; Zeilenumbruch1.Checked := WordWrap end end;

// Zeichen|Zeilenumbruch

Die Schriftarteinstellungen sind dank der Komplexität des FontDialogs ein Kinderspiel: procedure TForm2.Font1Click(Sender: TObject); // Zeichen|Font... begin FontDialog1.Font := RichEdit1.Font; if FontDialog1.Execute then RichEdit1.SelAttributes.Assign(FontDialog1.Font) end;

845

16.1 Einsteigerprogramm TEXTVERARBEITUNG

Fenster-Menü Zwecks ordentlicher Ausrichtung der Dokumente werden die Methoden Tile und Cascade des Rahmenfensters aufgerufen: procedure TForm2.Neben1Click(Sender: TObject); // Fenster|Nebeneinander begin Form1.Tile end; procedure TForm2.HinterClick(Sender: TObject); begin Form1.Cascade end;

// Fenster|Hintereinander

16.1.4 Programmtest Es hieße Eulen nach Athen zu tragen, wenn wir über den Umgang mit einer Windows-typischen MDI-Applikation viele Worte verlieren würden. Probieren Sie einfach alle Möglichkeiten aus und scheuen Sie sich nicht, auch am Quelltext etwas herumzudoktern:

■ Datenbank erstellen (Laufzeit/Entwurfszeit) ■ Verwendung Table-Objekt, Datenbank-Navigator, BatchMove-Objekt ■ Suchen in Tabellen ■ PageControl-Komponente

846

Kapitel 16

Applikationen

■ Datenimport/Datenexport ■ Zwischenablage

16.2 Grafikprogramm Paint Mit dem nachfolgend vorgestellten Grafikprogramm möchten wir dem Leser die Möglichkeit bieten, (fast) alle im Zusammenhang mit der Grafikprogrammierung auftretenden Fragen zu beantworten.

16.2.1 Allgemeines Das Programm verwendet sowohl die von Delphi zur Verfügung gestellten Grafikobjekte (TCanvas, TBitmap) als auch das Windows-GDI. "Wozu das?", werden Sie fragen. "Laut Handbuch kapseln doch die Delphi-Objekte das GDI!" Das ist auch so weit richtig, doch Borland hat einige Funktionen glatt "vergessen". Was kann eigentlich das Programm? Die Antwort ist schnell gegeben: fast alles, was WindowsPaint kann. Ausnahme: Auf die Unterstützung von DDE und OLE wurde verzichtet, um den Quelltext noch überschaubar zu halten.

Dafür finden Sie eine Raster-, eine wesentlich verbesserte Zoom- sowie ein paar zusätzliche Toolund Grafikfunktionen.

16.2 Grafikprogramm Paint

847

Das Programm wurde unter allen Windows-Versionen getestet. An dieser Stelle jedoch eine kleine Einschränkung: Bei der Bearbeitung von Bildern mit höherer Farbauflösung (>16 Farben) kommt es bei einigen Grafikkarten zu Fehlfunktionen (Umschalten zwischen den Farbpaletten). Wie jedes andere Grafikprogramm benötigt auch PAINT reichlich Arbeitsspeicher. Beispiel: Für eine Grafik mit 1024 x 768 Pixel bei 256 Farben werden satte 1,5 MByte verschwendet (Anzeige-Bitmap und UNDO-Bitmap). Noch ein abschließender Hinweis: Besitzer einer langsamen Grafikkarte und/oder eines "lahmen" Computers sollten das Programm an einigen Stellen anpassen. Dies betrifft z.B. die Scrollbars, statt des OnChange- wäre hier das OnScroll-Event vorzuziehen. Das Bild wird erst wieder aufgebaut, wenn die neue Position erreicht ist. Weiterhin wurde gegenüber der 16-Bit-Variante von Paint auf einen Skizzenmodus verzichtet, gezeichnet wird grundsätzlich auf der Hintergrund-Bitmap (doch dazu später mehr). Und noch etwas: Das Programm erhebt nicht den Anspruch eines High-End-Produkts. Dem Leser steht es frei, das Programm weiterzuentwickeln (diverse Filterfunktionen, Rotation, Paletten).

16.2.2 Ein kurzer Überblick Über die Bedienung des Programms sollen nicht allzu viele Worte verloren werden, einige Funktionen bedürfen jedoch einer kurzen Erläuterung.

Markieren Ziehen Sie mit gedrückter Maustaste einen Rahmen über den gewünschten Bereich. Nach dem Markieren stehen Ihnen weitere Funktionen unter Spezial zur Verfügung: ■ Invertieren ■ Vergrößern 10 % ■ Verkleinern 10 % ■ Spiegeln horizontal ■ Spiegeln vertikal ■ Kopieren Zum Deselektieren klicken Sie außerhalb des markierten Bereichs oder wählen ein anderes Tool.

Freihand Bei gedrückter linker Maustaste wird eine Freihandlinie mit der Vordergrundfarbe gezeichnet. Nehmen Sie die rechte Maustaste, verwendet das Programm die Hintergrundfarbe.

848

Kapitel 16

Applikationen

Linie, Rechteck, Kreis, abgerundetes Rechteck Die Verwendung erfolgt analog der Markierungsfunktion, mit gedrückter linker Maustaste zeichnen Sie die jeweilige Figur. Sie können den Mauscursor auch aus dem Bildbereich hinausbewegen, die abschließende Grafikoperation bezieht sich auf den gesamten Bildbereich (sichtbar oder nicht).

Radiergummi Mit diesem Tool können Sie einen mindestens 8 x 8 Pixel großen Bereich löschen. Vergrößerungen des Zeichenstiftes wirken sich auch auf den Radiergummi aus.

Farbeimer Zum Füllen größerer umrandeter Bereiche können Sie den "Farbeimer" verwenden. Füllfarbe ist immer die aktuelle Vordergrundfarbe.

Spraydose Die Größe des Sprühbereichs wählen Sie über die Stiftbreite, gesprüht wird nur, wenn Sie die Maus bewegen.

Pipette Mit diesem Werkzeug entnehmen Sie eine Farbe aus der Grafik und weisen sie der Vorder- bzw. Hintergrundfarbe zu. Die Vordergrundfarbe wählen Sie mit der linken, die Hintergrundfarbe mit der rechten Maustaste.

Text Zur Ausgabe mehrzeiliger Texte können Sie diese Funktion nutzen. Nach dem Zeichnen des Textbereichs (Rechteck) öffnet sich eine Textbox, in die Sie den gewünschten Text eingeben. Während der Eingabe lassen sich Schriftart und Schriftfarbe verändern. Schließen Sie die Eingabe mit der ESC-Taste ab. Auf die Funktionen Einfügen, Ausschneiden, Kopieren, Alles markieren brauchen wir wohl nicht extra einzugehen, jeder, der Windows kennt, weiß, worum es sich handelt.

Menü Spezial Interessanter ist da schon der Menüpunkt Spezial: Mit Farbtausch können Sie im gesamten Bild eine Farbe mit einer anderen vertauschen.

16.2 Grafikprogramm Paint

849

Wählen Sie die zu verändernde Farbe mit der linken und die gewünschte Farbe mit der rechten Maustaste. Mit Bild aufhellen können Sie z.B. Screenshots für den Druck vorbereiten. Manche Grafiken in diesem Buch wurden auf diese Weise bearbeitet, um eine bessere Darstellung zu erreichen (die Farbe Gelb wird auf den meisten Druckern besser wiedergegeben als Hellgrau). Die Funktionen Invertieren, Spiegeln etc. sind nur verfügbar, wenn ein Bereich markiert ist, dies kann auch die gesamte Zeichnung sein. Der Nutzen der Funktion Vergrößern/Verkleinern ist begrenzt, handelt es sich doch um Pixelgrafiken, die mit zunehmender Vergrößerung an Qualität einbüßen. Die obere Toolbar bietet folgende Möglichkeiten:

Datei Neu Auf die Verwendung der Standard-Dialogbox wurde verzichtet, ein Grafikprogramm braucht eine Preview-Funktion, und die ist nur mit einer eigenen Dialogbox sinnvoll realisierbar.

Haben Sie einen langsamen Computer oder sind die Grafiken sehr groß, können Sie die Vorschaufunktion auch ausschalten.

Zoomfaktor Dieser lässt sich zwischen 1 und 20 einstellen. Im Unterschied zur 16-Bit-Vorgängerversion stehen jetzt auch im Zoom-Modus alle Werkzeuge und Funktionen zur Verfügung.

Raster Eine weitere Programmfunktion ist das Fangraster, dessen Größe Sie frei wählen können. Obwohl das Raster nicht sichtbar ist, werden Linien bzw. Rechtecke in das Raster eingepasst. Auf diese Weise ist das Zeichnen horizontaler und vertikaler Linien bedeutend einfacher möglich.

850

Kapitel 16

Applikationen

Vorder-/Hintergrundfarbe Wie schon erwähnt, soll das Programm kein High-End-Produkt sein, die Farbpalette bleibt deshalb auf 16 Farben eingeschränkt.

Wählen Sie mit der linken bzw. rechten Maustaste die gewünschte Vorder- bzw. Hintergrundgrafik. HINWEIS: Das Fenster müssen Sie nicht schließen, es kann wie eine Toolbox verwendet wer-

den.

Stift/Pinsel Neben der Stiftbreite und -form können Sie den Füllmodus, d.h. den Pinsel, wählen.

Ist die Stiftbreite größer als ein Pixel, können nur durchgehende Linien gezeichnet werden. Leser, die zusätzliche Linienarten implementieren wollen, seien auf die GDI-Funktion LineDDA hingewiesen. Zusammen mit einer CallBack-Funktion sind der Realisierung beliebiger Linienarten/-formen keinerlei Grenzen gesetzt. Zweite Alternative: Sie verwenden die so genannten Geometric Pens.

Schriftart Der Schriftart-Dialog dürfte Ihnen bekannt vorkommen, es handelt sich um den Windows-Standarddialog zur Schriftauswahl

16.2 Grafikprogramm Paint

851

Koordinaten Last but not least die Anzeige der Mauskoordinaten. Im Zoom- bzw. Raster-Modus werden die für die Zeichenoperation verwendeten Koordinaten, d.h. die Fangpunkte, angezeigt. Die obigen Ausführungen zur Bedienung sollten ausreichen, wir können uns nun den "inneren" Werten des Programms zuwenden.

16.2.3 Aufbau/Programmierung Grundprinzip Ausgehend von vier wesentlichen Forderungen soll das Grundkonzept des Programms erläutert werden: ■ Realisierung einer Zoomfunktion ■ Undo-Funktion ■ schnelle Darstellung ■ minimaler Ressourcenbedarf Ein Blick in die Hilfe bzw. die Toolbar von Delphi zeigt zwei Alternativen: ■ Image-Komponente ■ PaintBox-Komponente Beide verfügen über das gewünschte Canvas-Objekt, auf dem Grafikausgaben vorgenommen werden können. Wenn Sie das Grafik-Beispielprogramm zu Delphi ausprobieren, werden Sie feststellen, dass dort eine Image-Komponente Verwendung findet. Dies wäre sicherlich der einfachste

852

Kapitel 16

Applikationen

und schnellste Weg, unsere obigen Forderungen lassen sich damit jedoch nicht oder nur sehr umständlich erfüllen. Zwangsläufig müssen wir uns also der PaintBox-Komponente zuwenden. Der wohl wesentlichste Unterschied zwischen beiden Komponenten betrifft das Wiederherstellen des Inhalts nach dem Verdecken durch ein anderes Fenster. Die Image-Komponente kümmert sich selbst um die Wiederherstellung des Inhalts (Grafik wird automatisch im Hintergrund gespeichert), bei der PaintBox-Komponente müssen wir dafür selbst sorgen. Was sich zunächst wie ein Nachteil anhört, hat auch seine Vorteile: Grafikoperationen in einer PaintBox sind wesentlich schneller als in einem Image. Stellen Sie sich vor, die bearbeitete Grafik ist größer als die Bildschirmauflösung. Sie müssten eine ScrollBox-Komponente verwenden, um das Image überhaupt darstellen zu können. Verwenden wir eine PaintBox, so ist der dargestellte Bereich gleich der Größe der PaintBox. Zum Wiederherstellen des Bildinhaltes nehmen wir eine Hintergrund-Bitmap vom Typ TBitmap. Die Arbeit mit der Hintergrund-Bitmap hat mehrere Vorteile. Wir können selbst darüber entscheiden, wann, wo und vor allem wie die Hintergrund-Bitmap eingeblendet wird. Wann bedeutet, dass dies nach der erfolgten Zeichenoperation im Hintergrund passieren muss. Für Scroll-Operationen können wir den sichtbaren Ausschnitt verschieben, zusätzlich lässt sich auch ein Zoomfaktor einführen, d.h., der Hintergrund liegt in Originalgröße vor, und der sichtbare Vordergrundausschnitt ist eine Vergrößerung der Hintergrund-Bitmap. Dreh- und Angelpunkt dieser Operationen sind zwei GDI-Funktionen: Kopieren mit BitBlt

Ausschnitt sichtbarer Bereich Hintergrundbitmap

BitBlt ermöglicht das einfache Kopieren von Bitmaps zwischen zwei DCs und ist entsprechend schnell, mit StretchBlt lassen sich auch Skalierungsoperationen durchführen. Kopieren mit StretchtBlt

Ausschnitt

sichtbarer Bereich Hintergrundbitmap

16.2 Grafikprogramm Paint

853

Skalieren bedeutet natürlich auch Geschwindigkeitsverlust, moderne Grafikkarten entlasten jedoch den Systemprozessor von derartigen Routineaufgaben. Mit der StretchBlt-Funktion ist es darüber hinaus auch möglich, eine Bitmap horizontal bzw. vertikal zu spiegeln. Die Umsetzung finden Sie ebenfalls im Listing. Beide GDI-Funktionen sind natürlich auch Methoden des Canvas-Objekts (Draw, StretchDraw). Aus Performance-Gründen arbeiten wir jedoch direkt mit den GDI-Funktionen. HINWEIS: Alle Zeichenoperationen im Programm werden grundsätzlich an der Hintergrund-

Bitmap ausgeführt (das gilt insbesondere für den Zoom-Modus), die danach mit StretchBlt in die PaintBox kopiert wird. Bei lahmen Grafikkarten führt dies zu einem extrem langsamen Bildaufbau. Da Beschleunigerkarten mittlerweile zur Standardausstattung gehören, dürfte die Performance jedoch in den meisten Fällen völlig ausreichen. Der Vorteil dieses Verfahrens: Sie können auch im Zoom-Modus alle Grafikoperationen ausführen und sehen direkt das Ergebnis.

Oberfläche Die Abbildung zeigt die Entwurfsansicht des Hauptfensters. Neben diversen Speed-Buttons finden Sie auch die Standarddialoge zum Sichern, Laden sowie für die Wahl der Schriftart.

Sowohl die Werte für die Zoomdarstellung als auch die Rastergröße können über ComboBoxen bestimmt werden. An dieser Stelle ein kleiner Hinweis zur Menügestaltung: Der Menüpunkt Einfügen soll nur dann aktiv sein, wenn sich eine Bitmap in der Zwischenablage befindet. Fügen Sie dazu in das OnClickEvent des übergeordneten Menüpunktes, d.h. Bearbeiten, folgenden Code ein: if Clipboard.HasFormat(CF_BITMAP) then einfgen1.enabled := true else einfgen1.enabled := false;

854

Kapitel 16

Applikationen

Ansonsten ist zur Oberflächengestaltung des Hauptfensters nichts weiter zu sagen. Dafür kommen wir noch kurz auf ein anderes interessantes Detail zu sprechen: die ComboBox-Komponente mit grafischem Inhalt. Wir werden diesen Typ dazu befähigen, verschiedene Linienarten bzw. Stiftbreiten anzuzeigen.

Grafiken in der ComboBox Das Erstellen von Combo- bzw. Listboxen mit grafischem Inhalt weist einige Besonderheiten auf.

Wichtig ist vor allem, dass Sie die Style-Eigenschaft auf csOwnerDrawFixed festlegen. Gegebenenfalls können Sie noch die Zellenhöhe mit ItemHeight verändern. Während der Laufzeit wird die Listbox über das OnDrawItem-Event mit Grafiken gefüllt. Dieses Ereignis fordert, je nach Bedarf, das Zeichnen einer bestimmten Zelle an. Es kann zum Beispiel durch Scrollen ausgelöst werden. Ihre Aufgabe besteht nun darin, die Grafiken in die Listbox einzublenden. Die Komponente stellt zu diesem Zweck ein Canvas-Objekt sowie die Abmessungen der aktuellen Zelle zur Verfügung. BEISPIEL: Anzeige verschiedener Stiftbreiten procedure TForm5.stiftbreiteDrawItem(Control: TWinControl; Index: Integer; Rect: TRect; State: TOwnerDrawState); var xofs,yofs,breite:integer; begin breite := Rect.right - Rect.left - 20; xofs := Rect.left + 10; yofs := Rect.top; stiftbreite.Canvas.fillrect(Rect); stiftbreite.Canvas.pen.width := index + 1; stiftbreite.Canvas.moveto(xofs,yofs+14); stiftbreite.Canvas.lineto(xofs+breite,yofs+14) end;

Sollen komplexere Grafiken dargestellt werden, ist es sinnvoll, diese in einer TBitmap- oder ImageList-Komponente zwischenzuspeichern.

Quelltext Statt eines vollständigen Listings (rund 1000 Zeilen), das Sie ohnehin auf der Buch-CD finden, werden nur einige Funktionen bzw. Methoden aus den Units Unit1 und Werkzeug vorgestellt. Soll-

855

16.2 Grafikprogramm Paint

ten Sie bei der Fülle der Funktionen und Aufgaben den Überblick verlieren, können Sie das Zusammenwirken am sinnvollsten mit dem Debugger nachvollziehen. Einige Funktionen werden Sie auch in Praxisbeispielen wiederfinden, das vorliegende Programm fasst diese zusammen und demonstriert das Zusammenspiel. Ein wichtiger Grundsatz bei der Programmierung lautet: "... möglichst wenige globale Variablen!" Auch unser Programm versucht dem gerecht zu werden, gänzlich konnten wir jedoch nicht darauf verzichten. Der Interface-Abschnitt der Werkzeug-Unit: const crLinie = crHand = crKreis = crRechteck = crEimer = crSpray = crFreihand = crText = crPipette = crSchere = crRndRect = crRadiergummi

1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; = 12;

type tooltype = (freihand,linie,kreis,rechteck,pipette,farbeimer,spray,Rndrect, radiergummi,schere,gtext); bildtype = record dateiname : string; xa,ya, xe,ye, zoom, raster : integer; tool : tooltype; aenderung, move, einf : boolean; left,top, offsetx, offsety : integer; {Einfügevorgang} pen : TPen; brush : TBrush; font : TFont; end; var bild : bildtype; bitmap,undobitmap : TBitmap; xa,ya, xe,ye : integer; clipbit : TBitmap;

856

Kapitel 16

stringvariable hg,vg

Applikationen

: string; : Tcolor;

procedure spraydose(x,y:integer;c:tcanvas); procedure uebernahme; procedure bitmapaufhellen(var b : TBitmap); procedure auswahlcursor; procedure bildloeschen(var b:TBitmap); function ja(t:pchar): boolean; function nein(t:pchar): boolean; procedure UndoVorbereiten; procedure zeigeClipbit(x,y:integer); function MouseInRect(x,y,x1,y1,x2,y2: Integer): Boolean; function min(x1,x2: Integer): Integer;

Die Variable Bild enthält alle Verwaltungsinformationen inklusive Stift-, Pinsel- und Font-Attribute. Wenn Sie derartige Objektvariablen verwenden, dürfen Sie nicht vergessen, diese mit der Methode Create zu initialisieren. Greifen Sie auf ein Objekt zu, das nicht initialisiert ist, kommt es zum Laufzeitfehler. In der obigen Auflistung finden Sie eine ganze Reihe von Konstanten, die mit cr anfangen. Diese Konstanten brauchen wir für die Auswahl des aktuellen Mauszeigers. Sollten Sie das Programm bereits getestet haben, wird Ihnen sicher aufgefallen sein, dass reger Gebrauch von selbst definierten Mauszeigern gemacht wurde. Diese finden Sie in der Ressourcen-Datei CURSOR.RES wieder. Bevor Sie sich der Mühe unterziehen, eigene Mauszeiger zu entwerfen, sollten Sie einmal diverse EXE- und DLL-Dateien auf Ihrer Festplatte mit einem Ressourcen-Editor untersuchen. Im Verzeichnis \\Tools\Cursors auf der Buch-CD finden Sie weitere gängige Mauszeiger. Das Einbinden der Ressourcen-Datei: {$R CURSORS.RES}

Wie schon erwähnt, müssen Pen-, Brush-Objekte vor dem ersten Zugriff initialisiert werden. Dazu bietet sich im Allgemeinen der Begin-End-Teil jeder Unit an, da dieser noch vor dem ersten Create oder Resize ausgeführt wird. begin with bild do begin pen brush font pen.width pen.color pen.style brush.color brush.style zoom dateiname raster tool

:= := := := := := := := := := := :=

TPen.Create; TBrush.Create; TFont.Create; 1; clBlack; psSolid; clWhite; bsClear; 1; ''; 1; freihand;

857

16.2 Grafikprogramm Paint

aenderung move

:= false; := false;

end;

Unsere Mauszeiger laden wir über die jeweils zugewiesenen Nummern, Sie können auch Bezeichner vergeben, verzichten Sie aber in diesem Fall auf die Funktion makeIntResource. screen.cursors[crLinie]:=LoadCursor(HINSTANCE,makeintresource(133)); ... screen.cursors[crText]:=LoadCursor(HINSTANCE,makeintresource(104)); end.

Nun wollen wir uns dem eigentlichen Programm, der Unit1 zuwenden. Als Erstes erstellen wir die Hintergrund-Bitmap sowie die zugehörige Undo-Bitmap. Vor jedem MouseDown wird der Inhalt von Bitmap in UndoBitmap kopiert, auf diese Weise lässt sich die jeweils letzte Aktion rückgängig machen. Allerdings ist dieses Verfahren relativ speicherplatzintensiv. procedure THauptformular.FormShow(Sender: TObject); begin application.processMessages; Bitmap := graphics.TBitmap.Create; Bitmap.height := 768; Bitmap.width := 1024; zoom.itemindex := 0; blatt.cursor := crFreihand; gitter.itemindex := 0; undobitmap := graphics.TBitmap.Create; undobitmap.width := bitmap.width; undobitmap.height := bitmap.height end;

Das Öffnen des Formulars löst ebenfalls das FormResize-Ereignis aus. Neben dem Positionieren der Scrollbars müssen wir uns um die PaintBox kümmern. Zwei wesentliche Fälle sind zu unterscheiden: ■ Kann die Grafik komplett dargestellt werden? ■ Benötigen wir die Scrollbars, um den sichtbaren Ausschnitt zu verschieben? Wichtig ist an dieser Stelle die Verwendung des Zoomfaktors. procedure THauptformular.FormResize(Sender: TObject); begin anzeige.left := Hauptformular.clientwidth - anzeige.width - 5; hscroll.top := Hauptformular.clientheight - 17; hscroll.width := Hauptformular.clientwidth - 47; vscroll.left := Hauptformular.clientwidth - 17; vscroll.height := Hauptformular.clientheight - 47; if (bitmap.width * bild.zoom) > (Hauptformular.clientwidth - 48) then begin blatt.width := ((Hauptformular.clientwidth-48) div bild.zoom)*bild.zoom; hscroll.enabled := true; hscroll.max := bitmap.width - blatt.width div bild.zoom;

858

Kapitel 16

Applikationen

end else begin blatt.width := bitmap.width * bild.zoom; hscroll.enabled := false; hscroll.position:= 0; end; if (bitmap.height * bild.zoom) > (Hauptformular.clientheight - 48) then begin blatt.height:=((Hauptformular.clientheight-48) div bild.zoom )*bild.zoom; vscroll.enabled := true; vscroll.max := bitmap.height - blatt.height div bild.zoom; end else begin blatt.height := bitmap.height * bild.zoom; vscroll.enabled := false; vscroll.Position:= 0; end; end;

Auf Änderungen (Skalieren, Verdecken etc.) an der PaintBox können Sie mit dem OnPaint-Event reagieren. procedure THauptformular.blattPaint(Sender: TObject); var x,y,xofs,yofs,z:integer; begin if bild.einf then uebernahme; stretchBlt(blatt.canvas.handle, 0, 0, blatt.clientwidth ,blatt.clientheight, bitmap.canvas.handle,hscroll.position , vscroll.position, blatt.clientwidth div bild.zoom, blatt.clientheight div bild.zoom, SRCCOPY);

Falls das Raster angezeigt werden muss: if (speedbutton9.down)and(bild.raster >= 10)and(bild.zoom = 1) then begin x := bild.raster; y := bild.raster; while x < blatt.width do begin while y < blatt.height do begin setpixel(blatt.canvas.handle,x,y,clblack); inc(y, bild.raster); end; y := bild.raster; inc(x,bild.raster); end; end;

Im Zoom-Modus 20 werden die einzelnen Pixel durch ein Bildschirmgitter dargestellt. Auf diese Weise ist ein präziseres Arbeiten möglich. if (bild.zoom = 20) then gitteranzeigen;

16.2 Grafikprogramm Paint

859

Zur besseren Übersicht kann ebenfalls eine Übersicht im Preview-Formular angezeigt werden. Dazu muss lediglich der Ausschnitt der Hintergrund-Bitmap in das betreffende Formular kopiert werden. if Preview.showing then begin z := bild.zoom; if z > 4 then z := 4; BitBlt(Preview.paintbox1.canvas.handle, 0, 0, Preview.paintbox1.clientwidth, Preview.paintbox1.clientheight, bitmap.canvas.handle,hscroll.position,vscroll.position,SRCCOPY); Preview.paintbox1.canvas.brush.style:=bsclear; Preview.paintbox1.canvas.pen.style:=psdot; Preview.paintbox1.canvas.rectangle(0, 0, blatt.clientwidth div bild.zoom, blatt.clientheight div bild.zoom) end end;

Nach den oben genannten Prozeduren/Funktionen erscheint das Fenster fertig aufgebaut und skaliert, die (noch) leere Bitmap (1024 x 768) ist dargestellt. Unser Programm soll jedoch nicht nur eine leere Bitmap anzeigen, sondern auch das Bearbeiten zulassen. Dazu benötigen wir verschiedene Tools, die über die linke Werkzeugleiste bereitgestellt werden. Durch einen Mausklick auf die gewünschte Funktion soll sich der Bearbeitungsmodus (und damit der Mauszeiger) ändern: procedure TForm1.tool_schereClick(Sender: TObject); begin if Sender = tool_Schere then bild.tool := Schere; if Sender = tool_Freihand then bild.tool := Freihand; if Sender = tool_Linie then bild.tool := Linie; if Sender = tool_Kreis then bild.tool := Kreis; if Sender = tool_Rechteck then bild.tool := Rechteck; if Sender = tool_RndRect then bild.tool := Rndrect; if Sender = tool_Pipette then bild.tool := Pipette; if Sender = tool_Eimer then bild.tool := Farbeimer; if Sender = tool_Spray then bild.tool := Spray; if Sender = tool_Radiergummi then bild.tool := Radiergummi; if Sender = tool_gText then bild.tool := gText; auswahlCursor end;

Greifen, wie in unserem Fall, mehrere Komponenten auf eine Ereignisprozedur zu, können Sie über das Sender-Objekt die auslösende Komponente identifizieren oder sogar auf deren Eigenschaften und Methoden zugreifen. Die eigentliche Entscheidung, was zu tun ist, treffen wir im MouseDown-Ereignis. Alle weiteren Aktionen werden nur in der Hintergrund-Bitmap ausgeführt. procedure THauptformular.blattMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);

860

Kapitel 16

Applikationen

begin bild.aenderung := True;

Genau hier müssen wir unterscheiden, ob es sich um einen Einfügevorgang (markierter Bereich ist aktiv) oder nur um eine normale Zeichenaktion handelt. Haben wir es mit einer Einfügeoperation zu tun, wird die Grafik aus dem Zwischenspeicher (ClipBit, es handelt sich nicht um den UndoSpeicher!) auf dem Bildschirm eingeblendet. Klickt der Anwender außerhalb des markierten Bereichs oder mit der rechten Maustaste, soll die Grafik endgültig übernommen werden (Hintergrund-Bitmap), sonst ändert sich lediglich der Mauscursor (Bewegen). if bild.einf then begin { Einfügevorgang weiterführen } zeigeclipbit(bild.left,bild.top); if (button = mbleft)and MouseInRect(x, y, bild.left, bild.top, bild.left+clipbit.width*bild.zoom, bild.top+clipbit.height*bild.zoom) then begin screen.cursor:=CrSize; bild.offsetx:=hscroll.position + x; bild.offsety:=vscroll.position + y; exit; end else uebernahme end;

Bevor wir Aktionen ausführen, ist die aktuelle Hintergrund-Bitmap in der Undo-Bitmap zu sichern: UndoVorbereiten;

Die weiteren Anweisungen initialisieren die Zeichenfläche sowie die Hintergrund-Bitmap (Stifte, Pinsel etc.): bitmap.canvas.pen:=bild.pen; bitmap.canvas.brush:= bild.brush; bitmap.canvas.font:= bild.font; if (bild.zoom = 1)and(bild.tool<>farbeimer) then begin

Die vom Event zur Verfügung gestellten Koordinaten können wir nur verwenden, wenn die Rastergröße auf eins eingestellt ist. In allen anderen Fällen runden wir die Mausposition auf ein Vielfaches der Rastergröße: bild.xa := round((hscroll.position + trunc(X / bild.zoom))/bild.raster)*bild.raster; bild.ya := round((vscroll.position + trunc(Y / bild.zoom))/bild.raster)*bild.raster; end else begin bild.xa := hscroll.position + trunc(X / bild.zoom); bild.ya := vscroll.position + trunc(Y / bild.zoom); end; bild.xe := bild.xa;bild.ye := bild.ya;

Einige Tools erfordern besondere Einstellungen: if bild.tool in [freihand,radiergummi,spray] then bitmap.canvas.pen.mode := pmCopy

16.2 Grafikprogramm Paint

else bitmap.canvas.pen.mode := pmNotXor; case bild.tool of pipette : if (button = mbleft) then begin vordergrund.brush.color:= blatt.canvas.pixels[x,y]; bild.pen.color:=blatt.canvas.pixels[x,y] end else begin hintergrund.brush.color:=blatt.canvas.pixels[x,y]; bild.brush.color:= blatt.canvas.pixels[x,y] end; radiergummi : begin blatt.canvas.pen.color := bild.brush.color; bitmap.canvas.pen.color := bild.brush.color; if bild.pen.width < 8 then begin blatt.canvas.pen.width := 8; bitmap.canvas.pen.width := 8; end; blatt.canvas.pen.width := blatt.canvas.pen.width* bild.zoom; blatt.canvas.moveto(xa,ya); blatt.canvas.pen.mode := pmCopy; end; schere : with bitmap.canvas do begin pen.style := psDot; brush.style:= bsclear; pen.color:= clblack; pen.width := 1; end; freihand : if (button = mbright) then bitmap.canvas.pen.color := bild.brush.color; gText : begin if editor = NIL then Application.CreateForm(TEditor, Editor); editor.showmodal end; end end;

Jede weitere Mausbewegung löst das folgende Event aus: procedure THauptformular.blattMouseMove(Sender: TObject; Shift:TShiftState; X,Y: Integer); var dx,dy:integer; r1,rold : THandle; begin

Wie schon beim MouseDown-Ereignis müssen wir den Einfügemodus getrennt behandeln: if (bild.einf)and (shift = [ssLeft]) then begin bild.move := true;

861

862

Kapitel 16

Applikationen

dx :=(x + hscroll.position) - bild.offsetx; dy :=(y + vscroll.position) - bild.offsety;

Wiederherstellen des Hintergrundes: ExcludeClipRect(blatt.canvas.handle,bild.left+1,bild.top+1, bild.left+clipbit.width* bild.zoom -1, bild.top+clipbit.height*bild.zoom-1); stretchBlt(blatt.canvas.handle, 0, 0, blatt.clientwidth, blatt.clientheight, bitmap.canvas.handle,hscroll.position, vscroll.position, blatt.clientwidth div bild.zoom, blatt.clientheight div bild.zoom, SRCCOPY); r1 := CreateRectRgnIndirect(blatt.boundsrect); selectobject(blatt.canvas.handle,r1);

Mit Hilfe der Region stellen wir sicher, dass nur der unbedingt nötige Bereich wiederhergestellt wird. Wie es nicht gemacht werden sollte, können Sie sich beim Windows Paint-Programm ansehen (Verschiebeoperationen sind viel zu langsam). Festlegen der neuen Position bild.left:=bild.left+dx; bild.top :=bild.top+dy; bild.offsetx:=hscroll.position+x; bild.offsety:=vscroll.position+y;

und erneutes Einblenden: zeigeclipbit(bild.left,bild.top); Exit; end;

Bisher haben wir die Koordinatenanzeige in der rechten oberen Ecke etwas vernachlässigt, das wollen wir nun ändern: if bild.zoom = 1 then begin x := round(x / bild.raster) * bild.raster; y := round(y / bild.raster) * bild.raster; end; bild.xe:= hscroll.position + X div bild.zoom; bild.ye:= vscroll.position + Y div bild.zoom; anzeige.caption := Format('%d : %d',[bild.xe,bild.ye]); if not ((shift = [ssRight]) or (shift = [ssLeft])) then exit;

Je nach gewähltem Werkzeug löscht der erste Aufruf der Prozedur zeichne bisherige XOR-Zeichnungen (z.B. Linie, Kreis etc.) oder zeichnet neu (Spray, Freihand). zeichne; blatt.onpaint(self); if bild.tool in [freihand,radiergummi,spray] then begin bild.xa := bild.xe; bild.ya := bild.ye; end else zeichne;

863

16.2 Grafikprogramm Paint

Der zweite Aufruf von zeichne ist für alle XOR-Zeichenoperationen gedacht. Die Prozedur zeichne (Herzstück des Programms): procedure Zeichne; var farbe,help :TColor; r : integer; b : integer; s : Tbrushstyle; begin with bitmap.canvas do begin case bild.tool of Linie, Freihand, Radiergummi : begin moveto(bild.xa,bild.ya); lineto(bild.xe,bild.ye); if pen.width = 1 then pixels[bild.xe,bild.ye]:= pen.color else begin r := pen.width div 2; s := brush.style; b := pen.width; farbe :=brush.color; pen.width := 1; brush.style := bsSolid; brush.color := pen.color; if bild.tool = radiergummi then rectangle(bild.xe-r,bild.ye-r,bild.xe+r,bild.ye+r) else ellipse(bild.xe-r,bild.ye-r,bild.xe+r,bild.ye+r); pen.width := b; brush.style := s; brush.color := farbe; end; end; Schere, Rechteck : Rectangle(bild.xa,bild.ya,bild.xe,bild.ye); RndRect : RoundRect(bild.xa,bild.ya,bild.xe,bild.ye, abs(bild.xa-bild.xe) div 4,abs(bild.ya-bild.ye) div 4); kreis : Ellipse(bild.xa,bild.ya,bild.xe,bild.ye); spray : Spraydose(bild.xe,bild.ye,bitmap.canvas);

Für den Farbeimer müssen wir kurzzeitig die Hintergrundfarbe tauschen: farbeimer

: begin screen.cursor:=CrHourglass; help :=brush.color; brush.color:=bild.pen.color; farbe:=pixels[bild.xa,bild.ya];

864

Kapitel 16

Applikationen

floodfill(bild.xa,bild.ya,farbe,fssurface); brush.color:=help; screen.cursor:=CrDefault; end; end; end; end;

Sicher fällt Ihnen der Aufwand für die Ausgabe von Linien auf. Hierbei handelt es sich allerdings um ein ganz trauriges Kapitel: Die LineTo-Funktion/Methode lässt den letzten Punkt der Linie einfach weg! Das wäre nicht weiter schlimm, wenn es eine Funktion zum Zeichnen eines Punktes mit dem aktuellen Stift geben würde (Ersatz: siehe oben). Wenn der Anwender die Zeichenoperation abschließen will, muss er die Maustaste loslassen. Für das Programm bedeutet dies, dass vom XOR-Modus in den normalen Zeichenmodus zurückgeschaltet werden muss. procedure THauptformular.blattMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin if bild.einf then begin zeigeClipbit(bild.left,bild.top); screen.cursor:= crDefault; exit; end; if (bild.zoom = 1) then begin x := round(x / bild.raster) * bild.raster; y := round(y / bild.raster) * bild.raster; end; bild.xe := hscroll.position + trunc(X / bild.zoom); bild.ye := vscroll.position + trunc(Y / bild.zoom); bitmap.canvas.pen.mode := pmCopy; if bild.tool <> schere then zeichne; blatt.onpaint(Hauptformular);

Für die Markierungsfunktion (Schere) bedeutet das Loslassen der Maustaste, dass der markierte Bereich in die Zwischen-Bitmap (clipBit) übernommen wird. if bild.tool = Schere then begin clipbit:= graphics.TBitmap.Create; clipbit.width:=abs(bild.xe-bild.xa); clipbit.height:=abs(bild.ye-bild.ya); bild.einf:=true; BitBlt(clipbit.canvas.handle, 0, 0, clipbit.width ,clipbit.height, bitmap.canvas.handle,min(bild.xa,bild.xe),min(bild.ya,bild.ye), SRCCOPY); bild.left := (min(bild.xa,bild.xe) - hscroll.position) * bild.zoom; bild.top := (min(bild.ya,bild.ye) - vscroll.position) * bild.zoom; bitmap.canvas.brush.style := bssolid; bitmap.Canvas.FillRect(Bounds(min(bild.xa,bild.xe), min(bild.ya,bild.ye),clipbit.width ,clipbit.height)); zeigeClipbit(bild.left,bild.top); end;

16.2 Grafikprogramm Paint

Einfügen einer neuen Bitmap aus der Zwischenablage: procedure THauptformular.NeuausZwischenablage1Click(Sender: TObject); begin if bild.einf then uebernahme;

Sollte nicht das richtige Format vorhanden sein, beenden wir gleich wieder: if not Clipboard.HasFormat(CF_BITMAP) then exit; if bild.aenderung and ja('Möchten Sie die Änderungen speichern?') then begin if (bild.dateiname = '') and (savedialog1.execute) then bild.dateiname := savedialog1.filename; if bild.dateiname <> '' then bitmap.savetofile(bild.dateiname); bild.aenderung := false; end; screen.cursor := crHourglass;

Der eigentliche Einfügevorgang: Bitmap:= graphics.TBitmap.Create; Bitmap.Assign(Clipboard);

Undo-Bitmap ebenfalls neu zuweisen: undobitmap.width := bitmap.width; undobitmap.height := bitmap.height; BitBlt(undobitmap.canvas.handle, 0, 0, bitmap.width, bitmap.height, bitmap.canvas.handle,0,0, SRCCOPY); bild.aenderung := true; bild.dateiname := ''; formResize(self); blatt.onpaint(self); screen.cursor := crDefault end;

Kopieren in die Zwischenablage: procedure THauptformular.Kopieren2Click(Sender: TObject); begin if bild.einf then clipboard.assign(clipbit); end;

Zum Invertieren des markierten Bereichs verwenden wir die Funktion BitBlt: procedure THauptformular.Invertieren1Click(Sender: TObject); begin if not bild.einf then exit; BitBlt(clipbit.canvas.handle,0,0,clipbit.width ,clipbit.height, clipbit.canvas.handle,0,0, DSTINVERT); zeigeclipbit(bild.left,bild.top) end;

865

866

Kapitel 16

Applikationen

Die Bitmap horizontal spiegeln: procedure THauptformular.Spiegelnhorizontal1Click(Sender: TObject); begin if not bild.einf then exit; StretchBlt(clipbit.canvas.handle,0,0, clipbit.width, clipbit.height, clipbit.canvas.handle, clipbit.width-1, 0, -(clipbit.width ), clipbit.height, SRCCOPY); zeigeclipbit(bild.left,bild.top) end;

Für das Auswerten der Tastaturereignisse verwenden wir den KeyDown-Event (die Eigenschaft KeyPreview des Formulars ist True): procedure THauptformular.FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState); var old : TPoint; x,y,n : integer; begin if bild.tool = gText then exit;

Sollen mit Hilfe der Tastatur (Cursortasten) Mausbewegungen simuliert werden, bietet sich die folgende Variante an: if key in [37,38,39,40] then begin getcursorpos(old);

Ist die Shift-Taste zusätzlich gedrückt, wird die Position um acht statt um einen Pixel inkrementiert: if shift = [ssShift] then n := 8 else n := 1; x := old.x; y := old.y; case key of 37 : dec(x,n); 38 : dec(y,n); 39 : inc(x,n); 40 : inc(y,n); end;

Die Veränderung der Mausposition (das löst natürlich auch ein MouseMove aus): setCursorpos(x,y); key := 0 end end;

Das war es eigentlich schon, der Rest ist einfaches Handwerkszeug.

Performance Neben der Stabilität ist die Performance das wesentliche Kriterium für die Leistungsfähigkeit eines Programms. Dass Delphi diesbezüglich an einigen Stellen Nachholbedarf hat, dürfte Ihnen sicher

16.2 Grafikprogramm Paint

867

schon aufgefallen sein. Da es sich bei unserer Applikation um ein Grafikprogramm handelt, wird unser spezielles Interesse den Grafikobjekten von Delphi gelten. Ein Blick in die Graphics-Unit bestätigt leider all unsere Befürchtungen: Mit der Methode Rectangle wird nicht etwa nur die GDIFunktion Rectangle aufgerufen, sondern auch noch reichlich "Verwaltungscode": procedure TCanvas.Rectangle(X1, Y1, X2, Y2: Integer); begin Changing; RequiredState([csHandleValid, csBrushValid, csPenValid]); Windows.Rectangle(FHandle, X1, Y1, X2, Y2); Changed end; procedure TCanvas.Changing; begin if Assigned(FOnChanging) then FOnChanging(Self) end; procedure TCanvas.Changed; begin if Assigned(FOnChange) then FOnChange(Self) end; procedure TCanvas.RequiredState(ReqState: TCanvasState); var NeededState: TCanvasState; begin NeededState := ReqState - State; if NeededState <> [] then begin if csHandleValid in NeededState then begin CreateHandle; if FHandle = 0 then raise EInvalidOperation.Create(SNoCanvasHandle) end; if csFontValid in NeededState then CreateFont; if csPenValid in NeededState then begin CreatePen; if Pen.Style in [psDash, psDot, psDashDot, psDashDotDot] then Include(NeededState, csBrushValid) end; if csBrushValid in NeededState then CreateBrush; State := State + NeededState end end;

Die markierte Zeile ist der eigentliche API-Funktionsaufruf, alles andere ist funktioneller Overhead. "Erschreckend ...", könnte man meinen. Die Begründung für dieses Vorgehen ist jedoch schnell gefunden: Programmierkomfort und Sicherheit müssen immer mit Ausführungs-

868

Kapitel 16

Applikationen

geschwindigkeit erkauft werden. Beispielsweise testet die Methode RequiredState diverse Voreinstellungen ab, um Programmfehler zu vermeiden. Warum wir z.B. bei der Spray-Funktion mit GDI-Aufrufen arbeiten, dürfte Ihnen nach obigen Ausführungen klar geworden sein. Bevor ein einzelnes Pixel gesetzt wird, testet Delphi jedes Mal die korrekte Initialisierung. Bei sauberer Programmierung können wir jedoch davon ausgehen, dass dies schon erfolgt ist. Da wir mit dem Einblenden der Hintergrund-Bitmap via StrechtBlt schon genügend Zeit verschwenden, sollten wir wenigstens hier mit jeder Millisekunde geizen. Die gemischte Verwendung von GDI- und Delphi-Objekten bereitet keine Schwierigkeiten, solange Sie nicht Änderungen an GDI-Objekten vornehmen, d.h., Sie erstellen neue Stifte oder Pinsel bzw. Sie kommen gar auf die Idee, Objekte zu löschen. Wer bisher mit Visual Basic gearbeitet hat, dürfte schon ähnliche Erfahrungen gemacht haben. Der Grund für diese Einschränkung findet sich in der internen Verwaltung der Grafikobjekte. Diese speichern zusätzliche Informationen beim Erstellen von Objekten ab, um diese beim Programmende wieder zu zerstören. Greifen Sie über direkte Programmierung in diesen Mechanismus ein, kann es zu Fehlfunktionen kommen.

Erweiterungen Wie Sie sicher schon festgestellt haben, sind einige Programmfunktionen verbesserungswürdig bzw. bedürfen noch der Implementierung. Einige Anregungen: ■ schnelleres Scrollen (nur der unbedingt erforderliche Teil der Grafik soll neu angezeigt werden) ■ Verbesserungen beim Verschieben des markierten Bereichs (Flimmern!) ■ Unterstützung verschiedener Pinsel- bzw. Stiftformen ■ Rotieren von Bitmaps (mit PlgBlt) ■ weitere Grafikformate ...

16.3 Funktionsplotter FMASTER Wer hatte nicht schon einmal das Problem, einen mathematischen Ausdruck grafisch auszuwerten, um sich eine Vorstellung vom Funktionsverlauf zu machen, oder haben Sie eine Ahnung, wie die Funktion

aussieht? Eine Berechnung "zu Fuß" dürfte sich im Computerzeitalter von selbst verbieten. Was liegt also näher, als dafür ein Delphi-Programm zu schreiben?

16.3 Funktionsplotter FMASTER

869

16.3.1 Allgemeines Die vorliegende Applikation erlaubt die Darstellung bzw. den Druck nahezu beliebiger Funktionen der Form y = f(x) für reelle x.1

16.3.2 Bedienung Menü und Operatoren In der Menüleiste finden Sie folgende Tools: Tool

Beschreibung/Funktion

Aufruf Formeleditor Zoomfunktion Grafik erneut berechnen bzw. Anzeigeformat verändern Programm beenden Folgende Funktionen bzw. Operatoren werden durch das Programm unterstützt:

1

Wie immer gilt auch hier: Wertebereich beachten! (Double)

870

Kapitel 16

Funktion

Beschreibung

+-*/^

Addition/Subtraktion/Multiplikation/Division/Potenz

sin( )

Sinus (Radiant)

cos( )

Cosinus (Radiant)

tan( )

Tangens (Radiant)

arcsin( )

Arcussinus (Radiant)

arccos( )

Arcuscosinus (Radiant)

arctan( )

Arcustangens (Radiant)

ln( )

natürlicher Logarithmus

log( )

dekadischer Logarithmus

exp( )

e hoch x

sqr( )

Quadrat

sqrt( )

Wurzel

int( )

ganzzahliger Anteil

frac( )

nicht ganzzahliger Anteil

abs( )

Absolutwert

rnd( )

Runden auf ganzzahligen Wert

Applikationen

Weitere Bedienhinweise ■ Zusätzlich können Sie noch die Kreiszahl Pi und die Laufvariable X verwenden. ■ Eine Begrenzung der Klammerebenen ist nicht vorgesehen, die maximale Formellänge ist ebenfalls nicht relevant (nullterminierter String). ■ Ziehen Sie bei gedrückter linker Maustaste ein Rechteck, so wird der Ausschnitt vergrößert dargestellt. ■ Durch Klicken mit der rechten Maustaste kann der sichtbare Ausschnitt vergrößert werden.

Optionen Mit der Optionsmaske lässt sich die Skalierung sowohl der x- als auch der y-Achse ändern. Legen Sie einfach die jeweiligen Endwerte fest. Mit der Schrittweite bestimmen Sie die Dichte der Stützwerte auf dem Bildschirm. Eine Schrittweite von 1 berechnet für jeden Bildpunkt in x-Richtung einen Funktionswert. Stellen Sie die Werte so ein, dass die Diagrammbeschriftung etwas Sinnvolles anzeigt (z.B. Zahlen, die durch 10 teilbar sind). Die Werte für rechts/links bzw. oben/unten dürfen sich nicht überschneiden, d.h., YMax darf nicht kleiner als YMin sein. In diesem Fall erfolgt keine Darstellung der Funktion. Um die Anzeigequalität zu erhöhen, werden die einzelnen Stützwerte durch das Programm linear miteinander ver-

16.3 Funktionsplotter FMASTER

871

bunden. Bei einigen unstetigen Funktionen, z.B. tan(x) im Bereich um Pi/2, kann es durch die lineare Verbindung zu falschen Darstellungen kommen:

Für die Eingabe der Formel verwenden Sie den integrierten Formeleditor (umseitige Abbildung). HINWEIS: Das Verlassen des Editors mit der OK-Taste ist nur dann möglich, wenn die Formel

in der Eingabezeile syntaktisch korrekt ist. Die Prüfung der Funktion erfolgt bereits während der Eingabe. Als Dezimaltrenner verwenden Sie bitte den Punkt (Kommas werden automatisch in Punkte umgewandelt!).

BEISPIEL: Syntaktisch richtige Formelschreibweise: SIN(X) 2.5*EXP( -4/X )*SIN( X )

872

Kapitel 16

Applikationen

-PI^(x) X*(1-X*(Pi-sin(X)))

HINWEIS: Statt x^2 verwenden Sie besser die Funktion SQR(), da diese schneller ist.

16.3.3 Aufbau/Programmierung Die DLL Der zentrale Programmteil, ein Formel-Parser, ist ebenfalls in Delphi geschrieben, befindet sich aber in einer DLL1. Der Parser zerlegt einen String-Ausdruck in mathematische Primitive (Operatoren, Variablen, Vorzeichen, Funktionen), die anschließend in der korrekten Reihenfolge (Klammern, Punkt vor Strich etc.) abgearbeitet werden. Über die DLL FPARSE32.DLL (nachfolgendes Listing zeigt die Schnittstelle der DLL) werden vier Funktionen/Prozeduren in unser DelphiProjekt importiert: library FParse32; uses ShareMem, Windows, parser in 'parser.pas'; procedure Definiere(s : PChar); stdcall; begin funk := TFunktion.create(string(s)) end; function Fehler:integer; stdcall; begin fehler:=Funk.fehler end; function Wert(x,y :double):double; stdcall; begin wert:= Funk.f(x,y) end; procedure Fertig;stdcall; begin Funk.Destroy end; function Version: integer;stdcall; begin Version := 2 end; exports Definiere, Fehler, Wert, Fertig, Version;

Wie Sie sehen, werden alle Funktionen mit der Konvention stdcall exportiert, die DLL kann also auch in Visual Basic oder C eingesetzt werden.

1

Bei Interesse kann eine Lizenz zur Nutzung des Formel-Parsers (inklusive Quellcode) bei den Autoren erworben werden. Die Copyright-Meldung entfällt in diesem Fall natürlich.

16.3 Funktionsplotter FMASTER

Funktion

Beschreibung

definiere()

... übergibt den Formel-String an den Parser

873

z.B. definiere("15*sin(x)/x") fehler()

... wertet den String auf mathematische Korrektheit aus bzw. gibt eine Fehlernummer bei Wertebereichsüberschreitung, Division durch null, nicht reellem Ergebnis sowie Speicherüberlauf zurück. Diese Funktion sollte nach der Definition zur Überprüfung genutzt werden.

wert()

... berechnet für die übergebenen Werte x und y mit der Funktion z=f(x,y) den Wert z. Natürlich können Sie auch nur eine Funktion mit einer unabhängigen Veränderlichen verarbeiten, übergeben Sie in diesem Fall einfach eine Null für den zweiten Parameter.

fertig

... beendet die Berechnung. Alle Variablen im Parser werden gelöscht. Diese Funktion muss nach der letzten Funktionswertberechnung unbedingt aufgerufen werden!

HINWEIS: Für den Formel-Parser ist keine Fehlerbehandlung (On Error...) notwendig, alle

Exceptions werden bereits in der DLL aufgefangen und können über die Funktion fehler ausgelesen werden. Die einzelnen Stützwerte der Funktion werden durch das Programm linear miteinander verbunden. Diese Vorgehensweise führt bei unstetigen Funktionen zu unkorrekten Ergebnissen und muss durch Verändern der Schrittweite bzw. der Darstellungsgröße korrigiert werden. Für alle Berechnungen verwenden wir den Datentyp Double. Auf die Realisierungsdetails des Parsers kann an dieser Stelle verständlicherweise nicht weiter eingegangen werden, da dies zu weit führen würde.

Oberfläche Kommen wir zur Programmierung der Benutzerschnittstelle:

874

Kapitel 16

Applikationen

Für die Grafikausgabe verwenden wir eine PaintBox-Komponente, da diese eine schnellere Grafikausgabe als ein Image erlaubt. Dies hat jedoch den Nachteil, dass nach dem Verdecken der Grafik der Inhalt wiederhergestellt werden muss. Möchten Sie diese Funktionalität programmieren, müssen Sie das OnPaint-Ereignis auswerten. Die Eigenschaften Max/Min der beiden Scrollbars legen Sie auf 1 bzw. -1 fest. Da die Scrollbars keine absolute, sondern nur eine relative Positionsänderung ermöglichen sollen, verwenden wir die jeweils erreichte Position (1/-1), um den Offset in x- bzw. y-Richtung festzulegen. Danach kann die Position auf 0 zurückgesetzt werden. Eine Beschränkung für die Offset-Werte ist nicht vorgesehen, es dürfte jedoch ziemlich lange dauern, bis der Double-Wertebereich überschritten ist.

Quellcode Fenster, die sich vergrößern oder verkleinern lassen, müssen dafür sorgen, dass die enthaltenen Komponenten dem neuen Clientbereich angepasst werden: procedure TForm1.FormResize(Sender: TObject); begin with scrollbar2 do begin left := form1.clientwidth-width; hoehe:= form1.clientheight-59; height:=hoehe; end; with scrollbar1 do begin top := panel2.top-height; breite:= form1.clientwidth-17; width:=breite; end; paintbox1.width :=breite; paintbox1.height:=hoehe; xdiff := breite - 67; ydiff := hoehe - 40; scalx := (xmax - xmin) / xdiff; scaly := (ymax - ymin) / ydiff; darstellen(paintbox1); end;

Neben der Oberfläche ist natürlich auch unsere Grafik von einer Größenänderung betroffen (PaintBox1). Dies wiederum hat Einfluss auf die Skalierungsfaktoren (scalx,scaly). Zum Abschluss wird die Grafik erneut berechnet und angezeigt. Bevor wir mitten im Programm landen, beginnen wir besser mit der Initialisierung. Alle globalen Variablen finden Sie in Unit3: unit Unit3; interface uses ShareMem, Graphics, ExtCtrls; var formel, formate :string;

16.3 Funktionsplotter FMASTER

875

xmin,xmax, ymin,ymax, scalx,scaly, xteiler,yteiler, yoffset :double; schrittweite, xdiff,ydiff, breite,hoehe :integer; procedure darstellen(p:tpaintbox); procedure Definiere(s:string);stdcall; function Fehler:integer;stdcall; function Wert(x,y:double):double;stdcall; procedure Fertig;stdcall; implementation uses WinProcs; procedure Definiere(s:string);far;external 'FParse32.dll'; function Fehler:integer;far; external 'FParse32.dll'; function Wert(x,y:double):double;far; external 'FParse32.dll'; procedure Fertig; far; external 'FParse32.dll'; begin formel :='SIN(X)/x'; formate := '0.0#'; schrittweite := 3; xmin := -30; xmax := 30; ymin := -1; ymax := 2; end.

Die Unit exportiert ebenfalls die DLL-Funktionen, die im implementation-Teil als external gekennzeichnet sind (Einbindung aus der DLL). Die Formel wird standardmäßig mit der Spaltfunktion initialisiert, an dieser Stelle könnte aber auch jede andere Formel stehen. Mit einer Schrittweite von 3 lassen sich die meisten Funktionen schnell und hinreichend genau darstellen. Haben Sie höhere Ansprüche, müssen Sie diesen Wert verkleinern. Die wichtigste Prozedur des Programms ist einer näheren Betrachtung wert. Als Übergabeparameter sind beliebige PaintBox-Objekte zulässig: procedure darstellen(p: TPaintBox); var f,yoffs,i : Integer; l,Y,X,xz,yz : Double; s :string; c : tcanvas;

Zum vereinfachten Zugriff auf den Canvas des übergebenen PaintBox-Objekts führen wir zusätzlich ein Objekt c vom Typ TCanvas ein. Wir hätten auch mit einem with p.Canvas do begin ... end-

876

Kapitel 16

Applikationen

Konstrukt auf die Methoden des Canvas zugreifen können, das Listing ist jedoch recht lang, was Übersicht und Zuordnung erschweren würde. begin c:=p.canvas; xteiler := (xmax - xmin); yteiler := (ymax - ymin);

Der Formel-Parser wird initialisiert definiere(formel);

und liefert über die Funktion fehler den internen Status zurück. Fehler treten im Allgemeinen durch Syntaxverletzungen (1) innerhalb der Formel auf. Eine weitere Ursache kann unzureichender Arbeitsspeicher (6) sein. Eine Fehlerbehandlung ist also angebracht: If fehler <> 0 Then begin MessageBox(0,'Funktion oder Diagrammdaten fehlerhaft !','Problem',16); Exit; End;

Sollte die Initialisierung ohne Probleme erfolgt sein, kann das Hintergrundgitter gezeichnet werden. Dazu müssen wir die entsprechenden Stiftfarben und -typen zuweisen: c.pen.color := clgray; c.pen.style := psdot; c.font.color:= clgray;

Danach wird der Bildschirm bzw. die PaintBox gelöscht. p.refresh;

Die beiden folgenden Schleifen zeichnen sowohl in horizontaler als auch in vertikaler Richtung das Gitter und fügen die Beschriftung ein: for i := 0 to 10 do begin str((xmin + i * xteiler / 10):10:3,s); X := 45 + i * xteiler / scalx / 10; c.moveto(round(X), 5); c.lineto(round(X), ydiff + 5); c.textout(round(X - (c.TextWidth(s)) div 2), ydiff + 8,s); end; for i := 0 To 10 do begin str((ymax - i * yteiler / 10):10:3,s); Y := 5 + i * yteiler / scaly / 10; c.moveto(45, round(Y)); c.lineto(xdiff + 45, round(Y)); c.textout (0,round(Y - (c.TextHeight(s)) / 2),s); end; c.pen.color:=clblack; c.pen.style:=pssolid; x := xmin;

Und schon können wir den ersten Funktionswert berechnen: y:= wert(X,0); c.MoveTo (45,round(5 + (yoffset - Y) / scaly)); f := fehler; l := 0;

16.3 Funktionsplotter FMASTER

877

Das Resultat ist in der Variablen y gespeichert, den Fehlerstatus merken wir uns in der Variablen f. Sollte bei den Berechnungen ein Fehler auftreten, ignorieren wir diesen einfach und verhindern an dieser Stelle die Darstellung der Funktion. Ursachen können Werteüberläufe, Division durch null etc. sein. while l <= xdiff do begin x:= xmin + l * scalx; y:= wert(x,0); yz:= 5 + (yoffset - Y) / scaly; If f <> 0 Then c.MoveTo(round(l + 45),round(yz)); f := fehler; If f = 0 Then c.LineTo(round(l + 45), round(yz)) Else c.MoveTo(round(l + 45),round(yz)); l := l + schrittweite; end;

Zum Schluss muss nur noch der Parser zurückgesetzt werden: fertig; end;

Damit sind die Formel bzw. deren Graph auf dem Bildschirm zu sehen. An dieser Stelle könnten wir eigentlich aufhören. Auf die Zoom-Funktion soll jedoch noch eingegangen werden, da sich diese grundlegend von der entsprechenden Funktion in unserem Grafikprogramm Paint unterscheidet. In diesem Fall wünschen wir nicht einfach eine Vergrößerung der Pixel, sondern eine echte Vergrößerung des gewählten Ausschnitts. Da wir mit dem Formel-Parser jeden gewünschten Wert berechnen können, ist es problemlos möglich, eine Zoomfunktion ohne Qualitätsverlust zu programmieren. Was benötigt wird, sind die Eckkoordinaten des neuen Grafikausschnitts. Zur Ermittlung der Koordinaten greifen wir wieder auf die bewährte GummibandMethode zurück. Im MouseDown-Event legen wir die erste Ecke des Rechtecks fest, um welche es sich dabei handelt, können wir erst im Zusammenhang mit dem MouseUp-Event sagen. procedure TForm1.PaintBox1MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin If button = mbleft Then begin paintbox1.canvas.pen.mode := pmNotXor; paintbox1.canvas.brush.style:=bsClear; kx := X; ky := Y; kxa := X; kya := Y; paintbox1.canvas.rectangle (kx, ky,kxa, kya); z :=1; end; end;

Bei jeder Mausbewegung muss der Markierungsrahmen gelöscht und anschließend neu gezeichnet werden:

878

Kapitel 16

Applikationen

procedure TForm1.PaintBox1MouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer); var xanz,yanz:string; begin str(((X - 45) * scalx + xmin):10:3,xanz); str((ymax - (Y - 5) * scaly):10:3,yanz); panel2.caption := ' P(' + xanz + ' ; ' + yanz + ')'; If z <>1 Then Exit; with paintbox1.canvas do begin rectangle (kx, ky, kxa, kya); kxa := X; kya := Y;rectangle(kx, ky,kxa, kya); end; end;

Beim MouseUp-Ereignis unterscheiden wir zwischen linker und rechter Maustaste. Wird auf die rechte gedrückt, ändert sich der Zoomfaktor um den Faktor 0,5. Handelt es sich um die linke Maustaste, ist das Markieren des neuen Ausschnitts abgeschlossen, die Grafik kann erneut berechnet werden. procedure TForm1.PaintBox1MouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); var diffxx,diffyy : Double; xanz, yanz : string; begin if button = mbright then begin diffxx := (xmax - xmin) / 2; diffyy := (ymax - ymin) / 2; xmin := xmin - diffxx; xmax := xmax + diffxx; ymin := ymin - diffyy; ymax := ymax + diffyy; scalx := (xmax - xmin) / xdiff; scaly := (ymax - ymin) / ydiff; yoffset := ymax; darstellen(paintbox1) end; if button = mbleft then begin if (abs(kx-x)<10) or (abs(ky-y)<10) then begin z := 0; darstellen(paintbox1); exit end; If kx < X then begin xmax := (X - 45) * scalx + xmin; xmin := (kx - 45) * scalx + xmin; end else begin xmax := (kx - 45) * scalx + xmin; xmin := (X - 45) * scalx + xmin; end; if ky > Y then begin ymin := ymax - (ky - 5) * scaly; ymax := ymax - (Y - 5) * scaly end else begin ymin := ymax - (Y - 5) * scaly; ymax := ymax - (ky - 5) * scaly end; scalx := (xmax - xmin) / xdiff; scaly := (ymax - ymin) / ydiff; yoffset := ymax; darstellen(paintbox1); z := 0 end end;

16.4 Mathematikprogramm GAUSS2

879

Drucken Die Grafik auf Papier zu bringen, erfordert nicht allzu viel Aufwand. Sie müssen lediglich die Prozedur darstellen dahingehend ändern, dass nicht ein TPaintbox-Objekt, sondern ein TCanvas übergeben wird. Welchem Objekt dieser zugeordnet ist, spielt nachfolgend keine Rolle. Mit darstellen(Printer.Canvas);

könnten Sie die Funktion auf dem Drucker ausgeben.

16.4 Mathematikprogramm GAUSS2 HINWEIS: Das komplette Programm bietet dem fortgeschrittenen Programmierer ein gutes

OOP-Training. Sie sollten aber vorher zumindest die in 13.3 vermittelten Grundlagen verstanden haben und außerdem etwas Zeit und Ruhe mitbringen. GAUSS2 baut auf den im Wissenschaftskapitel unter 13.3.1 gewonnenen allgemeinen Erkenntnissen zum Lösen linearer Gleichungssysteme auf. Es demonstriert dabei das objektorientierte Konzept von Delphi auf fortgeschrittenem Level. Damit auch jeder sieht, dass hier Mathematik nicht zum Selbstzweck praktiziert wird, ist dieses Programm mit einer konkreten Praxisanwendung aus dem Gebiet der Elektrotechnik gekoppelt.

16.4.1 Bedienoberfläche Form1 Für Eingabe und Anzeige der Koeffizienten bietet sich das StringGrid an. Die Zeilen- und Spaltenanzahl wird automatisch der Anzahl der Unbekannten angepasst. Eine ScrollBar erweist sich als ideal für das Einstellen der Ordnung des GLS, setzen Sie die Eigenschaften Min = 1 und Value = 10 (oder höher).

880

Kapitel 16

Applikationen

Bei den drei StringGrids müssen wir etwas an den Eigenschaftseinstellungen herumdoktern (Änderungen sind fett markiert): Eigenschaft

StringGrid1

StringGrid2

StringGrid3

FixedCols

1

1

1

FixedRows

1

0

0

ScrollBars

ssBoth

ssNone

ssNone

Options.goEditing

True

False

True

Options.goColSizing

True

False

False

Options.goRangeSet

False

False

False

Option.goTabs

True

False

False

Option.goAlwaysShowEditor

True

False

True

16.4.2 Quellcode der Klassen-Unit GlsMtrx Ein lineares GLS hat die allgemeine Form A x X = B ... wobei A, X und B Matrizen sind (zwei- bzw. eindimensional). Unser verbesserter Gauss-Algorithmus benötigt also drei Matrizen zum Abspeichern der Koeffizienten bzw. zum Steuern der Eliminationsreihenfolge (N = Zahl der Unbekannten): ■ A[N, N] = quadratisches Array (Double) für die linke Seite des GLS ■ B[N] = eindimensionales Array (Double) für die rechte Seite des GLS ■ P[N] = eindimensionales Array (Integer) für den Pivotvektor Nachdem eine Implementierung der drei Arrays auf Basis von drei Units einige Buchauflagen hartnäckig überstanden hat, haben wir diesmal die Anregung eines Lesers aufgegriffen und eine objektorientierte Lösung in Angriff genommen. Dabei konnten die drei Units durch eine einzige ersetzt werden. Diese stellt eine Klasse mit allen zum Aufstellen und Lösen linearer GLS erforderlichen Eigenschaften und Prozeduren zur Verfügung. Als Speichermedium wird der unter Delphi reichlich vorhandene Heap (Stapelspeicher) benutzt (siehe Kapitel 14). Fügen Sie Ihrem Projekt also eine neue Unit mit dem Namen GlsMtrx hinzu. unit GlsMtrx; interface type TDblArr = array[1..1] of Double; TIntArr = array[1..1] of Integer; TMtrx = class(TObject) private fN: Integer; pA: ^TDblArr;

// Double-Datenfeld // Integer-Datenfeld

// Klassendeklaration

// Pointer für A-Matrix

881

16.4 Mathematikprogramm GAUSS2

pB: ^TDblArr; pP: ^TIntArr;

// dto. für B // dto. für P

Die internen Zugriffsprozeduren für die Eigenschaften: function getA(i, j: Integer): Double; procedure setA(i, j: Integer; Value: Double); function getB(i: Integer): Double; procedure setB(i: Integer; Value: Double); function getP(i: Integer): Integer; procedure setP(i: Integer; Value: Integer); function getN: Integer;

Es folgen die von der Klasse zu exportierenden Methoden und Eigenschaften: public constructor Create(aN: Integer); // Objekt erzeugen destructor Destroy; override; // Objekt entfernen property N: Integer read getN; // Ordnung des GLS (nur Lesezugriff) property A[i, j: Integer]: Double read getA write setA; // Zugriff auf A property B[i: Integer]: Double read getB write setB; // dto. B property P[i: Integer]: Integer read getP write setP; // dto. P procedure gauss2; // der komplette Lösungsalgorithmus! end; implementation uses SysUtils, Dialogs;

Wundern Sie sich nicht darüber, dass im nachfolgenden Konstruktor alle Matrizen auf dem Heap um eine Ordnung größer angelegt werden, als es die Ordnung des GLS erfordert. Der Grund ist ein vereinfachtes Aufstellen des GLS nach der Methode der unbestimmten Matrizen. Auf den Lösungsalgorithmus hat diese geringfügige Redundanz keinerlei Auswirkungen. constructor TMtrx.Create; var i, j: Byte; begin

Zunächst ist der ererbte Konstruktor auszuführen: inherited Create;

Anschließend wird – in Abhängigkeit von der Ordnung des GLS – der erforderliche Heap-Speicherplatz reserviert: fN := aN + 1; GetMem(pA, SizeOf(Double) * fN * fN); GetMem(pB, SizeOf(Double) * fN); GetMem(pP, SizeOf(Integer) * fN); for i := 1 to fN do begin P[i] := i; // Pivotvektor initialisieren B[i] := 0; // Matrizen löschen ... for j := 1 to fN do A[i,j] := 0 end end;

882

Kapitel 16

Applikationen

Erst ist der belegte Heap-Speicherplatz freizugeben, ehe abschließend der ererbte Destruktor aufgerufen werden kann: destructor TMtrx.Destroy; begin FreeMem(pA, SizeOf(Double) * fN * fN); FreeMem(pB, SizeOf(Double) * fN); FreeMem(pP, SizeOf(Integer) * fN); inherited Destroy end;

Es folgen die Implementierungen der Lese-/Schreibzugriffe für die einzelnen Eigenschaften. Beginnen wir mit dem Zugriff auf die quadratische Koeffizientenmatrix (A): function TMtrx.getA; begin Result := pA^[(i-1) * fN + j] end; procedure TMtrx.setA; begin pA^[(i-1) * fN + j] := Value end;

Der Zugriff auf die rechte Seite des GLS (Spaltenvektor B): function TMtrx.getB; begin Result := pB^[i] end; procedure TMtrx.setB; begin pB^[i] := Value end;

Der Zugriff auf den Pivotvektor P: function TMtrx.getP; begin Result := pP^[i] end; procedure TMtrx.setP; begin pP^[i] := Value end;

Die Eigenschaft N (Ordnung des GLS) kann nur gelesen werden: function TMtrx.getN; begin Result := fN-1 end;

883

16.4 Mathematikprogramm GAUSS2

GAUSS-Algorithmus Die mit Abstand umfangreichste Methode der Klasse ist der Gauss-Algorithmus, mit dem das Gleichungssystem in mehreren verschachtelten Schleifen gelöst wird: procedure TMtrx.gauss2; const p1 = 1E-12; var i,j,k : Integer; w: Double; s: string; z,p0: Byte; begin

// // // //

Pivotschwelle Schleifenzähler Hilfsvariablen lokale Hilfsvariablen

Die Elimination: for k := N downto 2 do begin z:=1; // Pivotsuche: for i:=2 to k do if Abs(A[P[z],P[z]]) < Abs(A[P[i],P[i]]) then z:=i; p0:=P[z]; P[z] := P[k]; P[k] := p0; // vertauscht Gleichung if Abs(A[p0,p0]) < p1 then begin ShowMessage('Pivotfehler!'); Exit end; for j:=1 to k-1 do begin z:=P[j]; if A[z,p0] <> 0 then begin w:=A[z,p0]/A[p0,p0]; B[z] := B[z] - w * B[p0]; for i:=1 to k-1 do A[z, P[i]] := A[z, P[i]] - w * A[p0, P[i]] end end end;

Die Rücksubstitution: for j:=1 to N do begin z := P[j]; for i:=1 to j-1 do B[z] := B[z] - B[P[i]] * A[z, P[i]]; if A[z, z] = 0 then begin ShowMessage('Pivotfehler!'); Exit end; B[z] := B[z] / A[z,z] end end; end.

Der Gauss-Algorithmus funktioniert vom Prinzip her genauso wie bereits unter 13.3.2 beschrieben. Wichtigster Unterschied ist eine gleitende Pivotsuche über der Hauptdiagonalen, bei der immer das betragsgrößte Element der Restmatrix gesucht und die dazugehörige Gleichung zuerst eliminiert wird. Schrittweise schrumpft das GLS bis auf die Ordnung eins, um anschließend den Lösungs-

884

Kapitel 16

Applikationen

vektor durch Rücksubstitution zu ermitteln. Im Endergebnis ist die rechte Seite B mit dem Lösungsvektor X überschrieben. Um rein akademischen Leserkritiken bezüglich der Lösbarkeit ausgefallener mathematischer GLS (z.B. mit ungewöhnlichen Nullelementen) vorzubeugen: HINWEIS: Dieser Gauss-Algorithmus wurde speziell für das Lösen von Netzwerkgleichungs-

systemen aus dem Gebiet der Physik (z.B. Elektrotechnik/Elektronik) eingesetzt und hat sich im Industrieeinsatz bereits hundertfach bewährt!

16.4.3 Quelltext Unit1 Das Hauptprogramm soll das Lösen linearer Gleichungssysteme möglichst anschaulich demonstrieren. Dazu sind zwei Etappen zu bewältigen: ■ Aufstellen des GLS ■ Lösen des GLS Zur Erfüllung dieser Aufgaben benutzen wir eine Objektvariable mat, die wir als Instanz der von der Unit GlsMtrx bereitgestellten Klasse TMtrx bilden. Trotzdem haben wir uns noch um das gesamte Drumherum der Bedienoberfläche selbst zu kümmern, also um das "Füttern" des GaussAlgorithmus mit Daten und um das Anzeigen der Lösung. Die im interface-Abschnitt erforderlichen Ergänzungen sind durch Unterstreichung hervorgehoben: unit Unit1; interface uses Windows, ..., GlsMtrx;

// Klassen-Unit einbinden

type TForm1 = class(TForm) ....

Für den internen Gebrauch: protected procedure clearCells; procedure newGrids; procedure storeABMatrix;

// löscht die Anzeigegitter // Anzeigegitter mit neuen Abmessungen // speichert A- und B-Anzeigegitter

Für den Zugriff von außerhalb: public mat: TMtrx; procedure setGrids; procedure displayXMatrix; procedure displayABMatrix; end;

Nun zum interface-Abschnitt:

// // // //

Objektvariable !!! Anzeigegitter anpassen Lösung anzeigen A- und B-Matrix anzeigen

885

16.4 Mathematikprogramm GAUSS2

var N: i, w: s:

Integer; j: Integer; Double; String;

// Ordnung des GLS

Einige Hilfsprozeduren: procedure TForm1.clearCells; // löscht Inhalte der Gitter begin for i := 0 to N do begin if i < N then begin StringGrid2.Cells[0,i] := ''; StringGrid2.Cells[1,i] := ''; StringGrid3.Cells[0,i] := ''; StringGrid3.Cells[1,i] := '' end; for j := 1 to N do StringGrid1.Cells[i,j] := '' end end;

Wenn sich die Ordnung des GLS ändert, müssen die Gitter angepasst werden: procedure TForm1.newGrids; begin clearCells; StringGrid2.RowCount:= N; StringGrid3.RowCount := N; with StringGrid1 do begin RowCount:= N+1; ColCount:= N+1; for i:= 1 to N do begin Cells[i,0]:= IntToStr(i); Cells[0,i] := IntToStr(i); StringGrid2.Cells[0,i-1] := 'x'+IntToStr(i); StringGrid3.Cells[0,i-1] := 'b'+IntToStr(i) end end end;

Zweites und drittes Gitter mit dem ersten synchronisieren: procedure TForm1.StringGrid1TopLeftChanged(Sender: TObject); begin StringGrid2.TopRow:= StringGrid1.TopRow-1; StringGrid3.TopRow:= StringGrid1.TopRow-1 end;

Der Inhalt der Anzeigegitter 1 und 3 wird in der A- und B-Matrix abgespeichert: procedure TForm1.storeABMatrix; var code: Integer; begin for i:= 1 to N do with mat do begin Val(StringGrid3.Cells[1,i-1], w, code); B[i] := w; for j:= 1 to N do

// rechte Seite

886

Kapitel 16

begin Val(StringGrid1.Cells[j,i], w, code); A[i,j] := w end end end;

Applikationen

// linke Seite

... und umgekehrt: procedure TForm1.displayABMatrix; begin for i:=1 to N do begin w := mat.B[i]; Str(w:10:5,s); StringGrid3.Cells[1,i-1]:= s; for j:= 1 to N do begin w := mat.A[i,j]; Str(w:10:5,s); StringGrid1.Cells[j,i]:= s end end end;

// B-Matrix anzeigen

// A-Matrix anzeigen

Wie Sie den Argumenten der Str-Prozedur entnehmen, werden insgesamt zehn Stellen angezeigt, davon fünf Nachkommastellen. Das können Sie bei Bedarf ändern. Mit insgesamt acht Stellen, davon drei nach dem Komma, wird die Lösung X im mittleren Gitter zur Anzeige gebracht. procedure TForm1.displayXMatrix; begin for i:=1 to N do with mat do begin w := B[i]; Str(w:8:3, s); StringGrid2.Cells[1,i-1]:= s end end;

Wir wollen das Programm später so erweitern, dass auch Gleichungssysteme angezeigt werden können, die automatisch von Modellen generiert werden, die wir in anderen Formularen aufbauen (wir werden das an einem elektrischen Netzwerk demonstrieren). Diese Fremdformulare müssen dann folgende Methode von Form1 aufrufen: procedure TForm1.setGrids; begin N := mat.N; Panel1.Caption := IntToStr(N); newGrids; displayABMatrix end;

Abschließend die Event-Handler zur Realisierung der Bedienfunktionen:

16.4 Mathematikprogramm GAUSS2

887

Beginnen wir mit dem Programmaufruf: procedure TForm1.FormCreate(Sender: TObject); begin mat := TMtrx.Create(ScrollBar1.Position); newGrids; ScrollBar1Change(Self); StringGrid1.ColWidths[0]:= 25; StringGrid2.ColWidths[0]:= 25; StringGrid2.ColWidths[1] := 90; StringGrid3.ColWidths[0]:= 25; StringGrid3.ColWidths[1] := 60; end;

Das passiert, wenn Sie die Anzahl der Unbekannten ändern: procedure TForm1.ScrollBar1Change(Sender: TObject); begin N := ScrollBar1.Position; Panel1.Caption := IntToStr(N);

Heap-Speicherplatz freigeben und neu reservieren: mat.Free; mat := TMtrx.Create(N);

Gitteranzeige anpassen: newGrids; mat.A[1,1] := 1; mat.B[1] := 1; displayABMatrix end;

Nach Start des Lösungsalgorithmus muss abgespeichert, gerechnet und angezeigt werden: procedure TForm1.Button1Click(Sender: TObject); begin storeABMatrix; mat.gauss2; displayXMatrix end;

Den folgenden Aufruf eines zweiten Formulars mit einem Beispiel aus der E-Technik können Sie weglassen oder Sie brauchen erst später zu ergänzen. procedure TForm1.Button3Click(Sender: TObject); begin Form2.Show end;

16.4.4 Test mit Handeingabe der Koeffizienten Gleichungssystem mit drei Unbekannten Für einen ersten Test empfiehlt sich z.B. das "Drei-Brüder"-Beispiel aus 13.3.1, denn mit den paar Koeffizienten ist der Ärger nicht gar zu groß, wenn sich doch ein Laufzeitfehler im Code einge-

888

Kapitel 16

Applikationen

schlichen haben sollte. Stellen Sie zunächst die Ordnung des GLS ein (3) und tragen Sie im linken und rechten Gitter die Koeffizienten ein. Klicken Sie dann den Button "Gleichungssystem lösen". Im mittleren Gitter sehen Sie den Lösungsvektor:

Gleichungssystem mit fünf Unbekannten und Nullelement in der Diagonalen Als Nächstes sollten Sie sich ein größeres Beispiel vorknöpfen und dabei auch bewusst mit Nullelementen in der Hauptdiagonalen provozieren:

Wie Sie sehen, funktioniert die automatische Pivotisierung, denn haargenau das gleiche Beispiel führte beim einfachen Gauss-Algorithmus (13.3.2) unweigerlich zum Programmabsturz.

16.4 Mathematikprogramm GAUSS2

889

16.4.5 Automatisches Aufstellen des Gleichungssystems War die Tipparbeit für die fehlerfreie Eingabe der 30 Koeffizienten des obigen GLS nicht ein Gräuel? Die Anzahl der Koeffizienten wächst quadratisch mit der Ordnung des GLS, hat das GLS z.B. zehn Unbekannte, müssten von Ihnen 110 Werte eingegeben werden, eine Sisyphus-Arbeit! In der Praxis wird deshalb diese Aufgabe ebenfalls vom Computerprogramm mit übernommen. Wir werden eine entsprechende Programmergänzung vornehmen, welche die Nützlichkeit linearer Gleichungssysteme beweisen und das Know-how am Beispiel der Netzwerkanalyse elektronischer Schaltungen demonstrieren soll. Doch dies hier ist ein Buch über die Grundlagen von Delphi und keine Einführung in die Theoretische Elektrotechnik! Wir werden deshalb nicht weiter in deren Gesetzmäßigkeiten herumbohren, nur um die Regeln zu ergründen, nach denen das GLS der Knotenspannungsanalyse aufgestellt wird. Nur so viel: Es handelt sich um ein Lineares GLS, dessen Ordnung N sich aus der Gesamtknotenzahl des Netzwerks ergibt, wobei der Bezugsknoten nicht mitgerechnet wird. Zu jeder Spannungsquelle gehört ein Innenwiderstand, beide bilden ein Bauelement, das im Programm in eine äquivalente Stromquelle umgerechnet wird. Demnach zählt auch die interne Verbindung zwischen Spannungsquelle und ihrem Innenwiderstand nicht als Knoten. Als Ergebnis der Knotenspannungsanalyse werden die Spannungspotenziale aller Knoten gegenüber dem gemeinsamen Bezugsknoten (Masse) ermittelt. BEISPIEL: Das abgebildete Netzwerk besteht aus sechs Knoten, drei Spannungsquellen und sechs Widerstän-

den und führt zu einem Linearen GLS mit fünf Unbekannten, den Knotenspannungen U1, U2, U3, U4 und U5.

16.4.6 Oberfläche Form2 Fügen Sie dem Projekt ein weiteres Formular (Form2) hinzu. Auf einer Image-Komponente sind zwölf Editierfelder und sechs Labels platziert, die zur Direkteingabe der Schaltungsparameter und zur Anzeige der Analyseergebnisse dienen. Es macht sich gut, wenn die Labelfelder gelb eingefärbt werden:

890

Kapitel 16

Applikationen

Das Schaltbild wurde mit Visio gezeichnet, im BMP-Format exportiert und anschließend der Picture-Eigenschaft einer Image-Komponente zugewiesen. Damit das Objekt Form2 von Form1 erkannt wird, ist eine uses-Klausel im ImplementationAbschnitt von Unit1 hinzuzufügen: uses Unit2;

16.4.7 Quelltext Unit2 Im interface-Abschnitt von Unit2 sind zwei private Methoden für TForm2 zu ergänzen: type TForm2 = class(TForm) ... private procedure glsAufstellen; procedure uAnzeigen ; end;

Nun zum implementation-Abschnitt. Neben Unit1 ist auch die Klassen-Unit einzubinden: uses Unit1, GlsMtrx;

Die Objektvariable und weitere Hilfsvariablen: var mat: TMtrx; w, w1: Double; i,j, code: Integer; s: string;

Es folgen zwei Hilfsprozeduren, die das Addieren der elektrischen und topologischen Parameter der Schaltelemente zur A- bzw. B-Matrix besorgen. Widerstände (Anschlussklemmen j, k; Wert r) addieren: procedure addR(j,k:Integer; r:Double); begin

891

16.4 Mathematikprogramm GAUSS2

with mat A[j,j] A[k,k] A[j,k] A[k,j] end end;

do := := := :=

begin A[j,j]+ 1/r; A[k,k]+ 1/r; A[j,k]-1/r; A[k,j]-1/r

Spannungsquellen (Anschlussklemmen plus, minus; Wert e; Innenwiderstand r) addieren: procedure addE(plus, minus:Integer; e,r:Double); begin addR(plus, minus, r); with mat do begin B[minus]:= B[minus]- e/r; B[plus]:= B[plus] + e/r end end;

Alle sechs Widerstände werden nacheinander eingelesen: procedure TForm2.glsAufstellen; begin Val(Edit3.Text,w,code); addR(1,2,w); Val(Edit4.Text,w,code); addR(2,6,w); Val(Edit7.Text,w,code); addR(3,6,w); Val(Edit8.Text,w,code); addR(3,4,w); Val(Edit9.Text,w,code); addR(4,6,w); Val(Edit10.Text,w,code); addR(4,5,w);

// // // // // //

R1 R2 R3 R4 R5 R6

Nun die drei Spannungsquellen (mit ihrem zugeordneten Innenwiderstand Ri): Val(Edit1.Text,w,code); Val(Edit2.Text,w1,code); // E1 addE(6,1,w, w1); Val(Edit5.Text,w,code); Val(Edit6.Text,w1,code); // E2 addE(2,3,w, w1); Val(Edit11.Text,w1,code); Val(Edit12.Text,w,code); // E3 addE(5,6,w,w1); end;

Die Anzeige der fünf Spannungen (das ist die Lösung des GLS) erfolgt direkt im Schaltbild in den Labelfeldern: procedure TForm2.uAnzeigen; begin with mat do begin Str(B[1]:6:3, s); Label1.Caption := s; Str(B[2]:6:3, s); Label2.Caption := s; Str(B[3]:6:3, s); Label3.Caption := s; Str(B[4]:6:3, s); Label4.Caption := s; Str(B[5]:6:3, s); Label5.Caption := s end end;

892

Kapitel 16

Applikationen

Die Rahmenprozedur zum Aufstellen des GLS: procedure TForm2.Button2Click(Sender: TObject); begin mat.Free; mat := TMtrx.Create(5); glsAufstellen;

// Gleichungssystem aufstellen

Die folgende Objektreferenz stellt die Verbindung zum gleichnamigen Objekt in Form1 her: Form1.mat := mat;

// !!!

Das GLS ist fertig abgespeichert und steht nun auch in Form1 zur Verfügung. Bevor wir es mit gauss2 lösen, gilt es aber Folgendes zu bedenken: Über die "Zurück"-Schaltfläche wollen wir nicht nur ins Hauptformular zurückkehren, sondern dort soll uns auch das fertige Gleichungssystem zwecks näherer Begutachtung erwarten. Wir müssen also bereits jetzt dafür sorgen, dass die Inhalte der A- und B-Matrix in das erste und dritte Anzeigegitter gebracht werden. Warum? Durch den Gauss-Algorithmus wird das ursprüngliche Gleichungssystem zerstört (überschrieben), so dass der Inhalt bereits jetzt "gerettet" werden muss: Form1.setGrids;

Der Aufruf des Lösungsprogramms mat.gauss2; uAnzeigen end;

Zurück zum Hauptformular führt die "Zurück"-Schaltfläche: procedure TForm2.Button1Click(Sender: TObject); begin Close end; end.

16.4.8 Testbeispiel Elektrotechnik Starten Sie das Projekt wie üblich, wechseln Sie aber sofort vom Hauptformular in das Formular "Elektrotechnik". Damit nicht erst jedes Mal mühevoll die zwölf Editierfelder gefüllt werden müssen, empfiehlt es sich, bereits zur Entwurfszeit der Text-Eigenschaft sinnvolle Standardwerte zuzuweisen1. Verwenden Sie dabei die Grundmaßeinheiten Volt (für E und U) und Ohm (für R). Klicken Sie auf "Gleichungssystem aufstellen und lösen", und schon sehen Sie in den gelben Labelfeldern die Analyseergebnisse:

1

Siehe Programm auf der Buch-CD.

16.4 Mathematikprogramm GAUSS2

893

Nun können Sie nach Belieben an den Schaltungsparametern herumdoktern und die Potenzialänderungen beobachten. Fühlen Sie sich dabei wie ein Servicetechniker, der mit einem Digitalvoltmeter die Spannungen der Messpunkte 1 bis 5 gegen Masse (6) kontrolliert. Die Ergebnisanzeige (Maßeinheit Volt) erfolgt mit 1mV Genauigkeit. HINWEIS: Vermeiden Sie die Eingabe von Nullwerten für die Widerstände, da dies unweiger-

lich zu einem Pivotfehler führt. Auch in der Praxis gibt es keine Widerstände mit dem Wert null. Das Gleiche gilt für die Innenwiderstände realer Spannungsquellen. Wollen Sie trotzdem den Idealfall simulieren, so nehmen Sie einen sehr kleinen Wert für den Innenwiderstand, der sich dann nicht auf das Messergebnis auswirkt. Während Sie in Form2 mit der Schaltung experimentieren, können Sie in Form1 die Veränderungen der Koeffizienten des Gleichungssystems verfolgen. Allerdings müssen Sie hier erst auf "Gleichungssystem lösen" klicken, um auch die Anzeige des Lösungsvektors zu erhalten:

894

Kapitel 16

Applikationen

Die Werte x1 ... x5 sollten natürlich exakt den Werten von U1 ... U5 entsprechen. Falls Abweichungen auftreten, so liegt das daran, dass in Unit1 die ermittelten Koeffizienten mittels Str-Funktion in die Anzeigegittern eingelesen und wieder ausgelesen wurden, wodurch es (trotz der fünf Nachkommastellen!) unweigerlich zu Rundungsfehlern kommt. Die exakteren Werte sind deshalb stets die im Schaltbild (Form2).

16.5 WINCROSS – Ihr Kreuzworträtselexperte "Ein Optimist ist derjenige, der Kreuzworträtsel mit Tinte löst." Diesem altbekannten Spruch nehmen wir mit diesem Programm die Pointe! Wenn Sie gerne Kreuzworträtsel lösen oder sogar selbst welche aufstellen wollen, dann finden Sie in WINCROSS einen leistungsfähigen Assistenten. Hier die wichtigsten Programmoptionen: ■ Wörterbuch mit 2800 Begriffen, das Sie selbst ergänzen können. ■ Hilfe beim Lösen von Kreuzworträtseln (Suche nach passenden Wörtern bei vorgegebenem Muster und umgekehrt). ■ Automatisches Generieren von Kreuzworträtseln mit Druckoption. ■ Und nicht zuletzt eine Möglichkeit, das generierte Kreuzworträtsel zu lösen.

16.5 WINCROSS – Ihr Kreuzworträtselexperte

895

Die auf der Buch-CD mitgelieferte Datenbank umfasst knapp 3000 Begriffe, die im Wörterbuch editierbar sind. Die minimale Wortlänge beträgt zwei, die maximale dreizehn Buchstaben.

"Kennst Du ein römisches Bauwerk mit zwölf Buchstaben, der erste ist ein A, der letzte ein R ....", mit dieser und ähnlichen Fragen brauchen Sie nun niemanden mehr zu belästigen:

Sie geben einfach die gesuchten Buchstaben und die Wortlänge ein, und das Programm zeigt, so vorhanden, die möglichen Einträge an.

896

Kapitel 16

Applikationen

16.5.1 Datenbankstruktur Im Gegensatz zu den später vorgestellten Algorithmen ist die eigentliche Datenbankstruktur relativ simpel, es werden prinzipell nur zwei Felder benötigt (das gesuchte Wort und die Umschreibung). Dass Sie dennoch ein weiteres Feld mit der Länge des gesuchten Wortes in der Tabelle finden, hat seinen Grund in der Optimierung des späteren Suchvorgangs (gesucht wird ein Wort mit Platzhaltern, das auch eine bestimmte Länge hat).

Sowohl das Feld Wort als auch das Feld Länge sind indiziert, um eine spätere Suche in der Tabelle zu beschleunigen. Ob die Tabelle im dBASE- oder im Paradox-Format gespeichert wird, hat keinerlei Auswirkungen auf unser Programm. Sollten Sie die Größe der Datenbank wesentlich erweitern, dürfte eine Veränderung der Datenbankstruktur sinnvoll sein. Statt alle Worte in einer Tabelle zu speichern, werden lediglich alle Wörter gleicher Länge in einer Tabelle gespeichert. Auf diese Weise erhalten Sie statt einer zwölf Tabellen. Der Vorteil ist eine wesentlich beschleunigte Suche innerhalb der Datenbank, muss doch bei der Suche nach einem Wort, das mit "E" endet und das sieben Buchstaben lang ist, lediglich die richtige Tabelle geöffnet werden. Die zu durchsuchende Wortmenge reduziert sich durch die Aufteilung der Tabellen auf ein Zwölftel.

16.5.2 Oberfläche Grundlage ist eine PageControl-Komponente, auf der die Datenbankkomponenten Query1 bis Query3, DataSource1 ... DataSource3 sowie zwei Table-Komponenten platziert werden.

16.5 WINCROSS – Ihr Kreuzworträtselexperte

897

Auf den vier Seiten des PageControl sind neben einem DrawGrid vor allem datengebundene DBGrids angeordnet, die im Wesentlichen nur dazu benutzt werden, die gefundenen Einträge anzuzeigen. Lediglich die PageControl-Seite "Wörterbuch editieren" verfügt über eine DBNavigatorKomponente, mit welcher es möglich ist, Einträge hinzuzufügen oder zu editieren1. Bei allen Table- bzw Query-Komponenten wurde die DatabaseName-Eigenschaft nicht belegt. Auf diese Weise sucht das Programm die Datenbank im aktuellen, d.h. im Programmverzeichnis. Auf die Programmierung der Such- und Filterfunktionen gehen wir erst später ein, an dieser Stelle soll lediglich kurz die Editierfunktion besprochen werden. Datenbasis ist Table1, die mit DataSource1 über die Eigenschaft DataSet verknüpft ist. Um Probleme bei der späteren Auswahl und Suche von Wörtern zu vermeiden, konvertieren wir alle Eingaben in Großbuchstaben. Zu diesem Zweck brauchen Sie lediglich die Eigenschaft CharCase auf ecUpperCase festzulegen. Beachten Sie, dass die Komponente zur Anzeige der Wortlänge (DBEdit3) schreibgeschützt ist (ReadOnly=True). Die Aufgabe, diesen Eintrag festzulegen, überlassen wir besser dem Programm, auf diese Weise werden unnötige Eingabefehler vermieden. Ansatzpunkt ist das Ereignis BeforePost von Table1, das immer dann eintritt, wenn ein Datensatz in die Datenbank geschrieben werden soll (kurz davor). Durch folgenden Aufruf wird automatisch die Wortlänge bestimmt: procedure TForm1.Table1BeforePost(DataSet: TDataSet); begin Table1['länge'] := Length(DBEdit1.Text) end;

An dieser Stelle könnten Sie weitere Prüfungen durchführen (eventuell Kontrolle auf korrekte Schreibweise2). Die Kontrolle auf doppelt vorhandene Wörter können wir getrost der Datenbank überlassen. Da die Spalte "Wort" mit einem eindeutigen Index verknüpft ist, wird die Datenbank-Engine jeden Versuch abweisen, ein Wort zweimal zu speichern (es tritt ein Indexfehler auf). Möchten Sie verhindern, dass die zugehörige MessageBox angezeigt wird, können Sie das Ereignis PostError belegen:

1

Beachten Sie, dass die Eigenschaft AutoEdit der zugehörigen DataSource-Komponente auf False gesetzt ist. In diesem Fall muss vor dem Editieren der Daten erst die Edit-Taste gedrückt werden.

2

Die Autoren haben mit einer einfachen "Duden"-Tabelle gute Erfahrungen gesammelt, bei rund 96.000 Einträgen sind fast alle Wörter der deutschen Umgangssprache erfasst.

898

Kapitel 16

Applikationen

procedure TForm1.Table1PostError(DataSet: TDataSet; E: EDatabaseError; var Action: TDataAction); begin ShowMessage('Das Wort befindet sich bereits in der Tabelle'); Action := daAbort end;

Durch die Zuweisung von daAbort wird die Aktion intern abgebrochen, es kommt zu keinen weiteren Meldungen.

16.5.3 Programmierung Kreuzworträtsel generieren Alle Funktionen, Variablen und Arrays zum Erstellen des Kreuzworträtsels finden Sie in der Unit cross. unit cross; interface

Definition der Kreuzworträtselgröße (wichtig: bei Änderung muss auch das DrawGrid in Form1 angepasst werden): const zeilen = 20; { Zeilen- und Spaltenzahl des Gitters > 13x13 } spalten = 20;

Für die interne Verwaltung und das Erstellen des Kreuzworträtsels werden wir ein Array verwenden, das auf dem folgenden Typ basiert: type gitterType = record // nur für die Darstellung buchstabe : string[1]; nummer : integer; black : boolean; w,s : boolean; end;

Im Feld Buchstabe wird entweder ein Leerzeichen oder der gesuchte Buchstabe gespeichert. Ist Nummer mit einem Wert ungleich 0 initialisiert, befindet sich an dieser Stelle der Startpunkt für einen Eintrag (es handelt sich um die Nummer, die später im Kreuzworträtsel angezeigt wird). Die Variable Black entscheidet darüber, ob ein Eintrag geschwärzt oder als Leerstelle im Gitter angezeigt wird. W und S entscheiden bei einem Startpunkt darüber, ob das Wort in horizontaler oder vertikaler Richtung forgesetzt wird (entweder nach rechts oder nach unten). Vielleicht werden Sie sich darüber wundern, wie das folgende Array deklariert wird. Auf den Grund gehen wir später noch detailliert ein. var gitter x,y,i nummer umschr matrix

: : : : :

array[0..spalten+1,0..zeilen+1] of gitterType; integer; integer; string; array[0..spalten,0..zeilen] of string[1];

16.5 WINCROSS – Ihr Kreuzworträtselexperte

899

Das zweite Array dient lediglich dazu, die Benutzereingaben im noch nicht ausgefüllten Kreuzworträtsel aufzunehmen. Später können dann diese Eingaben mit den tatsächlich notwendigen Werten aus dem Array Gitter verglichen und ausgewertet werden. Die einzige Prozedur, die exportiert wird, ist SetWord. procedure SetWord(wortl:byte; anz : integer; max:byte);

Übergabewerte sind die Wortlänge, die maximale Anzahl von Durchläufen des internen Zufallsgenerators sowie eine Abbruchschwelle, die bestimmt, nach wie vielen missglückten Aktionen die weitere Suche abgebrochen werden soll. Durch geschickte Variation der beiden letzten Parameter können Sie die Wortverteilung innerhalb des Kreuzworträtsels beeinflussen. Da lange Worte immer zuerst eingefügt werden müssen, gleichzeitig aber viele Abhängigkeiten bestehen können (viele Buchstaben sind durch bereits eingefügte Wörter festgelegt), müssen Sie diesem Problem durch erhöhte Werte bei anz und max Rechnung tragen. Gleichzeitig müssen bei kurzen Wörtern beide Werte drastisch reduziert werden, das sonst die Gefahr besteht, dass zu viele kurze Wörter eingefügt werden. Im Mittel sollten sich bis zu 40 Einträge im vorliegenden Kreuzworträtsel (20 x 20) unterbringen lassen. Weniger Suchbegriffe deuten darauf hin, dass die Wortverteilung nicht optimal ist. Eine wesentliche Verbesserung lässt sich zudem nur durch die drastische Vergrößerung der zugrunde liegenden Datenbank erreichen (viele Worte erhöhen die Wahrscheinlichkeit, dass auch ein Wort mit vielen Abhängigkeiten noch gefunden wird).

Die Suche nach der Einfügeposition Die folgende Prozedur hat gewissermaßen die Hauptarbeit beim automatischen Generieren des Rätsels zu leisten. Um den Programmieraufwand richtig zu würdigen, versuchen Sie doch einmal, selbst "per Hand" ein Kreuzworträtsel aufzustellen! Das ist weitaus schwieriger als das Lösen! Insbesondere die Abhängigkeiten zwischen den verschiedenen Einträgen erschweren die Aufgabe ungemein. procedure setword(wortl:byte; anz : integer; max:byte); var x,y, versuche,i: byte; n : integer; horz : boolean; { horizontal ? } maske,wort : string;

Strukturfanatiker sollten an dieser Stelle bitte beide Augen schließen: label ma1;

In einer Schleife (Endwert = Parameter anz) versucht das Programm über einen Zufallszahlengenerator mögliche Einfügepositionen zu finden. Den auf den ersten Blick 400 (20 x 20) möglichen Varianten stehen jedoch tatsächlich wesentlich weniger zulässige Möglichkeiten gegenüber. So wird beispielsweise bei einem waagerechten Eintrag die maximal mögliche x-Koordinate innerhalb des Gitters durch die Wortlänge eingeschränkt. Bei 13 Zeichen reduziert sich die Einfügeposition auf die Werte [1...7].

900

Kapitel 16

Applikationen

begin versuche := 0; { nach jeder erfolglosen Aktion wird dekrementiert } horz := true; { beginnen mit horizontal } form1.gauge1.progress := 0; form1.gauge1.maxvalue := anz; for n := 1 to anz do begin if versuche >= max then exit; { erfolglose Versuche ... } maske := ''; if horz then begin { horizontal } x := 1 + random(spalten-wortl-1); y := 1 + random(zeilen);

Ist ein erster Zufallswert gefunden, der im zulässigen Bereich liegt, sind Prüfungen bezüglich des Kreuzworträtselaufbaus vorzunehmen. Grundvoraussetzung ist ein so genannter Blocker vor und hinter dem einzufügenden Wort: Blocker

Blocker

Ohne diese beiden Felder könnte die eindeutige Länge später nicht mehr bestimmt werden. if (gitter[x-1,y].buchstabe<>' ')or (gitter[x+wortl,y].buchstabe<>' ')then goto ma1;

Nächster Schritt ist die Kontrolle, ob an der aktuellen Position bereits ein Wort beginnt: if gitter[x,y].w then goto ma1; // es steht ein wort an dieser Stelle

Danach müssen wir berücksichtigen, dass ein eventuell an dieser Stelle eingefügtes Wort nicht die Blocker anderer Einträge überschreibt. Dazu prüfen wir, ob in der Zeile darüber oder darunter ein Wort endet: FEHLER

Zulässig

for i := 0 to wortl-1 do begin if (gitter[x+i,y].buchstabe = ' ')and

16.5 WINCROSS – Ihr Kreuzworträtselexperte

901

((gitter[x+i,y-1].buchstabe <> ' ')or (gitter[x+i,y+1].buchstabe <> ' ')) then goto ma1;

An dieser Stelle wird auch deutlich, warum das Array größer als notwendig ist: Normalerweise müsste bei gitter[x+i,y-1] geprüft werden, ob die y-Koordinate noch im Arraybereich liegt. Sollten beide Bedingungen erfüllt sein, kann gleichzeitig die Suchmaske aufgebaut werden, die aus Leerzeichen und den bereits vorgegebenen Buchstaben besteht (Beispiel: Wort mit sechs Buchstaben, an der 5. Stelle steht ein "E"). maske := maske + gitter[x+i,y].buchstabe; end;

Der gleiche Vorgang angepasst für vertikale Wörter: end else begin { vertikal } x := random(spalten)+1; y := random(zeilen-wortl-1)+1; if (gitter[x,y-1].buchstabe<>' ')or (gitter[x,y+wortl].buchstabe<>' ') then goto ma1; { kein Blocker } if gitter[x,y].s then goto ma1; // es steht ein Wort an dieser Stelle for i := 0 to wortl-1 do begin if (gitter[x,y+i].buchstabe = ' ')and ((gitter[x-1,y+i].buchstabe <> ' ')or (gitter[x+1,y+i].buchstabe <> ' ')) then goto ma1; maske := maske + gitter[x,y+i].buchstabe; end; end;

Sollte sich in der Suchmaske kein Platzhalter befinden, ist es sinnlos, nach einem Wort zu suchen: if pos(' ',maske) = 0 then goto ma1; { alle Zeichen bekannt }

Nächster Schritt ist die Suche in der Datenbank. Die Funktion liefert entweder ein gültiges Wort oder einen Leerstring zurück: wort := findword(maske);

Im Erfolgsfall: if wort <> '' then begin { eintragen des Wortes ...} if horz then begin { horizontal }

Vormerken, dass an der aktuellen Position bereits ein Wort eingetragen wurde: gitter[x,y].w:= true;

Falls nicht schon vorhanden, eine laufende Nummer vergeben: if gitter[x,y].nummer = 0 then begin inc(nummer); gitter[x,y].nummer := nummer; end;

902

Kapitel 16

Applikationen

In das Aufgabenformular werden Nummer, Einfügerichtung und Umschreibung eingetragen: form2.stringgrid1.rowcount := form2.stringgrid1.rowcount + 1; form2.stringgrid1.cells[0,form2.stringgrid1.rowcount-2]:= inttostr(nummer); form2.stringgrid1.cells[1,form2.stringgrid1.rowcount-2]:= 'waagerecht'; form2.stringgrid1.cells[2,form2.stringgrid1.rowcount-2]:= umschr;

Im internen Array wird das Wort eingetragen, um später die Lösung anzeigen zu können: for i := 0 to length(wort)-1 do begin gitter[x+i,y].buchstabe:=wort[i+1]; gitter[x+i,y].black:=false; end;

Der gleiche Ablauf für senkrechte Einträge: end else begin { vertikal } gitter[x,y].s:= True; if gitter[x,y].nummer = 0 then begin inc(nummer); gitter[x,y].nummer := nummer; end; form2.stringgrid1.rowcount := form2.stringgrid1.rowcount + 1; form2.stringgrid1.cells[0,form2.stringgrid1.rowcount-2]:= inttostr(nummer); form2.stringgrid1.cells[1,form2.stringgrid1.rowcount-2]:= 'senkrecht'; form2.stringgrid1.cells[2,form2.stringgrid1.rowcount-2]:= umschr; for i := 0 to length(wort)-1 do begin gitter[x,y+i].buchstabe:=wort[i+1]; gitter[x,y+i].black :=false; end; form1.drawgrid1.repaint; end; versuche := 1;

Sollte kein Wort gefunden werden, wird die Anzahl der Versuche inkrementiert, jedes gefundene Wort setzt den Versuchszähler auf 1 zurück. Auf diese Weise wird unnötiger Leerlauf vermieden, sollte sich nach max Versuchen kein Erfolg einstellen, wird die Schleife einfach abgebrochen. end else begin { kein Wort gefunden } inc(versuche) end;

Da die Sucherei etwas dauern kann, wird eine Fortschrittsanzeige bei jedem Durchlauf aktualisiert, gleichzeitig wird etwas Rechenzeit für die Oberfläche (Abbruch-Button) sowie andere Anwendungen freigegeben. ma1:

{ Noteinsprungmarke } form1.gauge1.progress := n; if n mod 10 = 0 then application.processmessages;

16.5 WINCROSS – Ihr Kreuzworträtselexperte

horz := not horz; end;

903

{ umschalten zwischen horz. und vertikal }

end;

Nach dem Durchlauf wird zwischen horizontaler und vertikaler Richtung gewechselt, damit das Einfügegitter möglichst gleichmäßig belegt wird. An dieser Stelle könnte eventuell eine Verbesserung vorgenommen werden: Um eine möglichst gleichmäßige Verteilung zu erreichen, könnte die Anzahl senkrechter und waagerechter Wörter gezählt werden.

Die Suche nach einem möglichen Eintrag ... oder vielleicht die Suche nach der Nadel im Heuhaufen? Eigentlich ist der Vergleich nicht ganz treffend, ist doch schon einiges über das Wort bekannt (Länge und eventuell eine Suchmaske). Nach dem Zufallsprinzip ermittelt die folgende (lokale) Funktion ein Wort aus der Datenbank, das der Vorgabe entspricht. Bei negativem Ausgang der Suche wird ein Leerstring zurückgegeben. Bevor es jedoch so weit ist, müssen wir die beiden Datenquellen richtig initalisieren. Warum wir mit einer Table und einer Query-Komponente arbeiten? Die Anwort ist schnell gefunden: Wenn es darum geht, ein beliebiges Wort mit vorgegebener Länge aus einer Tabelle zu ermitteln, ist eine Table-Komponente wesentlich schneller. Eine Query würde bei einer normalen SQL-Abfrage jede Menge Datensätze ermitteln, was natürlich seine Zeit dauert. Bei einer Table brauchen Sie lediglich den Index zu setzen (ilänge) und nachfolgend einen Bereich auszuwählen (SetRange). Mit MoveBy suchen wir uns dann nur noch einen beliebigen Datensatz aus der Tabelle heraus. function findWord(vorgabe:string):string; var sqlString, s:string; i,n :integer; begin result:= ''; { pessimistisch } n := 0; for i := 1 to length(vorgabe) do if vorgabe[i]= ' ' then begin inc(n); vorgabe[i] := '_'; end; if n = length(vorgabe) then with form1.table2 do begin active := true; setrange([length(vorgabe)],[length(vorgabe)]); first; moveby(random(Recordcount-1)); result := FieldByName('wort').AsString; umschr := FieldByName('Umschreibung').AsString; exit; end;

Etwas anders sieht die Sache bei einer Query aus. Zum einen müssen wir die Länge, zum anderen den Suchstring übergeben. Im Programm nutzen wir zu diesem Zweck die Möglichkeit, Parameter an eine Abfrage zu übergeben. Dazu definieren Sie zur Entwurfszeit folgende SQL-Abfrage:

904

Kapitel 16

Applikationen

Die beiden Parameter :maske und :zeichen können Sie zur Laufzeit über die ParamByNameMethode setzen. Definieren Sie jedoch vorher noch die Datentypen der Parameter (Eigenschaft Params):

Der Ablauf ist relativ simpel; Abfrage deaktivieren: form1.query3.Active := false;

Parameter setzen: form1.query3.parambyname('maske').asstring:= vorgabe; form1.query3.parambyname('zeichen').asinteger:= length(vorgabe); with form1.query3 do begin

Abfrage wieder aktivieren: Open;

Je nachdem, ob kein, ein oder mehrere Datensätze zurückgegeben werden, suchen wir einen zufälligen Datensatz, geben den einen gefundenen zurück oder beenden die Funktion:

16.5 WINCROSS – Ihr Kreuzworträtselexperte

905

i := Recordcount; case i of 0 : exit; 1 : result := FieldByName('wort').AsString; else begin moveby(random(Recordcount-1)); result := FieldByName('wort').AsString; end end; umschr := FieldByName('Umschreibung').AsString end end;

Sollten Sie das Programm dahingehend erweitern, dass alle Wörter einer Länge in jeweils einer Tabelle abgelegt werden, müssten Sie den SQL-String vor jedem Aufruf entsprechend verändern. Beispiel: ... Query3.SQL.Clear; Query3.SQL.Add("SELECT * FROM ..."); Query3.Open;

Was noch bleibt, ist die Initialisierung der Arrays, die im initialization-Abschnitt vorgenommen wird: initialization for x := 0 to spalten+1 do for y := 0 to zeilen+1 do begin gitter[x,y].buchstabe := ' '; gitter[x,y].nummer := 0; gitter[x,y].black := true; gitter[x,y].w := false; gitter[x,y].s := false; end; for x := 0 to spalten do for y := 0 to zeilen do matrix[x,y] := ' '; end.

Anzeige im DrawGrid Ist das Array gitter entsprechend gefüllt, könnte der Anwender damit beginnen, das Kreuzworträtsel zu lösen. Vorher muss allerdings eine geeignete Anzeigemöglichkeit gefunden werden. Mit dem DrawGrid bietet sich die Möglichkeit, beliebige Ausgaben in einem Gittersegment vorzunehmen. Dies ist insbesondere für die Anzeige der Nummern wichtig, die wesentlich kleiner als der eigentliche Buchstabe dargestellt werden sollen. Über das Ereignis DrawCell haben Sie die Möglichkeit, jede einzelne Zelle über ein CanvasObjekt mit grafischen Ausgaben zu füllen (dazu gehört eben auch Text). procedure TForm1.DrawGrid1DrawCell(Sender: TObject; Col, Row: Longint; Rect: TRect; State: TGridDrawState); begin with drawgrid1.canvas do begin if gitter[col+1,row+1].black then begin

906

Kapitel 16

Applikationen

brush.style := bsSolid; brush.color := clblack; fillrect(Rect); end else begin brush.style := bsClear; font.height:=14; font.Style := []; if gitter[col+1,row+1].nummer <> 0 then textout(Rect.left,Rect.top,IntToStr(gitter[col+1,row+1].nummer)); font.Style := [fsBold]; font.height:=36; if sichtbar then begin if gitter[col+1,row+1].buchstabe <> matrix[col,row] then font.color := clred else font.color := clblack; if gitter[col+1,row+1].buchstabe <> ' ' then textout(Rect.left+8,Rect.top+8,gitter[col+1,row+1].buchstabe) end else textout(Rect.left+8,Rect.top+8,matrix[col,row]) end end end;

Bei der Ausgabe wird zwischen zwei Varianten unterschieden: Entweder wird lediglich der Inhalt des matrix-Arrays (Nutzereingabe) oder der Inhalt von gitter (die Lösung des Kreuzworträtsels) angezeigt. Optional wird bei einem Wortanfang die kleine Nummer angezeigt, welche die Einfügeposition kennzeichnet. Über das KeyPress-Ereignis schränken wir die Möglichkeit ein, Eingaben im DrawGrid vorzunehmen. Zulässig sind lediglich Buchstaben, die automatisch in Großbuchstaben umgewandelt werden. Das Zeichen selbst wird nicht in der jeweiligen Zelle, sondern in einem Hilfsarray gespeichert. Die Werte dieses Arrays werden im DrawCell-Ereignis dazu genutzt, den Inhalt des Gitters darzustellen. procedure TForm1.DrawGrid1KeyPress(Sender: TObject; var Key: Char); begin if gitter[DrawGrid1.col+1,DrawGrid1.row+1].black then begin key:=#0; messagebeep(0); end else begin case key of 'A'..'z' : begin matrix[drawgrid1.col,drawgrid1.row]:=upcase(key); key :=#0; end; else begin matrix[drawgrid1.col,drawgrid1.row]:=' '; key :=#0; end; end;

16.5 WINCROSS – Ihr Kreuzworträtselexperte

907

drawgrid1.repaint; end; end;

Suchen von Begriffen und Umschreibungen Für die PageControl-Seiten "Beschreibung suchen" und "Begriff suchen" sind einige Anpassungen nötig. Unter anderem soll die Eingabe in die Suchmaske auf die zulässigen Zeichen beschränkt werden: procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char); begin case key of 'A'..'z' : begin (sender as TEdit).text:=upcase(key); key := #0; end; else begin key := #0; (sender as TEdit).text:='?'; end; end; end;

Die Routine wird von allen Eingabefeldern verwendet, über die Auswertung des Sender-Objekts können wir die gerade aktive Komponente ermitteln. Die eigentliche Suche wird von jeder Veränderung in den Eingabefeldern oder durch einen Wechsel in der ComboBox (Wortlänge) ausgelöst: procedure TForm1.ComboBox2Change(Sender: TObject); var i :integer; s,s1 : string; begin with query1 do begin active := false; filter := '[länge] = ' + inttostr(combobox2.itemindex+2); s1 := edit1.text + edit2.text + edit3.text + edit4.text + edit5.text + edit6.text + edit7.text + edit8.text + edit9.text + edit10.text + edit11.text + edit12.text + edit13.text; s1 := copy(s1,1,combobox2.itemindex+2); for i := 1 to combobox2.itemindex+2 do if s1[i]= '?' then s1[i]:= '_'; parambyname('suchwort').asstring := s1; open; end; end;

Die zugehörige SQL-Abfrage: SELECT Wort, Umschreibung, Länge

908

Kapitel 16

Applikationen

FROM woerter WHERE wort LIKE :suchwort

Wie schon beim Suchen von Wörtern für den Aufbau des Kreuzworträtsels wird aus mehreren Einzelstrings die Suchmaske aufgebaut. Nachfolgend werden alle Fragezeichen gegen den ANSIPlatzhalter ("_") ausgetauscht. Die so aufbereitete Suchmaske braucht nur noch als Parameter an die Abfrage übergeben zu werden.

Druckausgabe Neu in der Version WinCross 2.0 ist die Möglichkeit, das Kreuzworträtsel auch auszudrucken. Die Ausgabe erfolgt auf zwei einzelnen Blättern, auf diese Weise ist das Kreuzworträtsel nicht gar zu klein. procedure var w,v : OUTDC x,y

TForm2.Button2Click(Sender: TObject); TSize; : HDC; : integer;

begin

Einen Druckauftrag starten: printer.begindoc;

Nach dieser Zeile ist das Canvas-Objekt richtig initialisiert, wir können die Eigenschaft Handle für einige GDI-Aufrufe abfragen. outDC := printer.canvas.handle;

Auf die folgenden Anweisungen wollen wir an dieser Stelle nicht weiter eingehen, nur so viel: Es geht darum, das Koordinatensystem des Druckers so zu verändern, dass alle Koordinatenangaben in 1/10mm erfolgen können. setmapmode(OutDC,mm_lometric); // 1/10 mm aber Y geht nach oben GetWindowExtEx(OutDC,w); // Auflösung ermitteln GetViewportExtEx(OutDC,v); setmapmode(OutDC,MM_ANISOTROPIC); // neuer Abb.-Modus SetWindowExtEX(OutDC,w.cx,w.cy,nil); // Skalierung ... SetViewPortExtEx(OutDC,v.cx,-v.cy,nil);

Mit den folgenden Anweisungen wird das Grundraster des Kreuzworträtsels erzeugt: for x := 0 to 20 do begin printer.canvas.moveto(300 + x*75,300); printer.canvas.lineto(300 + x*75,1800); end; for y := 0 to 20 do begin printer.canvas.moveto(300,300 + y*75); printer.canvas.lineto(1800,300 + y*75); end;

16.5 WINCROSS – Ihr Kreuzworträtselexperte

909

Eintragen der Leerstellen und der Ziffern für die Einfügepositionen (die ganze Rechnerei sieht komplizierter aus, als sie es ist): for x := 1 to 20 do for y := 1 to 20 do begin if gitter[x,y].buchstabe <> ' ' then begin // Buchstabe if gitter[x,y].nummer <> 0 then begin

HINWEIS: Vergessen Sie nicht, die Pinselfarbe auf clwhite festzulegen, andernfalls ist der Text

nicht zu erkennen, da Textausgaben standardmäßig auf einem mit der aktuellen Pinselfarbe gefüllten Rechteck ausgeführt werden. printer.Canvas.Brush.Color := clwhite; printer.canvas.font.name := 'arial'; printer.canvas.font.height:= 25; printer.canvas.textout(310+(x-1)*75,310+ (y-1)*75,inttostr(gitter[x,y].nummer)); end; end else begin // schwarz printer.Canvas.Brush.Color := clblack; printer.canvas.fillrect(Bounds(300+(x-1)*75,300+(y-1)*75,75,75)) end; end;

Neue Druckseite auswählen: printer.newpage; printer.Canvas.Brush.Color := clwhite; printer.canvas.font.height:= 40;

Reine Textausgabe (Nummer, Richtung und Umschreibung): for y := 0 to stringgrid1.rowcount-2 do begin printer.canvas.textout(310,310+y*50,stringgrid1.cells[0,y]); printer.canvas.textout(410,310+y*50,copy(stringgrid1.cells[1,y],1,1)); printer.canvas.textout(510,310+y*50,stringgrid1.cells[2,y]); end; Printer.EndDoc end;

16.5.4 Bemerkungen ■ Dass die generierten Rätsel mitunter größere Lücken (schwarze Flächen) aufweisen, hat seine Ursache nicht nur in den verwendeten Algorithmen, sondern im auf ca. 3000 Einträge beschränkten Umfang der mitgelieferten Datenbank WOERTER.DB. Professionelle Kreuzworträtselgeneratoren greifen auf Datenbanken mit 40.000 und mehr Wörtern zurück! Sie können schrittweise Abhilfe schaffen, wenn Sie sich in Ihren Mußestunden ab und zu dem Ausbau des Wörterbuchs widmen. ■ Hauptanliegen des Programms WINCROSS ist die Demonstration von Algorithmen, die Perfektion der Kreuzworträtsel steht erst an zweiter Stelle!

17

How-to: Sprache

Kapitel

17

How-to: Sprache 17.1 Das Währungsformat ändern Die für die Währungsanzeige wichtigsten globalen Systemvariablen sind in der folgenden Tabelle enthalten: Deklaration

Standard

Erläuterung

CurrencyString: String;

€

Währungseinheit

ThousandSeparator: Char;

.

Tausender-Trennzeichen

DecimalSeparator: Char;

,

Dezimal-Trennzeichen

CurrencyDecimals: Byte;

2

Anzahl Nachkommastellen

Oberfläche Wir wollen dem Ergebnis vorgreifen und Sie gleich mit einer Laufzeit-Ansicht des Formulars konfrontieren. Es besteht im Wesentlichen aus fünf Editierfeldern (Edit1 ... Edit5) sowie zwei Schaltflächen (Button1, Button2). Da in die mittleren drei Editierfelder nur jeweils ein Zeichen einzugeben ist, setzen Sie deren MaxLength-Eigenschaft auf 1.

912

Kapitel 17

How-to: Sprache

Quelltext Wir wollen uns auf die Wiedergabe des wirklich interessierenden Codeteils beschränken, der sich im Implementation-Abschnitt der Formular-Unit befindet. Zunächst brauchen wir einige Variablen zum Zwischenspeichern var cs: string; ts, ds: Char; cd: Byte;

// Variablen zum Zwischenspeichern

und Routinen zum Sichern procedure saveStandards; begin cs := CurrencyString; ts := ThousandSeparator; ds := DecimalSeparator; cd := CurrencyDecimals end;

und Restaurieren der Standardwerte: procedure resetStandards; begin CurrencyString:=cs; ThousandSeparator:=ts; DecimalSeparator:=ds; CurrencyDecimals:=cd end;

Die aktuellen Systemeinstellungen anzeigen: procedure displayValues; begin with Form1 do begin Edit1.Text := CurrencyString; Edit2.Text:= ThousandSeparator; Edit3.Text := DecimalSeparator; Edit4.Text:= IntToStr(CurrencyDecimals); Edit5.Text := Format('%m',[1234.567890]) end end;

Nun zu den Ereignismethoden. Die Startanzeige: procedure TForm1.FormCreate(Sender: TObject); begin saveStandards; displayValues end;

Die Änderungen übernehmen: procedure TForm1.Button1Click(Sender: TObject); begin CurrencyString := Edit1.Text;

// Testausdruck

17.2 Beträge formatieren und berechnen

913

ThousandSeparator := Edit2.Text[1]; DecimalSeparator := Edit3.Text[1]; CurrencyDecimals := StrToInt(Edit4.Text); displayValues end;

Die Standardwerte anzeigen: procedure TForm1.Button2Click(Sender: TObject); begin resetStandards; displayValues end; end.

Test Starten Sie das Programm. Falls Sie (was bei einer standardmäßigen Windows-Installation anzunehmen ist) als Ländereinstellung "deutsch" aktiviert haben, sollte sich Ihnen der eingangs gezeigte Anblick bieten. Ändern Sie einige (oder alle) Einstellungen, und klicken Sie auf die Schaltfläche "Änderungen übernehmen". Auf diese Weise können Sie zu einem völlig neuen Währungsformat kommen (wie wäre es z.B. mit Teuro?). Da gleich bei Programmstart die Standardwerte gesichert werden, brauchen Sie keine Bedenken zu haben, dass Sie die Systemeinstellungen durcheinander bringen. Klicken Sie "Standardwerte wiederherstellen" an, um den ursprünglichen Zustand zu restaurieren.

Bemerkung Weitere Informationen entnehmen Sie bitte Ä 17.2 Beträge formatieren und berechnen

17.2 Beträge formatieren und berechnen Unter Delphi existiert eine fast schon erdrückende Vielfalt von Möglichkeiten, um Zahlen im gewünschten Format darzustellen. Wie man Währungsbeträge eingibt und wie man bei der Ausgabe gleichzeitig formatieren und rechnen kann, soll das folgende Demo-Beispiel zeigen.

Oberfläche Es sollte Ihnen keine Probleme bereiten, auf dem Startformular (Form1) in Windeseile die folgende Oberfläche "zusammenzuschieben", die im Wesentlichen aus einem Editierfeld (Edit1), zwei RadioButtons (RadioButton1 und RadioButton2) sowie zwei Schaltflächen (Button1, Button2) besteht:

914

Kapitel 17

How-to: Sprache

Setzen Sie die Text-Eigenschaft des Editierfeldes sowie die Caption-Eigenschaft des Anzeigefeldes auf einen Leerstring. Außerdem kann es nichts schaden, die AutoSize-Eigenschaft von Label1 auf False und WordWrap auf True umzustellen. Beide OptionButtons werden innerhalb einer GroupBox platziert, und die Checked-Eigenschaft eines von beiden wird auf True gesetzt.

Quelltext Da der Interface-Abschnitt der Formular-Unit keinerlei Besonderheiten bietet, beschränken wir uns auf den Implementation-Abschnitt: implementation var mwst, brutto: Single; fstr: String; // Formatstring code: Integer; procedure TForm1.RadioButtonClick(Sender: TObject); begin Label1.Caption := '' // Anzeige löschen end;

Die wesentlichen Aktivitäten: procedure TForm1.Button1Click(Sender: TObject); // Klick auf "Berechnen" begin // Mwst-Satz lesen: if RadioButton1.Checked then mwst := 0.16; if RadioButton2.Checked then mwst := 0.07; Val(Edit1.Text, brutto, code); // Eingabe lesen // formatierte Ausgabe: Label1.Caption := Format(fstr,[brutto/(1+mwst), brutto/(1+1/mwst)]) end;

Da wir nur einen einzigen Formatierungsstring verwenden, können wir ihn gleich zu Beginn zuweisen: procedure TForm1.FormCreate(Sender: TObject); begin fstr := 'Der Nettopreis beträgt %m, die entrichtete Steuer %m!'; end; end.

915

17.3 Das Datumsformat ändern

Test Geben Sie verschiedene Werte ein und kontrollieren Sie die Ausgabe:

17.3 Das Datumsformat ändern In der Hilfe zu Borland Delphi tummelt sich eine kaum noch überschaubare Vielzahl unterschiedlichster Formatierungsstrings ('c', 'd', 'dd', 'ddd', 'ddddd', 'dddddd', 'm', 'mm' ... usw.) für die FormatDateTime-Funktion bzw. die DateTimeToStr-Prozedur, deren spezielle Bedeutung wiederum von den folgenden globalen Variablen abhängt: Deklaration der globalen Variablen

Formatstring

Standardwert(e)

Erläuterung

DateSeparator: Char; ShortDateFormat: string;

/

.

Datumstrennzeichen

ddddd c

dd.mm.yy

kurzes Datumsformat

LongDateFormat: string;

dddddd

dddd,d.mmmm yyyy

langes Datumsformat

ShortMonthNames: array[1..12] of string;

mmm

Jan, Feb, Mrz, Apr ....

Array für die kurzen Monatsnamen

LongMonthNames: array[1..12] of string;

mmmm

Januar, Februar, März, ...

Array für die langen Monatsnamen

ShortDayNames: array[1..7] of string;

ddd

So, Mo, Di, Mi, Do, ...

Array für die kurzen Tagesnamen

LongDayNames: array[1..7] of string;

dddd

Sonntag, Montag, Dienstag, Array für die langen ... Tagesnamen

Die notwendige Sicherheit im Umgang mit diesen Formatstrings gewinnt man erst durch ein kleines Experimentierprogramm, das uns ein "Herumdoktern" an diesen Variablen und ein Begutachten der Auswirkungen auf diverse Datumsanzeigen erlaubt.

916

Kapitel 17

How-to: Sprache

Oberfläche Für die Ein- und Ausgabe brauchen wir eine Vielzahl von Editierfeldern. Um hier wenigstens etwas einzusparen, wird die Anzeige zwischen langen und kurzen Monats- bzw. Tagesnamen umgeschaltet. Für die nicht editierbaren Felder wird ReadOnly = True gesetzt, außerdem erhalten sie einen gelben Hintergrund.

Quelltext Wir beschränken uns auf die Wiedergabe des Implementation-Abschnitts von Form1: var datum: TDateTime;

Eine Anzeigeprozedur für die kurzen und langen Monatsnamen: procedure displayMonthNames; begin with Form1 do begin if RadioButton1.Checked then

17.3 Das Datumsformat ändern

begin Edit1.Text:= ShortMonthNames[1]; Edit2.Text:= ShortMonthNames[2];

und so weiter ... Edit12.Text:= ShortMonthNames[12] end else begin Edit1.Text:= LongMonthNames[1]; Edit2.Text:= LongMonthNames[2];

und so weiter ... Edit12.Text:= LongMonthNames[12] end end end;

Eine Anzeigeprozedur für die kurzen und langen Tagebezeichner: procedure displayDayNames; begin with Form1 do begin if RadioButton3.Checked then begin Edit13.Text:= ShortDayNames[1]; ... Edit19.Text:= ShortDayNames[7] end else begin Edit13.Text:= LongDayNames[1]; Edit14.Text:= LongDayNames[2]; ... Edit19.Text:= LongDayNames[7] end end end;

Das kurze und das lange Datumsformat anzeigen: procedure displayDateFormat; begin Form1.Edit20.Text := ShortDateFormat; Form1.Edit28.Text:= LongDateFormat end;

Anzeige zwischen langen und kurzen Namen umschalten: procedure TForm1.RadioButtonClick(Sender: TObject); begin displayMonthNames; displayDayNames end;

917

918

Kapitel 17

How-to: Sprache

Nun passiert es: procedure TForm1.Button1Click(Sender: TObject); begin DateSeparator := Edit21.Text[1]; datum := StrToDate(Edit33.Text); ShortDateFormat := Edit20.Text; LongDateFormat := Edit28.Text;

// Änderungen übernehmen

Die verschiedenen d-Formatierungen: Edit22.Text Edit23.Text Edit24.Text Edit25.Text Edit26.Text Edit27.Text

:= := := := := :=

FormatDateTime('d', datum); FormatDateTime('dd', datum); FormatDateTime('ddd', datum); FormatDateTime('dddd', datum); FormatDateTime('ddddd', datum); FormatDateTime('dddddd', datum);

Die verschiedenen m-Formatierungen: Edit29.Text Edit30.Text Edit31.Text Edit32.Text end;

:= := := :=

FormatDateTime('m', datum); FormatDateTime('mm', datum); FormatDateTime('mmm', datum); FormatDateTime('mmmm', datum);

Beim Laden des Formulars wird das aktuelle Datum genommen: procedure TForm1.FormCreate(Sender: TObject); begin displayMonthNames; displayDayNames; displayDateFormat; Edit21.Text := DateSeparator; Edit33.Text := DateToStr(Date); datum := Date; // Übernahme des aktuellen Datums Button1Click(Self) // zur Ereignisprozedur "Änderungen übernehmen" end;

Falls Sie lieber Sonnabend anstatt Samstag hätten, so fügen Sie in das FormCreate-Event noch folgende Anweisung ein: LongDayNames[7] := 'Sonnabend';

Test Nach dem Programmstart können Sie zunächst einmal die Standardeinstellungen, bezogen auf das aktuelle Datum, begutachten:

17.3 Das Datumsformat ändern

919

Als Nächstes können Sie spaßeshalber einmal ShortDateFormat oder LongDateFormat modifizieren. Sie haben hierbei ziemlich freizügige Gestaltungsmöglichkeiten. BEISPIEL: Tragen Sie unter "LongDateFormat" ein: dddd,"den" d.mm.yy

Sie erhalten nach Betätigen der Schaltfläche "Änderungen übernehmen" die Datumsanzeige: Dienstag, den 24.09.02 ... was dem Rückgabewert der Funktion FormatDateTime('dddddd', Date)

entspricht. Etwas vorsichtiger müssen Sie beim Verändern des Zeichens für DateSeparator zu Werke gehen. Um hier keinen Fehler zu produzieren, müssen Sie oben im Feld "Datum ändern" erst manuell das Datumsformat anpassen, ehe Sie die Schaltfläche "Änderungen übernehmen" betätigen. In den Formatierungsstrings wirkt sich der geänderte Separator nur dort aus, wo Sie vorher einen Slash (/) gesetzt haben.

920

Kapitel 17

How-to: Sprache

BEISPIEL: Geben Sie für DateSeparator das Zeichen "-" ein, müssen Sie per Handeintrag zunächst das Datum

anpassen: 24-09-02 Geben Sie nun für ShortDateFormat ein: dd/mm.yy Sie erhalten die Datumsangabe: 24-09.02 ... was dem Rückgabewert der Funktion FormatDateTime('ddddd', Date)

entspricht.

Bemerkungen Weitere Informationen entnehmen Sie bitte Ä 17.2 Beträge formatieren und berechnen Ä 17.5 Mit Datums-/Zeitfunktionen arbeiten Wie Sie Fehler bei falschen Datumseingaben abfangen können, siehe Ä 17.6 Auf Datum oder Zeit testen

17.4 Das Zeitformat ändern Es gelten ähnliche Überlegungen wie beim Ändern des Datumsformats, nur dass wir es diesmal nicht mit Datums-, sondern mit Zeitwerten zu tun haben, für deren Darstellungen im Wesentlichen drei globale Variablen in Frage kommen: Deklaration der globalen Variablen

Formatstring

TimeSeparator: Char;

:

ShortTimeFormat: string;

t

LongTimeFormat: string;

tt

Die globalen Variablen TimeAMString und TimePMString sind bei einer deutschsprachigen Systemeinstellung von zweitrangiger Bedeutung, so dass wir auch sehr gut ohne sie auskommen.

Oberfläche Als Vorbild soll der folgende Formularentwurf dienen. Achten Sie auf den Timer! Die IntervalEigenschaft des Timers bleibt auf dem Standardwert 1000 (ms).

17.4 Das Zeitformat ändern

921

Quelltext Wir beschränken uns auf die Wiedergabe des Implementation-Abschnitts der Formular-Unit. Beim Laden werden die aktuellen Einstellungen der globalen Variablen angezeigt: procedure TForm1.FormCreate(Sender: TObject); begin Edit1.Text := ShortTimeFormat; Edit2.Text := LongTimeFormat; Edit3.Text := TimeSeparator end;

Im Sekundentakt sorgt folgende Ereignisroutine für die Anzeige aller interessierenden Formatierungen, bezogen auf die aktuelle Uhrzeit: procedure TForm1.Timer1Timer(Sender: TObject); begin if RadioButton1.Checked then Edit4.text := FormatDateTime('t',Time) else Edit4.Text := TimeToStr(Time); Edit5.Text := FormatDateTime('h',Time); Edit6.Text := FormatDateTime('hh',Time); Edit7.Text := FormatDateTime('n',Time); Edit8.Text := FormatDateTime('nn',Time); Edit9.Text := FormatDateTime('s',Time); Edit10.Text := FormatDateTime('ss',Time) end;

Die Übernahme der vorgenommenen Änderungen an den globalen Variablen: procedure TForm1.Button2Click(Sender: TObject); begin

922

Kapitel 17

How-to: Sprache

ShortTimeFormat := Edit1.Text; LongTimeFormat := Edit2.Text; TimeSeparator := Edit3.Text[1] end;

Test Nach dem Programmstart können Sie an den globalen Variablen "herumdoktern" und sich sofort vom Ergebnis überzeugen. Im folgenden Beispiel wurde ShortTimeFormat so modifiziert, dass Sie eine andere als die sonst übliche Zeitanzeige erhalten:

Wenn Sie TimeSeparator ändern, erscheint das neue Symbol überall dort, wo in ShortTimeFormat bzw. LongTimeFormat der Doppelpunkt (:) steht.

Bemerkungen ■ Anstatt m sollten Sie besser n für das Minutensymbol nehmen, da hier keine Verwechslungsgefahr mit dem Monatssymbol bei Datumsstrings besteht. ■ Experimentieren Sie auch einmal mit dem Bezeichner c, der gewissermaßen ddddd und tt zwecks gleichzeitiger Anzeige von Datum und Zeit zusammenfasst.

17.5 Mit Datums-/Zeitfunktionen arbeiten Wer hatte nicht schon das Problem, Zeit- oder Datumsdifferenzen zu berechnen? Funktionieren die entsprechenden Delphi-Funktionen auch noch im Jahr 2000? Das folgende Beispielprogramm zeigt, wie Sie Datums- und Zeitwerte ermitteln und wie Sie damit rechnen können. Es vermittelt gleichzeitig nützliche Erkenntnisse über den Sinn von try...except-Blöcken.

923

17.5 Mit Datums-/Zeitfunktionen arbeiten

Oberfläche Erstellen Sie eine Eingabemaske nach folgendem Vorbild:

Quelltext Initialisieren der Eingabefelder mit den aktuellen Datumswerten: procedure TForm1.FormCreate(Sender: TObject); begin Panel1.Caption := DateTimeToStr(Now); Panel2.Caption := TimeToStr(Time); Panel3.Caption := DateToStr(Date); Edit2.Text := DateToStr(Date); Edit3.Text := DateToStr(Date) end;

Die folgenden Event-Handler haben wir mit try-except-Blöcken so geschützt, dass bei fehlerhaften Datumseingaben kein Programmabbruch stattfindet. Berechnung eines Datumswertes: procedure TForm1.Edit1Change(Sender: TObject); // Heute plus ... Tage ist ... begin try Panel4.Caption := FormatDateTime('dd.mm.yyyy',date + StrToInt(Edit1.Text)) except Panel4.Caption := 'Fehler' end end;

Ermitteln einer Datumsdifferenz: procedure TForm1.Edit2Change(Sender: TObject); begin try

// Die Tagesdifferenz zwischen ...

924

Kapitel 17

How-to: Sprache

Panel5.Caption := IntToStr(Round(StrToDate(Edit2.Text) - StrToDate(Edit3.Text))) except Panel5.Caption := 'Fehler!'; end end;

Zerlegen von Datumswerten: procedure TForm1.Edit4Change(Sender: TObject); // Geben Sie ein Datum ein ... var dat:TDateTime; begin try dat := StrToDate(Edit4.Text); Panel6.Caption := FormatDateTime('dd.mm.yyyy',dat); Panel7.Caption := FormatDateTime('dddd',dat); Panel8.Caption := FormatDateTime('mmmm',dat); Panel9.Caption := FormatDateTime('yy',dat) except Panel6.Caption := 'Fehler'; Panel7.Caption := 'Fehler'; Panel8.Caption := 'Fehler'; Panel9.Caption := 'Fehler' end end;

Falls im try-Abschnitt ein Fehler auftritt, wird im except-Abschnitt weitergemacht und eine gezielte Fehlerbehandlung durchgeführt.

Test Starten Sie das Programm und experimentieren Sie. Das ist der beste Weg, um Klarheit über den Sinn der einzelnen Datums-/Zeitroutinen zu erlangen.

17.6 Auf Datum oder Zeit testen

925

Bemerkungen ■ Dank try...except wird es Ihnen nicht gelingen, die Applikation durch Eingabe sinnloser Datumswerte zum Absturz zu bewegen. Voraussetzung dafür ist allerdings, dass Sie im Menü Tools|Debugger-Optionen... auf der "Sprach-Exceptions"-Seite das Häkchen "Bei DelphiExceptions stoppen" entfernt haben. Ansonsten sind Ihre schönen try-except-Blöcke für die Katz, und Sie werden mit den üblichen Delphi-Fehlermeldungen genervt. Dies passiert Ihnen allerdings nur zur Entwurfszeit. ■ Die fertige EXE-Datei berücksichtigt try-except-Blöcke in jedem Fall, die Einstellungen der Umgebungsoptionen bleiben ohne Einfluss.

17.6 Auf Datum oder Zeit testen Für die Überprüfung von Eingaben in ein Textfeld ist in vielen Fällen auch der Test auf Datum oder Zeit erforderlich. Eine entsprechende Funktion, die True oder False zurückgibt, werden Sie in Delphi nicht finden, in anderen Programmiersprachen gibt es so etwas aber. Wir wollen die Funktionen IsDate und IsTime von Visual Basic nachbilden.

Oberfläche Außer drei Buttons, einer Edit-Komponente und einem Label brauchen Sie nichts weiter:

926

Kapitel 17

How-to: Sprache

Quelltext Grundlage unserer "selbst gebastelten" Funktionen ist der Versuch, einen String in ein Datum oder eine Zeit umzuwandeln. Schlägt dieser fehl, handelt es sich eben nicht um ein Datum oder eine Zeit. Um den auftretenden Fehler abzufangen, verwenden wir eine Exception-Behandlung mit TryExcept: function IsDate(s:string): Boolean; var dummy : TDateTime; begin Result := True; try dummy := StrToDate(s) except Result := False end end; function IsTime(s:string): Boolean; var dummy : TDateTime; begin Result := True; try dummy := StrToTime(s) except Result := False end end;

Die Belegung der Buttons und ein Test der obigen Funktionen: procedure TForm1.Button1Click(Sender: TObject); // Datum prüfen begin if not IsDate(Edit1.Text) then begin MessageBeep(0); Label1.Caption := 'Das soll ein Datum sein?'

17.6 Auf Datum oder Zeit testen

927

end else begin Label1.Caption := 'Das ist der ' + FormatDateTime('dd. mmm. yyyy' + '" !"', StrToDate(Edit1.Text)); end end;

Zeit prüfen: procedure TForm1.Button2Click(Sender: TObject); begin if not IsTime(Edit1.Text) then begin MessageBeep(0); Label1.Caption := 'Das soll eine Zeit sein?' end else begin Label1.Caption := 'Das ist um ' + FormatDateTime('hh:nn' + '" !"', StrToTime(Edit1.Text)) end end;

Test Geben Sie verschiedene fehlerhafte Datums- und Zeitwerte ein und lassen Sie diese durch das Programm prüfen.

Bemerkung Die FormatDateTime-Funktion ist aufgrund des erforderlichen Formatstrings zwar umständlicher als die DataToStr- bzw. TimeToStr-Funktion zu handhaben, sollte aber trotzdem bevorzugt werden, da sie flexibler ist und Sie unabhängig von den Systemeinstellungen bleiben.

928

Kapitel 17

How-to: Sprache

17.7 Datumswerte vergleichen Die Antwort auf diese Frage ist einfach, wenn man Folgendes weiß: Datumswerte (TDateTime) sind Gleitkommazahlen, deren ganzzahliger Anteil der Anzahl von Tagen seit dem 30.12.1899 entspricht. Um festzustellen, ob ein Datum jünger oder älter als ein anderes ist, braucht man also nur beide Zahlen zu vergleichen (die größere Zahl entspricht dem jüngeren Datum).

Oberfläche Erstellen Sie eine Oberfläche mit folgendem Grundaufbau:

Quellcode Der implementation-Abschnitt von Form1 beginnt mit einer Typdefinition. type TPerson = record name: string[20]; geburt: TDateTime end;

// !!!

Die verwendeten Variablen: var personA, personB: TPerson; diff: TDateTime;

Die Hauptroutine : procedure TForm1.Button1Click(Sender: TObject); begin

Zunächst muss der Inhalt der beiden Datumsfelder mit der StrToDate-Funktion in Datumsvariablen umgewandelt werden. Damit sinnlose Eingaben nicht zum Programmabsturz führen, muss dafür gesorgt werden, dass Fehler in einem try-except-Block abgefangen werden: try personA.geburt := StrToDate(Edit2.Text); personB.geburt := StrToDate(Edit4.Text)

17.7 Datumswerte vergleichen

929

except Label1.Caption := 'Fehlerhaftes Geburtsdatum!'; Exit end; diff := personA.geburt - personB.geburt;

Der Vergleich beginnt: if diff > 0 then Label1.Caption := Edit1.Text + ' ist jünger als ' + Edit3.Text + ' !' else if diff < 0 then Label1.Caption := Edit1.Text + ' ist älter als ' + Edit3.Text + ' !' else Label1.Caption := Edit1.Text + ' und ' + Edit3.Text + ' sind gleichaltrig !' end;

Test Geben Sie zwei Namen und zwei gültige Datumswerte in die Eingabemaske ein, bevor Sie den Button "Vergleichen" drücken.

HINWEIS: Vorsicht bei der Eingabe zweistelliger Jahreszahlen, die sich immer auf die nächst-

liegende Möglichkeit beziehen! So wird z.B. im Jahr 2001 das Jahr 50 nicht als 1950, sondern als 2050 interpretiert!

Bemerkungen ■ Datumswerte vor dem 30.12.1899 haben ein negatives Vorzeichen. ■ Eine Datumsdifferenz erhält man, wenn man beide Datumswerte einfach subtrahiert.

930

Kapitel 17

How-to: Sprache

17.8 Eine Konsolenanwendung einsetzen Einfache Delphi-Quelltexte, bei denen man auf Grafikausgaben etc. verzichten kann, testet man am einfachsten nicht innerhalb der sonst üblichen Windows-Oberfläche, sondern innerhalb einer Konsolen-Anwendung. Letztere, auch unter dem Begriff "Textbildschirm-Anwendung" bekannt, wird vor allem den Turbo Pascal-Umsteigern vertraut vorkommen.

Vorbereitungen Wählen Sie Datei|Neu|Weitere ... und in der Objektgalerie "Konsolen-Anwendung":

Es erscheint das Fenster der Projektdatei:

17.8 Eine Konsolenanwendung einsetzen

931

Die eingebundene Unit SysUtils enthält wichtige Standardfunktionen, z.B. Stringfunktionen, Datums-/Zeitfunktionen etc.). Zwischen begin und end fügen Sie Ihren zu testenden Code ein. Sie können nahezu beliebige Sprachkonstrukte ausprobieren.

Quelltext Der folgende Beispielcode zeigt, wie bei Konsolenanwendungen generell die Interaktion mit dem Anwender über die Write(Ln)- bzw. Read(Ln)-Anweisung abgewickelt wird. Außerdem demonstriert er einige wichtige Sprachkonstrukte, wie die Length-Funktion und die For-Next-Schleife. program Project2; {$APPTYPE CONSOLE} uses SysUtils; var s : string; // Die benötigten Variablen i, n: Integer; begin s := 'Das ist ein Textbildschirm, '; s := s + 'aber trotzdem ein 32-Bit-Delphi-Programm!'; WriteLn(s); // Ausgabe mit Zeilenvorschub for i:=1 to Length(s) do Write('-'); WriteLn; // nur Zeilenvorschub Writeln('Geben Sie etwas ein!'); // weitere Ausgabe ReadLn(s); // Eingabe mit Zeilenvorschub WriteLn('Wie oft soll es untereinander ausgedruckt werden?'); ReadLn(n); // weitere Eingabe for i:=1 to n do WriteLn(i,#9,s); // Mehrfach-Ausgabe mit Tab-Trennung WriteLn('Druecken Sie Enter, um das Programm zu verlassen!'); // weitere Ausgabe ReadLn // muss am Schluss stehen! end.

Test Nach dem Starten des Programms könnte sich, in Abhängigkeit von den Nutzereingaben, folgender Dialogbildschirm ergeben:

932

Kapitel 17

How-to: Sprache

Bemerkungen ■ Für formatierte Ausgaben empfiehlt sich die Format-Funktion (in der Unit SysUtils enthalten). ■ Read(Ln) am Schluss verhindert, dass der Textbildschirm bei Programmende verschwindet. ■ Eine Konsolenanwendung eignet sich auch gut zum Testen von "Uralt-Pascal"-Quellcode aus der Zeit lange vor Windows.

17.9 Eine Unit erstellen und anwenden Wann sollte man eine eigene Unit entwickeln? Hier die Antwort: Der Aufwand lohnt sich nur dann, wenn man bestimmte Datentypen, Prozeduren und Funktionen wiederholt in verschiedenen Programmen benötigt und eventuell den entsprechenden Quelltext für andere Entwickler "unsichtbar" machen möchte. Im folgenden Einsteigerbeispiel wollen wir eine sehr einfache Unit schaffen, die Funktionen für die Berechnung von Brutto- und Nettowert bereitstellt. Gleichzeitig lernen Sie die Anwendung einer RadioGroup kennen.

Quelltext für Unit Öffnen Sie das Menü Datei|Neu..., wählen Sie das "Unit"-Symbol lett wie folgt aus:

und füllen Sie das leere Ske-

unit berechnungen;

Die Kopfzeilen der Funktionen unserer Unit müssen im Interface-Abschnitt deklariert werden: interface function netto(brutto: Double; mwst: Single): Double; function brutto(netto: Double; mwst: Single): Double;

Nun zum Implementation-Abschnitt, in dem wir die oben deklarierten Funktionen "ausprogrammieren" müssen. Wir machen dabei von der Kurzform Gebrauch, d.h., im Funktionskopf wird nur der Name, nicht aber die Parameterliste angegeben: implementation function netto; begin Result := brutto/(1 + mwst) end; function brutto; begin Result := netto * (1 + mwst) end; end.

933

17.9 Eine Unit erstellen und anwenden

Hier wollen wir erst einmal Schluss machen, Sie können jederzeit weitere Funktionen für den "Hausgebrauch" ergänzen (die Deklaration im Interface-Abschnitt nicht vergessen!). Speichern Sie die Unit unter ihrem Namen ab (Berechnungen.pas).

Test-Oberfläche Um unsere Unit zu testen, bietet sich die im Folgenden abgebildete Oberfläche an. Neben zwei Editierfeldern benötigen wir eine RadioGroup und einen Button.

Damit gleich zu Programmstart etwas Sinnvolles in den Editierfeldern steht, ändern wir deren TextEigenschaft entsprechend der obigen Abbildung. Über die Items-Eigenschaft der RadioGroup öffnen wir den String-Listen-Editor und füllen diesen mit zwei Einträgen:

Damit zu Beginn der zweite RadioButton aktiviert ist, ändern wir die ItemIndex-Eigenschaft der RadioGroup auf den Wert 1. HINWEIS: Standardmäßig hat die ItemIndex-Eigenschaft einer RadioGroup den Wert –1 (kein

Eintrag selektiert). Der erste Eintrag hat den Wert 0.

Quelltext für Test-Oberfläche (Form1) Wir beschränken uns auf die Wiedergabe des implementation-Abschnitts: implementation

Zu Beginn ist natürlich unsere Unit einzubinden, anschließend deklarieren wir die intern benötigten Variablen: uses Berechnungen; var brutt, nett: Double; ust: Single;

// Einbinden der benutzerdef. Unit // Brutto-, Nettobetrag // Umsatzsteuer

934

Kapitel 17

code: Integer;

How-to: Sprache

// Hilfsvariablen

Bei Programmstart sind die Variablen zu initialisieren: procedure TForm1.FormCreate(Sender: TObject); begin ust := 0.16; nett := 1; brutt := brutto(nett, ust) // Funktionsaufruf aus Unit Berechnungen! end;

Bei der Auswahl einer neuen Mehrwertsteuer: procedure TForm1.RadioGroup1Click(Sender: TObject); begin case RadioGroup1.ItemIndex of 0: ust := 0.07; 1: ust := 0.16 end; Edit2.Text := Format('%m',[brutto(nett, ust)]) end;

Der Nettobetrag wurde geändert: procedure TForm1.Edit1KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState); begin Val(Edit1.Text, nett, code); if code = 0 then begin Edit2.Text := Format('%m',[brutto(nett, ust)]) // Brutto neu berechnen end else Edit2.Text := '' end;

Der Bruttobetrag wurde geändert: procedure TForm1.Edit2KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState); begin Val(Edit2.Text, brutt, code); if code = 0 then Edit1.Text := Format('%m',[netto(brutt, ust)]) else Edit1.Text := '' end;

Test

17.10 Mit Stringlisten arbeiten

935

Bemerkungen ■ Die Datei Berechnungen.dcu, die Sie im Projektverzeichnis entdecken, ist die kompilierte Unit Berechnungen.pas. ■ Modernen Ansprüchen der objektorientierten Programmierung kann die hier vorgestellte klassische Pascal-Unit keinesfalls mehr genügen. Sie selbst haben festgestellt, dass für den Anwender dieser relativ "dummen" Unit noch viel zu tun übrig bleibt (Fehlerüberprüfung, Typkonvertierung, Formatierung), was die Arbeit unnötig erschwert und den Quelltext unübersichtlich macht.

17.10 Mit Stringlisten arbeiten Viele Eigenschaften von Delphi-Komponenten sind vom Typ TStrings, so zum Beispiel Lines (TMemo), Items (TListBox, TComboBox) oder SQL (TQuery). TStrings ist eine abstrakte Basisklasse für Objekte (Unit Classes), die eine Liste mit Strings darstellen. Die Eigenschaften und Methoden von TStrings bieten zahlreiche Möglichkeiten zur Stringlisten-Bearbeitung an: ■ Einfügen bzw. Löschen von Strings ■ Ändern der Reihenfolge der String-Einträge ■ Ansprechen von Strings über ihre Listenposition ■ Lesen bzw. Schreiben von Strings aus einer bzw. in eine Datei Das folgende Experimentierprogramm soll Ihnen einige dieser wichtigen Arbeitstechniken demonstrieren. Dabei wollen wir ein eigenes TStrings-Objekt erzeugen, dessen Inhalt mit den Stringlisten eines Memofeldes und einer Listbox wechselseitig ausgetauscht werden kann.

Oberfläche Platzieren Sie auf das Formular ein Memofeld (links) und eine Listbox (rechts) sowie eine ganze Reihe Buttons gemäß folgender Abbildung. Hinzu kommen eine OpenDialog- und eine SaveDialog-Komponente, die Sie auf der Seite "Dialoge" der Komponentenpalette finden.

936

Kapitel 17

How-to: Sprache

Quelltext Wir beginnen mit einem Eintrag im public-Abschnitt der Typdeklaration von TForm1: public meineListe: TStrings end;

// Listenfeld deklarieren

Beim Laden des Formulars wird eine Instanz vom Typ TStringList (ein Nachkomme von TStrings) erzeugt: procedure TForm1.FormCreate(Sender: TObject); begin meineListe := TStringList.Create // Listenfeld erzeugen end;

Wer das Eintippen einer Stringliste per Hand scheut, kann sich eine auf der Festplatte abgespeicherte Textdatei laden: procedure TForm1.Button5Click(Sender: TObject); // Öffnen begin with OpenDialog1 do begin Filter := 'Textdateien (*.TXT)|*.TXT'; DefaultExt := 'TXT'; if Execute then meineListe.LoadFromFile(Filename) end end;

Anschließend kann man die Stringliste in das Memo- oder in das Listenfeld kopieren und sich dort den Inhalt betrachten:

937

17.10 Mit Stringlisten arbeiten

procedure TForm1.Button7Click(Sender: TObject); begin Memo1.Lines := meineListe end; procedure TForm1.Button3Click(Sender: TObject); begin ListBox1.Items := meineListe end;

// Stringliste >> Memofeld

// Stringliste >> ListBox

Es steht Ihnen nun frei, an den beiden Kopien herumzudoktern, d.h., den Inhalt des Memofelds zu ändern oder einen bestimmten Eintrag im Listenfeld zu markieren, um ihn dann im Memofeld zu löschen: procedure TForm1.Button2Click(Sender: TObject); begin Memo1.Lines.Delete(ListBox1.ItemIndex) end;

// ausgewählten Eintrag löschen

So werden die Inhalte gegenseitig ausgetauscht: procedure TForm1.Button1Click(Sender: TObject); begin ListBox1.Items := Memo1.Lines end;

// Memofeld >> ListBox

procedure TForm1.Button8Click(Sender: TObject); begin meineListe := Memo1.Lines end;

// Memofeld >> Stringliste

procedure TForm1.Button11Click(Sender: TObject); begin meineListe := ListBox1.Items end;

// ListBox >> Stringliste

Die Umwandlung aller Zeichen in Großbuchstaben soll als Beispiel für das iterative Durchlaufen einer Stringliste und den indizierten Zugriff auf deren Elemente dienen: procedure TForm1.Button13Click(Sender: TObject); var i: Integer; begin for i := 0 to meineListe.Count - 1 do meineListe[i] := UpperCase(meineListe[i]) end;

// Großbuchstaben

So werden Strings (Zeilen) an das Ende der Liste angehängt: procedure TForm1.Button9Click(Sender: TObject); begin with meineListe do begin Add('Mit freundlichen Grüßen'); Add('');

// Hinzufügen

938

Kapitel 17

How-to: Sprache

Add('Gregor Größenwahn') end end;

Der gesamte Inhalt kann wie folgt gelöscht werden: procedure TForm1.Button10Click(Sender: TObject); begin meineListe.Clear end;

// Stringliste löschen

Fast hätten wir es vergessen, das Abspeichern der Stringliste in eine Datei (siehe auch nachfolgende Abbildung): procedure TForm1.Button4Click(Sender: TObject); // Speichern begin with SaveDialog1 do begin Filter := 'Textdateien (*.TXT)|*.TXT'; FileName := 'Firmenbrief'; DefaultExt := 'TXT'; Options := [ofOverwritePrompt; // Sicherheitsabfrage wegen Überschreiben if Execute then meineListe.SaveToFile(Filename) end end;

Test Starten Sie das Programm und überzeugen Sie sich von der Wirksamkeit der Stringlistenoperationen.

17.11 Zeichen aus einem String entfernen

939

Klicken Sie beispielsweise auf "Datei öffnen" und wählen Sie eine Datei (siehe Buch-CD) aus. Aber erst nachdem Sie "Stringliste >> Memofeld" oder "Stringliste >> ListBox" angeklickt haben, werden Sie den Inhalt sehen. Vergleichen Sie parallel den Quellcode im entsprechenden Event-Handler. HINWEIS: Denken Sie immer daran, dass die per Code erzeugte Stringliste (meineListe) quasi

"unsichtbar" ist und erst durch Kopieren in das Memo- oder Listenfeld betrachtet werden kann.

Ergänzungen ■ Wenn Sie TStrings-Eigenschaften von Komponenten im Objektinspektor zuweisen, so erscheint nach Doppelklick der Stringlisten-Editor (beispielsweise für die Lines-Eigenschaft eines Memo-Feldes oder Items bei ListBox). Da hier das Objekt von Delphi verwaltet wird, brauchen Sie sich im Quelltext um das Erzeugen bzw. Entfernen nicht zu kümmern. ■ Die Text-Eigenschaft eines TStrings-Objekts liefert keine Liste, sondern einen String (TString) zurück, in dem die Zeichen für Wagenrücklauf und Zeilenschaltung eingebettet sind. ■ Über weitere Eigenschaften und Methoden von TStrings-Objekten (Insert, Move, IndexOf etc.) informieren Sie sich in der Online-Hilfe. Das Gleiche gilt für das Hinzufügen von Objekten. ■ Seit Delphi 6 finden Sie auf der Palette "Zusätzlich" den so genannten ValueListEditor, eine Komponente, mit der Sie auf einfache Art und Weise eine StringList mit Wertepaaren anzeigen bzw. editieren können.

17.11 Zeichen aus einem String entfernen Kurz und knapp: Übergeben Sie der Funktion den String sowie das Zeichen, das Sie löschen möchten (z.B. Leerzeichen). function delChar(value:string; c:Char):string; begin while Pos(c,value)<> 0 do Delete(value,Pos(c,value),1); Result := value end;

BEISPIEL: Löschen aller Leerzeichen var s : string; ... s := delChar(s,' ');

HINWEIS: Die Funktion delChar finden Sie neben anderen Hilfsfunktionen in der Unit hFunc

auf der Buch-CD.

940

Kapitel 17

How-to: Sprache

Das entsprechende Demo-Programm finden Sie in Ä 17.16 Hilfsfunktionen testen

17.12 Auf Groß- oder Kleinbuchstaben testen Die folgende Funktion überprüft, ob das übergebene Zeichen in der Menge der Großbuchstaben vorkommt: function isUpper(c:Char): Boolean; begin result := c in ['A'..'Z','Ä','Ö','Ü'] end;

Analog für Kleinbuchstaben: function isLower(c:Char): Boolean; begin result := c in ['a'..'z','ä','ö','ü','ß'] end;

BEISPIEL: Test, ob das erste Zeichen eines Editierfeldes großgeschrieben ist: if isUpper(Edit1.Text[1]) then ShowMessage('Das erste Zeichen ist ein Großbuchstabe!')

BEISPIEL: Es liegt nahe, dass man auf diese Weise beliebige Funktionen schreiben kann, die das Vorhanden-

sein bestimmter Mengen von Zeichen untersuchen. HINWEIS: Die Funktionen isUpper und isLower finden Sie neben anderen Hilfsfunktionen in

der Unit hFunc auf der Buch-CD. BEISPIEL: Das entsprechende Demo-Programm finden Sie unter

Ä 17.16 Hilfsfunktionen testen

17.13 Auf gerade oder ungerade Werte prüfen Die folgende Funktion ermittelt, ob es sich um eine gerade oder ungerade Integer-Zahl handelt: function isGerade(value: Integer): Boolean; begin result := (value mod 2) = 0 end;

BEISPIEL: Es piept, wenn i einen ungeraden Wert hat. var i: Word; ... if not isGerade(i) then Beep;

17.15 Auf bestimmte Datentypen testen

941

HINWEIS: Die Funktion isGerade finden Sie neben anderen Hilfsfunktionen in der Unit hFunc

auf der Buch-CD. Noch einfacher geht es allerdings mittels Odd-Funktion. Das entsprechende Demo-Programm finden Sie unter Ä 17.16 Hilfsfunktionen testen

17.14 Auf Ziffern prüfen Um zu prüfen, ob das übergebene Zeichen eine Ziffer ist, verwenden Sie folgende Funktion: function isDigit(c: Char): Boolean; begin Result = c in ['0'..'9'] end;

BEISPIEL: Es piept, wenn z eine Ziffer ist. var z: Char; ... if isDigit(z) then Beep;

HINWEIS: Die Funktion isDigit finden Sie neben anderen Hilfsfunktionen in der Unit hFunc auf

der Buch-CD. Das entsprechende Demo-Programm finden Sie unter Ä 17.16 Hilfsfunktionen testen

17.15 Auf bestimmte Datentypen testen Möchten Sie kontrollieren, ob ein String-Eingabewert (z.B. Textbox) einem bestimmten Datentyp entspricht, können Sie folgendes Konstrukt nutzen: function isInteger(value: string): Boolean; begin Result := True; try StrToInt(value) except Result := False end end;

Hintergrund ist eine explizite Typumwandlung (z.B. StrToInt, StrToFloat, StrToBoolean, StrToCurr, StrToDateTime), die im Fehlerfall zu einem negativen Funktionsergebnis führt.

942

Kapitel 17

How-to: Sprache

HINWEIS: Die Funktion isInteger finden Sie neben anderen Hilfsfunktionen in der Unit hFunc

auf der Buch-CD. Das entsprechende Demo-Programm finden Sie im Rezept Ä 17.16 Hilfsfunktionen testen

17.16 Hilfsfunktionen testen In diesem Demo-Programm können Sie einige der in den vorangegangenen Rezepten beschriebenen Hilfsfunktionen "in Action" erleben, und zwar sind dies ■ isUpper, isLower (Test auf Groß-/Kleinschreibung) ■ isDigit (Test auf Ziffer) ■ isGerade (Test auf gerade oder ungerade Zahl) ■ isFloat (Test auf Fließkommazahl) ■ delChar (bestimmte Zeichen entfernen) Sie werden feststellen, dass doch einiges an "Drumherum" zu programmieren ist, um die Wirkung dieser Funktionen einigermaßen sinnvoll zu demonstrieren.

Oberfläche Neben einer Edit-Komponente werden eine Schaltfläche, ein UpDown-Button ("Win32"- Komponentenpalette) und ein Panel auf dem Formular platziert (siehe Screenshots am Ende). Setzen Sie im Objektinspektor die Min-Eigenschaft des UpDown-Buttons auf den Wert 1.

Quelltext uses hFunc; var c: Char;

// liefert die Hilfsfunktionen // das selektierte Zeichen

Beim Programmstart wird der Maximalwert des UpDown-Buttons der Länge des Eingabestrings angepasst: procedure TForm1.FormCreate(Sender: TObject); begin UpDown1.Max := Length(Edit1.Text) end;

Mit dem UpDown-Button können Sie die Markierung im Textfeld hin und her bewegen: procedure TForm1.UpDown1Changing(Sender: TObject; var AllowChange: Boolean); begin if UpDown1.Position >= Length(Edit1.Text) then UpDown1.Position := Length(Edit1.Text); Edit1.SetFocus; Edit1.SelStart := UpDown1.Position-1;

17.16 Hilfsfunktionen testen

943

Edit1.SelLength := 1; c := Edit1.SelText[1]; // ein Zeichen selektieren Button1.Caption := 'Alle ' + c + ' entfernen';

Zunächst erfolgt der Test des selektierten Zeichens auf Groß-/Kleinschreibung: if isUpper(c) then Panel1.Caption := c + ' ist ein Großbuchstabe!' else if isLower(c) then Panel1.Caption := c + ' ist ein Kleinbuchstabe!'

Dann der Test, ob es sich um eine Ziffer handelt: else if isDigit(c) then Panel1.Caption := c + ' ist eine Ziffer!' else Panel1.Caption := c + ' ist ein unbekanntes Zeichen!' end;

Bei jeder Änderung des Eingabestrings wird dieser als Ganzes untersucht: procedure TForm1.Edit1Change(Sender: TObject); begin

Zunächst erfolgt der Test auf gerade/ungerade Integerzahl und auf Fließkommazahl. Beachten Sie, dass zunächst die Umwandlung in eine Integer-Zahl versucht (try) und erst bei Fehlschlag auf Fließkomma getestet wird (except): try if isGerade(StrToInt(Edit1.Text)) then Panel1.Caption := Edit1.Text + ' ist gerade Zahl!' else Panel1.Caption := Edit1.Text + ' ist eine ungerade Zahl!'; except if isFloat(Edit1.Text) then Panel1.Caption := Edit1.Text + ' ist eine Gleitkommazahl!' end end;

Schließlich sollen nach Klick auf den Button alle Zeichen aus dem Eingabestring entfernt werden, die dem selektierten Zeichen entsprechen: procedure TForm1.Button1Click(Sender: TObject); begin Edit1.Text := delChar(Edit1.Text, c); Panel1.Caption := '' end;

Test Nach dem Programmstart geben Sie irgendetwas ein und bewegen sich dann mit dem UpDownButton durch den Eingabestring. Das selektierte Zeichen wird auf Groß- bzw. Kleinbuchstabe bzw. Ziffer untersucht und das Testergebnis angezeigt. Nach Klick auf die "Entfernen"-Schaltfläche werden alle Zeichen, die dem selektierten Zeichen entsprechen, aus dem Eingabestring entfernt.

944

Kapitel 17

How-to: Sprache

Falls der Eingabestring als Zahl interpretierbar ist, werden Sie darüber informiert, ob es sich um eine gerade oder ungerade Ganzzahl oder um eine Gleitkommazahl handelt.

Bemerkungen ■ Gleitkommazahlen werden nur mit einem Komma als Dezimaltrenner erkannt (also nicht mit einem Punkt!). ■ Falls während des Programmtests Fehlermeldungen auftreten, entfernen Sie bitte im Menü Tools|Debugger-Optionen auf der Seite "Sprach-Exceptions" das Häkchen "Bei Delphi-Exeptions stoppen". ■ Sie können das Programm problemlos erweitern, z.B. um einen Test auf Datums-/ Zeitwert.

17.17 Einen String in einzelne Wörter zerlegen Die im Folgenden beschriebene Funktion filter bietet eine einfache Möglichkeit, einen eingegebenen Text in einzelne Wörter zu zerpflücken. Rückgabewert ist eine StringList, die Sie auch sortieren können (Sorted := True). Im Weiteren gewährt Ihnen das Quelltextstudium nützliche Erkenntnisse über den Umgang mit nullterminierten Strings (PChar).

Oberfläche Auf das Startformular setzen Sie ein Memo und eine ListBox. Weisen Sie der Sorted-Eigenschaft der ListBox den Wert True zu.

17.17 Einen String in einzelne Wörter zerlegen

945

Quelltext In den implementation-Abschnitt von Form1 fügen Sie ein: function filter(source:PChar):TStringList; var p, start : PChar; token : string; begin result := TStringList.Create; p := source; while (p^ <> #0) do begin if p^ in [#1..#64,#91..#96,#123..#127] then Inc(p) else begin // ein Wort wurde gefunden ... start := p; while not (p^ in [#0..#64,#91..#96,#123..#127]) do Inc(p); SetString(token, start, p-start); result.Add(token) end end end;

Die Verwendung des PChar- anstatt des string-Datentyps ermöglicht ein einfaches Weiterbewegen zum nächsten Zeichen durch Inkrementieren. Zum Aufrufen der filter-Funktion benutzen wir beispielsweise das OnChange-Event der MemoKomponente: procedure TForm1.Memo1Change(Sender: TObject); begin Listbox1.Items := filter(PChar(Memo1.Text)); end;

Test Sie werden feststellen, dass mehrfach vorkommende Wörter nicht unterdrückt werden. Abhilfe finden Sie im nächsten Rezept.

946

Kapitel 17

How-to: Sprache

17.18 Wörter aus einem String filtern Das folgende Progrämmchen durchsucht einen Text auf mehrfach vorkommende Wörter. Der Rückgabewert ist ein String, in dem alle Wörter nur einmal vorhanden sind. Gleichzeitig findet eine Umwandlung in Großbuchstaben statt. Die einzelnen Wörter werden mit Punkten voneinander getrennt, außerdem entfallen alle Wörter, die kürzer als drei Buchstaben sind. Triviale Wörter, die in einem extra zu definierenden Referenzstring von Ihnen selbst festgelegt werden können, werden nicht übernommen!

Oberfläche Sie brauchen drei Memo-Komponenten (Memo1, Memo2, Memo3), die Sie auf dem Startformular untereinander anordnen, und einen Button zum Aufruf der Filter-Funktion.

Quelltext In den implementation-Abschnitt von Form1 kopieren Sie: const minWordLen : Byte = 3; var refString : String;

// Festlegen der minimalen Wortlänge // Referenzstring

Die eigentliche Filterfunktion: function filter(source:PChar):string; var p, start : PChar; token,dest : String; { $B- } // Compiler-Befehl, um Boolean-Prüfung zu verkürzen begin p := source; dest := '.';

Ein PChar findet wegen der einfachen Zugriffsweise Verwendung (einfach den Zeiger inkrementieren, und schon ist das nächste Zeichen gefunden). while (p^ <> #0) do begin case p^ of #1 .. #64, // Herausfiltern aller Sonderzeichen #91 ..#96, #123.. #127 : Inc(p); else begin // ein Wort wurde gefunden ... start := p; while not (p^ in [#0..#64,#91..#96,#123..#127]) do Inc(p); if (P-Start) >= minWordLen then begin // mindestens 3 Zeichen SetString(token, start, p - start); token := UpperCase(token) + '.'; if (pos('.' + token, refString) = 0) and (pos('.' + token, dest) = 0) then dest:= dest + token end end

17.18 Wörter aus einem String filtern

947

end // von case end; // von while { $B+ } result := dest end;

Beim Start des Formulars definieren wir einen vorläufigen Referenzstring. Alle darin enthaltenen Wörter werden nicht in den Rückgabestring aufgenommen (Filter). procedure TForm1.FormCreate(Sender: TObject); begin Memo3.Text := '.UND.ODER.DER.DIE.DAS.DEN.DEM.NUN.BEGIN.END.SUB.' + 'THEN.ELSE.SIE.SICH.EIN.EINER.BIS.VON.WER.WIE.WAS.' end;

Die Verwendung der Funktion ist relativ einfach, Sie müssen lediglich darauf achten, dass Sie den Referenzstring zuweisen und den eigentlichen Übergabestring in einen PChar-Typ umwandeln. procedure TForm1.Button1Click(Sender: TObject); // Filtern begin refString := Memo3.Text; Memo2.Text := filter(PChar(Memo1.Text)) end;

Test Starten Sie das Programm und geben Sie in das obere Memofeld einen Text ein. Erweitern Sie gegebenenfalls die zu unterdrückenden Referenzwörter (unteres Memofeld). Nach dem Klicken des "Filtern..."-Buttons sollte im mittleren Memofeld der gefilterte Text erscheinen.

948

Kapitel 17

How-to: Sprache

Bemerkungen ■ Erweitern Sie den Algorithmus gegebenenfalls um eine Sortierfunktion. Nachfolgend kann der Text in eine Datenbank eingelesen werden. Auf diese Weise lässt sich beispielsweise eine Volltextsuchfunktion realisieren. ■ Mit zunehmender Länge des Originaltextes kommt es zu immer mehr doppelt vorkommenden Wörtern. Damit wird auch der Filter immer effektiver, der zurückgegebene String ist deutlich kürzer als der Ausgangswert.

17.19 Strings auf Ähnlichkeit vergleichen Wenn in Listen oder Dateien nach bestimmten Informationen gesucht wird, sollte nicht nur penibel zeichenweise verglichen werden. Es müssen auch Ähnlichkeiten Berücksichtigung finden. BEISPIEL: Sie suchen nach "Leipzig-Hbf" und möchten dabei natürlich auch einen Eintrag wie "leipzig haupt-

bahnhof" herausfinden. Die vorgeschlagene Lösung verwendet eine Funktion, welche die ersten n Zeichen zweier Strings auf Übereinstimmung testet, ohne dabei die Groß-/Kleinschreibung sowie Leerzeichen zu berücksichtigen.

Oberfläche Zwei Editierfelder, deren Text-Eigenschaft Sie aus Bequemlichkeitsgründen schon etwas zuweisen können, drei Panels und zwei Buttons – das ist alles, was Sie für ein kleines Testprogramm brauchen.

Quelltext function vergleicheStringsN(s1, s2:string; n:Word): Boolean; var i: Word;

17.19 Strings auf Ähnlichkeit vergleichen

function delLZ(s: string): string; var ss: string; i,j: Word; begin j:=0; ss:=''; for i:=1 to Length(s) do begin if (s[i] <> ' ') and (s[i] <> '-') then begin Inc(j); ss:= ss + s[i] end; if j=n then Break end; Result := UpperCase(ss) end;

Nun zum Hauptkörper der Funktion: begin if delLZ(s1)=delLZ(s2) then Result:=True else Result:=False ; Form1.Panel1.Caption := delLZ(s1); Form1.Panel2.Caption := delLZ(s2) // nur zur Info end;

Das Austesten der Funktion: procedure TForm1.Button1Click(Sender: TObject); // Vergleichen begin if vergleicheStringsN(Edit1.Text, Edit2.Text, 8) = True then // erste 8 Zeichen Panel3.Caption := 'Beide Ortsnamen sind sich ähnlich!' else begin MessageBeep(0); Panel3.Caption := 'Beide Ortsnamen sind sich nicht ähnlich!' end end;

Test

949

950

Kapitel 17

How-to: Sprache

Bemerkung Die vorgestellte Lösung ist einfacher und gleichzeitig leistungsfähiger als die naheliegende Verwendung der Standardroutinen CompareStrings/CompareText.

17.20 Termineingaben dekodieren Das aufeinander folgende Eintragen von Beginn und Ende einer Vielzahl von Terminen (z.B. Dienstreisen) in eine Eingabemaske kann zu einer zeit- und nervtötenden Tortur ausufern. Das vorliegende Rezept zeigt einen Lösungsvorschlag, wie man sich (bzw. seiner Sekretärin) die Arbeit erleichtern kann. Der Sinn dürfte beim Betrachten der folgenden Abbildung klar werden. Beginn und Ende werden in einem Eingabestring zusammengefasst, die Jahreszahl wird separat eingegeben.

Oberfläche Unser Testprogramm soll zur Laufzeit folgenden Anblick bieten:

Für die Eingabe werden zwei Editierfelder benötigt (oben), der Ausgabe der decodierten Informationen dienen vier Labels (unten).

Quelltext Das gesamte Know-how steckt in der folgenden Unit, welche die Funktion decodeDates exportiert: unit stringRoutinen1; interface uses SysUtils, Dialogs; type TDates = record Beginn, Ende: TDateTime;

// wegen Stringfunktionen

951

17.20 Termineingaben dekodieren

std, min: Word end; function decodeDates(s, jahr:string):TDates; implementation

Die folgende Hilfsfunktion merzt vor- und nachstehende Leerzeichen aus: function deleteFirstLastLZ(st:string):string; // entfernt vor- und nachstehende LZ var a, z: Integer; begin Result:=''; if st <> '' then begin // alle vorstehenden LZ entfernen: a:=1; while st[a] = ' ' do begin Delete(st,a,1); if st= '' then Exit end; // alle nachstehenden LZ entfernen: z:=Length(st); while st[z] = ' ' do begin Delete(st,z,1); Dec(z) end; Result := st end end;

Zur Funktion decodeDates sind einige Vorabinformationen erforderlich: Der Übergabestring s kann in verschiedener Gestalt vorliegen, z.B. als '3.4. 10:15 - 12:45' oder nur '3.4. 10:15'. Davor, danach und dazwischen liegende LZ (Leerzeichen) spielen keine Rolle. Zwischen dem Beginn-Kurzdatum und der dazugehörigen Zeitangabe muss aber mindestens ein LZ liegen. Die Jahreszahl wird automatisch ergänzt (jahr-Übergabeparameter) und darf nicht in s enthalten sein! Der Ende-Termin wird nur durch die Zeit festgelegt und kann auch ganz entfallen, dann wird er automatisch auf 0 gesetzt (30.12.1899 0:00). Fehlen beide Terminangaben (s = Leerstring ('') oder eine beliebige LZ-Kette (' '), so werden Beginn- und Ende-Termin auf 0 gesetzt. Falls die Ende-Zeit früher als die Beginn-Zeit liegt, wird das Ende-Datum automatisch einen Tag später als das Beginn-Datum gesetzt. Die Funktion liefert als Ergebnis komplette TDateTime-Werte für Beginn und Ende sowie die dazwischen liegende Zeitdifferenz getrennt in Stunden und Minuten: function decodeDates; var dates:TDates; i, anz:Integer;

Beginn und Ende werden mit zwei lokalen Funktionen herausgefiltert: function returnBeginn: TDateTime; var b:string;

// liefert Beginn-Datum/Zeit

952

Kapitel 17

begin b:=''; Inc(i); while s[i] <> '-' do begin if s[i] = ' ' then begin b := b+jahr; jahr:='' end else b:=b+s[i]; Inc(i); if i > anz then Break end; Result := StrToDateTime(b) end; function returnEnde: TDateTime; // liefert Ende-Datum/Zeit var e: string; dt: TDateTime; begin e:=''; Inc(i); if i > anz then begin Result:=0; Exit end; while i <= anz do begin e := e + s[i]; Inc(i) end;

Die Funktion DateToStr versagt ab 2000, deshalb folgende Lösung: dt := StrToDateTime(FormatDateTime('d/m/yyyy', dates.Beginn) + ' ' + e); if dt < dates.Beginn then dt := dt + 1; Result := dt end;

Die Berechnung der Zeitdifferenz: procedure returnDauer; // liefert Zeitdifferenz var dum: Word; // Dummies für sek und msek begin if (dates.Beginn > 0) and (dates.Ende > 0) then begin DecodeTime((dates.Ende-dates.Beginn), dates.std, dates.min, dum, dum ) end end;

Nun geht es richtig los: begin // Hauptroutine von decodeDates with dates do // Rückgabewerte initialisieren begin Beginn := 0; Ende:=0; std:=0; min:=0 end; if s <> '' then // nur wenn kein Leerstring begin s:= deleteFirstLastLZ(s); // überstehende LZ entfernen i:=0; anz:=Length(s); if s[1] in ['.', ':', '-'] then begin ShowMessage('ungültige Eingabe'); Exit end; dates.Beginn := returnBeginn; dates.Ende := returnEnde; returnDauer

How-to: Sprache

17.21 Geldbeträge kaufmännisch runden

953

end; Result := dates end; end.

Test Starten Sie das Programm und experimentieren Sie mit verschiedenen Eingabewerten. Vergessen Sie nicht, Beginn und Ende durch einen Strich (-) voneinander zu trennen. Sie werden feststellen, dass sich beim Eintippen eine Menge Zeit sparen lässt. Die Funktion arbeitet weitestgehend fehlertolerant, eingefügte Leerzeichen spielen beispielsweise keine Rolle.

17.21 Geldbeträge kaufmännisch runden Wie schafft man es, einen Betrag immer auf 50 Cent aufzurunden, z.B. von 11,35 € auf 11,50 € oder von 11,52 € auf 12,00 €? Mit der Round-Funktion ist das nicht zu schaffen, denn die rundet auf oder ab, je nach nächstliegendem ganzzahligen Wert. Wir entwickeln eine Funktion, die dieses Problem löst.

Oberfläche Die folgende Laufzeitabbildung zeigt die Testoberfläche.

Quellcode Hier die entscheidende Funktion, die Sie in den implementation-Abschnitt von Unit1 kopieren: function betragR(betrag:Single): Single; // kaufmännisches Runden var eur, ct: Single; begin eur := Int(betrag); // Euro glatt ct := (betrag-eur)*100; // Cent glatt if ct <= 50 then ct := 50 else ct := 100; // Cent aufrunden Result := eur + ct/100 // Ergebnis zusammensetzen end;

Im Folgenden wird die Anwendung der Funktion gezeigt. Der Berechnungsvorgang startet nach Betätigen der Enter-Taste. Das Auswerten des code-Rückgabewertes der Val-Prozedur verhindert

954

Kapitel 17

How-to: Sprache

einen Fehlerabbruch bei Eingabe falscher Zeichen. Außerdem wird ein Dezimalkomma automatisch in einen Dezimalpunkt verwandelt. procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char); var geld: Single; code: Integer; begin if Key = ',' then Key := '.'; // Dezimalkomma in Dezimalpunkt umwandeln if key = #13 then begin // ENTER-Taste gedrückt key := #0; Val(Edit1.Text, geld, code); // wandelt Eingabestring in Geld if code = 0 then // fehlerfreie Eingabe Label1.Caption := Format('%m',[betragR(geld)]) // Aufruf der Rundungsfunktion else Label1.Caption := 'fehlerhafte Eingabe!' end end;

Bemerkungen ■ Der Formatstring '%m' formatiert das Ergebnis entsprechend der in der Windows-Systemeinstellung vorgenommenen Währungseinstellung. ■ Durch Ändern der fettgedruckten Zeile innerhalb der betragR-Funktion kann natürlich auch eine andere Rundungsschwelle als 50 Cent gewählt werden1.

17.22 Einen Wert auf Bit-Ebene manipulieren HINWEIS: Zu diesem Rezept gibt es keinen eigenständigen Quellcode auf der Buch-CD, da sich

das Know-how auf eine Vielzahl weiterer Rezepte verteilt, auf die im folgenden Text verwiesen wird. Haben Sie sich auch schon über Befehle wie XOR, SHL, SHR etc. gewundert, und konnten Sie nichts damit anfangen? Wozu brauchen wir derartige Befehle eigentlich? Die Antwort ist schnell gefunden, wenn Sie sich einmal folgende Rezepte näher ansehen, bei denen es um die möglichst effektive Verarbeitung von Ganzzahlwerten geht (codieren, verschlüsseln, packen, maskieren etc.). Ä 21.12 Nach Dateien rekursiv suchen Ä 29.4 Eine Prüfsumme erstellen

NOT Eine der einfachsten logischen Operationen ist der NOT-Operator, mit dem alle Bits invertiert werden.

1

Wie wäre es mit einer Funktion zum Berechnen des Trinkgelds?

17.22 Einen Wert auf Bit-Ebene manipulieren

1

955

0

NOT 0

1

AND (UND) Mit einer UND-Verknüpfung lässt sich auf einfache Weise prüfen, ob ein bestimmtes Bitmuster vorliegt oder nicht. 1

0

1

0

AND 1

1

0

0

0

0

= 1

0

BEISPIEL: Die Funktionen FindFirst und FindNext liefern Ihnen in einer Datenstruktur vom Typ TSearchRec

unter anderem die Attribut-Flags (readOnly, hidden etc.). Wollen Sie feststellen, ob ein bestimmtes Flag (Bit) gesetzt ist, ist der einfachste Weg eine Maskierung: var rec : TSearchRec; ... FindFirst(..., rec); if (rec.Attr AND faHidden) = faHidden then Label1.Caption := rec.Name + ' ist eine versteckte Datei!';

Bei obigem Vergleich wird einfach das 5. Bit maskiert (faDirectory = 16) und das Ergebnis mit 16 verglichen. Sind andere Bits gesetzt, hat dies keinen Einfluss auf den Vergleich. Eine praktische Anwendung finden Sie in Ä 21.12 Nach Dateien rekursiv suchen

OR (ODER) Eine ODER-Verknüpfung bietet Ihnen eine einfache Möglichkeit, alle Bits, die in dem einen oder in dem anderen Wert gesetzt sind, in das Ergebnis zu übernehmen. Dieses Vorgehen entspricht einer bitweisen Addition (kein Übertrag!). 1

0

1

0

OR 1

1

0

0

1

0

= 1

1

956

Kapitel 17

How-to: Sprache

BEISPIEL: Um an das vorhergehende Beispiel anzuknüpfen: Bei der Suche nach Dateien müssen Sie neben

der Suchmaske (z.B. *.* ) auch die gesuchten Attribute vorgeben. var rec: TSearchRec; begin FindFirst('*.*',faHidden OR faSysFile, rec);

Gesucht werden alle versteckten und alle System-Dateien (Bit 2 und 3 sind gesetzt).

XOR (Exklusiv ODER) Beim bitweisen Vergleich führt nur eine 1/0- bzw. 0/1-Kombination zu einer 1 im Funktionsergebnis: 1

0

1

0

XOR 1

1

0

0

1

0

= 0

1

BEISPIEL: Jedes zweite Bit eines Word-Wertes soll negiert werden (wird z.B. in der Nachrichtentechnik zur

Flankenbildung bei 0-Werten eingesetzt). var value, mask : word; ... mask := $AA ; // --> 10101010 binär value := 0; // --> 00000000 binär value := value XOR mask; // --> 10101010 binär

Da dieser Vorgang reversibel ist, kann der Ursprungswert mit der gleichen XOR-Verknüpfung wieder hergestellt werden. Siehe dazu auch: Ä 29.5 Einen Text verschlüsseln Interessant für die Grafikprogrammierung ist auch die XOR-Verknüpfung einer Zeichenfarbe mit dem Hintergrund. Durch nochmaliges Überzeichnen kann z.B. eine Linie wieder gelöscht werden. Siehe dazu Ä 19.30 Einen Markierungsrahmen erzeugen

SHL (Schiebe links) Mit dieser Anweisung verschieben Sie alle Bits um n Positionen nach links. Die entstehenden Leerstellen werden mit 0 aufgefüllt.

957

17.22 Einen Wert auf Bit-Ebene manipulieren

8

7

6

5

4

3

2

1

0

0

0

SHL 3 5

4

3

2

1

Neben der reinen Bit-Operation erfüllt dieser Befehl noch eine weitere recht nützliche Aufgabe: Jede Verschiebung um ein Bit entspricht einer Multiplikation mit 2. In der obigen Skizze wird also eine Multiplikation mit 8 ausgeführt. HINWEIS: Beachten Sie die Wertebereiche (links werden die Bits abgeschnitten)! BEISPIEL: Konvertierung eines LongIntegers in eine Binärzahl function IntToBinary(Value:LongInt; digits: Byte): string; var i : Byte; mask : LongInt; begin SetLength(result,digits); for i := 0 to digits-1 do begin mask := 1 shl i; if (mask and value) = mask then result[digits-i]:= '1' else result[digits-i]:= '0' ...

SHR (Schiebe rechts) Das entsprechende Gegenstück zur SHL-Funktion, hier werden alle Bits um n Positionen nach rechts verschoben. 8

7

6

5

4

3

2

1

5

4

3

SHR 2 0

0

8

7

6

Damit realisiert diese Funktion eine Ganzzahl-Division durch 2.

ROL (Rotiere links) Diesen Befehl werden Sie in Delphi vergeblich suchen, deshalb hier die Umsetzung in Pascal: function rol(x: LongInt; cnt: Byte): LongInt; begin Result := (x shl cnt) or (x shr (32 - cnt)) end;

958

Kapitel 17

How-to: Sprache

Im Gegensatz zu den Schiebebefehlen werden hier keine Bits "abgeschnitten", sondern einfach wieder in den Wert eingefügt. Verwendung finden derartige Befehle z.B. in Verschlüsselungsalgorithmen (verwürfeln).

8

7

6

5

4

3

2

1

1

8

7

ROL 2 6

5

4

3

2

ROR (Rotiere rechts) Auch diese Anweisung muss mit anderen Befehlen nachgebildet werden: function ror(value: Longword; count: Byte): LongWord; begin Result := (value shr count) or (value shl (32 - count)) end;

8

7

6

5

4

3

2

1

6

5

4

ROR 3 3

2

1

8

7

17.23 Byte in KiloByte umrechnen Soll die Größe einer Datei gelesen oder zugewiesen werden, so benutzen die entsprechenden Funktionen dafür meist die Maßeinheit Byte (LongInt-Zahl). Für eine übersichtliche Anzeige empfiehlt sich aber die Maßeinheit KiloByte.

Oberfläche Ein Edit-Feld, ein Button und ein Label genügen zum Ausprobieren.

Quelltext function kByte(byt:LongInt): string; var kb: Single; s: String; begin if byt > 1023 then begin

// liefert String Byte/kByte

17.24 Funktionstasten/Tastenkombinationen abfragen

959

kB := byt/1024; Str(kb:7:2, s); Result := s + ' KiloByte' end else Result := IntToStr(byt) + ' Byte' end;

Der Aufruf: procedure TForm1.Button1Click(Sender: TObject); begin Label2.Caption := kByte(StrToInt(Edit1.Text)) end;

Test

HINWEIS: Bytes können nur als Ganzzahl eingegeben werden.

17.24 Funktionstasten/Tastenkombinationen abfragen Offensichtlich ist es kein Problem, die Eingabe einzelner Zeichen zu überwachen, wenn man dazu das OnKeyPress-Event auswertet, siehe z.B. Ä 18.17 Zahleneingaben überprüfen Für die Abfrage von Nicht-ASCII-Tasten oder von Tastenkombinationen müssen Sie einen OnKeyDown- oder OnKeyUp-Event-Handler verwenden. Im Unterschied zu OnKeyPress wird bei diesen beiden Ereignissen der Key-Parameter anstatt als Char- als Word-Datentyp geliefert.

Oberfläche Lediglich ein Formular, ein Editierfeld sowie eine Panel-Komponente werden gebraucht.

Quelltext procedure TForm1.Edit1KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState); var s: string; begin case Key of VK_F1: s := 'F1'; VK_F2: s := 'F2';

960

Kapitel 17

How-to: Sprache

Hier können Sie weitere virtuelle Tastaturcodes testen, z.B. VK_F10: s := 'F10'; VK_MENU: s := 'ALT'; VK_CONTROL: s := 'Strg'; VK_RIGHT: s := 'Nach rechts';

Haben Sie den Tastaturcode nicht zur Hand, können Sie "normale" ASCII-Zeichen mit der OrdFunktion abfragen, z.B. Ord('A'): s := 'A';

Für alle hier nicht abgefragten Zeichen soll als "Entschädigung" wenigstens der Code angezeigt werden: else Str(Key, s); s := 'Code ' + s end; Panel1.Caption := 'Die ' + s + ' Taste wurde gedrückt!';

Am Ende der Demo wollen wir noch zeigen, wie eine Tastenkombination mit Hilfe des ShiftParameters abgefragt werden kann: if ((Shift = [ssAlt]) and (Key = VK_SNAPSHOT)) then Panel1.Caption := 'Die Alt- und Print-Taste wurden gemeinsam gedrückt!' end;

Test Geben Sie nach dem Programmstart verschiedene Tastenkombinationen ein:

. Bemerkungen ■ Außer [ssAlt] wären [ssShift] und [ssCtrl] weitere sinnvolle Werte des Shift-Parameters, was Tastaturkombinationen mit der Shift- bzw. Strg-Taste ermöglicht. ■ Da im Anhang nur die wichtigsten virtuellen Tastaturcodes aufgeführt sind, sollten Sie sich in der Online-Hilfe nach weiteren erkundigen.

18

How-to: Oberfläche

Kapitel

18

How-to: Oberfläche 18.1 Ein Info-Fenster beim Start anzeigen Geht es darum, direkt nach Aufruf eines Programms eine kurze Copyright-Meldung zu erzwingen, müssen Sie sich schon selbst um das Erstellen und die Anzeige dieses Formulars kümmern.

Oberfläche Neben dem Startformular (Form1) brauchen Sie ein weiteres für das Info-Fenster, das Sie über Datei|Neues Formular hinzufügen. Bei der Ausgestaltung können Sie Ihrer Kreativität freien Lauf lassen, wichtig ist lediglich ein Timer, über den das Info-Fenster später wieder ausgeblendet wird. Die Interval-Eigenschaft des Timers setzen Sie z.B. auf den Wert 5000, wenn das Info-Fenster nach fünf Sekunden wieder verschwinden soll. Eine Empfehlung: Setzen Sie die Eigenschaften BorderStyle auf bsDialog, Position auf poScreenCenter und FormStyle auf fsStayOnTop. In unserem Beispiel haben wir auch die Name-Eigenschaft in SplashForm geändert.

Quelltext Projektdatei Erweitern Sie das eigentliche Hauptprogramm Ihrer Anwendung (begin-end-Abschnitt der Projektdatei, die Sie über das Menü Projekt|Quelltext anzeigen öffnen) um folgende (unterstrichene) Anweisungen: ... begin SplashForm := TSplashForm.Create(Application); SplashForm.Show; SplashForm.Update; Application.Initialize; ... end.

// // // //

CopyrightForm Anzeige Copyright Anzeige erzwingen normaler Ablauf ...

962

Kapitel 18

How-to: Oberfläche

Quelltext Info-Fenster Vergessen Sie nicht, über das Timer-Ereignis das Info-Fenster auch wieder auszublenden: procedure TSplashform.Timer1Timer(Sender: TObject); begin Hide; Free end;

Test

18.2 Ein Formular automatisch zentrieren Für die Anzeige einer Dialogbox ist es günstig, wenn diese (unabhängig von der Grafikauflösung) in der Mitte des Bildschirms erscheint. Ohne viele Worte: Ändern Sie im Objektinspektor den Wert der Eigenschaft Position auf poScreenCenter. Um ein Formular bezüglich eines anderen Fensters zentriert auszurichten, müssen Sie sich selbst etwas einfallen lassen.

Oberfläche Sie brauchen zwei Formulare mit folgendem Aufbau:

963

18.2 Ein Formular automatisch zentrieren

Quelltext Zum Zentrieren können Sie die nachfolgende Prozedur verwenden: procedure zentriere(f1,f2 : TForm); begin f1.Left := (f2.Width - f1.Width) div 2 + f2.Left; f1.Top := (f2.Height - f1.Height) div 2 + f2.Top end;

f1 ist das zu zentrierende Formular, das sich auf f2 bezieht. HINWEIS: Voraussetzung für die korrekte Ausführung: f2 muss größer als f1 sein!

Der Aufruf von Form2: procedure TForm1.Button2Click(Sender: TObject); begin Form2.Show end;

// Zeige Form2

Das Zentrieren: procedure TForm2.Button1Click(Sender: TObject); begin zentriere(Self, Form1) end;

// Zentriere mich

Es wird vorausgesetzt, dass sich die Prozedur zentriere im Implementation-Abschnitt von Unit2 befindet.

964

Kapitel 18

How-to: Oberfläche

Test

18.3 Ein Formular automatisch entfernen Viele Programme (auch Delphi!) zeigen nach dem Start ein so genanntes Eröffnungsfenster, das nach einer bestimmten Zeit von selbst wieder verschwindet.

Oberfläche Platzieren Sie auf dem Formular einen Timer und legen Sie die Eigenschaft Interval zum Beispiel mit 5000 (Zeit in 1/1000 Sekunden) fest.

Quelltext In die Ereignisprozedur des Timers tragen Sie ein: procedure TForm1.Timer1Timer(Sender: TObject); begin Close end;

18.4 Ein Formular ohne Titelleiste erzeugen

965

Test Nach dem Programmstart können Sie sich fünf Sekunden am Anblick des Fensters erfreuen.

Bemerkung Eventuell können Sie das Formular mit Form1.ShowModal

laden, um zu verhindern, dass während der Anzeige ein anderes Fenster aktiviert wird.

18.4 Ein Formular ohne Titelleiste erzeugen Um Fenster zu erzeugen, die aus dem "Rahmen fallen", d.h., die über keinerlei Umrandung verfügen, müssen Sie die BorderStyle-Eigenschaft auf bsNone setzen. Das erledigen Sie normalerweise im Objektinspektor. Die Schattenseite: Leider dürfen solche Fenster keine Menüleiste haben. Für das Entfernen des Formulars müssen Sie also programmtechnisch vorsorgen, zum Beispiel mit einem extra "Schließen"-Button oder mit einem Timer. Im folgenden Testprogramm wollen wir zeigen, wie die BorderStyle-Eigenschaft zur Laufzeit zugewiesen werden kann, und die Gelegenheit auch dazu nutzen, um die anderen wichtigen BorderStyle-Einstellungen zu demonstrieren.

Oberfläche Platzieren Sie eine RadioGroup und einen Button auf dem Formular. Weisen Sie der Items-Eigenschaft der RadioGroup die Einträge gemäß der Abbildung zu.

Siehe dazu auch Ä 18.43 Eine RadioGroup programmieren

966

Kapitel 18

How-to: Oberfläche

Quelltext procedure TForm1.RadioGroup1Click(Sender: TObject); begin case RadioGroup1.ItemIndex of 0: BorderStyle := bsDialog; 1: BorderStyle := bsNone; 2: BorderStyle := bsSingle; 3: BorderStyle := bsSizeable end end;

Test Nach Programmstart können Sie das Outfit des Formulars beliebig ändern. Hier der Mitleid erregende Anblick eines Formulars ohne Titelleiste und Rand:

18.5 Ein Formular an oberster Position einblenden "Sich ja nicht unterkriegen lassen...", müsste der eigentliche Untertitel lauten. Um ein Fenster immer an oberster Position zu halten (zum Beispiel eine Toolbox), setzen Sie dessen FormStyleEigenschaft im Objektinspektor auf fsStayOnTop. Leider schließt dies die Verwendung eines MDIFensters aus. In diesem Fall müssen Sie mit der API-Funktion SetWindowPos nachhelfen.

Quelltext procedure TForm1.FormCreate(Sender: TObject); begin SetWindowPos(handle,HWND_TOPMOST,Left,Top,Width,Height,SWP_SHOWWINDOW) end;

18.6 Einen Fensterhintergrund füllen

967

Test

18.6 Einen Fensterhintergrund füllen Zum Füllen von Hintergründen werden häufig kleine Bitmaps verwendet, die mehrfach nebeneinander eingeblendet werden. Auf diese Weise lässt sich jede Menge Speicherplatz sparen, da eine große Bitmap für das gesamte Fenster sicherlich mehr Platz braucht als eine 50x50-Pixel-Bitmap. Voraussetzung ist allerdings, dass (ähnlich wie bei einer Tapete) das Muster fortlaufend ist.

Oberfläche Außer dem Formular brauchen wir nur eine Image-Komponente, deren Picture-Eigenschaft wir eine kleine Muster-Bitmap zuweisen und die zur Laufzeit unsichtbar bleibt (Visible = False).

Quelltext Erweitern Sie zunächst die Klassendefinition des Formulars um eine neue Botschaftsbehandlungsroutine: type TForm1 = class(TForm) Image1: TImage; private { Private-Deklarationen} procedure WMEraseBkgnd (var Msg : TMessage); message WM_ERASEBKGND; public { Public-Deklarationen} end;

Die Implementierung der neuen Methode gestaltet sich relativ trivial, über das neue Ereignis füllen wir den Hintergrund: procedure TForm1.WMEraseBkGnd; var rec : TRect; newBr : THandle; begin rec.left := 0;

968

Kapitel 18

How-to: Oberfläche

rec.top := 0; rec.right := ClientWidth; rec.bottom := ClientHeight; newBr := CreatePatternBrush(Image1.Picture.Bitmap.Handle);

Nachdem aus der Bitmap der Image-Komponente ein Brush-Objekt erzeugt wurde, kann mit der GDI-Funktion FillRect ein rechteckiger Ausschnitt (hier der Clientbereich des Formulars) mit eben diesem Pinsel gefüllt werden. Die Auswahl des Pinsels über SelectObject ist in diesem Fall nicht nötig, da das Handle direkt an die Zeichenfunktion übergeben wird. FillRect(Self.Canvas.Handle,rec,newBr);

Auf das Löschen des Objekts sollten wir nicht verzichten: DeleteObject(newBr); Msg.Result := 0 end;

Test Das Formular in der folgenden Abbildung erscheint mit einem dezenten, wasserzeichenähnlichen Graumuster (Bundesadler!), das in der Druckwiedergabe leider nicht besonders gut zu erkennen ist1:

Bemerkungen ■ Die Verwendung des WMEraseBkGnd-Ereignisses bietet gegenüber dem OnPaint-Ereignis einen wesentlichen Vorteil: Der Formularhintergrund (grau) wird nach dem Verdecken nicht immer wieder neu gezeichnet. Deshalb entfällt auch das lästige Flackern. ■ Zwei Beispiel-Bitmaps, mit denen sich Muster aufbauen lassen, sind auf der Buch-CD.

1

Um das Ergebnis richtig würdigen zu können, sollten Sie das Programm von der Buch-CD starten.

18.8 Ein Formular in der Taskleiste anzeigen

969

18.7 Das Löschen des Form-Hintergrundes verhindern Blenden Sie Grafiken auf einem Formular oder in einer Komponente ein (z.B. mit Canvas.Draw), wird es Ihnen sicher schon aufgefallen sein, dass Delphi in seinem Eigensinn erst einmal den Formularhintergrund neu zeichnet. Dieses sture Verhalten führt teilweise zu einem recht unschönen Flackern, das Sie vermeiden können.

Oberfläche Es bietet sich an, für unseren kleinen Test die gleiche Oberfläche wie im vorhergehenden Rezept zu benutzen.

Quelltext Auch hier lassen sich Parallelen zum Vorgängerrezept nicht verleugnen. Erweitern Sie die Klassendefinition des Formulars um eine neue Botschaftsbehandlungsroutine: type TForm1 = class(TForm) Image1: TImage; private procedure WMEraseBkgnd (var Msg : TMessage); message WM_ERASEBKGND; public end;

Die Implementierung der Methode: procedure TForm1.WMEraseBkGnd; begin Canvas.Draw(0,0,Image1.Picture.Bitmap); Msg.Result := 0 end;

Test Zwar schwer zu erkennen, aber trotzdem real: Die Anzeige der Grafik erfolgt ohne vorhergehendes Löschen des Formularhintergrunds.

18.8 Ein Formular in der Taskleiste anzeigen Wollen Sie eine Anwendung erstellen, bei der die einzelnen Formulare möglichst bequem erreicht werden sollen, ist es günstig, diese ebenfalls in der Taskleiste anzuzeigen.

Oberfläche Außer dem von Delphi angebotenen Startformular (Form1) brauchen Sie nichts weiter. Ändern Sie gegebenenfalls die Beschriftung der Titelleiste (Caption-Eigenschaft), um später festzustellen, ob diese in der Taskleiste angezeigt wird.

970

Kapitel 18

How-to: Oberfläche

Quelltext Ergänzen Sie einfach in der Klassendefinition der betreffenden Formulare die CreateParamsMethode: type TForm1 = class(TForm) private { Private-Deklarationen} public { Public-Deklarationen} protected procedure CreateParams(var Params: TCreateParams); override; end; var Form1: TForm1; implementation {$R *.DFM} procedure TForm1.CreateParams(var Params: TCreateParams); begin inherited; // ererbte Methode ausführen // ... und ergänzen: Params.ExStyle := Params.ExStyle or WS_EX_APPWINDOW end;

Test Nach dem Programmstart finden Sie neben der Anwendung (Project1) auch die zugehörigen Formulare in der Taskleiste (in unserem Test nur Form1). Die Beschriftung entspricht der von Ihnen zugewiesenen Caption-Eigenschaft:

18.9 Ein Fenster zur Laufzeit erzeugen Werden Ihre Projekte umfangreicher, empfiehlt es sich, nicht alle Formulare zu Beginn automatisch erzeugen zu lassen, sondern erst dann, wenn sie angezeigt werden sollen. In diesem Zusammenhang sei an den Menüpunkt Projekt|Optionen... erinnert, wo Sie unter anderem auch bestimmen können, welche Formulare automatisch, d.h. im Projektfile, erzeugt werden.

Oberfläche Eröffnen Sie eine neue Anwendung. Über das Menü Datei|Neues Formular fügen Sie Form2 hinzu. Statten Sie Form1 mit drei Schaltflächen aus:

971

18.9 Ein Fenster zur Laufzeit erzeugen

Ein Blick in Projektoptionen und Projekt-Quelltext Die Seite "Formulare" der Projektoptionen (Menüpunkt Projekt|Optionen...) bietet Ihnen folgenden Anblick:

Über den Menüpunkt Projekt|Quelltext anzeigen können Sie sich davon überzeugen, ob tatsächlich beide Formulare zu Programmbeginn mit der CreateForm-Methode des Application-Objekts erzeugt werden: program Project1; uses Forms, Unit1 in 'Unit1.pas' {Form1}, Unit2 in 'Unit2.pas' {Form2}; {$R *.RES} begin Application.Initialize; Application.CreateForm(TForm1, Form1); Application.CreateForm(TForm2, Form2); Application.Run; end.

// Form1 wird erzeugt und angezeigt // Form2 wird erzeugt

972

Kapitel 18

How-to: Oberfläche

Zwar wird nach Programmstart nur das zuerst erzeugte Formular (Form1) angezeigt (siehe Hauptformular-Einstellung in obiger Abbildung), aber Form2 befindet sich "abrufbereit" im Speicher und könnte bekanntlich von Form1 aus der Anweisung Form2.Show;

oder Form2.ShowModal;

sichtbar gemacht werden. Was aber passiert, wenn wir auf das automatische Erzeugen verzichten? Wir probieren das aus, indem wir im Dialogfenster "Projektoptionen" mittels Pfeiltaste die Form2 von der linken Seite ("Automatisch erzeugen:") auf die rechte Seite ("Verfügbare Formulare:") bringen:

Im Projekt-Quelltext werden die Auswirkungen sofort sichtbar, denn die Anweisung Application.CreateForm(TForm2, Form2);

ist verschwunden! Wollen Sie nun von Form1 wie gewohnt Form2.Show;

aufrufen, erhalten Sie das leider nur zu gut bekannte Meldungsfenster:

Fazit: Wenn Sie ein Formular erst zur Laufzeit erzeugen wollen, müssen Sie sich um die Initialisierung bzw. Freigabe der Objektvariablen (Form2) selbst kümmern.

Quelltext Wir beschränken uns auf den implementation-Abschnitt von Form1: implementation uses Unit2;

973

18.10 Ein ToolWindow realisieren

{$R *.DFM} procedure TForm1.Button1Click(Sender: TObject); // Form2.Show begin if Form2 = nil then Form2:= TForm2.Create(Application); Form2.Show end; procedure TForm1.Button2Click(Sender: TObject); begin if Form2 <> nil then begin MessageBeep(0); Form2.Release; Form2 := nil end end;

// Form2.Release

Würden wir das Formular Form2 einfach nur mit Release freigeben, macht obiges Codefragment bei einem erneuten Aufruf Ärger. Die Ursache: Das Objekt wurde zwar zerstört, der Zeiger Form2 (um mehr handelt es sich nicht!) hat jedoch immer noch den alten Wert. Aus diesem Grund sollten Sie nach der Freigabe des Formulars auch der Variablen Form2 den Wert nil zuweisen.

Test Nach dem Programmstart können Sie Form2 beliebig oft erzeugen bzw. freigeben. Der Piepton soll Sie davon überzeugen, dass Form2 tatsächlich aus dem Speicher entfernt wurde.

18.10 Ein ToolWindow realisieren Möchten Sie statt einer Werkzeugleiste ein frei verschiebbares Toolfenster realisieren, stehen Sie vor dem Problem, dass dieses vom Hauptfenster verdeckt wird, sobald der Fokus wechselt. Für eine Lösung des Problems bieten sich zwei Varianten an: Zum einen können Sie die FormStyle-Eigenschaft des Toolwindows auf fsStayOnTop festlegen, zum anderen den FensterStyle des Toolwindows ändern. Die erste Variante erzeugt ein Fenster, das über allen Fenstern der Applikation angezeigt wird, die zweite beschränkt sich auf ein einfaches Fenster. Auf die erste Variante "StayOnTop" brauchen wir nicht weiter einzugehen, denn es genügt, wenn Sie die FormStyle-Eigenschaft im Objektinspektor wechseln.

Oberfläche Alles, was Sie brauchen, sind zwei Fenster Form1 und Form2 sowie einen Button in Form1, über den Sie Form2 anzeigen. Form2 statten Sie mit einigen Buttons vom Typ TBitBtn aus (Seite "Zusätzlich" der Komponentenpalette), und weisen Sie der Glyph-Eigenschaft irgendwelche Bitmaps zu.

974

Kapitel 18

How-to: Oberfläche

Quelltext In Form1 ist lediglich folgender Aufruf wichtig: procedure TForm1.Button1Click(Sender: TObject); begin Form2.Show end;

// Werkzeugleiste einblenden

Etwas mehr gibt es im Quelltext von Form2 zu tun. Zum Verändern des Fensters-Styles ist es nötig, dass Sie die Methode CreateParams des Toolwindows überschreiben bzw. erweitern. Fügen Sie deshalb die unterstrichene Anweisung in die Typdeklaration von TForm2 ein: type TForm2 = class(TForm) BitBtn1: TBitBtn; ... private procedure CreateParams(var Params: TCreateParams ); override; public { Public-Deklarationen } end;

Die Umsetzung im implementation-Abschnitt: procedure TForm2.CreateParams(var Params: TCreateParams ); begin inherited CreateParams( Params ); Params.Style := Params.Style or WS_OVERLAPPED; Params.WndParent := Form1.Handle end;

Nach dem Aufruf der ursprünglichen Methode erweitern wir den Style-Parameter um die Option WS_OVERLAPPED. Als Parent übergeben Sie den Handle des Fensters, für welches das Toolwindow angezeigt wird.

18.11 Ein Fenster auf Icon-Größe halten

975

Test Nach dem Programmstart können Sie das Toolwindow aufrufen. Obwohl es sich frei verschieben lässt, kann es von Form1 nicht verdeckt werden. Beide Fenster scheinen auf geheimnisvolle Weise miteinander verbunden zu sein: Falls Form1 durch andere Fenster verdeckt ist, genügt ein Klick auf das Toolwindow, um Form1 wieder in den Vordergrund zu bringen (und umgekehrt).

18.11 Ein Fenster auf Icon-Größe halten Für einige Anwendungszwecke ist es sinnvoll, dass die Anwendung lediglich als Icon angezeigt wird (DDE-Server etc.). Wollen Sie verhindern, dass der Anwender das Fenster anzeigt bzw. vergrößert, müssen Sie die Botschaft WM_QUERYOPEN abfangen.

Oberfläche Sie brauchen lediglich ein Formular, dessen WindowState-Eigenschaft Sie auf wsMinimized festlegen.

Quelltext Erweitern Sie die Klassendefinition um die Deklaration eines weiteren Message-Handlers: type TForm1 = class(TForm) procedure FormCreate(Sender: TObject); private procedure WMQueryOpen(var Msg : TWMQueryOpen); message WM_QUERYOPEN; public { Public-Deklarationen } end;

Die Umsetzung im implementation-Abschnitt: procedure TForm1.WMQueryOpen(var Msg : TWMQueryOpen); begin Msg.Result := 0; end;

Test Nach Programmstart können Sie das Fenster der Anwendung nur auf der Taskleiste bewundern. Klicken Sie darauf, um es zu vergrößern, so scheint das Fenster-Icon ins Nirwana zu entschweben.

HINWEIS: Schließen der Anwendung ist über Kontextmenü der rechten Maustaste möglich.

976

Kapitel 18

How-to: Oberfläche

18.12 Die Titelleiste ausblenden Für die Anzeige von Copyright-Meldungen oder speziellen Dialogboxen ist es häufig wünschenswert, dass die Titelleiste ausgeblendet wird. Auf diese Weise können Sie zum Beispiel verhindern, dass der Nutzer das Fenster verschiebt oder einfach schließt. Sie können zwar auch die BorderStyle-Eigenschaft auf bsNone festlegen, in diesem Fall fehlt jedoch der gesamte Rahmen! Zu einer attraktiveren Lösung kommen wir, wenn wir die Fensterattribute über die API-Funktion SetWindowLong verändern.

Oberfläche Das mit einem Button "aufgewertete" Startformular (Form1) genügt für einen kleinen Test.

Quelltext Erweitern Sie das OnFormCreate-Ereignis wie folgt: procedure TForm1.FormCreate(Sender: TObject); begin SetWindowLong(Handle,GWL_STYLE, GetWindowLong(Handle,GWL_STYLE) AND NOT WS_CAPTION); ClientHeight:=Height; Refresh end;

Durch obigen Aufruf wird das Flag WS_CAPTION im Fensterattribut ausgeblendet.

Test Seiner Titelleiste beraubt, bietet unser kärglich ausgestattetes Fenster einen kläglichen Anblick, aber was soll's, ohne Rahmen wäre der Anblick noch trostloser!

18.13 Ein MDI-Child simulieren

977

18.13 Ein MDI-Child simulieren Möchten Sie verhindern, dass ein Fenster den Clientbereich eines anderen Fensters verlässt, können Sie entweder mit MDI-Formularen arbeiten, oder Sie manipulieren den Fenster-Style so, dass das eine Fenster der Parent des anderen ist. Sie können die zweite Variante aber auch so modifizieren, dass sich das Child-Window nur innerhalb einer Komponente, z.B. einem Panel, bewegen darf. Das Beispiel zeigt, wie es geht.

Oberfläche Erzeugen Sie zwei Formulare, Form1 sollte in der Lage sein, Form2 anzuzeigen (Button mit Ereignis Form2.Show). Setzen Sie eine ausreichend große TPanel-Komponente auf Form1. Die Laufzeitansicht:

Quelltext Die Klassendefinition von Form2 wird wie folgt erweitert: TForm2 = class(TForm) public procedure CreateParams(var Params: TCreateParams); override; end;

Die Umsetzung im implementation-Abschnitt: procedure TForm2.CreateParams(var Params: TCreateParams); begin inherited CreateParams(Params); with Params do begin Style := Style or WS_CHILD; // kann modifiziert werden! WndParent := Form1.Panel1.Handle; end end;

978

Kapitel 18

How-to: Oberfläche

Test Nach dem Programmstart rufen Sie Form2 auf. Sie werden feststellen, dass sich Form2 nur innerhalb von Panel1 bewegen lässt.

Ergänzungen ■ Soll sich, wie in einer "richtigen" MDI-Applikation üblich, Form2 nicht nur innerhalb von Panel1, sondern innerhalb der gesamten Form1 bewegen dürfen, so ändern Sie die entsprechende Anweisung im Methodenkörper von CreateParams wie folgt: WndParent := Application.MainForm.Handle;

Über Application.MainForm wird das Hauptfenster der Anwendung zurückgegeben. Sie könnten aber auch direkt ein Fenster zuweisen (Form1.Handle). ■ Falls sich z.B. ein Editierfeld im Child-Fenster befindet, müssen Sie mit Form2.Edit1.SetFocus;

den Eingabefokus zuweisen, ehe eine Eingabe möglich ist.

18.14 Ein Formular skalieren Ein leidiges Problem: Sie entwickeln Ihr Programm bei einer Bildschirmauflösung von 1024 x 768, und der Anwender versucht, das Programm bei 640 x 480 auszuführen. Das Resultat: Einige Dialogelemente sind nicht mehr sichtbar und damit auch nicht bedienbar! Die generelle Beschränkung auf 640 x 480 bzw. die Entwicklung mehrerer Programmversionen ist sicher keine befriedigende Lösung, zumal Ihnen Delphi in dieser Beziehung mit einigen Funktionen entgegenkommt.

Oberfläche Entwerfen Sie in einem hochauflösenden Bildschirmmodus (z.B. 1024 x 768) ein kleines Formular, in dem Sie einige Komponenten so platzieren, dass kaum noch Platz an den Formularrändern bleibt. Wählen Sie eine skalierbare Schriftart, zum Beispiel Arial. Die Schriftgröße müssen Sie jetzt so einstellen, dass auch noch in einem verkleinerten Formular alles lesbar ist (Empfehlung: 12 dpi, da bei 640 x 480 rund 6 dpi übrig bleiben).

18.14 Ein Formular skalieren

979

Quelltext const ScreenHeightDev = 768; ScreenWidthDev = 1024; procedure TForm1.FormCreate(Sender: TObject); var x, y: Integer; begin Scaled := True; x := Screen.Width; y := Screen.Height; if (y <> ScreenHeightDev) or (x <> ScreenWidthDev) then begin Form1.Height := (Form1.ClientHeight * y div ScreenHeightDev) + Form1.Height-Form1.ClientHeight; Form1.Width := (Form1.ClientWidth * x div ScreenWidthDev) + Form1.Height-Form1.ClientHeight ; ScaleBy(x, ScreenWidthDev) end; end;

In den beiden Konstanten ScreenHeightDev und ScreenWidthDev speichern wir die Auflösung zur Entwurfszeit des Formulars. Mit der Eigenschaft Scaled bereiten Sie das Formular für die Skalierung vor. Danach kontrollieren wir, ob die Bildschirmauflöung zur Laufzeit von der Auflösung zur Entwurfszeit abweicht. Beim Einstellen der neuen Außenmaße des Formulars dürfen Sie nicht den Fehler machen, die aktuellen Außenmaße für die Berechnung heranzuziehen. Der Grund sind die Formularränder bzw. der Formularkopf. Der nachfolgende Aufruf der Methode ScaleBy hat keinen Einfluss auf diese Bereiche. ScaleBy skaliert den Clientbereich eines Controls (also auch einer Form!) im angegebenen Verhältnis, in unserem Beispiel 640/1024 = 0,6.

Test Starten Sie das Programm mehrfach unter verschiedenen Bildschirmauflösungen, so sollten Sie etwa folgende Ergebnisse erhalten:

980

Kapitel 18

How-to: Oberfläche

18.15 Eine Anwendung beim Deaktivieren schließen Für einige Fälle kann es recht sinnvoll sein, dass die Applikation geschlossen wird, sobald der Benutzer zu anderen Anwendungen bzw. Fenstern wechselt.

Oberfläche

Quelltext (< Delphi 5) Erweitern Sie die Typdeklaration des Formulars um folgenden Eintrag: type TForm1 = class(TForm) procedure FormCreate(Sender: TObject); private procedure AppDeactivate(Sender: TObject); ...

Die Umsetzung im implementation-Abschnitt ist verblüffend einfach: Über das (nicht sichtbare) Application-Objekt können Sie das Ereignis OnDeactivate manipulieren: procedure TForm1.AppDeactivate(Sender: TObject); begin Close end;

Bei Programmstart wird obige Methode dem OnDeactivate-Ereignis des Application-Objekts zugewiesen: procedure TForm1.FormCreate(Sender: TObject); begin Application.OnDeactivate := AppDeactivate end;

Quelltext (ab Delphi 5) Seit Delphi 5 stellt es auch für den Programmieranfänger kein Problem mehr dar, auf das Deaktivieren der Anwendung zu reagieren. Platzieren Sie einfach eine ApplicationEvents-Komponente auf dem Formular und nutzen Sie das OnDeactivate-Ereignis, um zum Beispiel die Anwendung zu beenden, wenn der Programmnutzer auf eine andere Anwendung klickt. BEISPIEL: Deactivate-Ereignis procedure TForm1.ApplicationEvents1Deactivate(Sender: TObject); begin Close; end;

18.16 Wichtige Standardkomponenten kennen lernen

981

Test Sobald Sie mit der Maus außerhalb des Formulars klicken bzw. dieses verdecken oder über die Taskleiste zu einer anderen Anwendung wechseln, wird unser Testprogramm automatisch beendet. Statt die Anwendung zu beenden, können Sie diese natürlich auch verstecken (Hide), minimieren (WindowState := wsMinimized) oder beliebige andere Aktivitäten auslösen.

18.16 Wichtige Standardkomponenten kennen lernen Gerade der Einsteiger läuft Gefahr, sich von der funktionellen und gestalterischen Vielfalt der zahlreichen Delphi-Komponenten verwirren zu lassen. Deshalb ist es wichtig, dass er sich zunächst auf die am häufigsten benötigten Komponenten konzentriert. Im folgenden Demo-Programm wollen wir diese kurz vorstellen. Es handelt sich um ■ Editierfeld (TEdit) ■ Memofeld (TMemo) ■ ComboBox (TComboBox) ■ CheckBox (TCheckBox) ■ RadioGroup (TRadioGroup) ■ Schaltfläche (TButton) Die Abfrage soll auf einfachste Weise mittels Meldungsfenster (ShowMessage) erfolgen.

Oberfläche Die verwendeten Komponenten haben keine sinnvoll zusammenhängende Funktion, es handelt sich bei der abgebildeten Oberfläche also um ein "buntes Allerlei":

982

Kapitel 18

How-to: Oberfläche

Weisen Sie hemmungslos irgendwelche Beschriftungen bzw. Inhalte zu, denn diese haben nur dekorativen Charakter. Um die ComboBox zur Entwicklungszeit zu füllen, müssen Sie die ItemsEigenschaft verwenden. Geben Sie in der sich öffnenden Dialogbox (Stringlisten-Editor) für jeden Eintrag eine neue Zeile ein. Ähnlich verfahren Sie bei der RadioGroup, jeder RadioButton ist ein Eintrag in der Eigenschaft Items. Bei der Eigenschaft Items handelt es sich um ein TStrings-Objekt, das zuweisungskompatibel mit anderen TStrings-Objekten (z.B. die Printers-Eigenschaft des Printer-Objekts) ist. Sie können auf diese Weise recht schnell ein Listenfeld oder eine ComboBox füllen.

Quelltext Für den Programmierer viel interessanter ist die Auswertung der Komponenteninhalte zur Laufzeit. Was hat der Anwender markiert oder eingegeben? Beim Programmstart soll der erste Eintrag in der ComboBox angezeigt werden: procedure TForm1.FormCreate(Sender: TObject); begin ComboBox1.ItemIndex := 0 end;

Hinter dem "Abfragen"-Button finden Sie Quellcode, der die einzelnen Komponenteninhalte ausliest und auswertet: procedure TForm1.Button1Click(Sender: TObject); var s : string; kopie: Boolean; com : Integer; mess : Integer;

// Abfragen

begin s := Edit1.Text; ShowMessage('Inhalt der Eingabezeile: ' + s); s := Memo1.Text; ShowMessage('Inhalt des Memofeldes: ' + s); kopie := CheckBox1.checked; if kopie then ShowMessage('CheckBox1: True') else ShowMessage('CheckBox1: False'); kopie := CheckBox2.Checked; if kopie then ShowMessage('CheckBox2: True') else ShowMessage('CheckBox2: False'); com := RadioGroup1.ItemIndex+1; ShowMessage('RadioGroup: ' + Format('COM%d',[com])); mess := ComboBox1.ItemIndex; ShowMessage('ComboBox: ' + ComboBox1.Items[mess]) end;

18.16 Wichtige Standardkomponenten kennen lernen

983

Das Programm schließen: procedure TForm1.Button2Click(Sender: TObject); begin Close end;

Test Nach Programmstart und diversen Eingaben können Sie sich durch einmaliges Klicken auf den "Abfragen"-Button per Messagebox nacheinander die Inhalte der einzelnen Komponenten anzeigen lassen. Im Beispiel wird gerade der aktuelle Inhalt der Edit-Komponente angezeigt:

Bemerkungen Informativer als die Text-Eigenschaft der Memo-Komponente wäre deren Lines-Eigenschaft gewesen. Da diese aber vom Datentyp TStrings ist, kann sie nicht im Meldungsfenster angezeigt werden. Siehe dazu Ä 17.10 Mit Stringlisten arbeiten Detailliertere Informationen als dieser Grobüberblick vermitteln Ihnen die folgenden Rezepte, wie z.B.: Ä 17.14 Auf Ziffern prüfen Ä 18.20 Die Zeilenzahl eines Memofeldes bestimmen Ä 18.49 Einträge in einer ListBox löschen

984

Kapitel 18

How-to: Oberfläche

18.17 Zahleneingaben überprüfen In Datenbankanwendungen oder mathematischen Programmen ist es häufig erforderlich, nur Zahlen mit definiertem Wertebereich für die Eingabe zuzulassen. Wir wollen zwei Varianten zur Lösung des Problems gegenüberstellen.

Variante 1 Im einfachsten Fall kann man alle Zeichen außer 0, 1, ... 9, dem Dezimalpunkt und der BackspaceTaste auf folgende Weise unterdrücken: procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char); begin if Key = #13 then Key := #0 else if not (Key in [#8,#46,#48 .. #57]) then Key:= #0 end;

Beim Testen werden Sie feststellen, dass auch das leidige Problem der Umwandlung Dezimalkomma in Dezimalpunkt hier gewissermaßen en passant mit erschlagen wird, denn das Komma wird gar nicht erst angenommen:

Variante 2 Diese wesentlich komfortablere Möglichkeit gestattet eine detaillierte Prüfung des Zahlentyps und seines Wertebereichs. Damit ein praktischer Sinn erkennbar ist, soll das Prinzip anhand der simplen Addition zweier Gleitkommazahlen erläutert werden.

Oberfläche Auf dem Formular platzieren Sie drei Editierfelder und zwei Buttons. Da Edit3 nur zur Ergebnisanzeige dient, sollten Sie hier ReadOnly auf True setzen.

985

18.17 Zahleneingaben überprüfen

Quelltext Die folgenden Anweisungen werden beim Verlassen eines Editierfeldes ausgeführt: procedure testSingle(e: TEdit); var n: Single; code : Integer; s : string;

// Übergabeparameter ist ein Editierfeld!

begin s := e.Text; try Val(s,n,code) except MessageBox(0,'Wertebereich überschritten','Problem',16); e.SetFocus end; if code <> 0 then begin MessageBox(0,'Fehler im Ausdruck','Problem',16); e.SetFocus end end;

Die Fehlerbehandlung mit Try-Except ist unbedingt notwendig, da die Anweisung Val eine Wertebereichsverletzung nicht "verkraftet" und das Programm zum Absturz bringt. Der Aufruf von testSingle erfolgt in einem OnExit-Event-Handler, der von Edit1 und Edit2 gemeinsam benutzt wird: procedure TForm1.EditExit(Sender: TObject); begin testSingle((Sender as TEdit)) end;

Test Bei der Eingabe von Gleitkommazahlen können Sie auch die wissenschaftliche Notation (Exponentialschreibweise) verwenden, wie es die folgende Abbildung zeigt:

986

Kapitel 18

How-to: Oberfläche

Sobald Sie ein Editierfeld verlassen wollen, in dem keine gültige Gleitkommazahl steht, werden Sie durch ein Meldungsfenster gezwungen, die Eingabe zu korrigieren:

Ein Schließen des Formulars über den "Beenden"-Button ist erst dann möglich, wenn in den beiden Eingabefeldern keine fehlerhaften Werte stehen.

18.18 Ein einzelnes Zeichen eingeben Haben Sie mit var zeichen: Char;

eine Zeichenvariable deklariert und wollen Sie deren Wert über ein Editierfeld eingeben, so erzeugt folgende Zeile eine Fehlermeldung "Inkompatible Typen 'Char und TCaption'": zeichen := Edit1.Text;

Richtig ist die Anweisung zeichen := Edit1.Text[1];

Wenn Sie es nicht glauben, so probieren Sie einfach die folgende kleine Demo aus.

Oberfläche Wir brauchen ein Editierfeld, zwei Labels und einen Button. Da das Editierfeld nur ein Zeichen aufnehmen soll, ist die MaxLength-Eigenschaft zweckmäßigerweise auf eins zu setzen.

Quelltext procedure TForm1.Button1Click(Sender: TObject); // Zuweisen begin zeichen := Edit1.Text[1]; Label2.Caption := 'Es wurde das Zeichen ' + zeichen + ' zugewiesen!' end;

18.19 Mit der Enter-Taste zum nächsten Feld wechseln

987

Bemerkung Wenn die MaxLength-Eigenschaft des Editierfeldes den Wert 0 hat (Standardwert für unbegrenzte Länge), so wird quasi das erste Zeichen herauskopiert.

18.19 Mit der Enter-Taste zum nächsten Feld wechseln Finden Sie es auch lästig, dass man sich nur mit der Tabulatortaste zwischen mehreren Textfeldern bewegen kann? Insbesondere in großen Eingabemasken ist die Verwendung der Entertaste bzw. der Cursortasten viel sinnvoller1. Sie könnten die oben beschriebene Funktionalität natürlich mühevoll für jede einzelne Textbox programmieren, es bietet sich jedoch an, die Routine so anzupassen, dass eine allgemein gültige Lösung gefunden wird.

Oberfläche Einen Vorschlag zeigt die folgende Abbildung:

Wichtig ist, dass Sie die KeyPreview-Eigenschaft des Formulars auf True festlegen, jedes Tastaturereignis wird damit zuerst an das Formular gesendet und erst dann an das entsprechende Editierfeld weitergereicht. Setzen Sie TabStop von Button1 auf False, damit dieser aus der Reihenfolge herausgenommen wird.

Quelltext Im KeyPress-Ereignis können wir auf die Entertaste (#13) wie folgt reagieren: procedure TForm1.FormKeyPress(Sender: TObject; var Key: Char); begin 1

Unter DOS war so etwas (fast) selbstverständlich!

988

Kapitel 18

How-to: Oberfläche

if Key = #13 then Self.Perform(WM_NEXTDLGCTL, 0, 0) end;

Die Methode Perform sendet die Message WM_NEXTDLGCTL an das aktuelle Formular. Ist der zweite Parameter (wParam) null, wird der Fokus an das nächste Steuerelement des Fensters weitergegeben. Ist der Wert ungleich null, erhält die vorhergehende Komponente den Fokus. Auf diese Weise könnten Sie auch die Cursortasten zum Wechsel zwischen Steuerelementen verwenden.

Test Nach dem Programmstart werden Sie feststellen, dass die sechs Editierfelder durch Betätigen der Enter-Taste der Reihe nach durchlaufen werden. Aber auch die Tab-Taste funktioniert noch wie gewohnt.

18.20 Die Zeilenzahl eines Memofeldes bestimmen Das Memofeld verfügt leider über keine Eigenschaft, mit der sich die Zeilenzahl direkt bestimmen lässt. Über die Lines-Eigenschaft (Objekt vom Typ TString) ist es dennoch möglich.

Oberfläche Auf dem Startformular platzieren Sie eine Memo-Komponente, ein Label und zwei Buttons.

Quelltext procedure TForm1.Button1Click(Sender: TObject); begin Label1.Caption := 'Das Memofeld hat ' + IntToStr(Memo1.Lines.Count) + ' Zeilen!' end;

Test

18.21 Die Zeile/Spalte in Memofeldern bestimmen

989

18.21 Die Zeile/Spalte in Memofeldern bestimmen An welcher Position befindet sich die Einfügemarke im Memofeld? Diese Frage soll das vorliegende Rezept klären.

Oberfläche Ein Memo-Feld und ein Button – das ist alles, was wir für unseren Test brauchen. Günstig wäre es, wenn Sie der Lines-Eigenschaft der Memo-Komponente noch zur Entwurfszeit (StringlistenEditor) ein paar Zeilen Text zuweisen würden, das erspart Ihnen Tipparbeit beim Testen.

Quelltext Die aktuelle Zeile bzw. Spalte ermitteln wir mit Hilfe von Windows-Messages, die wir in zwei Funktionen einbetten: function GetMemoRow (M : TMemo) : LongInt; begin Result := SendMessage(M.Handle, EM_LINEFROMCHAR, M.SelStart, 0); end; function GetMemoCol (M : TMemo) : LongInt; begin Result := M.SelStart-SendMessage(M.Handle, EM_LINEINDEX, SendMessage(M.Handle, EM_LINEFROMCHAR, M.SelStart, 0), 0); end;

Die Verwendung beider Funktionen: procedure TForm1.Memo1KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState); begin Form1.Caption := Format('%d : %d',[ GetMemoRow(Form1.Memo1), GetMemoCol(Form1.Memo1)]) end;

Test

Bemerkungen Im obigen Beispiel haben wir das KeyUp-Ereignis verwendet, auf diese Weise wird die Anzeige nur aktualisiert, wenn die Taste losgelassen wird (günstig beim schnellen Scrollen). Soll die Anzeige auch auf das Tastenintervall reagieren, müssen Sie das KeyDown-Ereignis verwenden.

990

Kapitel 18

How-to: Oberfläche

18.22 Das aktuelle Wort unter dem Cursor ermitteln Verwenden Sie die RichEdit-Komponente in Ihren Programmen und möchten Sie auswerten, welches Wort sich gerade unter dem Mauscursor befindet? Wenn ja, dann sind Sie hier richtig. Eine Funktion erleichtert Ihnen die doch recht aufwändige Abfrage.

Oberfläche Fügen Sie in ein Formular eine RichEdit-Komponente und eine StatusBar zur Anzeige des Wortes ein.

Quelltext Den unter der Maus befindlichen Buchstaben bzw. dessen Position können Sie fast problemlos mit der Message EM_CHARFROMPOS abfragen. Etwas schwieriger ist es schon, das zugehörige Wort zu bestimmen. Dazu durchsuchen wir den Text vor und nach dem aktiven Buchstaben so lange, bis ein Trennzeichen gefunden wird. Das Wort braucht jetzt nur noch mit Hilfe der zwei Positionsmarken start_pos und end_pos bestimmt zu werden. function GetActiveWord(rch : TRichedit;x,y: integer): string; var pos : Integer; poin : TPoint; start_pos : Integer; end_pos : Integer; c : Char; txt : string; txtlen : Integer; begin poin.x := x; poin.y := y; pos := SendMessage(rch.handle, EM_CHARFROMPOS, 0, integer(@poin)); If pos <= 0 Then Exit; txt := rch.Text; while (pos > 0)and(txt[pos] in ['0'..'9','a'..'z','A'..'Z','_', 'ö','Ö','ü','Ü','ä','Ä']) do dec(pos); start_pos := pos+1; inc(pos); while (pos < length(txt))and(txt[pos] in ['0'..'9','a'..'z','A'..'Z','_', 'ö','Ö','ü','Ü','ä','Ä']) do inc(pos); end_pos := pos; result := copy(txt,start_pos,end_pos-start_pos); end;

Die Verwendung der Funktion: procedure TForm1.RichEdit1MouseMove(Sender: TObject; Shift: TShiftState; X,Y: Integer); begin statusbar1.SimpleText := GetActiveWord(richedit1,x,y); end;

991

18.23 Einen Zeilenumbruch erzwingen

Test Starten Sie das Programm und bewegen Sie die Maus über die RTF-Komponente. In der Statusleiste des Formulars wird Ihnen das gerade aktive Wort angezeigt.

18.23 Einen Zeilenumbruch erzwingen Um überlange Zeilen in einem Memofeld zu vermeiden, können Sie den Text durch Einfügen der Steuerzeichen für Wagenrücklauf (#13) und Zeilenvorschub (#10) umbrechen.

Oberfläche Auf dem Formular platzieren Sie eine Memo-Komponente und zwei Buttons. Setzen Sie die Eigenschaft WordWrap des Memofeldes auf False.

Quelltext procedure TForm1.Button1Click(Sender: TObject); begin Memo1.SelText := #13#10 end;

// Zeile umbrechen

Test Wenn Sie nach Programmstart etwas in das Memofeld hineinschreiben, können Sie einen Zeilenumbruch entweder mittels Enter-Taste oder durch Klicken auf den Button herbeiführen.

992

Kapitel 18

How-to: Oberfläche

Bemerkungen Auf die gleiche Weise lässt sich ein Zeilenumbruch auch für Labels oder für Messageboxen herbeiführen. BEISPIEL: Zeilenumbruch Label1.Caption := 'Hallo' + #10 + 'User';

Editierfelder sind und bleiben einzeilig und deshalb nicht auf die beschriebene Weise zu einem Zeilenumbruch zu bewegen.

18.24 Eine Undo-Funktion realisieren Hat man sich in einem Memo vertippt, ist es ganz nützlich, wenn sich der alte Inhalt wieder herstellen lässt.

Oberfläche Sie brauchen lediglich ein Memofeld und zwei Buttons.

18.25 Ränder in Memofeldern setzen

993

Quelltext Wir senden eine Botschaft an die Komponente: procedure TForm1.Button1Click(Sender: TObject); begin Memo1.Perform(EM_UNDO, 0, 0) end;

Test Nachdem Sie etwas eingegeben haben, können Sie es wieder rückgängig machen, wobei der Zustand bis zum vorangegangenen Undo wiederhergestellt wird.

Bemerkung EM_UNDO kann auch mehrfach aufgerufen werden. Auf diese Weise lässt sich auch die UNDOOperation wieder rückgängig machen (REDO).

18.25 Ränder in Memofeldern setzen Mit Hilfe der ebenso universellen wie segensreichen API-Routine SendMessage setzen Sie beispielsweise auch den linken und rechten Rand in Memofeldern (gemeint sind die Textbegrenzungen, nicht die äußeren Abmessungen der Komponente!).

Oberfläche Eine Memo-Komponente und ein Button genügen. In die Lines-Eigenschaft des Memofeldes kopieren Sie am besten gleich jetzt schon einen hinreichend langen Text, damit sparen Sie sich mühseliges Eintippen beim späteren Testen.

994

Kapitel 18

How-to: Oberfläche

Quelltext procedure TForm1.Button1Click(Sender: TObject); var Rect: TRect; begin

Abrufen der aktuellen Abmessungen: SendMessage(Memo1.Handle, EM_GETRECT, 0, LongInt(@Rect));

Verändern der Werte: Rect.Left:= Rect.Left + 20; Rect.Right := Rect.Right - 20;

Neusetzen: SendMessage(Memo1.Handle, EM_SETRECT, 0, LongInt(@Rect));

Auffrischen: Memo1.Refresh end;

Test Nach mehrmaligem Klick auf den Button werden die Ränder zunehmend breiter:

18.26 Einen vergrößerten Textcursor realisieren Ein Grundübel von Windows war und ist der mickrige Textcursor. Die Blinkrate lässt sich zwar noch über die Systemsteuerung einstellen, aber das war es dann auch schon. Selbsthilfe ist also wieder einmal angesagt.

995

18.26 Einen vergrößerten Textcursor realisieren

Ein erster Ratschlag: Verwenden Sie für Ihre Textboxen möglichst die Systemschriftart FixedSys, diese Schrift ist nicht proportional, d.h., ein i ist genauso breit wie ein w. Das erleichtert uns die Entscheidung für eine feste Cursorbreite.

Oberfläche Ein Memofeld und einen Button zum Beenden – das sollte für einen ersten Test genügen.

Quelltext Mit den beiden API-Funktionen CreateCaret und ShowCaret lässt sich ein neuer Textcursor definieren und anzeigen. Die Parameter für CreateCaret sind: ■ Handle auf das Textfeld ■ Null für Schwarz, sonst Grau ■ Breite in Pixeln ■ Höhe in Pixeln Mit ShowCaret wird der neue Cursor aktiviert. Die Definition bringen Sie im KeyDown-Ereignis unter: procedure TForm1.Memo1KeyDown(Sender: TObject; var Key: Word; begin CreateCaret(Memo1.Handle, 1, 5, 15); ShowCaret(Memo1.Handle) end;

Shift: TShiftState);

Warum nicht im OnEnter-Ereignis? Diese Antwort sollten uns die Borland-Entwickler geben, die bei jedem Fokus-Erhalt den Standard-Cursor wiederherstellen.

Test

996

Kapitel 18

How-to: Oberfläche

18.27 Einen grafischen Textcursor realisieren Als Cursor können Sie auch kleine Bildchen blinken lassen, das vorliegende Rezept zeigt eine Lösung.

Oberfläche Neben der obligatorischen Memo-Komponente brauchen wir noch eine (winzige) Image-Komponente, deren Picture-Eigenschaft wir eine ebenso winzige Bitmap (in unserem Fall ein simples Fragezeichensymbol) zuordnen:

Quelltext Gehen Sie wie im Vorgängerrezept vor, übergeben Sie jedoch statt null für den zweiten Parameter ein Bitmap-Handle. CreateCaret(Memo1.Handle, Image1.Picture.Bitmap.Handle, 8, 15); ShowCaret(Memo1.Handle);

Test Gewiss ist das blinkende Fragezeichen nicht sonderlich einfallsreich, aber eine Bitmap bietet ja weitere ungeahnte Gestaltungsmöglichkeiten, bei denen Sie Ihrer Fantasie freien Lauf lassen können.

18.28 Die Mauskoordinaten anzeigen Das folgende Beispiel zeigt bei jedem Mausklick die Koordinaten und den Klickpunkt an.

Oberfläche Ein Formular (Form1) und einen Button zum Beenden des Testprogramms – das ist alles.

18.29 Den Mausbereich verkleinern

997

Quelltext procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer) begin Canvas.TextOut(x,y,' '+IntToStr(x)+':'+IntToStr(y)); Canvas.MoveTo(x-2,y); Canvas.LineTo(x+3,y); Canvas.MoveTo(x,y-2); Canvas.LineTo(x,y+3) end;

Test Klicken Sie in den Clientbereich des Formulars und Sie erhalten die Pixel-Koordinaten.

18.29 Den Mausbereich verkleinern Unter Delphi kann die Maus tun und lassen was sie will, es gibt keine Funktion, die ihren hemmungslosen Bewegungsdrang einschränkt. In manchen Anwendungen könnte es aber durchaus erforderlich sein, vorübergehend den Mauscursor auf einen bestimmten Bereich, zum Beispiel auf die Innenfläche eines Fensters (Clientbereich), zu begrenzen.

998

Kapitel 18

How-to: Oberfläche

Oberfläche

Quelltext Binden Sie im FormCreate-Event folgenden Code ein: procedure TForm1.FormCreate(Sender: TObject); var rec: TRect; begin rec.left := Left; rec.top := Top; rec.right := Left + Width; rec.bottom:= Top + Height; ClipCursor(@rec) end;

Nach dem Druck auf eine Taste wird der alte Mausbereich wieder hergestellt: procedure TForm1.Button2Click(Sender: TObject); begin ClipCursor(nil) end;

Test Nach dem Programmstart werden Sie feststellen, dass sich die Maus nur innerhalb Form1 bewegen lässt.

Ergänzungen ■ Wenn Sie das Restaurieren des alten Mauscursorbereichs vergessen, bleiben die geänderten Parameter bis zum Beenden von Windows aktiv. Einzige Ausnahme: Versuchen Sie einmal, das Fenster zu vergrößern bzw. zu verkleinern. Sie werden feststellen, dass der Mausbereich auch dadurch wieder zurückgesetzt wird. ■ Das "Herumbasteln" am Mauszeiger sollten Sie nicht gar zu hemmungslos praktizieren, denn Windows ist ein Multitasking-System, und derartige Manipulationen wirken sich auf alle Anwendungen aus.

18.30 Den Mauscursor ausblenden

999

18.30 Den Mauscursor ausblenden Sie möchten ein Zeichenprogramm schreiben, das den Mauszeiger als Schnittpunkt zweier Achsen darstellt? Nichts einfacher als das! Blenden Sie einfach den Cursor aus und zeichnen Sie eine vertikale und eine horizontale Linie. Zum Ausblenden des Cursors nutzen Sie die Cursor-Eigenschaft. Setzen Sie diese auf -1, verschwindet der Cursor.

Quelltext Initialisieren: procedure TForm1.FormCreate(Sender: TObject); begin Cursor := -1; xa :=0; ya :=0; form1.Canvas.Pen.Mode:=pmnotxor end;

Zeichnen der Linien: procedure TForm1.FormMouseMove(Sender: TObject;Shift:TShiftState;X,Y:Integer); begin with form1.Canvas do begin MoveTo(xa, 0); LineTo(xa, ClientHeight); MoveTo(0, ya); LineTo(ClientWidth, ya); MoveTo(x, 0); LineTo(x,ClientHeight); MoveTo(0, y); LineTo(ClientWidth, y); xa :=x; ya :=y end end;

1000

Kapitel 18

How-to: Oberfläche

18.31 Eigene Mauszeiger verwenden Die paar unter Delphi zugänglichen Mauszeiger können leider nicht alle Wünsche und schon gar nicht jeden Geschmack befriedigen. Für ein Zeichenprogramm sucht man z.B. vergeblich nach einem Symbol in Form eines simplen Bleistifts. Neidvoll wird mancher nach anderen WindowsApplikationen schielen, die teilweise mit einer großen Vielfalt unterschiedlichster Mauszeiger brillieren. Der zum Lieferumfang von Delphi gehörende Bildeditor eignet sich unter anderem auch für die Erstellung von "hausgemachten" Mauszeigern. Im Folgenden wird anhand eines kleinen Testprogramms erläutert, wie man mit Hilfe des Bildeditors seinen "Mäusezirkus" aufstocken kann:

Ressourcen-Erstellung im Bildeditor Es erfolgt eine stichpunktartige Erläuterung: ■ Menü: Neu-Ressourcendatei (RES) ■ Menü: Ressource|Neu|Mauszeiger ■ Erstellen der Mauszeiger ■ Menü: Cursor|Sensitive Zone festlegen (Koordinaten angeben und testen) ■ Benennen Sie die Mauszeiger um und geben Sie ihnen eine fortlaufende Nummer ■ Menü: Datei/Projekt speichern (z.B. CURSORS.RES) HINWEIS: Den Kontaktpunkt benötigen Sie, um den aktiven "Klick"-Punkt bezüglich der linken

oberen Ecke festzulegen.

Kontaktpunkt

Oberfläche Platzieren Sie auf einem Formular zwölf Shape-Komponenten, es können aber auch Image-Komponenten oder andere Steuerelemente sein.

18.31 Eigene Mauszeiger verwenden

1001

Quelltext Die wohl wichtigste Aufgabe ist es, die erstellte Mauszeiger-Ressourcendatei in das Delphi-Projekt einzubinden: unit Unit1; interface ... implementation {$R *.DFM} {$R CURSORS.RES}

Für alle neuen Mauszeiger definieren Sie Konstanten (ist nicht unbedingt nötig, aber übersichtlicher). Die Werte sollten positiv sein, da 0 bis -21 bereits Delphi verwendet. const crLinie crHand crKreis crRechteck crEimer crSpray crFreihand crText crPipette crSchere ...

= = = = = = = = = =

1; 2; 3; 4; 5; 6; 7; 8; 9; 10;

Diese Ressourcen werden beim Erstellen des Formulars geladen. Übergeben Sie an MakeIntResource die Nummer des gewünschten Mauszeigers:

1002

Kapitel 18

How-to: Oberfläche

procedure TForm1.FormCreate(Sender: TObject); begin screen.cursors[crLinie]:=LoadCursor(HINSTANCE,makeintresource(133)); screen.cursors[crHand]:=LoadCursor(HINSTANCE,makeintresource(131)); screen.cursors[crKreis]:=LoadCursor(HINSTANCE,makeintresource(103)); screen.cursors[crRechteck]:=LoadCursor(HINSTANCE,makeintresource(6)); screen.cursors[crRndRect]:=LoadCursor(HINSTANCE,makeintresource(8)); screen.cursors[crEimer]:=LoadCursor(HINSTANCE,makeintresource(12)); screen.cursors[crSpray]:=LoadCursor(HINSTANCE,makeintresource(2)); screen.cursors[crFreihand]:=LoadCursor(HINSTANCE,makeintresource(1)); screen.cursors[crText]:=LoadCursor(HINSTANCE,makeintresource(104)); screen.cursors[crPipette]:=LoadCursor(HINSTANCE,makeintresource(110)); screen.cursors[crSchere]:=LoadCursor(HINSTANCE,makeintresource(3)); screen.cursors[crRadiergummi]:=LoadCursor(HINSTANCE,makeintresource(4)); screen.cursors[crText]:=LoadCursor(HINSTANCE,makeintresource(104));

Danach können Sie die neuen Mauszeiger so wie Delphi-eigene verwenden: shape1.cursor := crLinie; shape2.cursor := crHand; shape3.cursor := crKreis; shape4.cursor := crRechteck; shape5.cursor := crRndRect; shape6.cursor := crEimer; shape7.cursor := crSpray; shape8.cursor := crFreihand; shape9.cursor := crText; shape10.cursor := crRadiergummi; shape11.cursor := crSchere; shape12.cursor := crPipette; end;

Die auf der Buch-CD enthaltene Datei CURSORS.RES enthält rund 70 neue Mauszeiger, die Sie in eigene Applikationen übernehmen können1:

1

Ähnlichkeiten mit Ihnen bereits bekannten Mauszeigern sind rein zufällig ...!

18.32 Auf Mausbewegungen reagieren

1003

18.32 Auf Mausbewegungen reagieren Um jeglichen Missverständnissen vorzubeugen: Gemeint ist in diesem Fall nicht das einfache OnMouseMove etc., sondern die aus einigen Präsentationsprogrammen bekannte Funktion, auf das Hinein- bzw. Hinausbewegen der Maus zu reagieren. Beispielsweise könnte eine Erklärung eingeblendet werden, wenn sich die Maus über einer Image-Komponente befindet. Die nahe liegende Verwendung von MouseMove bereitet in diesem Zusammenhang einige Probleme. Die Realisierung der zwei neuen Ereignisse wollen wir am Beispiel einer Image-Komponente demonstrieren, dazu müssen wir eine neue Klasse ableiten.

Quelltext (Komponente) Um zwei neue Ereignisse zu realisieren, leiten wir einfach eine neue Komponente von TImage ab und erweitern die Klassendefinition: unit MMImage; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, ExtCtrls; type TMMImage = class(TImage) private FOnMouseEnter : TNotifyEvent; FOnMouseLeave : TNotifyEvent; Procedure CMMouseEnter(var Message: TMessage); message CM_MOUSEENTER; Procedure CMMouseLeave(var Message: TMessage); message CM_MOUSELEAVE; protected public published property OnMouseEnter: TNotifyEvent read FOnMouseEnter write FOnMouseEnter; property OnMouseLeave: TNotifyEvent read FOnMouseLeave write FOnMouseLeave; end; procedure Register; implementation procedure Register; begin RegisterComponents('MM', [TMMImage]) end;

Die Implementierung der beiden Ereignismethoden ist relativ simpel: procedure TMMImage.CMMouseEnter(var Message: TMessage); begin if Assigned(OnMouseEnter) then OnMouseEnter(Self); end;

1004

Kapitel 18

How-to: Oberfläche

procedure TMMImage.CMMouseLeave(var Message: TMessage); begin if Assigned(OnMouseLeave) then OnMouseLeave(Self); end; end.

Binden Sie die Komponente in ein neues oder ein existierendes Package ein und kompilieren Sie dieses.

Oberfläche (Testprogramm) Auf ein kleines Testprogramm wollen wir auch diesmal nicht verzichten, platzieren Sie einfach eine TMMImage-Komponente sowie ein Panel im Formular.

Quelltext (Testprogramm) Belegen Sie die beiden neuen Ereignisse von TMMImage wie folgt: procedure TForm1.MMImage1MouseEnter(Sender: TObject); begin Panel1.Visible := True end; procedure TForm1.MMImage1MouseLeave(Sender: TObject); begin Panel1.Visible := False end;

Test Das Resultat: Wird die Maus über dem Image bewegt, ist auch das Panel sichtbar.

18.33 Eine Menüleiste erstellen

1005

Bemerkung Bevor Sie das Beispiel von der Buch-CD abspielen können, müssen Sie die neue Komponente MMImage installieren (Menü Komponente|Komponente installieren...). Weitere Informationen über Komponentenprogrammierung finden Sie in den Rezepte Ä 25.11 Eine Farbauswahl-Komponente programmieren Ä 25.12 Eine unsichtbare Komponente programmieren Ä 25.13 Eine grafische Komponente programmieren

18.33 Eine Menüleiste erstellen Zu jedem "richtigen" Windows-Programm gehört die obligatorische Menüleiste. Mit dem Menüentwurfsfenster (Menü-Designer) stellt Delphi Ihnen dazu ein komfortables Werkzeug zur Verfügung. Die folgende kleine "Textverarbeitung" erläutert die wichtigsten Schritte im Umgang damit.

Oberfläche Auf das Startformular (Form1) setzen Sie ein Memofeld (Memo1) und eine, nur zur Entwurfszeit sichtbare, MainMenu-Komponente (MainMenu1), die gleich ganz vorn auf der Standard-Seite der Werkzeugpalette zu finden ist. Durch Doppelklick auf dieses Objekt öffnet sich das Menüentwurfsfenster. Klicken Sie auf das blaue Feld und tippen Sie die Hauptüberschrift des ersten Menüpunktes ("Datei") ein. Sie erkennen, dass diese in das Caption-Feld des Objektinspektors eingetragen wird, der automatisch eine Komponente mit dem Namen Datei1 anzeigt. Auf diese Weise erstellen Sie die weiteren Hauptmenüpunkte "Ansicht", "Bearbeiten" und "Hilfe". Sie brauchen dazu nur mit der Maus auf die entsprechende Stelle des Menü-Designers zu klicken und wie beschrieben fortzufahren. Um die Untermenüpunkte anzubringen, müssen Sie auf die entsprechenden Stellen unterhalb der Leiste klicken. Für die Trennungslinie geben Sie das Zeichen "-" ein (nur ein einziges!). Schließlich wird Ihnen das Menüentwurfsfenster folgenden Anblick bieten:

Ein Editieren dieser Einträge (Einfügen, Löschen, ...) ist möglich, wenn Sie die rechte Maustaste drücken und die gewünschte Option wählen.

1006

Kapitel 18

How-to: Oberfläche

Ergänzen Sie nun die übrigen Menüeinträge wie folgt: Ansicht: Schriftart, Vordergrund, Hintergrund Bearbeiten: Kopieren, Einfügen Hilfe: Info Das Ansicht-Menü soll nun noch weiter aufgesplittet werden. Über die rechte Maustaste erreichen Sie die Option Untermenü erstellen. Im Fenster wird eine weitere Menüebene eingeblendet, die auf analoge Weise auszufüllen ist: Schriftart: Times, Courier, Arial Vordergrund: schwarz, gelb, grün, blau Hintergrund: weiß, gelb, grün

Bereits jetzt können Sie sich von der Funktionsfähigkeit des Menüs überzeugen. Sie brauchen dazu nicht einmal das Programm zu starten:

Quelltext Da eine Menge unbekannter Objekte zu begutachten ist und weil wegen der beiden Zwischenablage-Funktionen die Unit ClipBrd der uses-Klausel hinzugefügt werden muss, gönnen wir uns diesmal das vollständige Listing von Unit11:

1

Sie brauchen das natürlich nicht abzutippen, denn das hat Delphi automatisch für Sie erstellt!

18.33 Eine Menüleiste erstellen

1007

unit Unit1; interface uses SysUtils, Windows, Messages, Classes, Graphics, Controls, Forms, Dialogs, Menus, StdCtrls, Clipbrd;

Die restlichen Deklarationen des Interface-Abschnitts werden von Delphi automatisch erstellt: type TForm1 = class(TForm) MainMenu1: TMainMenu; Memo1: TMemo;

Ab jetzt folgen die einzelnen, vom Menü-Designer erstellten, Menüobjekte: Datei1: TMenuItem; Ansicht1: TMenuItem; Bearbeiten1: TMenuItem; Hilfe1: TMenuItem; Beenden1: TMenuItem; Schriftart1: TMenuItem; Farben1: TMenuItem; Hintergrund1: TMenuItem; Kopieren1: TMenuItem; Einfgen1: TMenuItem; Neu1: TMenuItem; N1: TMenuItem; Times1: TMenuItem; Courier1: TMenuItem; System1: TMenuItem; Arial1: TMenuItem; gelb1: TMenuItem; grn1: TMenuItem; schwarz1: TMenuItem; wei2: TMenuItem; gelb2: TMenuItem; grn2: TMenuItem;

Die Deklarationen der Ereignisroutinen: procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure

Info1Click(Sender: Tobject); Beenden1Click(Sender: TObject); schwarz1Click(Sender: TObject); gelb1Click(Sender: TObject); grn1Click(Sender: TObject); blau1Click(Sender: TObject); wei2Click(Sender: TObject); gelb2Click(Sender: TObject); grn2Click(Sender: TObject); Neu1Click(Sender: TObject); Times1Click(Sender: TObject);

1008

Kapitel 18

procedure procedure procedure procedure end;

How-to: Oberfläche

Courier1Click(Sender: TObject); Arial1Click(Sender: TObject); Kopieren1Click(Sender: TObject); Einfgen1Click(Sender: TObject);

var Form1: TForm1; implementation {$R *.DFM}

Jetzt erst beginnt die Arbeit des Programmierers: Nach Doppelklick auf die entsprechenden Menüeinträge im Menü-Designer öffnet sich der Rahmencode für die Ereignisbehandlungen: Im Menü Datei|Neu beschränken wir uns auf das Löschen des Memofelds: procedure TForm1.Neu1Click(Sender: TObject); begin Memo1.Text := '' end;

// Datei|Neu

Vorder- und Hintergrundfarbe ändern: procedure TForm1.schwarz1Click(Sender: TObject); begin Memo1.Font.Color := clBlack end;

// Ansicht|Vordergrund|schwarz

procedure TForm1.gelb1Click(Sender: TObject); begin Memo1.Font.Color := clYellow end;

// Ansicht|Vordergrund|gelb

procedure TForm1.grn1Click(Sender: TObject); begin Memo1.Font.Color := clGreen end;

// Ansicht|Vordergrund|grün

procedure TForm1.blau1Click(Sender: TObject); begin Memo1.Font.Color := clBlue end;

// Ansicht|Vordergrund|blau

procedure TForm1.wei2Click(Sender: TObject); begin Memo1.Color := clWhite end;

// Ansicht|Hintergrund|weiß

procedure TForm1.gelb2Click(Sender: TObject); begin Memo1.Color := clYellow end;

// Ansicht|Hintergrund|gelb

procedure TForm1.grn2Click(Sender: TObject); begin Memo1.Color := clGreen end;

// Ansicht|Hintergrund|grün

Schriftarten ändern: procedure TForm1.Times1Click(Sender: TObject); begin Memo1.Font.Name := 'Times' end; procedure TForm1.Courier1Click(Sender: TObject); begin Memo1.Font.Name := 'Courier' end;

// Ansicht|Schriftart|Times

procedure TForm1.Arial1Click(Sender: TObject); begin Memo1.Font.Name := 'Arial' end;

// Ansicht|Schriftart|Arial

// Ansicht|Schriftart|Courier

1009

18.33 Eine Menüleiste erstellen

Das Menü für die Zwischenablage: procedure TForm1.Kopieren1Click(Sender: TObject); begin ClipBoard.AsText := Memo1.Text end;

// Bearbeiten|Kopieren

procedure TForm1.Einfgen1Click(Sender: TObject); begin Memo1.Text := Clipboard.AsText end;

// Bearbeiten|Einfügen

Die Programminfo beschränkt sich auf eine einfache Dialogbox: procedure TForm1.Info1Click(Sender: TObject); // Hilfe|Info begin MessageDlg('Menüentwurf mit Borland Delphi', mtInformation,[mbOK],0) end;

Und schließlich der Abgesang: procedure TForm1.Beenden1Click(Sender: TObject); begin Close end; end.

// Datei|Beenden

Test Nach dem Programmstart können Sie sich von der Funktionsfähigkeit der einzelnen Menüpunkte überzeugen:

Bemerkungen ■ Da die Text-Eigenschaft der Memo-Komponente maximal 255 Zeichen speichert (String!), sollten Sie für ernsthaftere Anwendungen die Clipboard-Funktionen über die Assign-Methode abwickeln. ■ Um das Progrämmchen zu einer vollwertigen kleinen Textverarbeitung auszubauen, müsste vor allem der Dateidialog qualifiziert werden.

1010

Kapitel 18

How-to: Oberfläche

18.34 Ein PopUp-Menü erzeugen Jede zeitgemäße Windows-Applikation stellt kontextsensitive PopUp-Menüs bereit. Diese erscheinen nach Klick mit der rechten Maustaste auf ein bestimmtes Objekt der Bedienoberfläche. Das folgende kleine Testprogramm zeigt, wie Sie mit Delphi im Handumdrehen Ihre eigenen Programme mit PopUp-Menüs "nachrüsten" können.

Oberfläche Auf dem Startformular (Form1) platzieren Sie außer einem Editierfeld (Edit1) und einer Schaltfläche (Button1) auch eine PopUp-Menü-Komponente (PopupMenu1), wie Sie sie auf der Standardseite der Werkzeugleiste finden:

Klicken Sie einmal auf die PopUpMenu-Komponente und anschließend im Objektinspektor auf den Items-Eintrag. Es erscheint ein neues Fenster: der Menü-Designer. Klicken Sie dort auf das leere eingerahmte Feld und tragen Sie die erste Menüzeile ein ("Text schwarz"):

Parallel taucht dieser Eintrag auch als Caption-Eigenschaft im Objektinspektor auf, so dass Sie dort editieren können. Auf diese Weise wird das komplette Menü fertig gestellt. Für die Trennlinie verwenden Sie einen Trennstrich (-). Was aber, wenn Ihnen ein Menüeintrag nicht gefällt, Sie zwischen zwei Menüzeilen eine weitere einfügen oder gar ein Submenü erstellen möchten? Kein Problem, drücken Sie über dem MenüEntwurfsfenster die rechte Maustaste. Das diesmal "in eigener Sache" erscheinende PopUp-Menü bietet Ihnen unter anderem auch die Optionen Einfügen, Löschen und Untermenü erstellen an.

Quelltext Jeder Menüeintrag ist genauso ein Objekt wie jede andere Komponente und verfügt über Eigenschaften und Methoden. Allerdings gibt es nur ein Ereignis, das OnClick-Event.

1011

18.34 Ein PopUp-Menü erzeugen

Wir wollen aus Übersichtlichkeitsgründen nur eine einzige Ereignisbehandlungsroutine schreiben, die wir PopUp1Click nennen. Entfernen Sie aus der Typdeklaration von Form1 die nicht benötigten Ereignismethoden und fügen Sie die für PopUp1Click hinzu: type TForm1 = class(TForm) Edit1: TEdit; Button1: TButton; PopupMenu1: TPopupMenu; Textschwarz1: TMenuItem; Textrot1: TMenuItem; Textgrn1: TMenuItem; N1: TMenuItem; Textlschen1: TMenuItem; procedure Button1Click(Sender: TObject); procedure PopUp1Click(Sender: TObject); end;

// hinzufügen!

Da wir aus Bequemlichkeitsgründen auf eine Namensänderung der Menüeinträge verzichtet haben, hat der Editor die Namen selbst auf Grundlage der Caption-Property nach bestem Wissen und Gewissen "zusammengebastelt". Dabei werden Umlaute einfach ignoriert. Die Ereignisbehandlung müssen wir komplett neu erstellen, die Herkunft des Menüklicks ergibt sich aus der allgemeinen Sender-Objektvariablen: procedure TForm1.PopUp1Click(Sender: TObject); begin with Edit1 do begin if Sender=TextSchwarz1 then Font.Color := clBlack; if Sender=TextRot1 then Font.Color := clRed; if Sender=TextGrn1 then Font.Color := clGreen; if Sender=TextLschen1 then Text := '' end end;

Wenn Sie diese Methode hinzugefügt haben, müssen Sie das Menüentwurfsfenster öffnen, auf den entsprechenden Eintrag klicken und dann die Ereignisse-Seite des Objektinspektors aufschlagen. Dort weisen Sie dem OnClick-Ereignis den Bezeichner PopUp1Click zu.

Test Starten Sie das Programm und drücken Sie über dem Editierfeld die rechte Maustaste. Es passiert – nichts! Kein Wunder, denn woher soll die Komponente Edit1 denn von ihrem Glück wissen, dass ihr ein Popup-Menü zugeordnet wurde? Deshalb: Setzen Sie die PopupMenu-Eigenschaft von Edit1 auf PopupMenu1! Dieser Bezeichner wird in der kleinen Rollbox daneben ausgewählt.

1012

Kapitel 18

How-to: Oberfläche

Über die PopupMenu-Eigenschaft verfügen Formulare und (fast) alle sichtbaren Komponenten. Falls Sie diese Property nicht besetzen, dürfen Sie sich später nicht wundern, wenn die rechte Maustaste keine Wirkung zeigt. Haben Sie das Versäumte nachgeholt, können Sie über das Popup-Menü die Schriftfarbe der Textbox ändern sowie deren Inhalt löschen:

Bemerkungen ■ Durch Setzen der Properties Visible, Enabled, Checked u.a. (siehe Objektinspektor) zur Laufzeit können Sie Menüeinträge verschwinden lassen, sperren oder mit einem Häkchen versehen. ■ Hinter dem Namensbezeichner N1 verbirgt sich der unverdienterweise in den Status eines "Objekts" erhobene Menü-Trennstrich.

18.35 Menüeinträge zur Laufzeit erzeugen Menüs lassen sich auch ohne API-Funktionen während der Laufzeit erstellen bzw. verändern. Lesen Sie in diesem Abschnitt, wie Sie Ihrer Menüzeile zusätzliche Einträge hinzufügen.

Oberfläche Legen Sie zuerst eine Menüstruktur mit dem Menüpunkt "Schriftarten" an. In das Formular kopieren Sie noch ein Label (Label1), mit dem wir später anzeigen, welcher Menüpunkt gewählt wurde.

Wie Sie aus der Bezeichnung des Menüpunktes unschwer erkennen dürften, sollen alle verfügbaren Bildschirmschriftarten angezeigt werden.

1013

18.35 Menüeinträge zur Laufzeit erzeugen

Quelltext Mit dem Erstellen des Formulars lesen wir die Anzahl der Screen-Fonts aus und legen entsprechend viele Menüpunkte an: procedure TForm1.FormCreate(Sender: TObject); var NewItem : TMenuItem; i : Integer; begin for i := 0 to Screen.Fonts.Count-1 do begin NewItem := TMenuItem.Create(Self); NewItem.Caption := Screen.Fonts.Strings[i]; NewItem.OnClick := Schriftarten1Click; schriftarten1.Add(NewItem) end; end;

// // // //

neuen Punkt erstellen Name der Ereignisprozedur Ereignisprozedur an das Menü anhängen

Die gemeinsame Ereignisprozedur: procedure TForm1.Schriftarten1Click(Sender: TObject); begin if Sender <> schriftarten1 then begin Label1.Font.Name := (Sender as TMenuItem).Caption; Label1.Caption := 'gewählt: '+ Label1.Font.Name end end;

Test Starten Sie das Programm. Falls, wie die folgende Abbildung vom Autoren-PC zeigt, viele Schriftarten auf dem Rechner installiert sind, können Sie sich an einer ellenlangen Liste erfreuen:

Nach der Auswahl eines Menüeintrags erscheint die Information im Label in der entsprechenden Schriftart:

1014

Kapitel 18

How-to: Oberfläche

18.36 Grafiken in Menüpunkte einbinden Um Ihre Anwendung optisch aufzuwerten, können Sie unter Windows auch Grafiken in die Menüzeile einbinden. Der Einwand, mit Hilfe der Bitmap- oder der Image-Eigenschaft können auch Grafiken in die Menüpunkte eingeblendet werden, ist zwar richtig, aber Sie können immer nur ein kleines Icon anzeigen. Das komplette Ersetzen der Menüpunkte ist nicht möglich. Es bleibt nur der umständliche Weg über die API-Funktionen.

Oberfläche Für ein kleines Demo-Programm brauchen Sie außer einer MainMenu-Komponente und einem Image nur noch zwei Buttons.

Laden Sie eine beliebige Bitmap in die Image-Komponente, dieses Bild soll zur Laufzeit im Menü angezeigt werden. Erstellen Sie ein neues Menü, das Sie Test nennen. Legen Sie sechs leere Menüpunkte an (Menüeditor öffnen durch Doppelklick auf MainMenu).

Quelltext Da die Menüs bereits über Handles verfügen, können wir uns die Arbeit sparen, diese umständlich über API-Funktionen zu ermitteln, und wir können gleich zur Sache kommen: procedure TForm1.Button1Click(Sender: TObject); var i : Integer; menu : THandle; begin

18.37 Das Systemmenü verkleinern

1015

for i := 0 to 5 do begin menu := GetMenuItemID(test.handle, i); ModifyMenu(test.Handle, menu, MF_BYCOMMAND Or MF_BITMAP, menu, PChar(Image1.Picture.Bitmap.Handle)) end end;

Etwas diffizil ist die Übergabe des Bitmap-Handle. Konvertieren Sie dieses einfach in den Datentyp PChar. Das sieht zwar nicht schön aus, erfüllt jedoch seinen Zweck.

Test Starten Sie das Programm und betätigen Sie den Button. Das Menü sollte jetzt so aussehen:

Ergänzung ■ Möchten Sie verschiedene Grafiken anzeigen, müssen Sie für jeden Menüpunkt eine Bitmap bereitstellen. Dies darf auch eine nicht sichtbare Speichergrafik vom Typ TBitmap sein. ■ Um in einem Menü neben Grafik auch Text darzustellen, müssen Sie den entsprechenden Text mittels TextOut in den Canvas des Image ausgeben.

18.37 Das Systemmenü verkleinern Jedes Delphi-Fenster verfügt über das Windows-typische Systemmenü. Nicht in jedem Fall möchte man aber alle Menüpunkte zulassen. Selbst definierte Menüs können Sie in Delphi beliebig freigeben bzw. sperren, mit dem Systemmenü geht das leider nicht so ohne weiteres. Sie haben zwar die Möglichkeit, das gesamte Menü auszublenden, aber das ist nicht immer erwünscht, vielfach sollen z.B. nur die Funktionen zum Schließen des Fensters entfernt werden.

1016

Kapitel 18

How-to: Oberfläche

Oberfläche Außer einem Button brauchen Sie keine weiteren Komponenten. Ein Label (Caption = "Beenden mit ALT+F4") am unteren Bildrand dient lediglich als "Gedächtnisstütze", anders können Sie die Anwendung später nicht verlassen.

Quelltext Für die Realisierung benötigen wir zwei API-Funktionen: GetSystemMenu und RemoveMenu. Mit GetSystemMenu holen wir das Menü-Handle, mit RemoveMenu können wir einzelne Menüpunkte löschen. Es sind folgende Parameter zu übergeben: Das zuvor ermittelte Handle, die Position des Menüeintrags sowie die Konstante MF_BYPOSITION. procedure TForm1.Button1Click(Sender: TObject); var handle : THandle; begin handle := GetSystemMenu(Self.Handle, False); RemoveMenu(handle, 8, MF_BYPOSITION); // RemoveMenu(handle, 7, MF_BYPOSITION); // RemoveMenu(handle, 6, MF_BYPOSITION); // RemoveMenu(handle, 5, MF_BYPOSITION) // end;

Wechseln zu Strich Schließen Strich

Test Nach dem Programmstart sieht das Systemmenü noch normal aus:

Ein Klick auf den Button – und unserem Systemmenü fehlt der letzte Eintrag. Man sehe und staune, auch die kleine "Schließen"-Schaltfläche in der Titelleiste rechts oben ist deaktiviert, so dass Ihnen nichts weiter übrig bleibt, als das Programm mit Alt+F4 zu beenden:

18.38 Das Systemmenü erweitern

1017

HINWEIS: Das Ausblenden der Menüpunkte bedeutet jedoch nicht, dass die Shortcuts nicht

mehr unterstützt werden.

18.38 Das Systemmenü erweitern Nach dem Löschen von Systemmenüpunkten wollen wir uns jetzt dem Einfügen von Menüpunkten zuwenden. Beispielsweise könnten Sie so eine Dialogbox aus dem Systemmenü heraus starten.

Oberfläche Wie die folgende Laufzeitansicht zeigt, brauchen wir für unseren Test zwei Formulare:

Quelltext Das Einfügen stellt eigentlich kein weiteres Problem dar. Der Funktion AppendMenu übergeben Sie einfach den Handle des Systemmenüs (diesen ermitteln wir mit GetSystemMenu), den Menütyp (MF_STRING), einen eindeutigen Identifizierer und natürlich den anzuzeigenden Text. Sollte der Text in einem String gespeichert sein, müssen Sie diesen in den Datentyp PChar umwandeln. procedure TForm1.FormCreate(Sender: TObject); begin AppendMenu(GetSystemMenu(Handle, False), MF_STRING, $F200, '&Copyright...') end;

Allerdings fehlt uns nach der Menüdefinition noch die Verknüpfung zu einer Prozedur oder Funktion. So einfach wie im Delphi-Menüeditor geht es in diesem Fall natürlich nicht, wir müssen die Message WM_SYSCOMMAND abfangen und entsprechend auswerten. Dazu brauchen wir einen Message-Handler, den wir wie folgt in der Klassendefinition des Formulars deklarieren:

1018

Kapitel 18

How-to: Oberfläche

type TForm1 = class(TForm) BitBtn1: TBitBtn; procedure FormCreate(Sender: TObject); private procedure WMSysCommand(VAR Message: TWMSysCommand); message WM_SYSCOMMAND; { Private-Deklarationen } public { Public-Deklarationen } end;

Die neue Ereignisprozedur: procedure TForm1.WMSysCommand(var Message: TWMSysCommand); begin Inherited; If Message.CmdType = $F200 Then Form2.ShowModal end;

An dieser Stelle brauchen wir wieder den eindeutigen Identifizierer. Wird der Menüpunkt ausgewählt, zeigen wir ein weiteres Formular an.

Test Da das Copyright-Fenster mit seiner ShowModal-Methode aufgerufen wird, müssen Sie erst auf OK klicken, ehe Sie weitermachen können.

18.39 Bildlaufleisten am Fensterrand positionieren Um eine Applikation an verschiedene Grafikmodi anzupassen, ist es nötig, die Lage bestimmter Komponenten von der Größe des Fensters abhängig zu machen1. Am Beispiel der Bildlaufleisten soll dies demonstriert werden. Bitte verwechseln Sie die ScrollBar-Komponente nicht mit den Bildlaufleisten, die Sie über die AutoScroll-Eigenschaft eines Formulars (True/False) einblenden können und die automatisch dann erscheinen, wenn eine Komponente außerhalb der sichtbaren Fläche liegt.

Oberfläche Auf dem Formular platzieren Sie an beliebiger Stelle zwei ScrollBar-Komponenten, denen Sie die Kind-Eigenschaft sbHorizontal bzw. sbVertical zuweisen.

1

In Java wird das durch so genannte Layout-Manager erledigt.

18.39 Bildlaufleisten am Fensterrand positionieren

1019

Quelltext Das OnResize-Event ist der ideale Platz, um die Lage der Komponenten den aktuellen Fensterabmessungen anzupassen: procedure TForm1.FormResize(Sender: TObject); begin ScrollBar1.Top := Form1.ClientHeight - ScrollBar1.Height; ScrollBar1.Width := Form1.ClientWidth - ScrollBar2.Width; ScrollBar1.Left := 0; ScrollBar2.Left := Form1.ClientWidth - ScrollBar2.Width; ScrollBar2.Height := Form1.ClientHeight - ScrollBar1.Height; ScrollBar2.Top := 0 end;

Test Nach Programmstart "kleben" beide Komponenten am unteren bzw. rechten Rand. Das bleibt auch so, wenn Sie die Größe des Formulars verändern.

1020

Kapitel 18

How-to: Oberfläche

18.40 Mit einem Schieberegler Werte einstellen Gewissermaßen als Alternative zum SpinButton können Sie auch mit einer simplen Bildlaufleiste diskrete Werte einstellen.

Oberfläche Auf dem Formular (Form1) platzieren Sie eine ScrollBar (ScrollBar1), einen Panel (Panel1) und (nicht unbedingt nötig) einen Button (Button1). Die Laufzeitansicht:

Wünscht man eine vertikale ScrollBar, so ist die Kind-Property von ScrollBar1 in sbVertical zu ändern. Obwohl sich auch alle anderen Schlüsseleigenschaften im Objektinspektor einstellen lassen, erfolgt hier aus Übersichtlichkeitsgründen deren Festlegung erst im Quelltext.

Quelltext procedure TForm1.FormCreate(Sender: TObject); var mini, maxi, pos: Integer; begin mini:= 0; // unterer Skalenwert maxi:= 100; // oberer Skalenwert pos:= 50; // aktuelle Position Panel1.Caption:= IntToStr(pos); // Anzeige with ScrollBar1 do begin SetParams(pos,mini,maxi); // Werte zuweisen LargeChange:= 10; // Grobabstufung SmallChange:= 1 // Feinabstufung end end; procedure TForm1.ScrollBar1Scroll(Sender: TObject; ScrollCode: TScrollCode; var ScrollPos: Integer); begin Panel1.Caption:= IntToStr(ScrollPos) end;

18.41 Verknüpfte und rastende Schalter realisieren

1021

Test Starten Sie das Programm und überzeugen Sie sich von der einfachen Handhabung des Schiebereglers! Wenn Sie mit der Maus direkt auf die Leiste (also ober- bzw. unterhalb des Schiebereglers) klicken, ergeben sich sprunghafte Änderungen (LargeChange-Eigenschaft).

Bemerkungen ■ Statt des OnScroll-Ereignisses kann auch OnChange verwendet werden. ■ Die Methode SetParams dient der Einsparung von drei Einzelanweisungen. In unserem kleinen Beispiel lässt sie sich ersetzen durch Position:= pos; Min:= mini; Max:= maxi;

■ Obige Werte können (soweit sinnvoll) auch ein negatives Vorzeichen haben. Gleitkommazahlen sind allerdings nicht möglich. Werden sie dennoch benötigt, so müssen sie nachträglich berechnet werden, z.B. wert:= ScrollBar1.Position / 10;

18.41 Verknüpfte und rastende Schalter realisieren Die "normalen" Buttons (TButton, TBitBtn) bleiben nur so lange gedrückt, wie Sie die Maustaste niederhalten. Außerdem ist es nicht ohne weiteres möglich, damit Schalterfelder zu realisieren, deren Tasten voneinander abhängig sind (immer nur eine Taste ist gedrückt, wie z.B. bei einer Werkzeugpalette). Zum Glück gibt es da noch den Schaltertyp TSpeedButton. Dieser hat ein sehr breites Anwendungsspektrum, das wohl kaum noch Wünsche offen lässt. Neben seinen Grafikfähigkeiten, auf die an anderer Stelle (s.u.) näher eingegangen wird, erlaubt er auch das Gruppieren bzw. Erstellen von Verknüpfungen innerhalb von Schalterfeldern.

Oberfläche Auf dem Formular (Form1) platzieren Sie insgesamt zehn Speed-Buttons und fünf Labels:

1022

Kapitel 18

How-to: Oberfläche

Eine Zusammenfassung aller zu verändernden Standardeigenschaften zeigt die folgende Tabelle: Komponente

Eigenschaften

Wert

Bemerkung

SpeedButton1 ...

Caption

1,2,3,4,5,6

Gruppe1 (verknüpft)

SpeedButton6

GroupIndex

1

SpeedButton7, SpeedButton8

Caption

A, B

GroupIndex

2

AllowAllUp

True

Tag

1, 2

Caption GroupIndex

Ich bin eingerastet! Einzelschalter 1 (einrastend, eingedrückt) 3

AllowAllUp

True

Down

True

Caption

Beenden

SpeedButton9

SpeedButton10

Gruppe2 (einrastend, nicht verknüpft,indiziert)

Einzelschalter 2 (normal)

Weiterhin ist zu beachten: ■ Am letzten Button (SpeedButton9) wird nicht "herumgedoktert". Er behält demnach den GroupIndex-Defaultwert 0 und wird sich deshalb im Folgenden durch keinerlei besondere Fähigkeiten hervorheben, sich also wie ein "stinknormaler" Button verhalten. ■ Wenn Sie die AllowAllUp-Eigenschaft für die Gruppe2 (A, B) in True ändern, genügt es, dies für einen einzelnen SpeedButton zu tun, der andere erhält dann diesen Wert automatisch.

Quelltext Um möglichst viele Informationen zu möglichen Programmiervarianten zu vermitteln, erhalten die einzelnen Gruppen unterschiedliche Ereignisbehandlungen. Den sechs Buttons der ersten Gruppe wird folgende gemeinsame OnClick-Ereignisprozedur zugewiesen: procedure TForm1.SpeedButton1Click(Sender: TObject); // Gruppe 1 var txt: string; begin txt:= 'Gruppe 1 => '; Canvas.TextOut(180,200,txt+TSpeedButton(Sender).Name); end;

Ausgewertet und angezeigt wird der Name des gedrückten Buttons (String!). Bei der zweiten Gruppe wird die Tag-Eigenschaft (Integer!) quasi als Selektor für den aktivierten Button verwendet:

1023

18.41 Verknüpfte und rastende Schalter realisieren

procedure TForm1.SpeedButton2Click(Sender: TObject); var txt: String; begin case TSpeedButton(Sender).Tag of 1: txt:= 'Der A-Button!'; 2: txt:= 'Der B-Button!' end; txt:= 'Gruppe 2 => ' + txt; Canvas.TextOut(180,200,txt) end;

// Gruppe 2

Bei der nur aus einem einzigen Button bestehenden dritten Gruppe (Einzelschalter1) wird die Down-Eigenschaft zum Abfragen des momentanen Zustandes (gedrückt/nicht gedrückt) und zur Änderung der Beschriftung ausgenutzt: procedure TForm1.SpeedButton9Click(Sender: TObject); // Einzelschalter 1 begin Canvas.TextOut(240,200,' '); with SpeedButton9 do if Down then Caption:= 'Ich bin eingerastet' else Caption:= 'Ich bin ausgerastet'; Canvas.TextOut(180,200,TSpeedButton(Sender).Caption) end;

Nichts Besonderes leistet der letzte Button (Einzelschalter2): procedure TForm1.SpeedButton10Click(Sender: TObject); // Beenden begin Close end;

Test Starten Sie das Programm und lernen Sie die Auswirkungen der GroupIndex, AllowAllUp und Down-Eigenschaft in der Praxis kennen!

1024

Kapitel 18

How-to: Oberfläche

18.42 Grafiken in Schaltflächen einsetzen Schluss mit dem tristen Einerlei der TButton-Typen! Sowohl mit dem Typ TBitBtn als auch mit TSpeedButton kann man neben Text auch Grafiken innerhalb von Schaltflächen anzeigen. Standardmäßig ist die Eigenschaft NumGlyphs auf 1 gesetzt, d.h., für jede Schalterstellung (oben, unten, gesperrt) steht nur eine Grafik zur Verfügung, die durch Setzen der Glyph-Eigenschaft zur Entwurfs- oder auch zur Laufzeit (s.u.) zugewiesen werden kann.

Grafiken erstellen In einem pixelorientierten Zeichenprogramm, z.B. Paintbrush, erstellen wir pro Schalter eine einzige Bitmap, die im gleichmäßigen Abstand nebeneinander (am besten auf weißem Hintergrund) die Symbole für die Zustände "Taste oben", "Taste gesperrt" und "Taste unten" enthält (ohne Beschriftung und ohne Rand!). Die Datei wird (am besten als 16-Farben-Bitmap) im Arbeitsverzeichnis abgespeichert (z.B. als TEST.BMP).

oben

gesperrt

unten

Die Wahl eines weißen Hintergrundes hat den Vorteil, dass dieser später gewissermaßen transparent erscheint und damit durch das Grau der Schaltflächen ersetzt wird.

Oberfläche Auf dem Formular (Form1) platzieren wir links einen SpeedButton (SpeedButton1) und rechts einen Bitmap-Button (BitBtn1). Die folgende Tabelle zeigt eine Zusammenstellung der zu ändernden Eigenschaften von SpeedButton1. Eigenschaft

Wert

Bemerkung

Caption

Die Fratze

Beschriftung

Glyph

TEST.BMP

Bitmap-Datei, wird im Dialogfenster zugewiesen

Layout

blGlyphBottom

Bild erscheint unten

NumGlyphs

3

drei Bitmaps

Spacing

0

Abstand Bild-Text

Margin

-1 (Standardwert)

zentriert, sonst Abstand Bild-Schalterkante

Für BitBtn1 brauchen wir kaum etwas umzustellen, lediglich für die Kind-Eigenschaft wird (entsprechend der geplanten Verwendung als Exit-Button) die "vorgefertigte" Variante bkClose ausgewählt. Wer es möchte, kann auch noch durch den Layout-Wert blGlyphRight erreichen, dass die

18.42 Grafiken in Schaltflächen einsetzen

1025

standardmäßig vorhandene Bitmap rechts neben der ebenfalls automatisch gelieferten Beschriftung erscheint:

Quelltext Irgendetwas muss passieren, wenn der Button gedrückt wird, und sei es nur ein kläglicher Piepton: procedure TForm1.SpeedButton1MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin MessageBeep(0) end;

Die Checkbox dient lediglich dazu, den Button zu sperren bzw. freizugeben: procedure TForm1.CheckBox1Click(Sender: TObject); begin if CheckBox1.Checked then SpeedButton1.Enabled:= False else SpeedButton1.Enabled:= True end;

Ein Ereigniscode für das Schließen des Formulars ist nicht notwendig, da dafür bereits die KindEigenschaft von BitBtn1 sorgt.

Test

1026

Kapitel 18

How-to: Oberfläche

Bemerkungen ■ Ein Zuweisen der Bitmap-Datei zur Laufzeit ist z.B. mit der Anweisung Glyph.LoadFromFile('C:\Delphi\Demo\Test.bmp')

möglich. ■ Die NumGlyphs-Eigenschaft kann maximal den Wert 4 annehmen. Dann aber sind vier Grafiken nebeneinander zu zeichnen, die letzte bezieht sich auf die Schalterstellung "dauernd gedrückt". In der Praxis dürfte dieser Zustand höchst selten sinnvoll sein, da er im Allgemeinen durch die "unten"-Position ausreichend nachgebildet wird. ■ Wenn Sie die Kind-Eigenschaft von BitBtn1 auf bkCustom setzen, kann dieser Button in unserem Beispiel genauso eingesetzt werden wie sein linker Nachbar (SpeedButton1).

18.43 Eine RadioGroup programmieren Dieses Steuerelement, das Sie auf der Standardseite der Komponentenpalette finden, hat es in sich: Mit wenigen Mausklicks können Sie ein Optionsfeld erstellen. Gegenüber der üblichen Programmierung mit einzelnen RadioButtons ergeben sich nicht nur Erleichterungen beim Entwurf, sondern auch erheblich verbesserte Zugriffsmöglichkeiten zur Laufzeit. Das folgende kleine Demoprogramm soll Ihnen den Unterschied verdeutlichen, indem wir die ColorEigenschaft des Formulars einmal mittels RadioGroup und ein anderes Mal mittels RadioButtons verändern.

Oberfläche Auf dem Formular platzieren Sie links zwei RadioGroups und rechts eine GroupBox:

Während Sie in GroupBox1 (rechts) sieben einzelne RadioButtons (RadioButton1 ... RadioButton7) einsetzen müssen, brauchen Sie bei RadioGroup1 bzw. RadioGroup2 nur die Items-Eigenschaft zu

18.43 Eine RadioGroup programmieren

1027

klicken und im Stringlisteneditor die entsprechenden Einträge vorzunehmen, wie hier für RadioGroup1:

Damit gleich zu Beginn die Farbe "Grau" aktiviert ist, setzen Sie die ItemIndex-Eigenschaft von GroupBox1 auf 6 und die Checked-Eigenschaft von RadioButton7 auf True. Stellen Sie für Columns von RadioGroup1 den Wert 2 ein, für ItemIndex von RadioGroup2 den Wert 1. HINWEIS: Die ItemIndex-Eigenschaft einer RadioGroup bezeichnet den momentan aktiven

Feldindex. Die Zählung beginnt mit Null (0).

Oberfläche Der implementation-Abschnitt von Form1 beginnt mit einer kleinen Überraschung: Eine initialisierte Array-Konstante! const farbe: array[1..7] of TColor = (clRed,clBlue, clYellow, clGreen, clBlack, clWhite, clBtnFace);

Die Programmierung von RadioGroup1: procedure TForm1.RadioGroup1Click(Sender: TObject); var i: Integer; begin i := RadioGroup1.ItemIndex + 1; Color := farbe[i]; // Formularfarbe ändert sich!

Das war es eigentlich schon! Doch wir wollen noch dafür sorgen, dass die aktive Farbauswahl auch in der GroupBox mit angezeigt wird. Sie sehen, dass sich der Schreibzugriff ziemlich umständlich gestaltet: case i of 1: RadioButton1.Checked := True; 2: RadioButton2.Checked := True;

1028

Kapitel 18

How-to: Oberfläche

3: RadioButton3.Checked := True; 4: RadioButton4.Checked := True; 5: RadioButton5.Checked := True; 6: RadioButton6.Checked := True; 7: RadioButton7.Checked := True; end end;

Nun zur Programmierung des gleichen Problems mit RadioButtons. Wir verwenden für alle sieben RadioButtons einen gemeinsamen Event-Handler (auf "Ereignisse"-Seite des Objektinspektors dem OnClick-Event zuweisen!): procedure TForm1.RadioButtonClick(Sender: var i: Integer; begin if Sender = RadioButton1 then i := 1; if if Sender = RadioButton3 then i := 3; if if Sender = RadioButton5 then i := 5; if if Sender = RadioButton7 then i := 7; Color := farbe[i];

TObject);

Sender = RadioButton2 then i := 2; Sender = RadioButton4 then i := 4; Sender = RadioButton6 then i := 6;

Das Synchronisieren der Anzeige in RadioGroup1 gestaltet sich wieder sehr einfach: RadioGroup1.ItemIndex := i- 1 end;

Gewissermaßen als "Zugabe" soll über RadioGroup2 die Spaltenanzahl der größeren Schwester eingestellt werden: procedure TForm1.RadioGroup2Click(Sender: TObject); begin RadioGroup1.Columns := RadioGroup2.ItemIndex + 1 end;

Test Starten Sie das Programm, so werden Sie keinerlei Unterschiede in der Arbeitsweise der beiden Optionsfelder feststellen, obwohl der Programmieraufwand bei der RadioGroup wesentlich geringer ist.

Bemerkungen Die Items-Eigenschaft einer RadioGroup können Sie statt im Stringlisten-Editor auch per Quellcode zuweisen, siehe Ä 17.10 Mit Stringlisten arbeiten HINWEIS: Über das Programmieren von initialisierten Arrays informieren Sie sich bitte in der

Online-Hilfe.

1029

18.44 Den Anfangswert in einer Listbox setzen

18.44 Den Anfangswert in einer Listbox setzen Lange Frage – kurze Antwort: Setzen Sie nach dem Füllen der Combo- oder Listbox die Eigenschaft ItemIndex auf den gewünschten Wert (das erste Listenelement hat die Nummer Null). Soll kein Eintrag markiert werden, übergeben Sie den Wert -1. HINWEIS: Das Setzen eines Anfangswertes funktioniert nur, wenn die MultiSelect-Eigenschaft

False bleibt (Standardwert).

Oberfläche Außer einer ListBox brauchen wir diesmal nichts! Auf das Zuweisen der Items-Eigenschaft im Stringlisten-Editor wollen wir diesmal bewusst verzichten und stattdessen das Füllen der ListBox zur Laufzeit demonstrieren.

Quelltext Die Einträge sind in einem typisierten Konstanten-Array abgelegt: const tage: array[1..7] of string = ('Montag','Dienstag','Mittwoch', 'Donnerstag', 'Freitag','Samstag','Sonntag');

Noch einmal: Beachten Sie, dass die Indizierung in einer ListBox mit 0 beginnt. procedure TForm1.FormCreate(Sender: TObject); var i: Integer; begin for i := 1 to High(tage) do ListBox1.Items.Add(tage[i]); ListBox1.ItemIndex := 3 end;

// Füllen der Listbox // Anfangswert = vierter Eintrag => Donnerstag

Test Nach dem Programmstart erscheint der Donnerstag als markiert.

1030

Kapitel 18

How-to: Oberfläche

18.45 Die markierten Einträge einer ListBox ermitteln Die Anzahl der markierten Einträge in einer Listbox lässt sich problemlos über die SelCountEigenschaft abfragen. Eine kleine Demo soll dies verdeutlichen und gleichzeitig auch zeigen, wie Sie eine ListBox (oder ComboBox) zur Entwurfszeit mit Werten füllen können.

Oberfläche Im Wesentlichen brauchen wir eine ListBox, ein Label und einen Button. Setzen Sie die MultiSelect-Eigenschaft der ListBox auf True! Anschließend füllen Sie die ListBox mit Einträgen, indem Sie mit Hilfe des Stringlisten-Editors die Items-Eigenschaft zuweisen:

Quelltext procedure TForm1.Button1Click(Sender: TObject); // markierte Einträge ermitteln begin Label1.Caption := IntToStr(ListBox1.SelCount) + ' markierte Einträge!' end;

Test Markieren Sie (bei gedrückter Strg-Taste) mehrere Einträge und lassen Sie sich das Ergebnis anzeigen!

18.46 Die Existenz eines Listbox-Eintrags feststellen

1031

Bemerkungen Wie Sie einem Listenfeld zur Laufzeit Werte zuweisen, erfahren Sie in Ä 17.10 Mit Stringlisten arbeiten Wie in (fast) allen Rezepten zu Listboxen gelten die Ausführungen in analoger Weise auch für Comboboxen.

18.46 Die Existenz eines Listbox-Eintrags feststellen Um zu prüfen, ob ein bestimmter Eintrag (zum Beispiel ein Name) in der Listbox existiert, können Sie eine Funktion einsetzen, die wir Ihnen im Folgenden kurz vorstellen.

Oberfläche Neben der obligatorischen Listbox platzieren wir auf dem Startformular (Form1) ein Edit-Feld, ein Label und zwei Buttons.

Quelltext Die Funktion bringen Sie im Implementation-Abschnitt von Unit1 unter: function vorhanden (lBox: TListBox; eintrag: string): Boolean; var i : Integer; begin Result := True; for i := 0 To lBox.Items.Count-1 do if lBox.Items[i] = eintrag then begin lBox.ItemIndex := i; Exit

1032

Kapitel 18

end; Result := False end;

How-to: Oberfläche

// Eintrag markieren und raus

Der Aufruf: procedure TForm1.Button1Click(Sender: TObject); // Suche starten begin if vorhanden(ListBox1,Edit1.Text) then Label1.Caption := Edit1.Text + ' ist vorhanden!' else begin Label1.Caption := Edit1.Text + ' ist nicht vorhanden!'; MessageBeep(0) end end;

Test

Bemerkungen ■ Wenn ein gefundener Eintrag nicht markiert wird, dann müssen Sie die MultiSelect-Eigenschaft von ListBox1 auf ihren Standardwert (False) zurücksetzen. ■ Eine verbesserte Suchmöglichkeit, bei der auch ähnliche Einträge festgestellt werden, finden Sie im folgenden Rezept.

18.47 In Listenfeldern suchen

1033

18.47 In Listenfeldern suchen Für die Suche bieten sich zwei Wege an: ■ ... ähnlich wie in der Windows-Hilfe (Suche ersten Buchstaben, dann den zweiten ...) ■ ... allgemeine Suche mit Platzhaltern (in unserem Fall der Stern "*") Unser "Suchalgorithmus" in Edit1Change vereinigt beide Möglichkeiten. Nach der Prüfung auf den Platzhalter (*) werden die folgenden zwei Fälle unterschieden: ■ Im ersten Fall genügt ein Vorkommen des Suchstrings im Listenfeldeintrag (If Pos ...), ■ im zweiten Fall wird linksseitig auf das Vorkommen geprüft (UpperCase(Copy ...). Ist das Suchergebnis positiv, wird die Prozedur mit Exit sofort verlassen. HINWEIS: Zum Testen der Routine finden Sie auf der Buch-CD die Datei daten.dat, in der über

400 Namen gespeichert sind. Über den Button "Liste füllen" wird diese Datei mit Hilfe der Methode LoadFromFile in das Listenfeld geladen.

Oberfläche Für unseren Test brauchen wir eine ListBox, ein Editierfeld und einen Button. Voraussetzung für die Funktionsfähigkeit des Suchalgorithmus ist ein sortiertes Listenfeld (ListBox1.Sorted = True).

Quelltext Das Füllen der ListBox: procedure TForm1.Button1Click(Sender: TObject); // Liste füllen begin // Datei wird im aktuellen Verzeichnis gesucht: ListBox1.Items.LoadFromFile(ExtractFilepath(ParamStr(0)) + 'daten.dat') end;

Die Suche beginnt bei jeder Änderung im Eingabefeld: procedure TForm1.Edit1Change(Sender: TObject); // Eingabe var s : string; i : Integer; begin s := Edit1.Text; if Copy(s,1,1) = '*' then begin // * als Platzhalter vorn s := Copy(s, 2, Length(s) - 1); for i := 0 To ListBox1.Items.Count - 1 do if Pos(s, ListBox1.Items[i]) <> 0 then begin ListBox1.ItemIndex := i; // Eintrag markieren Exit

1034

Kapitel 18

How-to: Oberfläche

end end else begin // sonst for i := 0 to ListBox1.Items.Count - 1 do if UpperCase(s) = UpperCase(Copy(ListBox1.Items[i],1, Length(s))) then begin ListBox1.ItemIndex := i; // Eintrag markieren Exit end end end;

Test Nach dem Programmstart füllen Sie zunächst die Liste. Experimentieren Sie nun mit verschiedenen Suchbegriffen. Die Suche beginnt bei jeder Änderung im Eingabefeld. Wie das Platzhalterzeichen (*) funktioniert, entnehmen Sie der folgenden Abbildung:

Bemerkung Die Suche wird mit jeder Änderung im Editfeld ausgelöst, dies kann bei langen Listenfeldern (und langsamen Computern) zu nicht unerheblichen Verzögerungen bei der Eingabe führen. Ändern Sie in diesem Fall die Prozedur dahingehend, dass Sie unter KeyPress die Enter-Taste abfangen (Key=#13) und erst damit die Suche einleiten.

18.48 Eine ListBox horizontal scrollen Eine Listbox kann normalerweise nur eine vertikale und keine horizontale Scrollbar besitzen. Was aber, wenn die Zeilenlänge die mögliche Breite der Listbox übersteigt? Auch hier hilft uns die SendMessage-Funktion weiter, wie die vorliegende Demo beweist.

18.49 Einträge in einer ListBox löschen

1035

Oberfläche Eine ListBox, die allerdings nicht zu breit sein sollte (damit sich das Scrollen auch lohnt).

Quellcode Die nachfolgende Prozedur benötigt als Übergabeparameter eine Listbox und die gewünschte Breite (in Pixel), über die gescrollt werden soll. procedure horScroll(lb: TListbox; width: Word); begin SendMessage(lb.Handle, LB_SetHorizontalExtent, width,longInt(0)) end;

Der Aufruf erfolgt hier beim Laden des Formulars. Vorher werden noch zwei lange Zeilen in die Listbox eingetragen: procedure TForm1.FormCreate(Sender: TObject); begin ListBox1.Items.Add('Das hier ist ein sehr langer Eintrag!'); ListBox1.Items.Add('Auch das hier ist ein sehr langer Eintrag!'); horScroll(ListBox1, 500) // Scrollbar mit 500-Pixel-Bereich end;

Test Nach dem Programmstart sollte sich Ihnen der folgende Anblick bieten:

18.49 Einträge in einer ListBox löschen Über Delete haben Sie zwar die Möglichkeit, Listeneinträge zu löschen, Sie müssen jedoch deren Nummer bzw. Index angeben. In einigen Fällen ist es sinnvoller, den entsprechenden Eintrag über seine Bezeichnung zu löschen. Ein kleiner "Schönheitsfehler" dieses Verfahrens soll nicht verschwiegen werden: Name bzw. Bezeichnung dürfen natürlich nur einmal vorhanden sein.

Oberfläche Für unser Testprogramm genügen neben der ListBox ein Editierfeld und ein Button. Weisen Sie der Items-Eigenschaft per Stringlisten-Editor ein paar Werte zu.

1036

Kapitel 18

How-to: Oberfläche

Quelltext procedure entferne (lBox: TListBox; eintrag : string); var i : Integer; begin for i := 0 To lBox.Items.Count-1 do if lBox.Items[i] = eintrag then begin lBox.Items.Delete(i); Exit end end;

Der Aufruf: procedure TForm1.Button1Click(Sender: TObject); begin entferne(ListBox1,Edit1.Text) end;

// Löschen

Test

Bemerkung Eine weitere und deutlich einfachere Variante zum Löschen eines einzelnen selektierten Eintrags: i := ListBox1.ItemIndex; ListBox1.Items.Delete(i);

18.50 Eine intelligente ComboBox programmieren Ja, Sie haben richtig gelesen, die Überschrift ist kein Witz! Mit geringstem Aufwand ist es möglich, eine "lernfähige" ComboBox zu programmieren. Gemeint ist damit, dass sich die ComboBox die vom Nutzer vorgenommenen Einträge "merkt" und anschließend zur Auswahl anbietet.

18.50 Eine intelligente ComboBox programmieren

1037

Oberfläche Außer einem Formular mit einer ComboBox brauchen Sie ... nichts! Setzen Sie die Sorted-Eigenschaft der ComboBox auf True.

Quelltext Die Programmierung beschränkt sich auf zwei Event-Handler, einer für das OnChange-, der andere für das OnDropDown-Event der ComboBox. Der implementation-Abschnitt von Unit1: var ix:Integer;

Wenn Sie etwas eintragen: procedure TForm1.ComboBox1Change(Sender: TObject); begin ix := ComboBox1.ItemIndex // an welchem Eintrag wurde herumgedoktert? end;

Wenn Sie die ComboBox aufklappen: procedure TForm1.ComboBox1DropDown(Sender: TObject); var i:Integer; begin with ComboBox1 do begin if Text = '' then // diesen Eintrag auch aus der Liste entfernen begin Items.Delete(ix); ix:=-1 // kein Eintrag ausgewählt end else begin for i := 0 to Items.Count-1 do if Text = Items[i] then Exit; // wenn Eintrag schon da ist: // ... nicht übernehmen! Items.Add(Text) // ... sonst hinzufügen end end end;

Test Beginnen Sie nach Programmstart mit der Eingabe von Werten. Beim Aufklappen der ComboBox wird der eingegebene Wert in die Liste übernommen. Die Eingabe doppelter Werte wird unterbunden! Wählen Sie einen Wert aus der Liste aus und löschen Sie ihn, so wird er auch aus der Liste entfernt! Allerdings muss für diesen Fall die Liste vorher zugeklappt sein.

1038

Kapitel 18

How-to: Oberfläche

Bemerkungen Wenn Sie möchten, dass der eingetragene Wert nicht nur durch das Aufklappen der ComboBox, sondern auch durch Betätigen der Enter-Taste übernommen wird, so fügen Sie folgenden EventHandler hinzu: procedure TForm1.ComboBox1KeyPress(Sender: TObject; var Key: Char); begin if key = #13 then ComboBox1DropDown(Self) end;

18.51 Eine ComboBox automatisch öffnen Mitunter möchte man auf die zittrigen Finger des Anwenders Rücksicht nehmen und ihm das Öffnen einer ComboBox per Mausklick ersparen. Das vorliegende Rezept zeigt eine Lösung, bei der uns wieder einmal die SendMessage-Funktion hilfreich zur Seite steht.

Oberfläche Ein Formular mit einer ComboBox und zwei Buttons genügt. Füllen Sie die Items-Eigenschaft mit einigen Einträgen (mittels Stringlisten-Editor, den Sie vom Objektinspektor aus aufrufen).

Quellcode Aufklappen: procedure TForm1.Button1Click(Sender: TObject); begin SendMessage(ComboBox1.Handle, CB_SHOWDROPDOWN, 1, 0) end;

Zuklappen: procedure TForm1.Button2Click(Sender: TObject); begin SendMessage(ComboBox1.Handle, CB_SHOWDROPDOWN, 0, 0) end;

18.52 Zwei Gitter-Komponenten synchronisieren

1039

Test Da sich erstaunlicherweise nach zweimaligem Klick auf die "Aufklappen"-Schaltfläche die Box wieder schließt, könnte man eigentlich auf die "Zuklappen"-Funktion verzichten – aber was soll's!

18.52 Zwei Gitter-Komponenten synchronisieren Stellen Sie sich vor, Sie haben zwei Anzeigegitter nebeneinander platziert, aber nur das erste verfügt über Bildlaufleisten. Sie wollen erreichen, dass das zweite Gitter quasi automatisch "mitläuft", also immer genau den gleichen Ausschnitt wie das erste anzeigt.

Oberfläche Sie brauchen für Form1 nur zwei StringGrids und einen Button. Belassen Sie die ScrollBarsEigenschaft von StringGrid1 auf ihrem Defaultwert (ssBoth) und ändern Sie nur die seines Nachbarn (StringGrid2) in ssNone.

Quelltext procedure TForm1.FormCreate(Sender: TObject); var i,j: Integer; // Zeilen- bzw. Spaltenzähler const n=10; // Anzahl Zeilen bzw. Spalten begin StringGrid1.RowCount:= n; StringGrid1.ColCount:= n; StringGrid2.RowCount:= n; StringGrid2.ColCount:= n; for i:= 0 to StringGrid1.RowCount-1 do // für alle Zeilen for j:=0 to StringGrid1.ColCount-1 do // für alle Spalten begin StringGrid1.Cells[j,i]:= IntToStr(i)+','+IntToStr(j); StringGrid2.Cells[j,i]:= StringGrid1.Cells[j,i] end; end;

Beim Laden des Formulars werden beide Gitter mit je zehn Zeilen und Spalten ausgestattet. Jede Zelle wird mit Zeilen- und Spaltenindex beschriftet: Knackpunkt ist die Ausnutzung des OnTopLeftChanged-Ereignisses von StringGrid1, das immer dann auftritt, wenn sich obere Zeilennummer oder linke Spaltennummer verändert haben. Im entsprechenden Event-Handler werden dann die Eigenschaften TopRow (oberste Zeile) und LeftCol (linke Spalte) des zweiten Gitters denen des ersten angepasst:

1040

Kapitel 18

How-to: Oberfläche

procedure TForm1.StringGrid1TopLeftChanged(Sender: TObject); begin StringGrid2.TopRow := StringGrid1.TopRow; StringGrid2.LeftCol:= StringGrid1.LeftCol end;

Test Nach Programmstart werden Sie feststellen, dass "wie von Geisterhand" das zweite Gitter die Ausschnittsverschiebungen seines Nachbarn mitmacht:

18.53 Im StringGrid einen Zeilenumbruch durchführen Ach, wie schön wäre es, könnte man in bestimmten Spalten des StringGrid mehrzeilige Texte ablegen! Das vorliegende Rezept zeigt, wie Sie sich mit der API-Funktion DrawText diesen Wunsch erfüllen können.

Oberfläche Lediglich ein Formular und ein StringGrid:

18.53 Im StringGrid einen Zeilenumbruch durchführen

1041

Quelltext Der implementation-Abschnitt von Form1: var wCol: Word;

// Spalte, in der der Zeilenumbruch stattfinden soll

Das OnDrawCell-Event des StringGrids wird ausgewertet: procedure TForm1.StringGrid1DrawCell(Sender: TObject; ACol, ARow: Integer; Rect: TRect; State: TGridDrawState); var aStr : string; aRect : TRect; // zum Zwischenspeichern begin aStr := StringGrid1.Cells[ACol, ARow]; // Zelleninhalt "merken" if aStr <> '' then begin aRect := Rect; // Originalabmessungen der Zelle "merken" if (ACol = wCol) and (ARow <> 0) then // Sonderbehandlung für die WordWrap-Spalte begin

Der API-Aufruf: DrawText(StringGrid1.Canvas.Handle, pChar(aStr), Length(aStr), aRect, DT_CALCRECT // liefert aRect mit neuen Abmessungen (entspr. aStr) or DT_WORDBREAK // falls nötig, wird ein Zeilenumbruch erzeugt or DT_LEFT); // Text wird linksbündig positioniert

Die neue Höhe der Zelle kann ermittelt und (falls nötig) gesetzt werden: if (aRect.Bottom - aRect.Top) > StringGrid1.RowHeights[ARow] then StringGrid1.RowHeights[ARow] := (aRect.Bottom - aRect.Top); aRect.Right := Rect.Right // Zelle an neue Position setzen end;

Die Zellen aller Spalten werden zunächst gelöscht und anschließend neu gezeichnet: StringGrid1.Canvas.FillRect(aRect); if (ACol = wCol) and (ARow <> 0) then // Wordwrap (aber nicht in Titelspalte) DrawText(StringGrid1.Canvas.Handle, pChar(aStr),Length(aStr), aRect, DT_WORDBREAK or DT_LEFT) // diesmal ohne DT_CALCRECT ! else // für alle anderen Zellen DrawText(StringGrid1.Canvas.Handle, pChar(aStr),Length(aStr), aRect, DT_CENTER // horiz. zentriert or DT_VCENTER or DT_SINGLELINE) // vert. zentriert end end;

Das Initialisieren des StringGrids nehmen wir beim Laden des Formulars vor, einige der Eigenschaften hätte man natürlich auch im Objektinspektor zuweisen können: procedure TForm1.FormCreate(Sender: TObject); begin with StringGrid1 do begin

1042

Kapitel 18

How-to: Oberfläche

Options := Options + [goEditing]; ColCount := 3; FixedCols := 0; // linke Fixspalte ausblenden Cells[0,0] := 'Name'; Cells[1,0] := 'Vorname';

Die Vorbereitung der WordWrap-Spalte: wCol := 2; Cells[wCol,0] := 'Beurteilung'; ColWidths[wCol] := 155 end end;

Test Nach dem Programmstart geben Sie in die ersten beiden Spalten normalen und in die dritte Spalte überlangen Text ein. Zweckmäßigerweise benutzen Sie dazu die TAB-Taste. Der Zeilenumbruch findet erst nach dem Verlassen der dritten Spalte statt. Die Einträge in den ersten beiden Spalten werden lediglich zentriert.

Vereinfachte Programmierung mit bedingten Konstanten-Arrays Schauen Sie sich folgenden Quelltextauszug aus obigem Listing einmal näher an: if (ACol = wCol) and (ARow <> 0) then DrawText(StringGrid1.Canvas.Handle, pChar(aStr),Length(aStr), aRect, DT_WORDBREAK or DT_LEFT) else DrawText(StringGrid1.Canvas.Handle, pChar(aStr),Length(aStr), aRect, DT_CENTER or DT_VCENTER or DT_SINGLELINE);

Da sich beide Aufrufe der API-Funktion DrawText lediglich in den Werten der übergebenen Flags unterscheiden, wird der gewiefte (oder faule?) Programmierer nach einer eleganteren Lösung suchen, die weniger Schreibarbeit erfordert: Delphi bietet nämlich die Möglichkeit zur Definition von Konstanten-Arrays, deren Wert von einer Bedingung abhängig ist. In unserem Fall müsste Folgendes deklariert werden: const flgs: array[Boolean] of Integer = (DT_CENTER or DT_VCENTER or DT_SINGLELINE, DT_WORDBREAK or DT_LEFT);

Obiger Quelltext schrumpft damit wie folgt zusammen: DrawText(StringGrid1.Canvas.Handle, pChar(aStr),Length(aStr), aRect, flgs[(ACol = wCol) and (ARow <> 0)]);

Überzeugt?

18.54 Den Text im StringGrid rechtsbündig ausrichten

1043

18.54 Den Text im StringGrid rechtsbündig ausrichten Die standardmäßige linksbündige Ausrichtung der Einträge im StringGrid stört spätestens dann, wenn Zahlenspalten auftreten. Das vorliegende Rezept zeigt, wie uns die GDI-Funktion DrawText bei der Lösung des Problems hilft.

Oberfläche Zur Laufzeit soll sich der folgende Anblick bieten. Die ersten beiden Spalten werden normal, die Gehalts-Spalte aber rechtsbündig ausgerichtet.

Quellcode Der implementation-Abschnitt von Form1: var rCol: Word; // Index der Zelle, deren Inhalt rechtsbündig ausgerichtet werden soll

Beim Laden des Formulars wird unser StringGrid für den Test vorbereitet: procedure TForm1.FormCreate(Sender: TObject); begin with StringGrid1 do begin Options := Options + [goEditing] + [goTabs]; ColCount := 3; DefaultColWidth := 110; FixedCols := 0; // linke Fixspalte ausblenden Cells[0,0] := 'Name'; Cells[1,0] := 'Vorname';

Die auszurichtende Spalte: Cells[2,0] := 'Gehalt (Euro)'; rCol := 2; // Spalte 2 soll rechtsbündig werden ColWidths[rCol] := 80 end end;

Die eigentliche Arbeit wird im OnDrawCell-Event geleistet: procedure TForm1.StringGrid1DrawCell(Sender: TObject; ACol, ARow: Integer; Rect: TRect; State: TGridDrawState); var aStr : string; // zum Zwischenspeichern des Inhaltes einer Zelle

1044

Kapitel 18

How-to: Oberfläche

begin aStr := StringGrid1.Cells[ACol, ARow]; if aStr <> '' then begin if (ACol = rCol) then begin StringGrid1.Canvas.FillRect(Rect); // alter Text wird gelöscht // ... und neu gezeichnet: DrawText(StringGrid1.Canvas.Handle, pChar(aStr),Length(aStr), Rect, DT_RIGHT) end end end;

Test Nach dem Start geben Sie zunächst einige Datensätze in das Gitter ein. Die rechtsbündige Ausrichtung wird erst dann sichtbar, wenn Sie zur nächsten Zelle wechseln (siehe obige Abbildung).

Bemerkungen ■ Eine andere horizontale Ausrichtung erreichen Sie durch Einsetzen von DT_CENTER bzw. DT_LEFT anstatt DT_RIGHT in die DrawText-Funktion. ■ Falls der Text auch noch vertikal zentriert werden soll, so ist das Flag DT_RIGHT durch den zusammengesetzten Ausdruck DT_RIGHT or DT_VCENTER or DT_SINGLELINE zu ersetzen. Dann sollten Sie aber auch alle übrigen Spalten vertikal zentrieren, d.h., nochmals neu mit DrawText zeichnen.

18.55 Den Inhalt eines StringGrids in einer Datei sichern Da hat man nun mühselig den Inhalt seines Datengitters mit Daten gefüllt, aber wie sollen diese das Beenden des Programms bzw. Ausschalten des Computers überleben, so dass sie nach dem erneuten Programmstart wieder zur Verfügung stehen? Als Lösung bietet sich das zeilenweise Abspeichern in einer typisierten oder in einer Textdatei an, aber der modebewusste Delphi-Entwickler wird dafür natürlich ein FileStream-Objekt verwenden. Die Vorgehensweise soll anhand einer kleinen Personaldatei demonstriert werden.

Oberfläche Auf Form1 platzieren Sie drei Buttons und ein StringGrid. Letzteres holen Sie von der Seite "Zusätzlich" der Komponentenpalette. Im Objektinspektor brauchen Sie außer ScrollBars = ssVertical dem StringGrid keine weiteren Eigenschaften zuzuweisen, dies wird aus Übersichtlichkeitsgründen im OnCreate-Event-Handler von Form1 erledigt (siehe unten).

18.55 Den Inhalt eines StringGrids in einer Datei sichern

1045

Unit newStringGrid Es dient der Übersichtlichkeit und erleichtert die Wiederverwendbarkeit ungemein, wenn wir den Code in eine separate Unit auslagern. Fügen Sie also über Datei|Neu ... eine neue Unit hinzu und ändern Sie deren Namen z.B. in newStringGrid: unit newStringGrid; interface

Nun müssen die erforderlichen Units eingebunden werden: uses Grids, Classes, SysUtils;

Warum gerade die obigen drei Units? Sie können zum Beispiel nach der "try and error"-Methode ziemlich schnell herausfinden, welche Units benötigt werden, indem man mehrere Compilierversuche durchführt. Setzen Sie auf einen vom Compiler nicht erkannten Bezeichner den Textcursor und drücken Sie F1. In der aufgerufenen Hilfeseite sehen Sie nun unter anderem auch einen Hinweis auf die fehlende Unit. Folgende drei Prozeduren sollen von unserer Unit newStringGrid veröffentlicht werden: procedure saveGrdToFile(grd: TStringGrid); procedure loadGrdFromFile(grd: TStringGrid); procedure clearGrd(grd: TStringGrid); implementation var

fStream: TFileStream; buff: string; const pfad = 'Test.dat';

// Filestream (unser Dateityp) // Puffervariable für eine Zelle des Gitters // Dateiname (Datei wird im Projektverzeichnis abgelegt)

Kommen wir jetzt zur Implementierung der Schreib- und Leseprozeduren. Wer den Umgang mit Textdateien gewohnt ist, wird sich etwas umstellen müssen, insbesondere was die relativ umständliche Behandlung des String-Datentyps angeht. Bei einem FileStream läuft hier der Schreibvorgang in zwei Schritten ab: Zunächst wird die Länge des Strings abgespeichert und danach der eigentliche String. procedure saveGrdToFile; var i, j, row, col, len: Word; begin fStream := TFileStream.Create(pfad, fmCreate); // erzeugt neue (leere) Datei // bzw. überschreibt vorhandene fStream.Free; fStream := TFileStream.Create(pfad, fmOpenWrite); // öffnet Datei für Schreibzugriff

Am Beginn der Datei sollen die Angaben über Zeilen- und Spaltenanzahl stehen, wobei die nullte Zeile und die nullte Spalte nicht mit gesichert werden brauchen: col := grd.ColCount - 1; row := grd.RowCount - 1; fStream.WriteBuffer(row, SizeOf(Word)); fStream.WriteBuffer(col, SizeOf(Word));

1046

Kapitel 18

How-to: Oberfläche

Es folgt nun das Auslesen der Gitterzellen. Da wir es mit dem Datentyp String zu tun haben, muss als Erstes die Länge und als Zweites der Inhalt abgespeichert werden: for i := 1 to row do for j := 1 to col do begin buff:= grd.Cells[j,i]; len := Length(buff); fStream.WriteBuffer(len, SizeOf(Word)); // Länge fStream.WriteBuffer(buff[1], len) // Inhalt (beachte die Übergabe von buff!) end; fStream.Free; end;

Das Lesen der Datei geschieht analog: procedure loadGrdFromFile; var i, j, row, col, len: Word; begin fStream := TFileStream.Create(pfad, fmOpenRead); // öffnet Datei für Lesezugriff fStream.ReadBuffer(row, SizeOf(Word)); fStream.ReadBuffer(col, SizeOf(Word)); for i := 1 to row do for j := 1 to col do begin fStream.ReadBuffer(len, SizeOf(Word)); SetLength(buff, len); fStream.ReadBuffer(buff[1], len); grd.Cells[j,i] := buff // Datei => Buffer end; fStream.Free end;

Die Routine zum Löschen der Zellinhalte ist relativ einfach: procedure clearGrd; var i, j: Word; begin for i := 1 to grd.ColCount-1 do for j:=1 to grd.RowCount-1 do grd.Cells[i,j] := '' end; end.

Unit1 Hier genügt es, wenn wir nur auf den implementation-Abschnitt eingehen: uses newStringGrid; var pmax: Word = 10;

// Einbinden der Unit // max. 10 Personen

1047

18.55 Den Inhalt eines StringGrids in einer Datei sichern

Die Eigenschaften des Gitters werden beim Laden zugewiesen (alternativ wären sie auch im Objektinspektor einstellbar): procedure TForm1.FormCreate(Sender: TObject); var i: Word; begin with StringGrid1 do begin ColCount := 4; DefaultColWidth:= 100; // alle Spalten zunächst 100 Pixel breit ColWidths[0] := 30; // erste Spalte nur 30 Pixel breit

Die Spaltenüberschriften: Cells[0,0] := 'Nr'; Cells[1,0] := 'Name'; Cells[2,0] := 'Vorname'; Cells[3,0] := 'Geburtsdatum'; RowCount := pmax + 1; Options := Options + [goEditing, goTabs, goColSizing];

Damit die Liste besser aussieht, wollen wir noch die Zeilen durchnummerieren: for i := 1 to pmax do Cells[0,i] := IntToStr(i) end end;

Dank der Unit newStringGrid sind die folgenden Aufrufe kurz und übersichtlich. In die Datei schreiben: procedure TForm1.Button1Click(Sender: TObject); begin saveGrdToFile(StringGrid1) end;

Die Datei lesen: procedure TForm1.Button2Click(Sender: TObject); begin loadGrdFromFile(StringGrid1) end;

Gitterinhalt löschen: procedure TForm1.Button3Click(Sender: TObject); begin clearGrd(StringGrid1) end;

// inneren Gitterinhalt löschen

1048

Kapitel 18

How-to: Oberfläche

Test

Der Button "Gitter löschen" löscht nur die Anzeige, nicht aber die Datei! Die Reihenfolge ■ "in Datei schreiben" ■ "Gitter löschen" ■ "aus Datei lesen" dürfte deshalb auch den Skeptiker von der Funktionsfähigkeit des Progrämmchens überzeugen. Eine quasi leere Datei erzeugen Sie mit der Reihenfolge "Gitter löschen", "in Datei schreiben".

Bemerkungen ■ Aus Gründen der besseren Übersicht hat im obigen Beispiel die Datei einen festen Namen (Test.dat) und einen festen Ort (Anwendungsverzeichnis). Durch Einbau einer SaveDialogund einer OpenDialog-Komponente könnten Sie aber Namen und Ort der abzuspeichernden Datei selbst bestimmen. ■ Das Ergänzen der Unit newStringGrid um weitere Methoden wäre eine dankbare Übungsaufgabe und eine exzellente Vorbereitung für den späteren Übergang zur objektorientierten Programmierung (Schreiben einer Klasse bzw. einer neuen Komponente). Siehe dazu Ä 19.22 Aus einer Unit eine Komponente machen

18.56 Die Spalten im StringGrid automatisch anpassen Zu dumm, wenn wieder einmal eine bestimmte Spalte im StringGrid zu schmal geraten ist. Aber auch Überbreiten sind beim Betrachter kein Anlass für Freudenausbrüche. Das vorliegende Rezept zeigt, wie man mit einer einfachen Prozedur dieses Problem lösen kann.

18.56 Die Spalten im StringGrid automatisch anpassen

1049

Oberfläche Ein StringGrid und ein Button genügen für unsere kleine Demo.

Quellcode Der Prozedur wird neben einem StringGrid auch die minimal zulässige Spaltenbreite min (Pixel) übergeben, ansonsten würden leere Spalten auf die Breite 0 zusammenschrumpfen und einen kläglichen Anblick bieten. procedure grdColWidth(grd: TStringGrid; min: Word); var i, j, tmp, max: Word; const dx = 5; // zusätzliche Breite (Pixel) begin with grd do begin for j := 0 to (ColCount -1) do begin // für alle Spalten max := 0; for i := 0 to (RowCount - 1 ) do begin // für alle Zeilen tmp := Canvas.TextWidth(Cells[j, i]); if tmp > max then max := tmp // neue Maximalbreite feststellen end; if max > min then // nur wenn Minimalbreite überschritten wird, ColWidths[j] := max + GridLineWidth + dx // ... dann Spalte verbreitern end end end;

Das Austesten der Prozedur: procedure TForm1.Button1Click(Sender: TObject); begin grdColWidth(StringGrid1, 30) end;

Der folgende Code sorgt dafür, dass unser StringGrid editierbar wird und die Tab-Taste benutzt werden kann (natürlich hätte man auch im Objektinspektor die entsprechenden Werte der OptionsEigenschaft setzen können): procedure TForm1.FormCreate(Sender: TObject); begin StringGrid1.Options := StringGrid1.Options + [goEditing] + [goTabs] end;

Test Geben Sie in irgendeine Zelle einen möglichst langen Ausdruck ein und testen Sie die Funktionsfähigkeit!

1050

Kapitel 18

How-to: Oberfläche

18.57 Die blaue Zelle im StringGrid entfernen Sie kann mitunter nerven, die aufdringliche blaue Zelle, die ungebeten immer dann im StringGrid erscheint, wenn dieses den Fokus verliert. Das vorliegende Rezept zeigt eine Möglichkeit, wie man dieses aufdringliche Feature loswerden kann.

Oberfläche Ein StringGrid, eine CheckBox und mehrere Buttons (diese haben keine Funktion und dienen nur zur Verschiebung des Fokus) – das ist schon alles.

Quellcode Die Funktion: procedure cleanGrd(grd: TStringGrid); var grdRec: TGridRect; begin with grdRec do begin Top := -1; Left := -1; Right := -1; Bottom := -1 end; grd.Selection := grdRec end;

Im OnExit-Ereignis des StringGrids kann nun wahlweise die Säuberungsaktion durchgeführt werden. Öffnen Sie den Event-Handler über den Objektinspektor! procedure TForm1.StringGrid1Exit(Sender: TObject); begin if CheckBox1.Checked then cleanGrd(StringGrid1) end;

Test Erst wenn Sie mit der Maus auf eine Zelle klicken und anschließend auf ein beliebiges anderes Steuerelement (Dummy-Buttons), so merken Sie den "feinen" Unterschied.

18.58 Grafiken im StringGrid anzeigen

1051

Das althergebrachte lästige Verhalten:

Das neue Verhalten wird nicht sofort nach dem Setzen des Häkchens sichtbar, sondern erst nachdem Sie wieder auf eine Zelle geklickt haben:

18.58 Grafiken im StringGrid anzeigen Wer möchte das triste Outfit seiner Gitterkomponenten nicht durch ein paar Grafiken aufmotzen? Das vorliegende Rezept unterbreitet dazu einen Lösungsvorschlag. Verwendung findet die DrawMethode des Canvas-Objekts, die innerhalb des OnDrawCell-Events aufgerufen wird.

Oberfläche Nicht der Rede wert – nur ein StringGrid, das zur Laufzeit etwa den in der folgenden Abbildung gezeigten Anblick bieten soll: HINWEIS: Die einzelnen Bitmap-Dateien sollten Sie vorher in das Anwendungsverzeichnis

kopieren. Die Umbenennung in BM1.bmp, BM2.bmp, ... vereinfacht die Programmierung, da das Laden in einer Schleife möglich wird.

1052

Kapitel 18

How-to: Oberfläche

Quellcode const nr = 4; sp = 1;

// Anzahl der Bilder // Index der Anzeigespalte

In einem statischen Array werden die Bildchen zwischengespeichert. var bilder: array[1..nr] of TBitmap;

// Bildzwischenspeicher

Der gesamte Code wird beim Laden des Formulars abgearbeitet: procedure TForm1.FormCreate(Sender: TObject); var i: Word; begin for i := 1 to nr do begin bilder[i] := TBitmap.Create; // leeres Bildobjekt erzeugen bilder[i].LoadFromFile('BM' + IntToStr(i) + '.bmp'); // Bild laden StringGrid1.RowHeights[i] := bilder[i].Height // Zeilenhöhe anpassen end;

Das erste Bildchen bestimmt die Spaltenbreite: StringGrid1.ColWidths[sp] := bilder[1].Width end;

Die Anzeige der Bildchen geschieht im OnDrawCell-Event, das für jede einzelne Gitterzelle aufgerufen wird: procedure TForm1.StringGrid1DrawCell(Sender: TObject; ACol, ARow: Integer; Rect: TRect; State: TGridDrawState); begin if (ACol = sp) and (ARow <> 0) and (ARow <= nr) then with StringGrid1.Canvas do Draw(Rect.Left, Rect.Top, bilder[ARow]) //!!! end;

18.59 Eine ComboBox im StringGrid anzeigen

1053

Bemerkungen ■ Wer keine geeigneten BMP-Bitmaps zur Hand hat, sollte sich das Beispiel von der Buch-CD laden. ■ Für andere Bildformate (JPG, GIF) empfiehlt es sich, statt der TBitmap- eine TImage-Komponente als Bildzwischenspeicher zu verwenden.

18.59 Eine ComboBox im StringGrid anzeigen Was sich so unglaublich anhört, ist tatsächlich machbar, allerdings über einige Umwege. Wir wollen dies am Beispiel des Dienstplans einer einschlägigen Institution erläutern.

Oberfläche Den Grundaufbau der Oberfläche entnehmen Sie bitte der folgenden Abbildung:

Die Größe der ComboBox ist (ebenso wie ihre Positionierung) egal, sie passt sich später exakt den Zellabmessungen des StringGrids an. Das Zuweisen der ComboBox-Einträge geht am schnellsten über die Items-Eigenschaft im Objektinspektor:

Die von den Standardeigenschaften abweichenden Einstellungen des StringGrids werden komplett im Quellcode vorgenommen.

1054

Kapitel 18

How-to: Oberfläche

Quellcode Obwohl wir uns sonst kaum um den Interface-Abschnitt eines Formulars kümmern (wird von der IDE automatisch erzeugt), gibt es in diesem Rezept eine Ausnahme: Die folgende Methodendeklaration muss per Hand in die Typdeklaration von TForm1 eingefügt werden: procedure setRect(rec: TRect);

// !!!

Nun zum Implementation-Abschnitt: Beim Laden des Formulars werden die notwendigen Initialisierungen des StringGrid durchgeführt: procedure TForm1.FormCreate(Sender: TObject); begin with StringGrid1 do begin

Spalten definieren: ColCount := 8; ColWidths[0] := 80; Cells[0,0] := 'Zeitraum'; Cells[1,0] Cells[2,0] := 'Montag'; Cells[3,0] Cells[4,0] := 'Mittwoch'; Cells[5,0] Cells[6,0] := 'Freitag'; Cells[7,0]

// erste Spalte 80 Pixel breit := 'Sonntag'; := 'Dienstag'; := 'Donnerstag'; := 'Sonnabend';

Zeilen definieren: RowCount := 4; Cells[0,1] := ' 6:00 - 14:00'; Cells[0,2] := '14:00 - 22:00'; Cells[0,3] := '22:00 - 6:00';

Weitere Eigenschaften des Gitters (alternativ auch im Objektinspektor einstellbar): Options := Options + [goTabs]; end end;

Die Positionierung der ComboBox : procedure TForm1.setRect(rec: TRect); var r: TRect; begin with ComboBox1 do begin CopyRect(r, rec); // rec => r (Eck-Koordinaten an Hilfsrechteck übergeben)

Umrechnung der Eck-Koordinaten des Hilfsrechtecks: r.BottomRight := Parent.ScreenToClient(StringGrid1.ClientToScreen(r.BottomRight)); r.TopLeft := Parent.ScreenToClient(StringGrid1.ClientToScreen(r.TopLeft));

Positionierung der ComboBox (Left, Top, Width und Height werden zugewiesen): SetBounds(r.Left, r.Top, r.Right-r.Left, r.Bottom-r.Top); BringToFront // ComboBox in Vordergrund bringen end end;

18.59 Eine ComboBox im StringGrid anzeigen

1055

Im OnDrawCell-Event wird die ComboBox neu positioniert: procedure TForm1.StringGrid1DrawCell(Sender: TObject; ACol, ARow: Integer; Rect: TRect; State: TGridDrawState); begin if (ACol >= StringGrid1.FixedCols) and (ARow >= StringGrid1.FixedRows) and (gdFocused in State) then setRect(Rect) end;

Der ComboBox-Inhalt wird in die Zelle übertragen: procedure TForm1.ComboBox1Change(Sender: TObject); begin Beep; with StringGrid1 do Cells[Col, Row] := ComboBox1.Text end;

Der folgende Event-Handler versteckt die ComboBox, wenn sie aus dem StringGrid "herausgescrollt" wird: procedure TForm1.StringGrid1TopLeftChanged(Sender: TObject); begin with StringGrid1 do setRect(CellRect(Col,Row)) end;

Test

Die ComboBox wandert immer zur Zelle, die den Eingabefokus besitzt. Erst wenn Sie einen Eintrag ausgewählt haben, wird dieser übernommen. Sehr bequem können Sie sich auch mit der TabTaste im Datengitter bewegen.

Bemerkungen ■ Eine andere (allerdings nicht ganz unproblematische) Lösungsmöglichkeit wäre es, wenn Sie die Objects-Eigenschaft des StringGrid mit der ComboBox verbinden würden bzw. die ParentEigenschaft der ComboBox mit dem StringGrid. ■ Falls nur zwei Spalten erforderlich sind, sollten Sie sich einmal folgendes Rezept anschauen: Ä 18.70 Den ValueListEditor kennen lernen

1056

Kapitel 18

How-to: Oberfläche

18.60 Zeilen in ein StringGrid einfügen/löschen Das zeilenweise Hinzufügen bzw. Entfernen von Einträgen dürfte wohl mit zu den häufigsten Operationen gehören, die man mit dem StringGrid durchführt. Leider verfügt das StringGrid über keine eingebauten Methoden, so dass man diese Funktionalität per Hand nachrüsten muss. Unser Demo-Programm verdeutlicht die Wirkungsweise und den Aufruf der Prozeduren ■ insertRow (fügt eine leere Zeile unterhalb der aktuellen Zelle ein) und ■ deleteRow (löscht die aktuelle Zeile)

Oberfläche Ein StringGrid und zwei Buttons, so dass sich zur Laufzeit folgender Anblick bietet:

Quellcode Damit es nicht gar zu trostlos aussieht, wird bereits beim Laden des Formulars unser Gitter mit einigen Einträgen gefüllt. procedure TForm1.FormCreate(Sender: TObject); var i:Word; begin with StringGrid1 do begin ColCount := 4; DefaultColWidth:= 100; // alle Spalten zunächst 100 Pixel breit ColWidths[0] := 30; // erste Spalte nur 30 Pixel breit Cells[0,0] := 'Nr'; Cells[1,0] := 'Name'; Cells[2,0] := 'Vorname'; Cells[3,0] := 'Geburtsdatum'; Options := Options + [goEditing, goTabs, goColSizing]; for i := 1 to ColCount do Cells[0,i] := IntToStr(i); // Zeilen durchnummerieren end end;

1057

18.60 Zeilen in ein StringGrid einfügen/löschen

Die Prozedur zum Einfügen einer Zeile unterhalb von rowNr: procedure insertRow(rowNr: Word; grd: TStringGrid); var i: Word; begin with grd do begin RowCount := RowCount+1; Row := rowNr; for i := RowCount-1 downto Row+1 do Rows[i] := Rows[i-1]; //Zeilen verschieben for i := 0 to ColCount-1 do Cells[i, Row+1] := '' // eingefügte Zeile säubern end end;

Die Prozedur zum Löschen der Zeile rowNr: procedure deleteRow(rowNr: Word; grd: TStringGrid); var i : Word; begin with grd do begin Row := rowNr; if (Row = RowCount-1) then RowCount := RowCount-1 // letzte Zeile else begin for i := rowNr to RowCount-2 do Rows[i] := Rows[i+ 1]; // nicht letzte Zeile RowCount := RowCount-1 end end end;

Der Aufruf: procedure TForm1.Button1Click(Sender: TObject); var z: Word; begin z := StringGrid1.Row; insertRow(z, StringGrid1) end;

// Zeile unterhalb einfügen

procedure TForm1.Button2Click(Sender: TObject); var z: Word; begin z := StringGrid1.Row; deleteRow(z, StringGrid1) end;

// Zeile entfernen

Test Klicken Sie auf eine bestimmte Zelle und danach auf einen der beiden Buttons und überzeugen Sie sich von der Funktionsfähigkeit des Programms.

1058

Kapitel 18

How-to: Oberfläche

18.61 Zellen im StringGrid farblich hervorheben Das triste grauweiße Outfit der Zellen muss nicht widerspruchslos hingenommen werden. Das vorliegende Rezept zeigt, wie bestimmte Zellen durch farbliche Hervorhebung die Aufmerksamkeit des Betrachters auf sich ziehen können.

Oberfläche Zur Laufzeit soll sich folgender Anblick bieten, d.h., die Einträge in den Spalten Sonnabend und Sonntag sollen markiert werden (weiße Schrift auf pinkfarbenem Untergrund).

Quellcode Zunächst kümmern wir uns um das grundlegende Outfit des StringGrids: procedure TForm1.FormCreate(Sender: TObject); begin with StringGrid1 do begin

Spalten initialisieren: ColCount := 8; ColWidths[0] := 80; // erste Spalte 80 Pixel breit Cells[0,0] := 'Zeitraum'; Cells[1,0] := 'Sonntag'; Cells[2,0] := 'Montag'; Cells[3,0] := 'Dienstag'; Cells[4,0] := 'Mittwoch'; Cells[5,0] := 'Donnerstag'; Cells[6,0] := 'Freitag'; Cells[7,0] := 'Sonnabend';

Zeilen initialisieren: RowCount := 4; Cells[0,1] := ' 6:00-14:00'; Cells[0,2] := '14:00-22:00'; Cells[0,3] := '22:00- 6:00'; DefaultRowHeight := 20;

Fähigkeiten zum Editieren und Tabulieren herstellen: Options := Options + [goEditing] + [goTabs]; end end;

Jetzt kommen wir zum wesentlichen Teil des Quellcodes, der im OnDrawCell-Ereignis des StringGrids ausgeführt wird:

18.62 Im StringGrid Enter- statt Tab-Taste verwenden

1059

procedure TForm1.StringGrid1DrawCell(Sender: TObject; ACol, ARow: Integer; Rect: TRect; State: TGridDrawState); var oldColor : TColor; oldBrush : TBrush; begin with StringGrid1.Canvas do begin oldColor := Font.Color; oldBrush := Brush; if (StringGrid1.Cells[aCol,0] = 'Sonnabend') or (StringGrid1.Cells[aCol,0] = 'Sonntag') then if aRow > 0 then begin // Spaltenüberschrift nicht färben Brush.Color := clFuchsia; // neue Hintergrundfarbe FillRect(Rect); Font.Color := clWhite; // neue Stiftfarbe TextOut(Rect.Left+2,Rect.Top+2, StringGrid1.Cells[aCol,aRow]) end else begin // ursprüngliche Farben wiederherstellen Font.Color := oldColor; Brush := oldBrush end end end;

18.62 Im StringGrid Enter- statt Tab-Taste verwenden Viele Sekretärinnen (Sie vielleicht auch?) verwenden lieber die Enter- als die Tab-Taste, um sich zum nächsten Eingabefeld zu bewegen. Auch beim StringGrid kann man diesen Komfort zur Verfügung stellen, wie die vorliegende Lösung beweist.

Oberfläche Mehr als ein StringGrid brauchen Sie nicht.

Quellcode Beim Laden des Formulars werden zunächst Editier- und Tabulierfähigkeit des StringGrids eingestellt: procedure TForm1.FormCreate(Sender: TObject); begin with StringGrid1 do Options := Options + [goEditing] + [goTabs] end;

Im OnKeyPress-Event des StringGrids werden die Ereignisse, die von der Enter-Taste ausgelöst werden, einer Sonderbehandlung unterzogen: procedure TForm1.StringGrid1KeyPress(Sender: TObject; var Key: Char); begin if Key = #13 then / Enter-Taste gedrückt with StringGrid1 do if Col < ColCount-1 then // zur nächsten Spalte Col := Col + 1 else if Row < RowCount-1 then

1060

Kapitel 18

begin Row := Col := end else begin Row := Col := end

How-to: Oberfläche

// zur nächsten Zeile Row + 1; 1 // wieder von vorne beginnen 1; 1

end;

Test Sie werden feststellen, dass die Eingabe nun wesentlich flotter vonstatten geht, wenn Sie diese mit Enter abschließen. Auch die Eingabemarke blinkt sofort in der nächsten Zelle, was beim Weiterbewegen mit Tab nicht der Fall ist.

18.63 Verschiedene ListView-Ansichten verwenden Mit der Komponente TListView (Seite "Win32" der Komponentenpalette) können Sie eine Liste mit Einträgen auf unterschiedlichste Weise anzeigen (mit kleinen oder großen Symbolen, zeilenoder spaltenweise, mit Überschrift und Untereinträgen). Die folgende Übersicht zeigt die verschiedenen Werte der Eigenschaft ViewStyle: Wert

Bedeutung

vsIcon

Die einzelnen Elemente werden entsprechend der LargeImages-Eigenschaft mit Beschriftung unterhalb angezeigt.

vsSmallIcon

Die einzelnen Elemente werden entsprechend der SmallImages-Eigenschaft zeilenweise mit Beschriftung rechts angezeigt.

vsList

Die einzelnen Elemente werden entsprechend der SmallImages-Eigenschaft spaltenweise mit Beschriftung rechts angezeigt.

vsReport

Die einzelnen Elemente erscheinen zeilen- und spaltenweise. Die äußerste linke Spalte enthält das Symbol entsprechend der SmallImages-Eigenschaft und die Beschriftung. Die nachfolgenden Spalten enthalten die Unterelemente (SubItem-Eigenschaft der ListItem-Objekte). Wenn ShowColumnHeaders True ist, besitzt jede Spalte eine Überschrift.

In unserem Beispiel soll eine "Liste mit Einzelteilen" nebst Erläuterungen angezeigt werden.

Oberfläche Neben einer ListView werden noch eine ImageList, eine RadioGroup sowie ein Label benötigt.

18.63 Verschiedene ListView-Ansichten verwenden

1061

Klicken Sie doppelt auf die ImageList und füllen Sie diese mit geeigneten Bildchen, Sie finden diese z.B. im Verzeichnis ...\Programme\Gemeinsame Dateien\Borland Shared\Images\Icons.

Mit wenigen Mausklicks haben Sie auch die Items-Eigenschaft für die RadioGroup zugewiesen.

Quelltext procedure TForm1.FormCreate(Sender: TObject);

Eine initialisierte zweidimensionale Array-Konstante liefert einige fertige Einträge und erspart uns so eine Menge Tipparbeit (die Einträge der zweiten Spalte sind nur für die vsReport-Ansicht von Bedeutung): const Zeilen: array[1..5, 1..2] of string = ( ('Kreisel', 'für Kinder'), ('Schaltkreis', 'für Computer'), ('komisches Ding', 'was weiß ich?'), ('Weltkugel', 'für Erdkundeunterricht'), ('Zahnrad', 'für Maschinenbau') );

Neben einer normalen Zählvariablen werden auch zwei Objektvariablen benötigt: var i: Integer; ListItem: TListItem; NewColumn: TListColumn;

Die Anfangseigenschaften einstellen: begin with ListView1 do begin LargeImages := ImageList1; SmallImages := ImageList1; RowSelect := True; GridLines := True end;

// // // //

Bildchen für vsIcon Bildchen für vsSmallIcon, vsList und vsReport komplette Zeile selektieren (nur für vsReport) Gitterlinien (nur für vsReport)

1062

Kapitel 18

How-to: Oberfläche

Die Einträge vornehmen: for i := Low(Zeilen) to High(Zeilen) do begin ListItem := ListView1.Items.Add; ListItem.Caption := Zeilen[i][1]; ListItem.ImageIndex := i-1; // Bildindex beginnt mit 0 ListItem.SubItems.Add(Zeilen[i][2]) // zweite Spalte (nur für vsReport) end;

Zwei persistente Spalten mit Überschrift hinzufügen (nur für vsReport erforderlich): NewColumn := ListView1.Columns.Add; NewColumn.Caption := 'Einzelteil'; NewColumn.Width := 100; NewColumn := ListView1.Columns.Add; NewColumn.Caption := 'Erläuterung'; NewColumn.Width := 200 end;

Beim Klicken auf einen Eintrag soll die Caption-Eigenschaft eines selektierten Elements im Label angezeigt werden: procedure TForm1.ListView1Click(Sender: TObject); // Eintrag selektieren begin Label1.Caption := ListView1.Selected.Caption end;

In der RadioGroup wird die ViewStyle-Eigenschaft geändert: procedure TForm1.RadioGroup1Click(Sender: TObject); // ViewStyle wechseln begin case RadioGroup1.ItemIndex of 0: ListView1.ViewStyle := vsIcon; 1: ListView1.ViewStyle := vsSmallIcon; 2: ListView1.ViewStyle := vsList; 3: ListView1.ViewStyle := vsReport end end;

Test Starten Sie das Programm und probieren Sie die verschiedenen Ansichten:

18.64 Drag & Drop in der Anwendung realisieren

1063

18.64 Drag & Drop in der Anwendung realisieren Statt stundenlang über langatmigen Drag & Drop-Beschreibungen zu brüten, sollten Sie besser eigene praktische Erfahrungen anhand eines kleines Testprogramms sammeln, mit dem einige der in Frage kommenden Möglichkeiten ausprobiert werden können.

Oberfläche Im Mittelpunkt stehen eine Image-Komponente (Image1), die als Ziel der Drag & Drop-Operationen dient. Sie finden zwar noch zwei weitere Images:

1064

Kapitel 18

How-to: Oberfläche

Diese werden jedoch nur für eine kleine Animation benötigt. Ändern Sie deshalb deren VisibleEigenschaft in False. Die AutoSize-Eigenschaft aller Images wird auf True gesetzt. Weiterhin brauchen Sie eine FileListbox, eine DirectoryListbox und eine DriveComboBox, die Sie über die Eigenschaft DirList bzw. FileList miteinander koppeln. Die DragMode-Eigenschaft der FileListbox legen Sie auf Automatic fest. Alles Weitere dürfte aus dem folgenden Oberflächenentwurf hervorgehen:

Quelltext Nach dem Programmstart wird die Grafik "geschlossener Aktenschrank" in Image1 kopiert: procedure TForm1.FormCreate(Sender: TObject); begin Image1.Picture := Image3.Picture end;

Auf diese Weise müssen wir nicht drei Grafiken in der EXE-Datei speichern. Da DragMode von FileListbox1 auf Automatic festgelegt ist, brauchen wir uns um den Beginn der Drag & Drop-Operation nicht weiter zu kümmern. Sobald die linke Maustaste über der Listbox gedrückt wird, beginnt die Drag & Drop-Operation. Unsere Aufgabe ist es, das Loslassen über dem Zielobjekt (Image1) vorzubereiten. Dazu dient die Ereignismethode OnDragOver: procedure TForm1.Image1DragOver(Sender, Source: TObject; X, Y: Integer; State: TDragState; var Accept: Boolean);

Über den Parameter Source ermitteln wir die Quelle der Drag & Drop-Operation. State gibt darüber Aufschluss, ob die Maus hinein, hinaus oder innerhalb des Objektes bewegt wird. Der Parameter Accept teilt dem Sender-Objekt mit, ob das Zielobjekt für die Übergabe bereit ist: begin Accept := True;

18.64 Drag & Drop in der Anwendung realisieren

1065

if state = dsDragEnter then Image1.Picture := Image2.Picture; if state = dsDragLeave then Image1.Picture := Image3.Picture end;

Beim Hineinbewegen der Maus blenden wir die Grafik "geöffneter Aktenschrank" ein. Beim Verlassen "schließen" wir den Aktenschrank wieder. Da nur ein Sender-Objekt in Frage kommt, brauchen wir keine Unterscheidung vorzunehmen. Wir akzeptieren das Senderobjekt und setzen Accept auf True. Die letzte Funktion ist das Loslassen (das Drop). Über das DragDrop-Event können Sie auf dieses Ereignis reagieren. Der Parameter Source ist der Ursprung des DragDrop-Vorgangs. Lesen Sie die benötigten Eigenschaften und führen Sie dann entsprechende Funktionen aus: procedure TForm1.Image1DragDrop(Sender, Source: TObject; X, Y: Integer); begin if Source = FileListbox1 then begin Label1.Caption := (Source as TFileListbox).Filename; MessageBeep(0) end end;

Test Starten Sie das Programm und ziehen Sie die ausgewählten Dateien in den Aktenschrank, der sich wie von Geisterhand öffnet!

Bemerkungen Sie haben auch noch die Möglichkeit, den Mauscursor an die einzelnen Phasen von Drag & Drop anzupassen. Verwenden Sie dazu die DragCursor-Eigenschaft von Quell- und Zielobjekt. Wie Sie eigene Mauszeiger einbinden, steht in Ä 18.31 Eigene Mauszeiger verwenden

1066

Kapitel 18

How-to: Oberfläche

18.65 Komponenten zur Laufzeit verschieben Möchten Sie eine Komponente (z.B. ein Panel) zur Laufzeit mit der Maus "anfassen" und verschieben (ähnlich wie Sie das in der Entwurfsumgebung gewohnt sind), können Sie dies mit der folgenden Ereignisprozedur erreichen: procedure TForm1.Button1MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin Button1.Perform(WM_LBUTTONUP, 0, 0); Button1.Perform(WM_SysCommand,SC_MOVE+2,2) end;

Wir wollen mit der folgenden Demo aber eine allgemein gültige Ereignisprozedur verwenden, die für alle Komponenten anwendbar ist, die über das OnMouseDown-Event verfügen.

Oberfläche Als willfährige "Opfer" für unsere "Schiebereien" dienen ein Button und ein Edit-Feld.

Quelltext Schreiben Sie zunächst die obige Ereignisprozedur für Button1 und ändern Sie dann auf der "Ereignisse"-Seite des Objektinspektors (nicht im Quelltext!) den Namen der Ereignisprozedur in KomponenteMouseDown. Weisen Sie dann im Objektinspektor dem OnMouseDown-Event von Edit1 die gleiche Ereignisprozedur zu (die kleine Rollbox aufklappen und auswählen). Anschließend ersetzen Sie den Bezeichner Button1 durch TWinControl (Sender): procedure TForm1.KomponenteMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin TWinControl(Sender).Perform (WM_LBUTTONUP, 0, 0); TWinControl(Sender).Perform(WM_SysCommand,SC_MOVE+2,2) end;

Test Starten Sie das Programm und verschieben Sie die Komponenten mit der Maus!

18.66 Komponenten zwischen Fenstern verschieben

1067

18.66 Komponenten zwischen Fenstern verschieben In der Windows-Dokumentation finden Sie häufig die Begriffe "Parent-" bzw. "Elternfenster" etc. Was es damit auf sich hat, zeigt Ihnen das folgende kleine Programm. Gleichzeitig soll das Beispiel Ihnen auch eine Anregung geben, wie Sie die Fensterflut in Ihren Anwendungen etwas reduzieren können. Ein in Form2 enthaltenes DBGrid wird mit zugehöriger Navigator-Komponente einfach in den verbleibenden Clientbereich von Form1 eingeblendet. Auf diese Weise können Sie weiterhin einzelne Eingabemasken programmieren, die Darstellung erfolgt allerdings fast wie in einer MDI-Anwendung (ohne die Einschränkungen von MDI). Der Anwender bekommt von alledem nicht viel mit, er arbeitet immer nur mit Form1.

Oberfläche Entwerfen Sie ein Hauptformular (Form1) mit Toolbar (zwei Buttons, die ihre Bildchen über eine ImageList beziehen). Das Panel dient als Container für den "Beenden"-Button bzw. für weitere Steuerelemente, damit diese nicht durch die von Form2 bzw. Form3 einzublendenden Panels verdeckt werden. HINWEIS: Zum Ausrichten des Panels in Form1 legen Sie dessen Align-Eigenschaft auf alRight

fest. Wenn Sie es gern einfacher hätten, können Sie auch auf die Toolbar verzichten und stattdessen zwei normale Buttons auf Panel1 setzen. Für die Gestaltung von Form2 und Form3 haben Sie absolut freie Hand. Es ist lediglich wichtig, dass sich alle Komponenten, die zwischen den Formularen ausgetauscht werden sollen, in einer Panel-Komponente befinden. Auf diese Weise brauchen wir lediglich die Parent-Eigenschaft des entsprechenden Panels zu ändern, um es in das Hauptformular zu verschieben.

In unserem Beispiel beinhalten Form2 und Form3 Eingabemasken für eine Datenbank (siehe Buch-CD).

1068

Kapitel 18

How-to: Oberfläche

Quelltext Der Quellcode für die beiden Buttons in Form1 (vergessen Sie nicht, die beiden Units Unit2 und Unit3 einzubinden): procedure TForm1.ToolButton1Click(Sender: TObject); begin if Form3.Panel1.Parent = Self then Form3.Panel1.Parent:= Form3; if Form2.Panel1.Parent = Form2 then Form2.Panel1.Parent := Form1; Caption := Form2.Table1.TableName end; procedure TForm1.ToolButton2Click(Sender: TObject); begin if Form2.Panel1.Parent = Self then Form2.Panel1.Parent := Form2; if Form3.Panel1.Parent = Form3 then Form3.Panel1.Parent:= Self; Caption := Form3.table1.TableName end;

Test Über die Toolbar lassen sich die jeweiligen Inhalte von Form2 und Form3 in Form1 einblenden.

18.67 Komponenten auf einer StatusBar platzieren

1069

HINWEIS: Alle Ereignisse im Panel werden auch weiterhin im ursprünglichen Formular verar-

beitet.

18.67 Komponenten auf einer StatusBar platzieren Die von Delphi angebotene StatusBar ist leider nicht in der Lage, andere Komponenten per Drag & Drop aufzunehmen. Möchten Sie zum Beispiel einen Fortschrittsbalken realisieren, sind Sie auf andere Komponenten angewiesen, oder Sie programmieren eine eigene Routine im OnDrawPanelEreignis. Beides ist umständlich. Mit wenigen Programmzeilen bringen Sie die StatusBar dazu, andere Komponenten zu akzeptieren. Es muss lediglich die Parent-Eigenschaft der jeweiligen Komponente auf die StatusBar gesetzt werden, leider funktioniert dies nur zur Laufzeit.

Oberfläche Platzieren Sie eine StatusBar mit vier Panels (rechte Maustaste, Bereichseditor) auf dem Formular. Zusätzlich fügen Sie noch einen BitButton, einen Timer und eine ProgressBar ein.

Quelltext Mit der folgenden Funktion können Sie jede Komponente, die von TWinControl abstammt, auf der StatusBar platzieren. Sie können sogar das gewünschte Panel angeben, die eingefügte Komponente wird an die Abmessungen des Panels angepasst. procedure SetControl2Panel(control : TWincontrol; // welche Komponente statusbar : TStatusBar; // auf welche Statusbar panelId : Integer); // in welches Panel var ARect : TRect; begin Statusbar.Perform((WM_USER + 10), panelId, Integer(@ARect)); control.Parent := statusbar; control.Top := ARect.Top; control.Left := ARect.Left; control.Width := ARect.Right-ARect.Left; control.Height := ARect.Bottom-ARect.Top end;

1070

Kapitel 18

How-to: Oberfläche

Die Zuweisung der Komponenten erfolgt im OnShow-Ereignis: procedure TForm1.FormShow(Sender: TObject); begin SetControl2Panel(progressbar1,statusbar1,2); SetControl2Panel(BitBtn1,statusbar1,0) end;

Etwas "Bewegung" tut der ProgressBar gut: procedure TForm1.Timer1Timer(Sender: TObject); begin Inc(i); if i = 100 then i := 0; ProgressBar1.Position := i end;

Test Nach dem Programmstart sollte sich Ihnen das folgende Bild bieten:

18.68 Einen Schatten hinter Komponenten erzeugen "Das Auge isst mit" bzw. abgewandelt "das Auge programmiert mit", unter diesem Motto steht das folgende Rezept. Dass sich Schatteneffekte etc. auch ressourcenschonend programmieren lassen, soll das folgende Beispiel zeigen.

Oberfläche Fügen Sie in ein Formular mehrere Editfelder ein:

18.68 Einen Schatten hinter Komponenten erzeugen

1071

Quelltext Im Folgenden finden Sie eine universelle Routine, der ein Form- und ein TControl-Objekt übergeben wird, sowie Breite und Farbe des Schattens: procedure Shadow(f: TForm; c : TControl; width : integer; color: TColor); var rec : TRect; old : TColor; begin rec := c.BoundsRect; rec.Left := rec.left + width; rec.Top := rec.Top + width; rec.Right := rec.right + width; rec.Bottom := rec.Bottom + width; old := f.Canvas.Brush.Color; f.Canvas.Brush.Color := color; f.Canvas.FillRect(rec); f.Canvas.Brush.Color := old; end;

Der Aufruf erfolgt zweckmäßigerweise immer beim Neuzeichnen des Formulars: procedure TForm1.FormPaint(Sender: TObject); var i : integer; begin for i := 0 to self.ControlCount-1 do Shadow(self,self.Controls[i], 3, clblack); end;

Möchten Sie eine Unterscheidung der Komponenten treffen, können Sie in der Schleife den Typ der Komponente auswerten: ... if self.Controls[i] is TButton then Shadow(self,self.Controls[i], 2, clred); ...

Test Der Lohn der Mühe:

1072

Kapitel 18

How-to: Oberfläche

18.69 Verschwundene Komponenten aufspüren Hilfe! Eine dumme Sache ist passiert, die TMainMenu-Komponente ist plötzlich auf Nimmerwiedersehen entschwunden. Wahrscheinlich geschah es, als mehrere Komponenten gemeinsam verschoben wurden, dabei ist der Ausreißer außerhalb der Formulargrenzen "abgetaucht", denn ein Nachsehen unterhalb diverser Panels etc. blieb erfolglos. Zwar funktioniert das Programm noch, wie aber z.B. neue Menüpunkte hinzufügen?

Lösung Nach mehreren genauso verzweifelten wie erfolglosen Versuchen (Deklarationen aus Form-Objekt entfernen und neue TMainMenu-Komponente hinzufügen, ...) endlich die Lösung in Stichpunkten: ■ Menü: Bearbeiten|Alles auswählen. ■ Den gesamten markierten Block so verschieben, dass auch die außerhalb liegenden Komponenten wieder sichtbar werden. ■ Nun die Markierung aufheben und den Ausreißer an einen "sicheren" Platz ziehen, dann wieder Bearbeiten|Alles auswählen klicken und alles wieder ordentlich an seinen alten Platz verschieben.

Bemerkung Es lohnt sich, bei größeren Projekten, von Zeit zu Zeit einmal auf die beschriebene Weise nach "verlorengegangenen" Komponenten Ausschau zu halten, eventuell werden einige gar nicht vermisst und unbemerkt als Ballast mit herumgeschleppt.

18.70 Den ValueListEditor kennen lernen Eine ab Delphi 6 eingeführte Komponente ist der ValueListEditor (Seite "Zusätzlich" der Komponentenpalette). Dabei handelt es sich um eine spezielle Art von Datengitter (siehe StringGrid), das aus nur zwei Spalten besteht. Die erste Spalte (Keys) und die zweite (Values) können direkt mit Stringlisten (TStrings) verknüpft werden. Der komplette Inhalt ist in der Strings-Eigenschaft enthalten. Die Online-"Hilfe" für diese (von der Sache her simple) Komponente ist ein weiteres furchtbares Beispiel dafür, wie man immer wieder versucht, sich mit ellenlangen und verquasten "Erläuterungen" der einzelnen Eigenschaften, Methoden und Ereignisse wie "die Katze um den heißen Brei" um konkrete Quelltextbeispiele herumzuwinden. Ein Einsteigerbeispiel wie das folgende erscheint deshalb bitter nötig. Ziel der simplen Demo ist das Erstellen einer Liste, in der bestimmten Vornamen wahlweise bestimmte Berufe zugeordnet werden können.

18.70 Den ValueListEditor kennen lernen

1073

Oberfläche Platzieren Sie einen ValueListEditor, ein Editierfeld und drei Buttons auf das Startformular.

Quellcode Zu Beginn des implementation-Abschnitts deklarieren wir eine Variable berufe, die uns später die Eingabe in die rechte Spalte erleichtern wird: var berufe: TStringList;

Die Anfangsaktivitäten: procedure TForm1.FormCreate(Sender: TObject); begin

Einstellung grundlegender Eigenschaften: with ValueListEditor1 do begin DisplayOptions := [doColumnTitles, doAutoColResize];

Die standardmäßige Spaltenbeschriftung wird überschrieben: TitleCaptions[0] := 'Vorname'; TitleCaptions[1] := 'Beruf' end;

Zusammenstellung der Einträge, wie sie für die zweite Spalte in einer Klappbox ausgewählt werden sollen: berufe := TStringList.Create; berufe.Add('Bäcker'); berufe.Add('Angler'); berufe.Add('Psychiater'); berufe.Add('Informatiker');

1074

Kapitel 18

How-to: Oberfläche

Unabhängig von obiger Reihenfolge soll die Stringliste alphabetisch sortiert werden: berufe.Sort;

Schließlich sollte bereits zu Beginn irgendein Vorname im Editierfeld stehen: Edit1.Text := 'Emil' end;

Das Hinzufügen einer Zeile: procedure TForm1.Button1Click(Sender: TObject); begin with ValueListEditor1 do begin InsertRow(Edit1.Text, '', False);

Jetzt wird festgelegt, dass in der rechten Spalte des Eintrags eine Klappbox erscheint, die alle in der Stringliste berufe enthaltenen Strings zur Auswahl anbietet. with ItemProps[Row-1] do begin EditStyle := esPickList; PickList := berufe end end end;

// Klappbox

Das Löschen einer Zeile: procedure TForm1.Button2Click(Sender: TObject); begin with ValueListEditor1 do if Strings.Count > 0 then DeleteRow(Row) end;

Da, im Gegensatz zur zweiten Spalte, die Vornamen in die erste Spalte nicht direkt eingetragen werden, muss eine eigene Routine her, die das mit Hilfe des Editierfeldes ermöglicht: procedure TForm1.Button3Click(Sender: TObject); begin with ValueListEditor1 do if Strings.Count > 0 then Keys[Row] := Edit1.Text end;

Test Füllen Sie zunächst die Liste mit einigen Einträgen, indem Sie einen Vornamen in das Editierfeld eingeben, den Button "Hinzufügen" klicken und anschließend mit Hilfe der Klappbox einen Beruf zuweisen. Die Klappbox müssen Sie nicht unbedingt in Anspruch nehmen, denn Sie können die Berufe auch direkt eintippen. Testen Sie auch das Korrigieren (Überschreiben) von Vornamen und das Löschen einer Zeile.

18.71 Eine Uhr einblenden

1075

Bemerkungen Dieses Rezept sollte lediglich einen Einstieg vermitteln. Zu weiteren Eigenschaften, Methoden und Ereignissen informieren Sie sich bitte in der Online-Hilfe. Das Hinzufügen weiterer Funktionalitäten dürfte keine Hürde sein, wenn man sich mit Stringlisten ein wenig auskennt: BEISPIEL: Abspeichern des Inhalts in eine Datei ValueListEditor1.Strings.SaveToFile('Test.dat');

BEISPIEL: Zuweisen des Inhalts in ein Memofeld Memo1.Lines := ValueListEditor1.Strings;

18.71 Eine Uhr einblenden Eigentlich lohnt es sich kaum, ein Rezept über dieses Thema zu schreiben, ist doch mit Hilfe eines Timers und einer Label- bzw. Panel-Komponente in wenigen Sekunden eine derartige Funktion realisiert. Wir wollen dennoch darauf eingehen und zusätzlich noch eine Datumsanzeige hinzufügen.

Oberfläche Obwohl ein Timer und ein Panel (oder gar ein Label) genügen, haben wir zusätzlich noch eine StatusBar- und eine TrackBar-Komponente eingefügt (siehe Laufzeitansicht). So lernen Sie als nützlichen Nebeneffekt auch gleich noch die Programmierung dieser Controls kennen. Setzen Sie die Interval-Eigenschaft des Timers auf 1000 (1 Sekunde) und die Eigenschaft Max der TrackBar auf 60 (Anzahl der Sekunden). Der StatusBar müssen Sie zwei Panel-Objekte hinzufü-

1076

Kapitel 18

How-to: Oberfläche

gen (Eigenschaft Panels), auf die Sie später über den Index zugreifen können. Klicken Sie dazu einfach doppelt auf die StatusBar und fügen Sie in der sich öffnenden Dialogbox zwei neue Panels-Objekte hinzu.

Quelltext Die aktuelle Zeit soll zum einen in der Panel-Komponente, zum anderen in der StatusBar (linkes Panel-Objekt) angezeigt werden. Im rechten Panel-Objekt der StatusBar erfolgt eine ausführliche Datumsanzeige: procedure TForm1.Timer1Timer(Sender: TObject); var Hour, Min, Sec, mSec: Word; begin Panel1.Caption:= TimeToStr(Time); StatusBar1.Panels[0].Text:= TimeToStr(Time); StatusBar1.Panels[1].Text:= FormatDateTime('"Heute ist "dddd," der "d.mmmm yyyy"', Date) DecodeTime(time, Hour, Min, Sec, mSec); Trackbar1.Position := Sec end;

Die FormatDateTime-Funktion bietet weitaus individuellere Gestaltungsmöglichkeiten als die alternativ einsetzbare DateToStr-Funktion. Um im der TrackBar die aktuelle Sekunde anzuzeigen, mussten wir den Datumswert in seine Einzelbestandteile zerlegen (DecodeTime).

Test

18.72 Mit dem DateTimePicker arbeiten Mit dem DateTimePicker ("Win32"-Seite der Komponentenpalette) steht eine aufklappbare Kalender-Komponente zur Verfügung, gut geeignet zur schnellen Auswahl eines Datums. Wir wollen damit demonstrieren, wie man die Tagesdifferenz zwischen zwei Datumsangaben ermitteln kann.

18.72 Mit dem DateTimePicker arbeiten

1077

Oberfläche Gebraucht werden zwei DateTimePicker, eine Edit-Box und ein Button.

Quellcode Die Routine zur Umrechnung: procedure TForm1.Button1Click(Sender: TObject); var tage: Integer; begin

Die Round-Funktion dient hier der Typkonvertierung TDateTime zu Integer: tage := Round(DateTimePicker1.Date - DateTimePicker2.Date); Edit1.Text := IntToStr(tage) + ' Tage' end;

Test Starten Sie das Programm und testen Sie alle Eventualitäten bei der Datumseingabe.

Bemerkungen ■ Wenn man weiß, dass die Date-Eigenschaft eine Gleitkommazahl (TDateTime bzw. Extended) ist, deren ganzzahliger Anteil die Anzahl der Tage angibt, die seit dem 30.12.1899 vergangen sind, dürfte das Verständnis des obigen Quellcodes nicht schwierig sein. ■ Falls das erste Datum jünger als das zweite ist, erhalten Sie eine negative Differenz. ■ Es wird Ihnen nicht gelingen, das Programm zu überlisten (z.B. mit Schaltjahren).

1078

Kapitel 18

How-to: Oberfläche

18.73 Ein Textverarbeitungsprogramm schreiben An einem durchgängigen Beispiel lernen Sie in diesem etwas komplexen Rezept wichtige Oberflächen-Komponenten kennen, wie z.B. MDI-Fenster, Erzeugen und Entfernen von Formularen zur Laufzeit, Datei-, Drucker- und Fontdialoge, den Zugriff auf Textdateien, Menüentwurf, RichTextKomponente, Zwischenablage, Stringlisten ...

Oberfläche Unsere Applikation besteht aus zwei Formularen: dem MDI-Rahmenfenster (Form1) und einem Kindfenster (Form2). Letzteres wird erst zur Laufzeit hinzugefügt und kann sich beliebig oft vermehren. MDI-Rahmenfenster Die FormStyle-Eigenschaft von Form1 setzen Sie auf fsMDIForm. Platzieren Sie eine MainMenuund eine OpenDialog-Komponente auf dem Formular.

Doppelklicken Sie auf die MainMenu-Komponente und erstellen Sie im Menü-Editor die in der Abbildung gezeigten Einträge. HINWEIS: Den Trennbalken innerhalb des Menüs erreichen Sie durch Eintrag eines einzelnen

"-"-Zeichens als Caption-Eigenschaft. Der Shortcut entsteht durch Voranstellen eines "&"-Zeichens. MDI-Kindfenster Obwohl wir in unserer Applikation mit mehreren Dokumenten (MDI-Kindfenster) gleichzeitig arbeiten können, genügt es, wenn wir einen einzigen "Prototyp" entwerfen. Fügen Sie über Datei| Neues Formular ein weiteres Formular (Form2) hinzu. Dort findet eine RichEdit-Komponente (Seite "Win32" der Komponentenpalette) ihren Platz, die nach Setzen der Align-Eigenschaft auf alClient das Fenster vollkommen ausfüllt (siehe Abbildung) Wie Sie sehen, ist auch noch ein ganzes Sammelsurium weiterer Komponenten erforderlich: MainMenu, PopUpMenu, SaveDialog, FontDialog, PrinterSetupDialog, PrintDialog (von links).

1079

18.73 Ein Textverarbeitungsprogramm schreiben

Der Menüentwurf für die MainMenu-Komponente gestaltet sich etwas aufwändiger als der für das MDI-Rahmenfenster: Datei Neu Öffnen... Schließen Speichern Speichern als ... Drucken Drucker einrichten ... Beenden

Bearbeiten Ausschneiden Kopieren Einfügen Löschen Alles auswählen

Zeichen Links Rechts Zentriert Font ...

Fenster Nebeneinander Hintereinander

HINWEIS: Die Name-Eigenschaft von Menüobjekten wird standardmäßig aus der Caption-

Eigenschaft gebildet. Dabei werden aber Umlaute und "ß" unterdrückt, was sehr übel aussehen kann. Korrigieren Sie deshalb aus Übersichtlichkeitsgründen hier die Name-Eigenschaft im Objektinspektor. Zwecks Definition des PopUp-Menüs doppelklicken Sie auf die Komponente und erstellen im Menüeditor die folgenden Einträge:

Weisen Sie der PopUpMenu-Eigenschaft von Form2 die Komponente PopUpMenu1 zu! Setzen Sie außerdem die FormStyle-Eigenschaft auf fsMDIChild. Und noch eine "Kleinigkeit" gilt es zu berücksichtigen: Da wir die Kindfenster (Dokumente) erst zur Laufzeit selbst hinzufügen bzw. entfernen wollen, müssen wir deren automatische Erstellung

1080

Kapitel 18

How-to: Oberfläche

durch Delphi verhindern. Wählen Sie den Menüpunkt Projekt|Optionen... und verschieben Sie Form2 auf die rechte Seite:

Quelltext für MDI-Rahmenfenster Der Code ist im Handumdrehen erstellt und beschränkt sich auf die Definition von drei EventHandlern. HINWEIS: Um den Rahmencode der Event-Handler zu erhalten, klicken Sie im Entwurfsmodus

auf den entsprechenden Menüeintrag! implementation uses Unit2;

// Kindfenster-Unit einbinden!

{$R *.DFM}

Ein neues Kindfenster (Dokument) wird erzeugt: procedure TForm1.Neu1Click(Sender: TObject); begin TForm2.Create(Self) end;

// Datei|Neu // Konstruktor aufrufen

procedure TForm1.Oeffnen1Click(Sender: TObject); // Datei|Öffnen begin with OpenDialog1 do begin Filter := 'Text Files (*.txt)|*.txt|Alle Files(*.*)|*.*'; DefaultExt := 'txt'; if Execute then with TForm2.Create(Self) do dateiOeffnen(FileName) end end;

Die Methode dateiOeffnen wird von Unit2 zur Verfügung gestellt. procedure TForm1.Beenden1Click(Sender: TObject); begin Close end;

// Datei|Beenden

1081

18.73 Ein Textverarbeitungsprogramm schreiben

Quelltext für MDI-Kindfenster Im Vergleich zum MDI-Rahmenfenster ist hier erheblich mehr Programmierarbeit zu leisten. Fügen Sie zur Klassendefinition von TForm2 folgende Ergänzungen in den privaten und den öffentlichen Abschnitt ein: private { Private-Deklarationen } pfad: string; // private Variable hinzufügen public procedure dateiOeffnen(const dateiName: string); // öffentliche Methode hinzufügen end; var Form2: TForm2;

Wenn Sie ein neues Dokument öffnen, soll im Titel die Beschriftung "ohne Namen" stehen: const standardFileName = 'ohne Namen';

// Konstante hinzufügen

Nun zum Implementation-Abschnitt: implementation {$R *.DFM}

Neben der Unit des Rahmenfensters (Unit1) werden noch die Units für den Zugriff auf Zwischenablage und Drucker gebraucht: uses Clipbrd, Printers, Unit1;

// Units hinzufügen

Die von uns hinzugefügte Methode muss noch definiert werden: procedure TForm2.dateiOeffnen; begin Pfad := dateiName; Caption := ExtractFileName(dateiName); with RichEdit1 do begin Lines.LoadFromFile(pfad); // Datei => Anzeige SelStart := 0; Modified := False // es wurde noch nichts im Text verändert end end;

Kindfenster laden und schließen Das passiert beim Laden eines Dokuments: procedure TForm2.FormCreate(Sender: TObject); // neues Dokument begin pfad := StandardFileName; SaveDialog1.Filter := 'Text Files (*.txt)|*.txt|Alle Files(*.*)|*.*'; SaveDialog1.DefaultExt := 'txt' end;

1082

Kapitel 18

How-to: Oberfläche

Wenn Sie das Dokument schließen, sind OnCloseQuery und OnClose zu besetzen: procedure TForm2.FormCloseQuery(Sender: TObject; var CanClose: Boolean); const warnText = 'Änderungen speichern in %s?'; begin if RichEdit1.Modified then begin case MessageDlg(Format(warnText, [pfad]), mtConfirmation, [mbYes, mbNo, mbCancel], 0) of idYes: Speichern1Click(Self); idCancel: CanClose := False end end end; procedure TForm2.FormClose(Sender: TObject; var Action: TCloseAction); begin Action := caFree // Dokument wird gelöscht end;

Datei-Menü Das Menü des Rahmenfensters hat nur Bedeutung, wenn kein Dokument geladen ist. Ansonsten ist immer das Menü des aktiven Kindfensters zu sehen. Um die Datei-Event-Handler der Kindfenster zu besetzen, werden einfach die gleichnamigen Methoden des Rahmenfensters aufgerufen: procedure TForm2.Neu1Click(Sender: TObject); begin Form1.Neu1Click(Sender) end;

// Datei|Neu

procedure TForm2.Oeffnen1Click(Sender: TObject); // Datei|Öffnen begin Form1.Oeffnen1Click(Sender) end;

Nicht zu verwechseln mit dem Beenden der Applikation ist das Schließen eines einzelnen Dokuments: procedure TForm2.Schliessen1Click(Sender: TObject); begin Close end;

// Datei|Schließen

Dieser Vorgang löst dann die Ereignisse OnCloseQuery und OnClose aus (siehe oben). Wenden wir uns jetzt dem Speichern zu: procedure TForm2.Speichern1Click(Sender: TObject); // Datei|Speichern begin if pfad = StandardFileName then Speichernals1Click(Sender) // ruft Speichern als Event-Handler auf else begin RichEdit1.Lines.SaveToFile(pfad); // Text => Datei RichEdit1.Modified := False // Dirty-Flag zurücksetzen end end;

1083

18.73 Ein Textverarbeitungsprogramm schreiben

procedure TForm2.Speichernals1Click(Sender: TObject); // Datei|Speichern als begin SaveDialog1.FileName := pfad; if SaveDialog1.Execute then begin pfad := SaveDialog1.FileName; Caption := ExtractFileName(pfad); Speichern1Click(Sender) // ruft Speichern-Event-Handler auf end end;

Beim Drucken nimmt uns die PrinterSetUpDialog-Komponente die ganze Arbeit ab: procedure TForm2.Druckereinrichten1Click(Sender: TObject); // Datei|Druckereinrichtung begin PrinterSetupDialog1.Execute end; procedure TForm2.Drucken1Click(Sender: TObject); begin if PrintDialog1.Execute then RichEdit1.Print(pfad) end;

// Datei|Drucken

Das gesamte Programm wird beendet: procedure TForm2.Beenden1Click(Sender: TObject); begin Form1.Beenden1Click(Sender) end;

// Datei|Beenden

Bearbeiten-Menü Nun zur Arbeit mit dem Clipboard-Objekt: procedure TForm2.KopierenClick(Sender: TObject); begin RichEdit1.CopyToClipboard end;

// Bearbeiten|Kopieren

procedure TForm2.AusschneidenClick(Sender: TObject); begin RichEdit1.CutToClipboard end;

// Bearbeiten|Ausschneiden

procedure TForm2.Loeschen1Click(Sender: TObject); begin RichEdit1.ClearSelection end;

// Bearbeiten|Löschen

procedure TForm2.EinfuegenClick(Sender: TObject); begin RichEdit1.PasteFromClipboard end;

// Bearbeiten|Einfügen

procedure TForm2.Allesauswaehlen1Click(Sender: TObject); // Bearbeiten|Alle auswählen begin RichEdit1.SelectAll end;

Einige Funktionen des Bearbeiten-Menüs sollen auch über das PopUp-Menü ausführbar sein. Weisen Sie deshalb den PopUp-Einträgen im Objektinspektor die gleichnamigen Methoden des Hauptmenüs zu! Zur Steuerung der Menüanzeige ist ein zusätzlicher Event-Handler erforderlich: procedure TForm2.Bearbeiten1Click(Sender: TObject); var HasSelection: Boolean;

// Bearbeiten

1084

Kapitel 18

begin Einfuegen1.Enabled := Clipboard.HasFormat(CF_TEXT); Einfuegen2.Enabled := Einfuegen1.Enabled; HasSelection := RichEdit1.SelLength > 0; Ausschneiden1.Enabled := HasSelection; Ausschneiden2.Enabled := HasSelection; Kopieren1.Enabled := HasSelection; Kopieren2.Enabled := HasSelection; Loeschen1.Enabled := HasSelection end;

How-to: Oberfläche

// nur Text // PopUp-Menü! // True, wenn was selektiert ist // PopUp-Menü // PopUp-Menü

Zeichen-Menü Nun zum Ausrichten der Zeilen. Die drei Menüeinträge "Links", "Rechts" und "Zentriert" benutzen einen gemeinsamen Event-Handler: procedure TForm2.AusrichtenClick(Sender: TObject); // Zeichen|Links, Rechts, Zentriert begin Links1.Checked := False; // Häkchen zurücksetzen Rechts1.Checked := False; Zentriert1.Checked := False; with Sender as TMenuItem do Checked := True; // Häkchen setzen with RichEdit1.Paragraph do if Links1.Checked then Alignment := taLeftJustify else if Rechts1.Checked then Alignment := taRightJustify else if Zentriert1.Checked then Alignment := taCenter end;

Der Zeilenumbruch: procedure TForm2.Zeilenumbruch1Click(Sender: TObject); begin with RichEdit1 do begin WordWrap := not WordWrap; if WordWrap then ScrollBars := ssVertical else ScrollBars := ssBoth; Zeilenumbruch1.Checked := WordWrap end end;

// Zeichen|Zeilenumbruch

Die Schriftarteinstellungen sind dank der Komplexität des FontDialogs ein Kinderspiel: procedure TForm2.Font1Click(Sender: TObject); // Zeichen|Font... begin FontDialog1.Font := RichEdit1.Font; if FontDialog1.Execute then RichEdit1.SelAttributes.Assign(FontDialog1.Font) end;

1085

18.73 Ein Textverarbeitungsprogramm schreiben

Fenster-Menü Zwecks ordentlicher Ausrichtung der Dokumente werden die Methoden Tile und Cascade des Rahmenfensters aufgerufen: procedure TForm2.Neben1Click(Sender: TObject); begin Form1.Tile end;

// Fenster|Nebeneinander

procedure TForm2.HinterClick(Sender: TObject); begin Form1.Cascade end;

// Fenster|Hintereinander

Test Es hieße Eulen nach Athen zu tragen, wenn wir über den Umgang mit einer Windows-typischen MDI-Applikation viele Worte verlieren würden. Probieren Sie einfach alle Möglichkeiten aus und scheuen Sie sich auch nicht, am Quelltext etwas herumzudoktern:

Bemerkungen ■ Die RichEdit-Komponente ähnelt der Memo-Komponente, ist aber weitaus leistungsfähiger, da sie quasi die Funktionalität eines vollständigen kleinen Textverarbeitungsprogramms kapselt. ■ Ausführliche Informationen zu den Themen "MDI" und "Projekteinstellungen" finden Sie im Grundlagenteil dieses Buchs.

1086

Kapitel 18

How-to: Oberfläche

18.74 Ein Formular aus der DFM-Datei laden Möchten Sie das Layout von Formularen zur Laufzeit des Programms ändern, stehen Sie vor dem Problem, dass die EXE neu compiliert werden muss. Auf Ihrem Computer mag das ja noch gehen, den Endverbrauchern werden Sie die Quelltexte aber wahrscheinlich nicht geben wollen. Die folgende Beispiellösung zeigt, wie Sie die jeweilige DFM-Datei erst zur Laufzeit laden und auch verändert speichern können. Es ergeben sich zwei wesentliche Vorteile: ■ Die eigentliche EXE ist relativ klein, dies gilt insbesondere, wenn Sie viele Bitmaps etc. verwenden. Daraus resultiert auch eine wesentliche Beschleunigung beim Compilieren der Anwendung. ■ Der Endanwender Ihrer Applikation kann in begrenztem Umfang Änderungen am Formularlayout vornehmen, ohne in die eigentliche EXE eingreifen zu müssen. Ein Nachteil sei nicht verschwiegen: Neben Ihrer EXE-Datei müssen Sie auch noch die DFMDateien mitgeben, was schnell im Chaos enden kann. Unser Beispiel wird sich darauf beschränken, zum einen eine DFM-Datei zu laden (und natürlich auch anzuzeigen), zum anderen diese Datei wieder zu speichern.

Oberfläche Entwerfen Sie zwei Formulare nach folgender Abbildung:

In Unit2 kommentieren Sie die Verbindung zur DFM-Datei aus: ... implementation //{$R *.DFM} // Auskommentiert !!!!!

Entfernen Sie über den Menüpunkt Projekt|Optionen|Formulare nachfolgend Form2 aus der Liste der automatisch zu erstellenden Formulare.

Quelltext (Form1) Binden Sie in Unit1 die Unit2 ein: uses unit2; {$R *.DFM}

18.74 Ein Formular aus der DFM-Datei laden

1087

Das eigentliche Laden des Formulars beschränkt sich auf wenige Quellcodezeilen. Die beiden Schlüsselfunktionen sind in diesem Zusammenhang CreateNew und ReadComponentResFile. Über CreateNew wird ein Dummy-Form erzeugt, das die eigentlichen Ressourcen nicht benötigt. Mit ReadComponentResFile werden die zu ladenden Ressourcen der TForm2-Instanz zugewiesen: procedure TForm1.Button1Click(Sender: TObject); var path : string; begin path := ExtractFilepath(Paramstr(0)); Form2 := TForm2.CreateNew(Application); ReadComponentResFile(path + 'unit2.dfm', Form2 );

Der eigentliche Aufruf: Form2.Show end;

Quelltext (Form2) In Form2 erstellen Sie zunächst zwei einfache Ereignisprozeduren für die beiden Buttons, damit später auch zu sehen ist, dass das Formular voll funktionstüchtig ist: procedure TForm2.Button1Click(Sender: TObject); begin ShowMessage('Bla Bla') end; procedure TForm2.Button2Click(Sender: TObject); begin Beep end;

Mit dem Schließen des Fensters speichern wir die aktuellen Einstellungen des Formulars (Größe, Position) in der DFM-Datei ab: procedure TForm2.FormClose(Sender: TObject; var Action: TCloseAction); var path : string; begin path := ExtractFilepath(Paramstr(0)); WriteComponentResFile(path + 'unit2.dfm', self ) end;

HINWEIS: Stellen Sie geeignete Routinen bzw. einen eigenen Objektinspektor bereit, kann das

gesamte Formularlayout geändert und auch gespeichert werden.

Test Starten Sie das Programm und rufen Sie Form2 auf. Verändern Sie die Position und Größe des Fensters und schließen die Anwendung. Nach einem erneuten Start müsste die geänderte Form2 an der neuen Position auftauchen.

1088

Kapitel 18

How-to: Oberfläche

18.75 Kollegen mit einem IQ-Tester ärgern Wollten auch Sie es schon immer mal Ihrem Kollegen Besserwisser heimzahlen? Mit einem kleinen Intelligenz-Test ist das schnell erledigt. Bauen Sie in ein Delphi-Projekt einfach folgende Dialogbox zum Beenden ein.

Oberfläche Ohne viele Worte:

Quelltext In das MouseMove-Event (für beide Buttons!) tragen Sie folgenden Code ein: procedure TForm1.ButtonMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer); var s:string; begin Button1.Top := Random(ClientHeight - Button1.Height); Button1.Left := Random(ClientWidth - Button1.Width); Button2.Top := Random(ClientHeight - Button2.Height); Button2.Left := Random(ClientWidth - Button2.Width); s:= Button1.Caption; Button1.Caption := Button2.Caption; Button2.Caption := s end; procedure TForm1.Button1Click(Sender: TObject); begin Close end;

Test Es ist zum Verrücktwerden: Die Buttons weichen bei Annäherung mit der Maus plötzlich aus und widersetzen sich hartnäckig jeglichem Klickversuch1.

1

Als "intelligent" zählt ein Kollege, der dem Spuk mit der Enter-Taste ein Ende bereitet.

19

How-to: Grafikprogrammierung

Kapitel

19

How-to: Grafikprogrammierung 19.1 Zwischen PaintBox und Image unterscheiden Was ist eigentlich der Unterschied zwischen einer PaintBox und einem Image? Beide verfügen doch über ein Canvas-Objekt, über dessen Methoden Sie Grafiken ausgeben können. Die Antwort auf die Frage soll das folgende kleine Testprogramm liefern.

Oberfläche Wie sicher nicht anders zu erwarten, brauchen wir zuerst einmal eine Image- und eine PaintboxKomponente. Zusätzlich fügen wir noch einige Buttons ein, über die wir einen Zeitvergleich starten und außerdem eine Möglichkeit schaffen, die Grafik zu sichern bzw. zu laden.

1090

Kapitel 19

How-to: Grafikprogrammierung

Quelltext Als Erstes werden wir etwas Leben in die Sache bringen. Dazu erweitern wir die Ereignisse MouseDown und MouseMove : procedure TForm1.Image1MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin if Shift = [ssright] then Image1.Canvas.TextOut(x,y,IntToStr(x) + ':' + IntToStr(y)) end; procedure TForm1.Image1MouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer); begin if Shift = [ssleft] then Image1.Canvas.LineTo(x,y) end;

Drücken Sie auf die linke Taste und bewegen Sie die Maus, wird eine Linie gezeichnet. Ein Druck auf die rechte Maustaste zeigt die aktuellen Mauskoordinaten an. Soll die Grafik gelöscht werden, müssen Sie den rechteckigen Bereich mit der Hintergrundfarbe füllen. Wir verwenden dazu die Methode FillRect: procedure TForm1.Button4Click(Sender: TObject); // Löschen var rect: TRect; begin rect:= Bounds(0,0,Image1.Width,Image1.Height); Image1.Canvas.Brush.Color := clWhite; Image1.Canvas.FillRect(rect) end;

Die Image-Komponente bietet über das Picture-Objekt die Möglichkeit, eine Bitmap zu sichern bzw. zu laden: Image1.Picture.SaveToFile('c:\test.bmp'); Image1.Picture.LoadFromFile('c:\test.bmp');

// Grafik sichern // Grafik laden

Test Starten Sie das Programm und führen Sie zunächst normale Grafikmethoden aus, indem Sie Linien ziehen bzw. sich mit der rechten Maustaste die Koordinaten anzeigen lassen. Wenn Sie jetzt vorübergehend beide Grafiken durch andere Fenster überdecken, so können Sie bereits einen Hauptunterschied zwischen beiden Komponenten feststellen. Während das Image seinen Inhalt automatisch regeneriert, klaffen bei der PaintBox erbärmliche Lücken:

19.1 Zwischen PaintBox und Image unterscheiden

1091

Anschließend können Sie einen weiteren Vorzug der Image-Komponente kennen lernen. Klicken Sie auf "Grafik laden":

1092

Kapitel 19

How-to: Grafikprogrammierung

Sie können das Bild mit Linien "verschönern" und wieder abspeichern. Leider verfügt die PaintBox nicht über Methoden zum Laden und Abspeichern von Grafikdateien (siehe Bemerkungen), so dass bei diesem Vergleich die rechte Hälfte des Formulars leer bleibt.

Bemerkungen Testen Sie auch die Möglichkeiten zum Sichern und Laden der Image-Bitmap. Siehe dazu auch: Ä 19.6 Bitmaps zur Laufzeit zuweisen Ä 19.3 Die ImageList einsetzen

19.2 Mit der ChartFX-Komponente arbeiten Zum Darstellen unterschiedlichster Diagramme und Graphen hat der Delphi-Programmierer die Qual der Wahl zwischen mehreren Controls. Wir wollen uns in diesem Rezept mit einem kleinen Beispiel an die sehr komplexe und leistungsfähige ChartFX-Komponente heranwagen. HINWEIS: Es handelt sich nicht um die Chart-Komponente auf der Seite "Zusätzlich", sondern

um ChartFX auf der "ActiveX"-Seite der Komponentenpalette! "Die Möglichkeiten der ChartFX-Komponente sind fantastisch, die Bedienung ist mittelalterlich". Mit diesen Worten lässt sich die Komponente wohl am besten beschreiben. Statt die sowieso vorhandenen Eigenschaften zur Laufzeit nutzen zu können, muss alles über umständliche Steueranweisungen abgewickelt werden. Ein mit dem Komfort von Delphi nicht zu vereinbarender Widerspruch!

Oberfläche Die Oberfläche wird über ein PageControl (Seite "Win32") in einen Diagramm- und einen Tabellenbildschirm aufgeteilt. Über den Eintrag "Neue Seite" des PopUp-Menüs fügen Sie zwei Seiten hinzu (TabSheet1 und TabSheet2), denen Sie im Objektinspektor neue Caption-Eigenschaften zuweisen ("Daten editieren" und "Diagramm"). Auf TabSheet1 platzieren Sie eine StringGrid-Komponente und zwei SpinEdit-Komponenten. HINWEIS: Innerhalb der Options-Eigenschaft des StringGrid müssen Sie goEditing = True set-

zen, anderenfalls können Sie nichts in das Gitter eingeben!

19.2 Mit der ChartFX-Komponente arbeiten

1093

Setzen Sie nun die Chart-Komponente auf TabSheet2 und staunen Sie über das prächtige Outfit, welches die Komponente bereits jetzt zur Entwurfszeit zur Schau trägt.

1094

Kapitel 19

How-to: Grafikprogrammierung

Um die in der obigen Grafik angezeigten Toolbars zu erhalten, müssen Sie die Eigenschaften PaletteBar, PatternBar und ToolBar auf True setzen. Über die Align-Eigenschaft des PageControl kann die Komponente im Formular ausgerichtet werden (alClient).

Quelltext Das StringGrid wird über die SpinEdit-Komponenten zur Laufzeit angepasst: procedure TForm1.SpinEditChange(Sender: TObject); var i: Integer; begin StringGrid1.ColCount := SpinEdit1.Value+2; StringGrid1.RowCount := SpinEdit2.Value+2; for i := 2 to StringGrid1.ColCount do StringGrid1.Cells[i,0] := IntToStr(i-1); StringGrid1.Cells[1,0] := 'Beschriftung'; for i := 2 to StringGrid1.RowCount do StringGrid1.Cells[0,i] := IntToStr(i-1); StringGrid1.Cells[0,1] := 'Beschriftung'; ChartFX1.OpenDataEX(COD_VALUES, SpinEdit1.Value-1, SpinEdit2.Value-1); ChartFX1.CloseData(COD_VALUES) end;

HINWEIS: Weisen Sie dem OnChange-Event beider SpinEdit-Komponenten im Objekt-

inspektor den obigen Event-Handler zu! Zum Anpassen der Diagrammgröße verwenden wir das FormResize-Event: procedure TForm1.FormResize(Sender: TObject); begin ChartFX1.Width := TabSheet2.Width; ChartFX1.Height := TabSheet2.Height end;

Mit dem Verlassen der Tabelleneingabe (Umschalten zum Diagramm) werden alle Daten ins Diagramm übernommen. Dazu müssen Sie mit OpenDataEx den Übertragungskanal öffnen. Vergessen Sie nicht, den Kanal wieder zu schließen1. procedure TForm1.StringGrid1Exit(Sender: TObject); var d: Double; i,x,y : Integer; begin MessageBeep(0); ChartFX1.Visible := False; ChartFX1.OpenDataEx(COD_VALUES, SpinEdit1.Value-1, SpinEdit2.Value-1); for x:=2 to StringGrid1.ColCount-1 do begin ChartFX1.ThisSerie := x-2; // Welcher Balken? 1

Properties hätten an dieser Stelle die Bedienung wesentlich vereinfacht ...

// Öffnen

1095

19.2 Mit der ChartFX-Komponente arbeiten

for y:= 2 to StringGrid1.RowCount-1 do begin Val(StringGrid1.Cells[x,y],d,i); ChartFX1.Value[y-2] := d end end; ChartFX1.CloseData(COD_VALUES); ChartFX1.Visible := True end;

// Länge des Balkens

// Schließen

Test HINWEIS: Vor dem Compilieren bringen Sie die Seite mit dem Diagramm in den Vordergrund

(oder stellen Sie die ActivePage-Eigenschaft des Page-Controls auf TabSheet2 ein), ansonsten kann es nach der Dateneingabe zu einer Fehlermeldung kommen! Nach Programmstart schalten Sie um auf "Daten editieren".

Die Vielfalt der Darstellungsmöglichkeiten, die man in der Menüleiste wählen kann, ist schon beeindruckend und erst durch längeres Experimentieren annähernd zu erschließen:

1096

Kapitel 19

How-to: Grafikprogrammierung

19.3 Die ImageList einsetzen Geht es darum, mehrere gleich große Grafiken sinnvoll zu verwalten, ist die ImageList-Komponente die erste Wahl. Ein kleines Beispiel zeigt, wie Sie zur Laufzeit auf die enthaltenen Grafiken zugreifen können.

Oberfläche Binden Sie eine ImageList- sowie eine PaintBox-Komponente zur Anzeige der Grafiken ein. Weiterhin brauchen wir einen Timer, eine Trackbar und zwei Buttons.

Bestimmen Sie mit Hilfe der Height- und Width-Eigenschaft die Größe der Grafiken in der ImageList. Nach einem Doppelklick auf die Komponente können Sie geeignete einzelne Grafiken in die Komponente laden. Gleichzeitig können Sie die Reihenfolge und den Hintergrund bestimmen.

19.3 Die ImageList einsetzen

1097

Über eine Timer-Komponente blenden Sie zur Laufzeit jeweils eine Bitmap in die PaintBox ein. Durch die Aufeinanderfolge von Grafiken entsteht der Eindruck einer Animation.

Quelltext Die Ausgabe erfolgt mit der Draw-Methode, der Sie neben dem Ziel-Canvas auch die Zielkoordinaten und den Index der Grafik übergeben müssen: procedure TForm1.Timer1Timer(Sender: TObject); begin ImageList1.Draw(PaintBox1.Canvas,0,0,i); Inc(i); if i = 7 then i := 0 end;

Einfacher geht es wohl nicht mehr! So regeln Sie die Geschwindigkeit des "Flimmerkinos": procedure TForm1.TrackBar1Change(Sender: TObject); begin timer1.interval:= trackbar1.position; label2.caption := inttostr(1000 div timer1.interval); end;

Test Lassen Sie sich von der fröhlich winkenden Witzfigur erheitern!

1098

Kapitel 19

How-to: Grafikprogrammierung

19.4 Grafiken in einem Listenfeld anzeigen Dass sich List- und Comboboxen unter Windows nicht nur für die Anzeige von Text, sondern auch von Grafiken eignen, ist Ihnen sicher schon aufgefallen. Im Folgenden wollen wir Ihnen eine Realisierungsmöglichkeit vorstellen.

Oberfläche Für unser Beispiel brauchen wir natürlich auf alle Fälle eine ListBox. Legen Sie über die ItemHeight-Eigenschaft die Zeilenhöhe fest. Wollen Sie normale Icons anzeigen, sollten Sie hier 38 eingeben (ein Icon ist 32 Pixel hoch, den Rest nutzen wir als Rand). Weiterhin müssen Sie die StyleEigenschaft anpassen (lbOwnerDrawFixed). Über die Items-Eigenschaft bestimmen Sie die Anzahl und den Inhalt der einzelnen Zeilen innerhalb der Listbox. Da alle Bilder gleich groß sind, können wir eine ImageList-Komponente zum Speichern der Grafiken verwenden. Bestimmen Sie die Grafikgröße mit Height und Width. Klicken Sie danach doppelt auf die ImageList. Im folgenden Dialog können Sie die Reihenfolge und die Anzahl der Grafiken bestimmen:

Quelltext Haben Sie die Eigenschaft Style auf lbOwnerDrawFixed festgelegt, sind Sie selbst dafür verantwortlich, die Listbox bei allen Veränderungen (Scrollen, Auswahl etc.) neu zu zeichnen. Was sich so kompliziert anhört, ist relativ einfach bewerkstelligt. Ihre Aufgabe besteht lediglich darin, im DrawItem-Ereignis auf entsprechende Anforderungen der Komponente zu reagieren. In unserem Fall geht es zum einen darum, den Text anzuzeigen (bei Auswahl soll der Text vergrößert dargestellt werden), zum anderen sollen zwei Icons eingeblendet werden, von denen eins nur bei Auswahl sichtbar ist. procedure TForm1.ListBox1DrawItem(Control: TWinControl; Index: Integer; Rect: TRect; State: TOwnerDrawState); begin

19.5 Grafiken in die Zwischenablage kopieren

1099

listbox1.canvas.brush.color := clWhite; listbox1.canvas.fillrect(rect); if listbox1.selected[index] then begin imagelist1.draw(listbox1.canvas,rect.left,rect.top+3,1); listbox1.canvas.font.size := -15; listbox1.canvas.font.style := [fsbold]; listbox1.canvas.font.color := clblue; end; imagelist1.draw(listbox1.canvas,rect.left + 32,rect.top+3,0); listbox1.canvas.textout(64,rect.top+11,listbox1.items[index]) end;

Gezeichnet wird auf dem Canvas der Komponente, der betreffende Ausschnitt wird durch den Parameter Rect gekennzeichnet. Die eigentliche Grafikausgabe erfolgt mittels Draw-Methode. Auch der Ausgabetext muss über eine Methode angezeigt werden.

Test Nach Programmstart sind alle Icons gleich. Klicken Sie nun auf einzelne Einträge!

Bemerkung Sollten Sie viele Schriftarten in der Listbox anzeigen wollen, ist es sinnvoll, diese vorher zu erstellen und in einem Bitmap-Array oder einer ImageList-Komponente abzulegen.

19.5 Grafiken in die Zwischenablage kopieren Für die Arbeit mit der Zwischenablage stellt Delphi das Objekt TClipboard zur Verfügung (Unit Clipbrd). Sie brauchen davon keine Instanz abzuleiten, da bereits bei Programmstart eine Variable Clipboard standardmäßig vorhanden ist. Die Assign-Methode erlaubt einen Datenaustausch in beiden Richtungen.

1100

Kapitel 19

How-to: Grafikprogrammierung

Mit dem folgenden kleinen Testprogramm können Sie das Kopieren und Einfügen von Grafiken (TPicture) nachvollziehen.

Oberfläche Auf dem Startformular (Form1) platzieren Sie drei Image-Komponenten (Image1, Image2 und Image3). Weisen Sie der Picture-Eigenschaft jeweils ein Bildchen zu, das Sie vorher z.B. mit Paintbrush gezeichnet haben. Die AutoSize-Property der Image-Komponenten setzen Sie auf True, damit passen sich deren Abmessungen automatisch der Größe der Bildchen an. Unterhalb platzieren Sie drei RadioButtons (RadioButton1, RadioButton2 und RadioButton3) und drei Schaltflächen (Button1, Button2, Button3). Die Checked-Property von RadioButton1 ändern Sie auf True.

Quelltext Fügen Sie den Eintrag ClipBrd ans Ende der Uses-Klausel von Unit1 an! Anschließend weisen Sie den drei Buttons folgenden Ereigniscode zu: procedure TForm1.Button1Click(Sender: TObject); // Kopieren begin if RadioButton1.Checked then Clipboard.Assign(Image1.Picture); if RadioButton2.Checked then Clipboard.Assign(Image2.Picture); if RadioButton3.Checked then Clipboard.Assign(Image3.Picture) end; procedure TForm1.Button2Click(Sender: TObject); // Einfügen begin if RadioButton1.Checked then Image1.Picture.Assign(Clipboard); if RadioButton2.Checked then Image2.Picture.Assign(Clipboard); if RadioButton3.Checked then Image3.Picture.Assign(Clipboard) end;

Test Nach dem Programmstart können Sie nach Belieben in die Zwischenablage kopieren bzw. von dort einfügen. Die Operationen beziehen sich immer auf das mit dem RadioButton markierte Bild. Man

19.6 Bitmaps zur Laufzeit zuweisen

1101

braucht keine Bedenken zu haben, dass die in den Image-Komponenten eingelagerten Bitmaps durch das Überschreiben verloren gehen. Nach einem erneuten Programmstart ist der ursprüngliche Zustand wiederhergestellt.

Bemerkungen ■ Mit der Anweisung Clipboard.Clear können Sie die Zwischenablage löschen. ■ Testen Sie den Grafikaustausch mit anderen gleichzeitig geöffneten Windows-Applikationen, z.B. Word oder Paintbrush! Sie können auch mit Paintbrush eine Grafik entwerfen, diese dort in die Zwischenablage kopieren und anschließend in unser Progrämmchen einfügen.

19.6 Bitmaps zur Laufzeit zuweisen Die kurze Antwort: Verwenden Sie die LoadFromFile-Methode, mit der Sie verschiedenen Objekten eine Bilddatei zuweisen können. Das folgende Beispiel erläutert dies für zwei Varianten und liefert gleichzeitig noch eine Demo für den Einsatz des (unsichtbaren!) TBitmap-Objekttyps.

Oberfläche Auf dem Startformular platzieren Sie eine Paintbox (Seite "System") und einen Bitmap-Schalter (Seite "Zusätzlich"). Zoomen Sie den Rahmen der Paintbox genügend weit auf, so dass die komplette Bitmap später darin Platz finden kann, ansonsten wird nur ein Ausschnitt angezeigt. Analoges gilt für den Schalter.

Quelltext Voraussetzung für die Funktion dieses Programms ist das Vorhandensein der beiden BitmapDateien Bild1.BMP und Bild2.BMP im Projektverzeichnis. procedure TForm1.PaintBox1Paint(Sender: TObject); var Bitmap1: TBitmap; begin Bitmap1 := TBitmap.Create; Bitmap1.LoadFromFile('bild1.bmp'); PaintBox1.Canvas.Draw(0, 0, Bitmap1); Bitmap1.Free end; procedure TForm1.FormCreate(Sender: TObject); begin BitBtn1.Glyph.LoadFromFile('bild2.bmp') end; procedure TForm1.BitBtn1Click(Sender: TObject); begin Form1.Close end;

1102

Kapitel 19

How-to: Grafikprogrammierung

Test Das Ergebnis ohne viele Worte:

Bemerkungen ■ Statt in den Canvas der PaintBox könnte man nach dem gleichen Prinzip natürlich auch direkt in den Canvas des Formulars zeichnen. Die Paintbox bietet allerdings den Vorteil, dass der Zeichenbereich begrenzbar ist. ■ Verwenden Sie statt der PaintBox- eine Image-Komponente (Achtung, Ressourcenfresser!), ist die Syntax etwas einfacher (ohne Canvas und TBitmap): Image1.Picture.LoadFile('bild1.bmp')

■ Wenn Sie das fertige Programm später als EXE-Datei starten wollen, müssen Sie gegebenenfalls eine Anpassung des Pfadnamens im Argument von LoadFile vornehmen.

19.7 Eine Bitmap-Ressourcendatei erstellen Es gibt unter Delphi bekanntlich verschiedene Arten von Ressourcendateien, die mit dem integrierten Bildeditor bearbeitet werden können: ■ Ressourcen-Datei (*.res) ■ Delphi-Komponenten-Ressourcen-Datei (*.dcr) ■ Bitmap-Datei (*.bmp)

19.7 Eine Bitmap-Ressourcendatei erstellen

1103

■ Symbol-Datei (*.ico) ■ Cursor-Datei (*.cur) Die folgende Demonstration soll sich auf das Erstellen einer DCR-Datei beschränken, wie man sie beispielsweise für die Schaltflächen der Komponentenpalette benötigt. Der Name der entsprechenden Komponenten-Unit soll lauten UniBlack.pas.

Aufbau der Dateistruktur Der Aufruf des Bildeditors erfolgt über das Menü Tools|Bildeditor:

Als Nächstes fügen wir über den Menüpunkt Ressource|Neu zwei Bitmaps zu:

Jede dieser Bitmaps hat die Abmessungen 24 x 24 Pixel. Bei späteren Problemen mit der Grafikkarte sollten Sie es anstelle der hier empfohlenen 16 Farben einmal mit 256 Farben versuchen. Über Ressource|Umbenennen muss der Name der Bitmap auf den der entsprechenden Komponente gesetzt werden:

1104

Kapitel 19

How-to: Grafikprogrammierung

In unserem Beispiel heißen die zugehörigen Komponentenklassen TEditBlack und TLabelBlack, es handelt sich also um Modifikationen der TEdit- und TLabel-Komponenten (siehe Bemerkungen).

Zeichnen Nun kann es an die Arbeit gehen! Doppelklicken Sie auf den Namen der Bitmap und stellen Sie Ihre künstlerischen Fähigkeiten unter Beweis!

In unserem Fall haben wir ein klein wenig getrickst und versucht, das Brett an der dünnsten Stelle zu bohren, es wurden einfach die fertigen Bitmaps der Vorfahren TEdit und TLabel über Bearbeiten|Einfügen hereinkopiert und lediglich mit einem schwarzen Rahmen "nachbearbeitet". Woher die Altvorderen nehmen? Alle .DCR-Dateien der Delphi-Komponentenpalette befinden sich im Verzeichnis Borland\DelphiX\Lib. Öffnen Sie am besten eine zweite Instanz des Bildeditors und laden Sie die Datei StdReg.DCR (entspricht der Seite "Standard"). Sie kopieren nacheinander TEDIT und TLABEL in die Zwischenablage und fügen diese dann in die noch leeren Bitmaps TEDITBLACK und TLABELBLACK der ersten Instanz des Bildeditors ein.

19.8 JPEG-Grafiken als Ressourcen speichern

1105

Abspeichern DCR-Dateien müssen in das gleiche Verzeichnis kopiert werden, in dem sich auch die (compilierte) Komponenten-Unit (.DCU) befindet. Auch der Name muss exakt dem der Unit entsprechen. Wählen Sie deshalb im Menü des Bildeditors Datei|Speichern als und geben Sie als Dateinamen UniBlack.DCR ein. Damit wäre die Ressourcendatei fertig. Um die Früchte der Arbeit in der Komponentenpalette zu bewundern, müssen beide Komponenten erst noch installiert werden (Menü Komponente|Komponente installieren...).

Bemerkungen ■ Auf der Buch-CD ist lediglich die Datei UniBlack.DCR enthalten, es gibt also zu diesem Beispiel kein ausführbares Projekt! ■ Eine konkrete Anwendung dieser Ressourcendatei bei der Entwicklung eigener Komponenten finden Sie in unserem Buch "Borland Delphi 7 – Grundlagen und Profiwissen".

19.8 JPEG-Grafiken als Ressourcen speichern Für einen Splash-Screen oder eine Hintergrund-Bitmap ist eine BMP-Datei einfach zu groß! Binden Sie diese in Ihre Anwendung als Ressource ein, quillt die Datei auf wie ein Hefekuchen. Abhilfe verspricht das JPEG-Format, das bei fast gleich guter Qualität eine wesentlich kleinere Datei erzeugt. Das Problem ist nur: Wie binde ich derartige Grafiken ein und wie zeige ich diese später an?

Vorbereitungen Bevor es losgeht, sollten Sie die gewünschte Bitmap mit Hilfe eines Grafiktools (z.B. PaintShop) in das JPEG-Format umwandeln. Hier bestimmen Sie mit Hilfe des Kompressionsfaktors auch die Qualität der Grafik. BEISPIEL: Eine ursprünglich 45 KByte große Bitmap (BMP-Format) ist im JPEG-Format mit 20% Kompres-

sion nur noch 9,66 KByte groß (links) bzw. mit 80 % Kompression nur 4,19 KByte (rechts).

1106

Kapitel 19

How-to: Grafikprogrammierung

Wer über keine Möglichkeit zum Erstellen von JPEG-Dateien verfügt, der sollte sich des folgenden Programms von der Buch-CD bedienen: Ä 19.9 BMP in JPEG-Grafiken umwandeln Nehmen wir an, dass schließlich eine Datei mit dem Namen Bild1.jpg vorliegt, die Sie am besten gleich mit in das Delphi-Projektverzeichnis kopieren. Wie auch bei einer normalen Bitmap müssen Sie zunächst eine Ressourcen-Datei erzeugen, siehe dazu: Ä 19.7 Eine Bitmap-Ressourcendatei erstellen Wer an einer kurzen und bündigen Erläuterung interessiert ist, für den erfolgt hier stichpunktartig eine Beschreibung der notwendigen Schritte: Starten Sie einen Texteditor, z.B. das Windows-Notepad, und tippen Sie folgende Zeile ein: 105 RCDATA "Bild1.jpg"

Bei Bedarf können Sie hier in den nächsten Zeilen weitere Grafikdateien hinzufügen (andere ID wählen). Speichern Sie dieses so genannte Ressourcen-Script z.B. unter dem Namen Bilder.rc in Ihr Projektverzeichnis ab. Sicher nicht der eleganteste, aber der zuverlässigste Weg: Kopieren Sie den Ressourcen-Compiler brc32.exe (er befindet sich im Unterverzeichnis Delphix\Bin) in Ihr Projektverzeichnis (keine Angst, er ist nur ca. 70 KByte groß!). Klicken Sie auf den Windows-Startbutton, wählen Sie "Ausführen..." und klicken Sie im Dialogfenster auf die "Durchsuchen"-Schaltfläche. Wählen Sie im Dateidialog Ihr Projektverzeichnis und dort die Datei brc32.exe. Ergänzen Sie den Aufruf von brc32.exe, indem Sie (durch ein Leerzeichen getrennt) den Namen der Script-Datei (exe und rc-Extension können entfallen) anfügen. In unserem Fall sieht das dann so aus: ...\brc32 Bilder

19.8 JPEG-Grafiken als Ressourcen speichern

1107

Klicken Sie auf OK, ignorieren Sie das zwischenzeitliche gespenstische Auftauchen des DOSFensters, und überzeugen Sie sich anschließend davon, dass in Ihrem Projektverzeichnis eine neue Ressourcen-Datei mit dem Namen Bilder.res aufgetaucht ist.

Oberfläche Platzieren Sie auf dem Startformular eine Image-Komponente und zoomen Sie diese etwa auf Fenstergröße auf. Zweckmäßigerweise setzen Sie die Stretch-Eigenschaft auf True (AutoSize kann False bleiben).

Quelltext Am Anfang des implementation-Abschnitts von Unit1 binden Sie die JPEG-Unit und die Ressource ein: uses ..., jpeg; {$R Bilder.RES}

Unsere JPEG-Grafik soll gleich zu Beginn angezeigt werden: procedure TForm1.FormCreate(Sender: TObject); var ResStream : TResourceStream; begin

Der Ressourcen-Stream wird erzeugt, anhand der ID (105) wird das richtige Bild zugewiesen: ResStream := TResourceStream.CreateFromID(HInstance, 105, RT_RCDATA);

Das Laden unterscheidet sich etwas von der bisherigen Vorgehensweise, wir brauchen ein neues TJPEGImage-Objekt (ab Delphi 3): Image1.Picture.Graphic := TJPEGImage.Create; with TJPEGImage(image1.Picture.Graphic) do begin PixelFormat := jf24Bit; Grayscale := False; end; Image1.Picture.Graphic.LoadFromStream(ResStream); resStream.Free end;

Sie können die Darstellungsqualität und -geschwindigkeit noch über die Eigenschaften Pixelformat (8 und 24 Bit), GrayScale und Performance anpassen.

Test Die Freude an dem Anblick, der sich Ihnen sofort nach dem Programmstart bietet, wird erheblich dadurch gesteigert, dass die in die Projekt-EXE eingebettete Ressource nur einen Bruchteil des Speicherplatzes der ursprünglichen Bitmap belegt (im Beispiel auf der Buch-CD sind dies ca. 30 KByte statt 372 KByte).

1108

Kapitel 19

How-to: Grafikprogrammierung

Bemerkung Einen weiteren Vorteil der JPEG-Ressourcen erkennen Sie erst, wenn Sie TrueColor-Bilder zur Anzeige bringen wollen. Hat der Anwender lediglich eine Farbtiefe von 256 Farben eingestellt, bleibt von Ihrer Grafik nicht mehr viel übrig. Anders bei TJPEG, die Komponente konvertiert die Grafik automatisch in eine 256-Farben-Grafik, die meist noch recht brauchbar aussieht.

19.9 BMP in JPEG-Grafiken umwandeln Wie schon im vorhergehenden Rezept beschrieben, bietet sich mit dem JPEG-Format eine sinnvolle, weil speicherplatzsparende Alternative zu den konventionellen BMP-Dateien. Aus diesem Grund gehört JPEG zu den im Internet üblichen Standardformaten. Eine direkte BMP-JPEGUmwandlung (z.B. mit einer Methode) ist in Delphi allerdings (noch) nicht vorgesehen. Genau diese Lücke soll das folgende kleine Beispiel schließen. Mit diesem durchaus praxistauglichen Programm können Sie eine Bitmap-Grafik beispielsweise unter Windows-Paintbrush erzeugen, um sie dann in JPG zu konvertieren.

Oberfläche Für unseren Grafikkonverter benötigen wir neben einem OpenPictureDialog noch eine TrackBar, über die wir den Kompressionsfaktor des JPEG-Algorithmus bestimmen.

19.9 BMP in JPEG-Grafiken umwandeln

1109

Die Funktion der beiden Buttons dürfte ersichtlich sein. Das Konvertieren erfolgt automatisch sofort nach dem Laden der BMP-Datei.

Quelltext Zu Beginn des implementation-Abschnitts binden wir die Unit JPEG ein: uses ..., jpeg;

Bevor es zur Sache geht, brauchen wir eine kleine Hilfsfunktion, die dafür sorgt, dass die neue JPEG-Datei den gleichen Namen trägt wie die BMP-Datei: function setJPGFileName(BMPFileName: string):string; var i:Integer; s:string; begin s := ExtractFileName(BMPFileName); for i := 1 to 3 do Delete(s,Length(s),1); result := s + 'JPG' end;

Laden und Konvertieren: procedure TForm1.BitBtn1Click(Sender: TObject); var fNameBMP, fNameJPG:string; pic : TImage; begin

Öffnen einer Grafikdatei und Auswerten des Typs: fNameBMP := Uppercase(OpenPictureDialog1.FileName); if ExtractFileExt(fNameBMP) = '.BMP' then begin

Wir erstellen eine temporäre Image-Komponente, in die wir die Bitmap laden: pic := TImage.Create(nil); pic.Picture.LoadFromFile(fNameBMP);

1110

Kapitel 19

How-to: Grafikprogrammierung

Zusätzlich wird eine TJPEGImage-Komponente erzeugt. Bevor Sie die Bitmap zuweisen, können Sie die Parameter der JPEG-Grafik einstellen (z.B. den Kompressionsfaktor): with TJPEGImage.Create do begin Performance := jpBestQuality; CompressionQuality := trackbar1.Position; Assign(pic.Picture.Graphic); fNameJPG := setJPGFileName(fNameBMP); SaveToFile(fNameJPG); Free end; pic.Free;

Hohe Werte für CompressionQuality entsprechen einer guten Bildqualität, Werte unter 50 führen zu deutlich abnehmender Qualität. Zum Laden der neuen JPEG-Grafik genügt ein Aufruf der Methode LoadFromFile: Image1.Picture.LoadFromFile(fNameJPG); end else Image1.Picture.LoadFromFile(fNameBMP) end end;

Test Starten Sie das Programm, stellen Sie den Kompressionsfaktor ein und wählen Sie eine BitmapDatei aus. Die neue JPEG-Datei findet sich anschließend im Projektverzeichnis.

Wie Sie sehen, wurde noch eine Druckvorschau mit QuickReport-Komponenten als Beigabe spendiert. Den Quellcode finden Sie auf der Buch-CD.

1111

19.10 Informationen über BMP-Dateien gewinnen

19.10 Informationen über BMP-Dateien gewinnen Zur Lösung des Problems müssen Sie die Grafik nicht unbedingt in den Arbeitsspeicher laden1, vielmehr genügt es, wenn Sie die entsprechende Header-Information der Datei einlesen und auswerten. Am Anfang einer Bitmap-Datei steht der Datei-Header, der sich in einen File- und einen InfoHeader unterteilt. Die dort abgespeicherten Werte sind entweder vom Datentyp Integer (2 Byte) oder vom Datentyp Long (4 Byte). Aus der Reihenfolge ihrer Anordnung ergibt sich die Byte-Position, wie sie den folgenden zwei Tabellen zu entnehmen ist: File-Header (14 Bytes) Byte-Position Wert

Datentyp Bemerkung

1

bmfType

Integer

Kennzeichen für eine BMP-Datei (BM)

3

bmfSize

Long

Dateigröße

7

bmfReserved1

Integer

reserviert

9

bmfReserved2

Integer

reserviert

11

bmfOffBits

Long

Offset des ersten Grafikbytes

Info-Header (40 Bytes) Byte-Position Wert

Datentyp Bemerkung

15

bmSize

Long

Größe der Struktur

19

bmWidth

Long

Breite (Pixel)

23

bmHeight

Long

Höhe (Pixel)

27

bmPlanes

Integer

Anzahl Farbebenen (immer 1)

29

bmBitCount

Integer

Farbtiefe (1, 4, 8, 24 Bit)

31

bmCompression

Long

Kompressionstyp

35

bmSizeImage

Long

Bildgröße in Bytes

39

bmXPixPerMeter Long

Anzahl Pixel pro Meter (x-Richtung)

43

bmYPixPerMeter

Long

Anzahl Pixel pro Meter (y-Richtung)

47

bmCrUsed

Long

Anzahl der genutzten Farben

51

bmCrImportant

Long

Anzahl der notwendigen Farben für die Darstellung

Oberfläche Neben einer OpenDialog-Komponente brauchen wir eine ListBox-Komponente sowie eine Schaltfläche:

1

Bei größeren Bitmaps ist dies ohnehin nicht zu empfehlen.

1112

Kapitel 19

How-to: Grafikprogrammierung

Quelltext Delphi stellt mit TBitmapFileHeader und TBitmapInfoHeader bereits zwei entsprechende Typen bereit, um die oben genannten Daten zu verarbeiten. Alles, was wir machen müssen, ist das Auslesen der Daten. Dazu verwenden wir ein TFileStream-Objekt: procedure TForm1.Button1Click(Sender: TObject); var fileheader : TBitmapfileheader; infoheader : TBitmapInfoHeader; s : TFilestream; begin if openpicturedialog1.Execute then begin s := TFilestream.Create(openpicturedialog1.FileName,fmOpenRead or fmShareDenyNone); s.Read(fileheader,sizeof(fileheader)); s.Read(infoheader,sizeof(infoheader)); s.free; listbox1.Items.Clear; listbox1.items.add('Dateigröße: ' + inttostr(fileheader.bfSize)); listbox1.items.add('Breite : ' + inttostr(infoheader.biWidth)); listbox1.items.add('Höhe : ' + inttostr(infoheader.biHeight)); listbox1.items.add('Farbtiefe : ' + inttostr(infoheader.biBitCount)); listbox1.items.add('Farbanzahl: ' + inttostr(infoheader.biClrUsed)); end; end;

HINWEIS: Die Farbtiefe wird in Bits/Pixel zurückgegeben (1 = Schwarz-Weiß, 4 = 16 Farben,

8 = 256 Farben ...).

Test Laden Sie eine beliebige Bitmap und lassen Sie sich deren Farbtiefe anzeigen:

19.13 Mit großen Grafiken arbeiten

1113

19.11 Eine RGB-Grafik manipulieren Lesen Sie dazu bitte Abschnitt 15.2 im Grundlagenteil dieses Buchs!

19.12 Die Scanline-Eigenschaft verwenden Lesen Sie dazu bitte Abschnitt 15.2 im Grundlagenteil dieses Buchs!

19.13 Mit großen Grafiken arbeiten Mit der Image-Komponente stellt Delphi ein leistungsfähiges Control für die Grafikausgabe zur Verfügung. Solange die Grafik relativ klein ist, treten auch keinerlei Probleme auf. Mit zunehmender Größe wird die Darstellung jedoch immer langsamer. Kommen Sie dann noch auf die Idee, die Grafik zu vergrößern (um z.B. eine Zoom-Ansicht zu erhalten), "steht" der Rechner. Dass es auch anders geht, soll unsere kleine Applikation zeigen. Als "schlechtes Beispiel" ist auch eine Realisierung mittels Image-Komponente enthalten. Laden Sie einmal die mitgelieferte Grafik in das Image und vergleichen Sie die Darstellungsgeschwindigkeit mit den anderen Beispielen!

Oberfläche Den Aufbau der Oberfläche entnehmen Sie bitte der folgenden Abbildung. Das Image ist in eine ScrollBox eingefügt, um auch die nicht sichtbaren Bereiche der Grafik darstellen zu können. Für die anderen Beispiele verwenden wir statt einer Image-Komponente eine Paintbox. Diese ist schneller und verbraucht nicht so viele Ressourcen. Auf eine Scrollbox können wir hier locker verzichten, wir nehmen "einfache" Scrollbars. Den OpenDialog verwenden wir zum Laden einer beliebigen BMP-Datei. HINWEIS: Die Stretch-Eigenschaft des Image müssen Sie auf True setzen, um ein Vergrößern

der Grafik zu ermöglichen.

1114

Kapitel 19

How-to: Grafikprogrammierung

Quelltext Für die erweiterten Funktionen brauchen wir zwei Variablen, die in Unit1 zu deklarieren sind: ... implementation uses Windows; var rec : TRect; bitmap : TBitmap;

HINWEIS: Die folgenden Listings sind thematisch geordnet, die Reihenfolge entspricht deshalb

nicht dem Programmlisting. 1. Image-Komponente Wie bereits versprochen, wollen wir auf ein schlechtes Beispiel nicht verzichten: die Image-Komponente. Ist der Aufruf des OpenDialogs erfolgreich gewesen (eine Bilddatei wurde ausgewählt), können wir mit der LoadFromFile-Methode die Grafik in das Image laden. Das nachfolgende Verändern von AutoSize bzw. Width und Height verfolgt den Zweck, die Grafik auf doppelte Größe zu skalieren. procedure TForm1.Button2Click(Sender: TObject); begin if OpenDialog1.Execute then begin Screen.Cursor:=CrHourGlass; Image2.Autosize := True; Image2.Picture.LoadFromFile(openDialog1.fileName);

19.13 Mit großen Grafiken arbeiten

1115

Image2.AutoSize := False; Image2.Width := Image2.Width * 2; Image2.Height := Image2.Height * 2; Screen.Cursor:=CrDefault end end;

Um das Verschieben mit Hilfe der Scrollbars brauchen wir uns in diesem Beispiel nicht zu kümmern, die ScrollBox nimmt uns diese Aufgabe ab (wenigstens ein Vorteil). 2. CopyRect-Methode Die folgende Variante verwendet ausschließlich Methoden des Canvas-Objekts und ist schon relativ schnell. Der Aufwand gegenüber der Image-Komponente erhöht sich jedoch. Bevor wir eine Grafik laden können, müssen wir die Objektvariable Bitmap initialisieren. Dies geschieht mit TBitmap.Create. Wie auch beim vorangegangenen Beispiel können wir die Grafik über die LoadFromFile-Methode in die Bitmap laden. Zu diesem Zeitpunkt wird jedoch noch keine Grafik auf dem Bildschirm dargestellt, Bitmap ist ein unsichtbares Objekt und existiert nur im Speicher! Wir brauchen eine Methode, um einen Teilausschnitt von Bitmap in das Image einzublenden. Das Canvas-Objekt verfügt mit CopyRect über die gewünschte Funktion. Übergeben wird das Zielrechteck, die Quelle (d.h. Bitmap) und das Quellrechteck. Wozu zweimal das Rechteck? Die Antwort ist schnell gefunden, wenn Sie unterschiedliche Rechtecke verwenden. Der Ausschnitt der Quellgrafik wird so skaliert, dass er in das Zielrechteck hineinpasst. Es kann sich sowohl um eine Verkleinerung als auch um eine Vergrößerung handeln. procedure TForm1.Button1Click(Sender: TObject); begin rec:= bounds(0,0,image1.clientwidth,image1.clientheight); if opendialog1.execute then begin Bitmap := TBitmap.Create; screen.cursor:= CrHourGlass; bitmap.loadfromfile(opendialog1.filename); scrollbar1.max := Bitmap.height-image1.height; scrollbar2.max := Bitmap.width-image1.width; image1.canvas.copyrect(rec,bitmap.canvas,rec); screen.cursor:= CrDefault end end;

Nach Ausführung der obigen Prozedur ist die Bitmap zwar auf dem Bildschirm, den sichtbaren Ausschnitt können wir jedoch noch nicht verschieben. Dafür brauchen wir die Scrollbars, deren Maximalwerte wir bereits so festgelegt haben, dass der noch fehlende Bildausschnitt sichtbar gemacht werden kann.

1116

Kapitel 19

How-to: Grafikprogrammierung

scrollbar2.max

scrollbar1.max

sichtbarer Ausschnitt

Hintergrundbitmap

Im Change-Event der beiden Scrollbars wird die folgende Prozedur aufgerufen: procedure anzeige; var rec1:TRect; begin with form1 do begin rec1:= bounds(scrollbar2.position,scrollbar1.position, image1.clientwidth,image1.clientheight); image1.canvas.copyrect(rec,bitmap.canvas,rec1) end end;

Eigentlich passiert nichts anderes als beim Laden, nur dass diesmal die Positionen der Scrollbars berücksichtigt werden. 3. BitBlt-Funktion Mit der BitBlt-Funktion verlassen wir den "sicheren Boden" der Delphi-Methoden und wenden uns den direkt von Windows zur Verfügung gestellten GDI-Funktionen zu. Im Unterschied zu den vorangegangenen Beispielen brauchen wir diesmal eine Paintbox als Ausgabe-Komponente, ansonsten ändert sich nicht viel. Die Methode CopyRect wird durch die Funktion BitBlt ersetzt. Die Funktion erwartet ein Handle für den Gerätekontext (HDC). Dieses können Sie über die Eigenschaft Handle des Canvas-Objekts ermitteln. procedure TForm1.Button3Click(Sender: TObject); begin if opendialog1.execute then begin Bitmap := tBitmap.create; screen.cursor:=CrHourGlass; bitmap.loadfromfile(opendialog1.filename); scrollbar4.max :=Bitmap.height-paintbox1.height; scrollbar3.max :=Bitmap.width-paintbox1.width; BitBlt(paintbox1.canvas.handle, 0, 0, paintbox1.clientwidth, paintbox1.clientheight,bitmap.canvas.handle,scrollbar3.position,

19.13 Mit großen Grafiken arbeiten

1117

scrollbar4.position, SRCCOPY); screen.cursor:=CrDefault end end;

Für den Typ der Rasteroperation setzen wir SRCCOPY ein, jedes Pixel der Ziel-Bitmap wird durch die Quell-Bitmap überschrieben. Für die Scrollbars gelten analog die Ausführungen zu CopyRect. procedure anzeige2; var rec1 : TRect; begin with form1 do BitBlt(paintbox1.canvas.handle, 0,0,paintbox1.clientwidth, paintbox1.clientheight,bitmap.canvas.handle,scrollbar3.position, scrollbar4.position, SRCCOPY) end;

4. StretchBlt-Funktion In den beiden letzten Beispielen wurde die Hintergrund-Bitmap 1:1 auf die Vordergrund-Bitmap abgebildet, eine Zoomfunktion ließ sich auf diese Weise nicht realisieren. Um den gleichen Effekt wie in Beispiel 1 zu erreichen (die Zoomfunktion, nicht den langsamen Grafikaufbau!), verwenden wir statt BitBlt die Funktion StretchBlt. Werden dieser unterschiedliche Größen für Quell- und Zielrechteck übergeben, wird die Ziel-Bitmap im entsprechenden Verhältnis skaliert. procedure TForm1.Button4Click(Sender: TObject); begin if opendialog1.execute then begin Bitmap := tBitmap.create; screen.cursor:=CrHourGlass; bitmap.loadfromfile(opendialog1.filename); scrollbar5.max :=Bitmap.height-paintbox2.height; scrollbar6.max :=Bitmap.width-paintbox2.width; stretchBlt(paintbox2.canvas.handle, 0, 0, paintbox2.clientwidth, paintbox2.clientheight,bitmap.canvas.handle, scrollbar6.position, scrollbar5.position, paintbox2.clientwidth div 2,paintbox2.clientheight div 2,SRCCOPY); screen.cursor:=CrDefault end end;

Für den Zoomfaktor verwenden Sie sinnvollerweise Integerwerte. Die Ganzzahldivision div erspart uns die Umwandlung in einen Integerwert mittels Round. procedure anzeige3; var rec1 : TRect; begin with form1 do begin stretchBlt(paintbox2.canvas.handle, 0, 0, paintbox2.clientwidth,

1118

Kapitel 19

How-to: Grafikprogrammierung

paintbox2.clientheight,bitmap.canvas.handle,scrollbar6.position, scrollbar5.position, paintbox2.clientwidth div 2, paintbox2.clientheight div 2, SRCCOPY) end end;

Die Darstellung ließe sich vor allem im Zoom-Modus noch weiter beschleunigen1, wenn nur der Bereich neu kopiert werden würde, der vorher verdeckt war. Der Rest müsste im entsprechenden Verhältnis verschoben werden. Doch dazu mehr im Rezept: Ä 19.15 Einen Bildausschnitt scrollen

Test Starten Sie das Programm, und laden Sie eine Grafik:

19.14 Gedrehten Text ausgeben Wenn Sie ein Diagramm oder eine Zeichnung beschriften möchten, vermissen Sie die Möglichkeit, Texte in beliebigem Drehwinkel auszugeben. Nach einer Eigenschaft Font.Angle werden Sie vergeblich suchen. Um ein Ergebnis wie in der unten stehenden Abbildung zu erreichen, müssen Sie schon etwas tiefer in die Windows-Trickkiste greifen. Vielleicht sind Sie auch schon auf die Idee gekommen, eine entsprechende Funktion im Windows-GDI zu suchen. Doch die vorhandene GDI1

Allerdings spielt hier die Grafikkarte eine nicht zu vernachlässigende Rolle. Je nach Typ werden die Grafikoperationen unterschiedlich beschleunigt.

19.14 Gedrehten Text ausgeben

1119

Funktion TextOut hat leider keine Parameter für Drehrichtung oder Schrifthöhe. Dies ist allerdings kein Beinbruch. Alle GDI-Ausgabefunktionen greifen auf vordefinierte Objekte wie zum Beispiel Schriften, Pinsel oder Stifte zu. Die Definition dieser Objekte bleibt dem Programmierer überlassen. Ausnahme: die vordefinierten Objekte, die mit GetStockObject abgerufen werden können. Neben der für unser Programm benötigten Funktion CreateFont gibt es noch eine Reihe anderer Funktionen, auf die wir aber an dieser Stelle nicht weiter eingehen wollen. Die Funktion CreateFont gibt einen Handle auf die erzeugte Schriftart zurück (hFont). An dieser Stelle eine kleine Einschränkung: Es lassen sich nur TrueType-Schriftarten drehen, was aber zu verschmerzen ist. Muss es unbedingt eine "Nicht-TrueType"-Schriftart sein, geben Sie den Text in einem TBitmap-Objekt aus und kopieren dann diese Bitmap mit Hilfe der GDI-Funktion PlgBlt in den gewünschten Ausgabe-Canvas. Weitere Details finden Sie in Ä 19.17 Eine Bitmap drehen Mit der Funktion SelectObject übernehmen wir den "neuen" Font für unser Ausgabegerät, danach kann das Handle auf den virtuellen Font verworfen werden (DeleteObject).

Quelltext Die eigentliche Textausgabe erfolgt mit der Funktion TextOut. Length(Text) bestimmt die Stringlänge. Werte von 0 sind unzulässig, deshalb die Prüfung auf einen Leerstring am Anfang der Prozedur. Ausgaberoutine ist die Prozedur DC_Textout. Übergeben Sie die Koordinaten, den Drehwinkel und die Größe sowie den Ausgabetext: procedure DC_TextOut(x,y,winkel,groesse:integer;txt:string); var hfont, fontold : Integer; dc : hdc; fontname : string; begin if length(txt)= 0 then exit; dc := Screen.ActiveForm.Canvas.handle; fontname := Screen.ActiveForm.Canvas.font.name; hfont := CreateFont(-groesse,0,winkel*10,0,fw_normal, 0,0,0,1,4,$10, 2,4,PChar(fontname)); fontold := SelectObject(dc,hfont); TextOut(dc,x,y,PChar(txt),length(txt)); SelectObject(dc, fontold); DeleteObject(hfont); end;

Über die Eigenschaft Screen.ActiveForm.Canvas.Handle ermitteln wir den Gerätekontext des aktiven Fensters. Diesen brauchen wir für die GDI-Funktionen, um das Ausgabegerät eindeutig zu spezifizieren.

1120

Kapitel 19

How-to: Grafikprogrammierung

HINWEIS: Beachten Sie, dass der bisher gesetzte Font gesichert wird und nach der Zeichen-

operation wiederhergestellt werden muss, andernfalls kann es zu unangenehmen Problemen kommen. Vergessen Sie nicht, den neu erstellten Font wieder zu löschen, es stehen nicht unbegrenzt Systemressourcen zur Verfügung. In unserem Beispiel wird die Grafik mit jeder Größenänderung des Fensters erneut ausgegeben, dazu müssen Sie das Resize-Ereignis verwenden: procedure TForm1.FormResize(Sender: TObject); var i,n,x,y : Integer; begin Refresh; n := 60; i := 0; x := clientWidth div 2; y := clientHeight div 2; while i < 500 do begin if n > 10 then Dec(n,2) else if n > 2 then dec(n); DC_textOut(x, y, i, n, ' rotierender Text'); Inc(i,15); end; end;

Die Zeile if n > 10 then Dec(n,2) else if n > 2 then Dec(n);

passt die Änderung der Schriftgröße dynamisch an, sind die Fonts kleiner, ändert sich die Schriftgröße nicht mehr so stark.

Test

19.15 Einen Bildausschnitt scrollen

1121

Bemerkung Um die Grafikausgabe, z.B. in einem CAD-Programm, zu beschleunigen, sollten Sie alle Zeichenoperationen mit jeweils einem Font zusammenfassen. Erst danach erzeugen Sie einen neuen Font oder restaurieren den alten.

19.15 Einen Bildausschnitt scrollen Für die Programmierung von Grafikanimationen, Zeichenroutinen etc. werden Sie nach einer Möglichkeit suchen, den Bildhintergrund zu bewegen. Im Folgenden bieten wir Ihnen gleich drei Varianten zur Auswahl an: ■ Verschieben über die Delphi-Methoden ■ Verschieben von Bildausschnitten mit der GDI-Funktion BitBlt ■ Kombination der GDI-Funktionen ScrollDC und BitBlt Welches Verfahren das optimale ist, kann nicht eindeutig beantwortet werden. In jedem Fall sind die beiden letztgenannten die leistungsfähigeren. In Abhängigkeit davon, ob Ihre Grafikkarte BitBlt-Funktionen unterstützt (Beschleunigerkarte), erhalten Sie unterschiedliche Ergebnisse.

Oberfläche Neben der eigentlichen Ausgabefläche, einer PaintBox, brauchen Sie noch eine Image-Komponente, in die Sie bereits zur Entwurfszeit eine Bitmap laden (siehe Abbildung).

1122

Kapitel 19

How-to: Grafikprogrammierung

Das Image funktioniert quasi wie ein Container, zur Laufzeit wird es ausgeblendet, die Grafik kann jedoch in die Paintbox kopiert werden. Auf diese Weise ersparen wir uns das Laden der Grafik aus einer Datei.

Quelltext An dieser Stelle müssen wir Sie prophylaktisch davor warnen, die ProcessMessages-Anweisung aus einem der folgenden Listings zu entfernen. Sie haben dann keine Möglichkeit mehr, das Programm sinnvoll zu beenden (außer über den Task-Manager). Innerhalb der Unit deklarieren Sie eine Statusvariable vom Typ Boolean: unit Unit1; interface ... implementation {$R *.DFM} var run : boolean;

Hinter den Buttons findet sich in allen Fällen der folgende Code: run := not run; if run then prozess2;

Lediglich die aufgerufenen Prozeduren unterscheiden sich. Über die Variable run können Sie die im Folgenden beschriebenen Prozeduren starten und auch beenden. 1. Draw-Methode Nach dem Laden der Bitmap in die Paintbox wird in einer Endlosschleife das Bild immer wieder von rechts nach links verschoben. Dies geschieht so lange, bis durch einen der Buttons die Variable run zurückgesetzt wird. Damit auch noch andere Anwendungen zum Zuge kommen (bzw. damit unsere Anwendung überhaupt reagiert), müssen wir mit processMessages etwas Rechenzeit freigeben. Im vorliegenden Beispiel wird nur bei jedem vierzigsten Durchlauf Rechenzeit freigegeben. Starten Sie einmal zwei Instanzen dieses Programms gleichzeitig und Sie werden feststellen, dass beide Anwendungen sehr stark ruckeln. Um dem abzuhelfen, geben Sie einfach bei jedem Durchlauf Rechenzeit frei. Beide Instanzen laufen dann zwar etwas langsamer, jedoch ruckelfrei. procedure prozess1; var breite,hoehe,i:integer; begin form1.paintbox1.canvas.draw(0,0,form1.image1.picture.bitmap); breite := form1.image2.width; hoehe := form1.image2.height; i := 0; repeat; if i mod 40 = 0 then application.processmessages; form1.paintbox1.canvas.draw(-i,0,form1.image1.picture.bitmap);

19.15 Einen Bildausschnitt scrollen

1123

form1.paintbox1.canvas.draw(form1.image1.clientwidthi,0,form1.image1.picture.bitmap); inc(i); if i = breite then i := 0; until not run; end;

Wenn wir mit der Draw-Methode arbeiten, können wir die Bitmap nicht innerhalb der Paintbox verschieben, wir müssen die Grafik bei jedem Durchlauf aus der Image-Komponente nachladen. Dies dürfte auch der Grund dafür sein, dass diese Methode nicht so schnell wie die beiden folgenden ist. 2. BitBlt-Funktion In diesem Beispiel kopieren wir mittels BitBlt-Funktion einen Teil der Bitmap in Paintbox1 um einen Pixel nach links, die fehlende Spalte am rechten Rand füllen wir aus Image1 auf. Diese Operation kann die Grafikkarte bzw. der Prozessor sehr schnell ausführen, handelt es sich doch einfach um eine Verschiebung im Speicher. Einige Grafikkarten unterstützen ein "Hardware-BitBlt", in diesem Fall ist eine wesentliche Beschleunigung gegenüber der ersten Methode zu erwarten. procedure prozess2; var breite,hoehe,i:integer; begin form1.paintbox1.canvas.draw(0,0,form1.image1.picture.bitmap); breite := form1.paintbox1.width; hoehe := form1.paintbox1.height; i := 0; repeat; if i mod 40 = 0 then application.processmessages; BitBlt(form1.paintbox1.canvas.handle, 0, 0, breite-1,hoehe, form1.paintbox1.canvas.handle, 1, 0, SRCCOPY); BitBlt(form1.paintbox1.canvas.handle, breite-1, 0, 1,hoehe, form1.image1.canvas.handle, i, 0, SRCCOPY); inc(i); if i = breite then i := 0; until not run; end;

3. ScrollDC + BitBlt-Funktion Diese Kombination ist die wohl effektivste Möglichkeit, eine Bitmap zu scrollen. Statt mit BitBlt wird der größte Teil der Bitmap mit ScrollDC verschoben. Die fehlende Spalte am rechten Rand füllen wir, wie auch im vorigen Beispiel, mit BitBlt auf. Bei den Autoren hat diese Methode die besten Ergebnisse gebracht: Acht Instanzen liefen ruckelfrei über den Screen! procedure prozess3; var breite,hoehe,i:integer; rec,rec1 : Trect; begin form1.paintbox1.canvas.draw(0,0,form1.image1.picture.bitmap); breite := form1.paintbox1.width;

1124

Kapitel 19

How-to: Grafikprogrammierung

hoehe := form1.paintbox1.height; i := 0; rec := bounds(0,0,breite-1,hoehe); repeat; if i mod 40 = 0 then application.processmessages; scrolldc(form1.paintbox1.canvas.handle,-1,0,rec,rec,0,@rec1); BitBlt(form1.paintbox1.canvas.handle, rec1.left, 0, 1,hoehe, form1.image1.canvas.handle, i, 0, SRCCOPY); inc(i); if i = breite then i := 0; until not run; end;

Quasi als Alternative möchten wir Ihnen noch eine weitere Realisierungsmöglichkeit vorstellen, die zwar auch auf der ScrollDC-Funktion basiert, aber statt der Verwendung von Application.ProcessMessages einen zweiten Thread erzeugt, der für die Ausgabe verantwortlich ist. Auf diese Weise bleibt Ihre Anwendung ebenfalls reaktionsfähig, allerdings ist jetzt nicht Ihre Anwendung, sondern das System für die Zuteilung von Rechenzeit verantwortlich. Als Erstes brauchen Sie eine zweite Unit, die die Klassendefinition des Threads aufnimmt: unit Unit2; interface uses Classes,windows; type TAnzeige = class(TThread) private breite,hoehe,i:integer; rec,rec1 : TRect; protected procedure Show; procedure Execute; override; end; implementation uses unit1; procedure TAnzeige.Execute; begin breite := form1.image2.width; hoehe := form1.image2.height; i := 0; rec := bounds(0,0,breite-1,hoehe); while True do begin Synchronize(Show); inc(i); if i = breite then i := 0; if Terminated then exit; end; end;

19.16 Bitmaps manipulieren

1125

Wie bekannt ist, können Sie auf Eigenschaften und Methoden von VCL-Objekten nicht direkt aus der Execute-Methode zugreifen. Nur mit Hilfe der Methode Synchronize lässt sich die eigentliche Anzeigeprozedur aufrufen. procedure TAnzeige.Show; begin scrolldc(form1.image2.canvas.handle,-1,0,rec,rec,0,@rec1); BitBlt(form1.image2.canvas.handle, rec1.left, 0, 1,hoehe, form1.image1.canvas.handle, i, 0, SRCCOPY); end;

Zum Erzeugen des Thread verwenden wir den Konstruktor Create: run := not run; if button1.enabled then begin form1.image2.canvas.draw(0,0,form1.image1.picture.bitmap); anzeige := TAnzeige.Create(False); anzeige.FreeOnTerminate:= True;

An dieser Stelle können Sie die Priorität des Thread beeinflussen: anzeige.priority := tpnormal; end else anzeige.terminate; button1.enabled := not button1.enabled; button2.enabled := not button2.enabled; button3.enabled := not button3.enabled;

Test Starten Sie einmal mehrere Instanzen der letzten Programmvariante und vergleichen Sie die Anzeigegeschwindigkeit mit den übrigen Versionen!

19.16 Bitmaps manipulieren Dass Sie mit StretchtBlt und BitBlt Bitmaps mehr als nur scrollen und kopieren können, soll Ihnen dieses Beispiel zeigen. Die Funktionen im Einzelnen: ■ Invertieren einer Bitmap ■ Spiegeln um die vertikale Achse ■ Spiegeln um die horizontale Achse ■ Austauschen einer Farbe gegen eine andere Besonders Grafikprogramme machen von diesen zusätzlichen Möglichkeiten regen Gebrauch. Alle oben genannten Verfahren müssen sich natürlich nicht auf die gesamte Bitmap auswirken, es ist auch möglich, nur Teile der Bitmap zu verändern. Siehe dazu auch Ä 19.18 Eine Lupenfunktion programmieren

1126

Kapitel 19

How-to: Grafikprogrammierung

Oberfläche Alle Operationen werden an einer Bitmap ausgeführt, Sie brauchen also bloß eine Image-Komponente zur Aufnahme der Grafik, vier Buttons für die Auswahl des jeweiligen Verfahrens sowie eine Farbpalette. Mit Letzterer können Sie die zu tauschenden Farben auswählen (die Vordergrundfarbe wird in die Hintergrundfarbe konvertiert). Die Palette bedienen Sie mit der rechten bzw. linken Maustaste.

Quelltext Alle Methoden wurden in einzelnen Prozeduren gekapselt, auf diese Weise ist eine einfache Übertragung in andere Programme möglich. Da Zeichenoperationen am besten in "unsichtbaren" Objekten vorgenommen werden sollten, wurde als Übergabeparameter für die Prozeduren der Objekttyp TBitmap gewählt. Sie können sowohl eine Variable dieses Typs deklarieren, als auch die BitmapEigenschaft eines Picture-Objekts verwenden. Das Invertieren kann mit der Funktion BitBlt erfolgen. Ziel- und Quell-Bitmap sollten die gleiche Größe aufweisen. Ist das nicht der Fall, kann es passieren, dass nur ein Teil der Ziel-Bitmap invertiert wird. Weitere Verknüpfungsoperatoren zum BitBlt-Befehl finden Sie am Ende dieses Abschnitts. procedure Invertieren(quelle,ziel:TBitmap); begin ziel.width := quelle.width; ziel.height:= quelle.height; BitBlt(ziel.canvas.handle,0,0,ziel.width ,ziel.height,quelle.canvas.handle, DSTINVERT); end;

0,0,

Die beiden Spiegel-Operationen erfordern eine Überschneidung der Koordinatenangaben von Zielund Quell-Bitmap. Beim horizontalen Spiegeln müssen die Quellkoordinaten in x-Richtung negativ angegeben werden, beim vertikalen Spiegeln die y-Koordinaten. Obwohl beide Bitmaps gleich groß sind, kommen wir nicht um die StretchBlt-Funktion herum, wir könnten sonst nicht die Breite der Quell-Bitmap bestimmen. procedure SpiegelnHorizontal(quelle,ziel:TBitmap); begin ziel.width := quelle.width; ziel.height:= quelle.height;

19.16 Bitmaps manipulieren

1127

StretchBlt(ziel.canvas.handle,0,0, ziel.width, ziel.height, quelle.canvas.handle,quelle.width, 0, -quelle.width,quelle.height, SRCCOPY); end; procedure SpiegelnVertikal(quelle,ziel:TBitmap); begin ziel.width := quelle.width; ziel.height:= quelle.height; StretchBlt(ziel.canvas.handle, 0, 0, ziel.Width, ziel.Height, quelle.canvas.handle, 0, quelle.Height, quelle.Width,-quelle.Height, SRCCOPY); end;

Bevor die Methode zum Farbtausch ausgeführt werden kann, sichern wir den Status der Hintergrundfarbe, d.h. Brush.Color. Über die Zuweisung des Rechtecks an Rect können Sie den gewünschten Ausschnitt wählen, in unserem Fall die gesamte Bitmap. procedure Farbwechsel(bitmap:TBitmap;vorher,nachher:TColor); var Rect :TRect; h :TColor; begin h := bitmap.canvas.brush.color; Rect := bounds(0,0,bitmap.width,bitmap.height); bitmap.canvas.brush.color:= nachher; bitmap.canvas.BrushCopy(Rect,Bitmap, Rect, vorher); bitmap.canvas.brush.color := h; end;

Die folgenden Prozeduren bzw. Events werden durch die jeweiligen Tasten ausgelöst. Der Aufruf der Refresh-Methode ist notwendig, um die Bitmap auf den Bildschirm zu bringen. procedure TForm1.Button1Click(Sender: TObject); begin invertieren(image1.picture.bitmap,image1.picture.bitmap); image1.refresh; end; procedure TForm1.Button2Click(Sender: TObject); begin spiegelnHorizontal(image1.picture.bitmap,image1.picture.bitmap); image1.refresh; end; procedure TForm1.Button3Click(Sender: TObject); begin spiegelnVertikal(image1.picture.bitmap,image1.picture.bitmap); image1.refresh; end; procedure TForm1.Button4Click(Sender: TObject); var h :integer; begin Farbwechsel(image1.picture.bitmap,colorgrid1.foregroundcolor,

1128

Kapitel 19

How-to: Grafikprogrammierung

colorgrid1.backgroundcolor); image1.refresh; h := colorgrid1.foregroundindex; colorgrid1.foregroundindex:= colorgrid1.backgroundindex; colorgrid1.backgroundindex := h; end;

Test

Bemerkungen ■ Weitere Möglichkeiten der Bitmap-Manipulation eröffnen sich mit den Parametern der BitBltbzw. StretchBlt-Funktion. ■ Setzen Sie die Eigenschaft Monochrome auf True, wird eine farbige in eine einfarbige Bitmap konvertiert. Alle Farben werden schwarz, Weiß bleibt erhalten. ■ Siehe auch Ä 19.17 Eine Bitmap drehen Ä 19.23 Spezialeffekte erzeugen

19.17 Eine Bitmap drehen Eine Bitmap spiegeln ist kein Problem, doch wie kann man eine Bitmap um einen beliebigen Winkel drehen? Das Drehen jedes einzelnen Pixels kostet sehr viel Rechenzeit! In die 32-Bit-API haben die Microsoft-Programmierer mit PlgBlt deshalb eine fertige Funktion integriert, die auch mit ihrer Performance durchaus überzeugen kann. Allerdings steht diese Funktion nur unter Windows 2000/XP zur Verfügung! Ihre Aufgabe als Programmierer besteht lediglich darin, die Positionen der drei Punkte P(1), P(2), P(3) zu berechnen und zu übergeben. Neben einfachen Drehungen lassen sich auf diese Weise auch Verzerrungen realisieren. Sie berechnen einfach ein Trapez, in das die Grafik hineinskaliert werden soll. Die Abbildung zeigt das Grundprinzip:

1129

19.17 Eine Bitmap drehen

P(1)

P(2)

P(3)

Beachten Sie die Reihenfolge der Werte bei der Übergabe: ■ linke obere Ecke P(1) ■ rechte obere Ecke P(2) ■ linke untere Ecke P(3)

Oberfläche Auf einem Formular platzieren Sie eine Image-Komponente und einen Timer.

Quelltext Variablen: var punkte : array[0..2] of TPoint; winkel : double;

Die eigentliche Berechnung: procedure TForm1.berechnePunkte; var si, co : double; begin si := Sin(winkel); co := Cos(winkel); // linke obere Ecke punkte[0].x := ClientWidth div 2; punkte[0].y := ClientHeight div 2; // rechte obere Ecke punkte[1].x := Round(ClientWidth div 2 + image1.clientWidth * co); punkte[1].y := Round(ClientHeight div 2 + image1.clientWidth * si); // linke untere Ecke punkte[2].x := Round(ClientWidth div 2 - image1.clientHeight * si); punkte[2].y := Round(ClientHeight div 2 + image1.clientHeight * co); end;

1130

Kapitel 19

How-to: Grafikprogrammierung

Über den Timer wird die Grafik zyklisch in einem neuen Winkel gezeichnet: procedure TForm1.Timer1Timer(Sender: TObject); begin berechnePunkte; PlgBlt(canvas.handle, punkte[0], image1.picture.bitmap.canvas.handle, 0, 0, image1.ClientWidth, image1.ClientHeight,0,0,0); winkel := winkel - PI / 100 end;

Test Nach dem Programmstart beginnt sofort die langsame Rotation der Grafik:

Bemerkung Ausführliche Informationen zum Rotieren von Vektorgrafiken finden Sie im Grundlagenteil dieses Buchs.

19.18 Eine Lupenfunktion programmieren Das folgende Beispiel beschäftigt sich mit zwei Problemen: ■ Vergrößerung eines Bitmap-Ausschnitts ■ Beschränkung von Grafikoperationen auf einen bestimmten Bereich Für das erste Problem werden Sie in der Delphi-Hilfe schnell eine Antwort finden, für das zweite müssen Sie sich schon intensiv mit der API beschäftigen. Unter Windows ist es möglich, eine Grafikoperation, z.B. LineTo(100,100), auf einen bestimmten Bereich zu beschränken. Der restliche Teil der Bitmap wird von dieser Operation nicht betroffen. Dazu werden so genannte Regions verwendet. Welche Form diese haben, können Sie selbst bestimmen. Auch Delphi macht davon Gebrauch, verwendet jedoch nur eine einfache Form, das Recht-

1131

19.18 Eine Lupenfunktion programmieren

eck. Wir wollen eine etwas aufwändigere Form benutzen: einen Kreis. Die Linse einer Lupe ist im Allgemeinen auch rund. Möchten Sie kompliziertere Formen als z.B. die grafischen Primitive Ellipse und Rechteck verwenden, können Sie Regionen auch über ein Polygon definieren. Zusätzlich lassen sich Regionen auch kombinieren:

CombineRgn

RGN_AND

RGN_COPY

RGN_DIFF

RGN_OR

RGN_XOR

Oberfläche Für die Oberfläche brauchen wir drei Image-Komponenten. Image1 nimmt die zu vergrößernde Grafik auf, Image2 dient der Zoomdarstellung und der Anzeige der Lupe, und Image3 ist der Container für die Abbildung "Lupe". Der Inhalt von Image3 wird zur Laufzeit in Image2 kopiert. Image3 selbst ist zur Laufzeit nicht sichtbar. Über die ComboBox kann zur Laufzeit der Zoomfaktor gewählt werden, tragen Sie die gewünschten Werte ein (z.B. 1, 2, 3, 4 etc.).

1132

Kapitel 19

How-to: Grafikprogrammierung

Quelltext Beim Laden des Fensters wird Image2 skaliert, danach kann die Grafik "Lupe" kopiert werden. procedure TForm1.FormCreate(Sender: TObject); begin image2.width := image3.picture.bitmap.width; image2.height:= image3.picture.bitmap.height; image2.canvas.draw(0,0,image3.picture.bitmap); end;

Mit jeder Mausbewegung über der großen Abbildung soll der Ausschnitt unter dem Mauscursor in Image2 vergrößert dargestellt werden. Dazu verwenden wir die StretchBlt-Funktion. Die Region schränkt die Ausgabe auf einen kreisförmigen Ausschnitt ein. Ein Problem sind die Ränder der Grafik, an diesen Stellen kann auch mit StrechBlt nichts vergrößert bzw. angezeigt werden. Wir löschen daher den Bereich vor dem Zeichnen (BitBlt). Die Region muss mit jedem Durchlauf erneut erzeugt und gelöscht werden. Ursache ist die RefreshMethode, die alle Objekte wieder zurücksetzt, dies trifft auch auf die Region zu. procedure TForm1.Image1MouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer); var r : Integer; rhandle : Hrgn; begin r := 140 div ((combobox1.itemindex+1) * 2); rhandle := CreateEllipticRgn(13,12,146,147); SelectObject(image2.canvas.handle,rhandle); BitBlt(image2.canvas.handle,13,12,146,147,image2.canvas.handle,0 ,0, blackness); StretchBlt(image2.canvas.handle,10,10,150,150, image1.picture.bitmap.canvas.handle,x-r ,y-r,2*r,2*r, SRCCOPY); image2.refresh; DeleteObject(rhandle) end;

Test

19.19 Polygone zeichnen

1133

19.19 Polygone zeichnen Das folgende Progrämmchen zeigt, wie Sie mit Polygonen umgehen können. Leider hat die Polygon-Methode des Canvas-Objekts einen wesentlichen Nachteil: Möchte man zur Laufzeit unterschiedliche Polygone zeichnen, haben Sie keine sinnvolle Möglichkeit, der Methode die Anzahl der Ecken zu übergeben (es sei denn, Sie deklarieren pauschal ein genügend großes Array, von dem Sie mit Hilfe der Funktion Slice Teile an die Methode Polygon übermitteln können). Aus diesem Grund verwenden wir die zugehörige GDI-Funktion Polyline, der neben dem PunkteArray auch die Anzahl der Ecken übergeben werden kann.

Oberfläche Lediglich ein Timer, über den wir zyklisch die Form des Polygons verändern, und, wenn Sie wollen, ein Button sind erforderlich.

Quelltext Um nicht unnötig kostbaren Arbeitsspeicher zu verschwenden, greifen wir auf die Möglichkeit zurück, Speicher dynamisch zu belegen. Das Array erstellen wir beim Start (OnCreate) und schließen es über das OnClose-Ereignis. type figurType = array[0..0] of TPoint; var figur : ^figurType; ecken : integer;

Beim Starten: procedure TForm1.FormCreate(Sender: TObject); begin

1134

Kapitel 19

ecken := 2; GetMem(figur,sizeof(figur^[0])*40)

How-to: Grafikprogrammierung

// Speicher reservieren

end;

Für die Berechnung der Ecken brauchen wir einige trigonometrische Funktionen: procedure TForm1.Timer1Timer(Sender: TObject); var i : Integer; begin inc(ecken); if ecken = 40 then ecken :=3; refresh; canvas.brush.color:=color; canvas.textout(10,40,'Anzahl Ecken: ' + inttostr(ecken)); canvas.brush.style:=bsSolid; canvas.brush.color:=clred; for i := 0 To ecken - 1 do begin figur^[i].x := round(clientWidth / 2 + 90 * Cos(i * 2 * PI / ecken)); figur^[i].y := round(clientHeight / 2 + 90 * Sin(i * 2 * PI / ecken)); end;

Aufruf der API-Funktion mit dem nullten Feld und der Anzahl der Ecken: polygon(canvas.handle,figur^[0],ecken) end;

Beim Beenden: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin FreeMem(figur,Sizeof(figur^[0])*40) // Speicher freigeben end;

Test Wenn Sie die Interval-Eigenschaft des Timers auf 600 Millisekunden eingestellt haben, können Sie sich entspannt zurücklehnen und die schrittweise Verwandlung des Polygons in einen Kreis beobachten.

Bemerkung ■ Auch eine PaintBox-Komponente könnten wir verwenden: polygon(PaintBox1.canvas.handle,figur^[0],ecken);

■ Ganz nebenbei haben Sie in diesem Beispiel eine Alternative zu den dynamischen Arrays von Delphi kennen gelernt, die in Ihrer Anwendung sicher einfacher zu handhaben ist. ■ Übrigens erzeugen auch Zeichenprogramme einen Kreis nach dem Prinzip "Polygon mit vielen Ecken".

19.20 Grafiken auf dem Screen ausgeben

1135

19.20 Grafiken auf dem Screen ausgeben Möchten Sie einen Bildschirmschoner à la "After Dark" schreiben? Dann brauchen Sie eine Möglichkeit, direkt auf dem Windows-Desktop zu zeichnen. Das Screen-Objekt von Delphi verfügt weder über entsprechende Methoden noch über ein Handle. Der Grund für diese Einschränkungen ist schnell gefunden, wenn Sie das nachfolgend beschriebene Programm ausprobieren und das Sichern des Desktops ausschalten. Kein Fenster "merkt", dass es übermalt wurde (fehlende Message WM_Paint), und reagiert deshalb auch nicht. Schon nach wenigen Zeichenoperationen ist der Bildschirm (natürlich nur dessen Inhalt!) irreparabel zerstört:

Für die Realisierung werden wir auf GDI-Programmierung nicht verzichten können, im Gegenteil, wir müssen intensiven Gebrauch davon machen. Wir benötigen für die GDI-Grafikausgaben einen Handle auf den Gerätekontext. Für den Screen können wir nicht auf einen vordefinierten DC zugreifen, sondern müssen einen neuen anlegen: dc := CreateDC('DISPLAY', Nil, Nil, Nil); dx := Screen.Width; dy := Screen.Height;

1136

Kapitel 19

How-to: Grafikprogrammierung

Um den Screen nach dieser "Schmiererei" wieder in den alten Zustand zu versetzen, legen wir uns für dessen Sicherung eine Speicher-Bitmap an. Diese Bitmap kann am Programmende wieder zurückkopiert werden: hDestDC := CreateCompatibleDC(dc); hBM := CreateCompatibleBitmap(dc, dx, dy); Hbold := SelectObject(hDestDC, hBM);

Kopieren der Bitmap: BitBlt(hDestDC, 0, 0, dx, dy, dc, 0, 0, SRCCopy);

Für die Linienausgabe definieren wir uns einen neuen Stift (Pen), der etwas breiter als der DefaultStift ist. Durch Variieren der Parameter können Sie auch andere Farben, Breiten und Muster erzeugen. hp := CreatePen(0, 10, 0); ho := SelectObject(dc, hp);

In einer Schleife werden mit Zufallswerten Linien gezeichnet: For i := 1 To 500 do begin LineTo(dc, Round(dx * Random), Round(dy * Random)); Application.ProcessMessages end;

Ein neu erstellter Stift muss nach der letzten Ausgabe wieder gelöscht werden: DeleteObject(SelectObject(dc, ho));

Die Bitmap zurückkopieren BitBlt(dc, 0, 0, dx, dy, hDestDC, 0, 0, SRCCopy);

und beide Gerätekontexte und Bitmap wieder freigeben: SelectObject(dc,hbold); DeleteObject(hbm); deletedc(hDestDC); deletedc(dc) end;

Bemerkung Natürlich lassen sich auch weitaus weniger harmlose Anwendungsmöglichkeiten für unser Programmbeispiel finden. Kombinieren Sie einen Timer (10 Sekunden) in einem nicht sichtbaren Fenster (Hide) mit einer Zeitabfrage und lassen Sie zum Feierabend auf dem PC Ihres Kollegen eine entsprechende Grafik ausgeben. Der Effekt ist verblüffend!

19.21 Ein Koordinatensystem erzeugen

1137

19.21 Ein Koordinatensystem erzeugen Neben dem von Delphi bereitgestellten Koordinatensystem und der GDI-Funktion SetMapMode, Ä 24.5 Eine eigene Druckvorschau realisieren mit der sich nur eine Skalierung bzw. Verschiebung realisieren lässt, steht dem 32-Bit-Programmierer unter Windows NT/2000/XP noch eine weitere, sehr leistungsfähige Funktion zur Verfügung: SetWorldTransform. Neben den Möglichkeiten zum Skalieren und Verschieben können Sie mit dieser Funktion das Koordinatensystem zusätzlich drehen, scheren und spiegeln. HINWEIS: Windows 95/98-Programmierer müssen an dieser Stelle leider passen, lediglich Win-

dows NT/2000/XP bietet dieses Feature. Übergabewerte an die Funktion sind der Gerätekontext und eine Strukturvariable vom Typ XFORM: TXForm = packed record eM11: Single; eM12: Single; eM21: Single; eM22: Single; eDx: Single; eDy: Single; end;

Bevor es jedoch so weit ist, dass Sie Koordinatentransformationen vornehmen können, müssen Sie den erweiterten Grafikmodus mit SetGraphicsMode aktiviert haben. BEISPIEL: Aktivieren des erweiterten Grafikmodus SetGraphicsMode(Canvas.Handle, GM_ADVANCED); ...

Wie Sie die einzelnen Elemente von TXForm verwenden ist im Abschnitt 15.1.2 beschrieben.

Oberfläche Zur Gestaltung der Oberfläche ist nicht viel zu sagen, platzieren Sie einfach ein paar Buttons auf dem Formular und beschriften Sie diese mit "Rotation", "Verschiebung", "Scherung", "Skalierung" und "Normal". Fügen Sie zusätzlich eine Image-Komponente ein, in die Sie eine Bitmap laden.

Quelltext Definition der Variablen: var dc : HDC; XForm : TXForm;

1138

Kapitel 19

How-to: Grafikprogrammierung

In diesem Fall ist es unbedingt nötig, einen eigenen DC zu erzeugen, da für unser Problem ein einheitlicher DC gebraucht wird. Weiterhin dürfen Sie nicht vergessen, in den Advanced-Grafikmodus zu schalten, da sonst alle Bemühungen umsonst sind. procedure TForm1.FormShow(Sender: TObject); begin dc := GetDC(handle); SetGraphicsMode(dc, GM_ADVANCED) end;

Die eigentliche Anzeigefunktion: procedure zeichne; begin MoveToEx(dc, 100, 100, nil); LineTo(dc, 150, 200); Rectangle(dc, 100, 100, 150, 200); BitBlt(dc, 0,0,100,100,form1.image1.picture.bitmap.canvas.handle, 50, 0,SRCCOPY) end;

Verschieben: procedure TForm1.Button2Click(Sender: TObject); begin XFORM.eM11 := 1; XFORM.eM12 := 0; XFORM.eM21 := 0; XFORM.eM22 := 1; XFORM.eDx := 15; XFORM.eDy := 0; ModifyWorldTransform(dc, XFORM, MWT_LEFTMULTIPLY); zeichne end;

Rotation: procedure TForm1.Button1Click(Sender: TObject); begin XFORM.eM11 := 0.9848077530122; XFORM.eM12 := -0.1736481776669; XFORM.eM21 := 0.1736481776669; XFORM.eM22 := 0.9848077530122; XFORM.eDx := 0; XFORM.eDy := 0; ModifyWorldTransform(dc, XFORM, MWT_LEFTMULTIPLY); zeichne end;

Scheren: procedure TForm1.Button3Click(Sender: TObject); begin

1139

19.21 Ein Koordinatensystem erzeugen

XFORM.eM11 := 1; XFORM.eM12 := 1; XFORM.eM21 := 0; XFORM.eM22 := 1; XFORM.eDx := 0; XFORM.eDy := 0; SetWorldTransform(dc, XFORM); zeichne end;

Normales Koordinatensystem: procedure TForm1.Button5Click(Sender: TObject); begin XFORM.eM11 := 1; XFORM.eM12 := 0; XFORM.eM21 := 0; XFORM.eM22 := 1; XFORM.eDx := 0; XFORM.eDy := 0; SetWorldTransform(dc, XFORM); zeichne end;

Skalieren: procedure TForm1.Button4Click(Sender: TObject); begin XFORM.eM11 := 0.9; XFORM.eM12 := 0; XFORM.eM21 := 0; XFORM.eM22 := 0.9; XFORM.eDx := 0; XFORM.eDy := 0; ModifyWorldTransform(dc, XFORM, MWT_LEFTMULTIPLY); zeichne end;

Was wir nicht vergessen sollten: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin ReleaseDC(handle,dc); end;

Der erzeugte Gerätekontext muss natürlich freigegeben werden. Bevor Sie lange über die Bedeutung der Werte für die Rotation nachdenken, können Sie sich auch der folgenden Berechnungen bedienen: XFORM.eM11 := Cos(DegToRad(10)); XFORM.eM12 := Sin(DegToRad(10));

// Drehung um 10°

1140

Kapitel 19

How-to: Grafikprogrammierung

XFORM.eM21 := -Sin(DegToRad(10)); XFORM.eM22 := Cos(DegToRad(10));

Die Umwandlung DegToRad ist nötig, da die Winkelfunktionen von Delphi mit Bogenmaß arbeiten. Binden Sie für die Konvertierungsfunktionen die Unit math ein. Wer auf diese Unit verzichten will, multipliziert einfach den Drehwinkel mit π/180. HINWEIS: Wie Sie obigen Listings entnehmen können, lassen sich die einzelnen Funktionen

auch nacheinander aufrufen, da ModifyWorldTransform bestehende Werte nicht einfach überschreibt, sondern in die Berechnung mit einbezieht.

Test Starten Sie das Programm und probieren Sie die einzelnen Funktionen aus. Variieren Sie die Parameter, und alle offenen Fragen beantworten sich von selbst.

19.22 Bézierkurven darstellen Wer hat nicht schon Grafikprogramme bestaunt, wo Figuren mit Hilfe so genannter Bézierkurven erzeugt werden können? Die Win32-Schnittstelle bietet dem Delphi-Programmierer auch dieses Feature. Wie so oft ist auch hier die Realisierung nur mit GDI-Funktionen möglich.

Oberfläche Um nicht einfach nur eine Kurve auf dem Bildschirm darzustellen, wollen wir das Ganze etwas animieren, d.h., Sie haben die Möglichkeit, zur Laufzeit das Aussehen der Kurve zu beeinflussen, indem Sie sowohl Anfangs- und Endpunkt als auch die beiden Kontrollpunkte verschieben. Der Aufwand sollte allerdings nicht allzu groß sein, deshalb werden wir nur vier Punkte verwenden, obwohl Sie eine Bézierkurve auch aus mehreren Kurvenstücken zusammensetzen können.

19.22 Bézierkurven darstellen

1141

Die Gestaltung der Oberfläche beschränkt sich auf ein Formular sowie vier Panel-Komponenten. Legen Sie die Größe der Komponenten auf 8 x 8 Pixel fest und geben Sie jeder Komponente eine andere Farbe. Fügen Sie weiterhin eine Image-Komponente ein, die wir als Zeichenfläche verwenden werden.

Quelltext In den Deklarationsabschnitt nehmen Sie die folgende Array-Definition auf: var punkte: array [0..3] of TPoint;

Mit dem Laden des Formulars wird das Punkte-Array gefüllt. Dazu verwenden wir die Koordinaten der einzelnen Panel-Komponenten: procedure TForm1.FormCreate(Sender: TObject); begin punkte[0].X := panel1.Left + 4; punkte[0].Y := panel1.TOP + 4; punkte[1].X := panel2.Left + 4; punkte[1].Y := panel2.TOP + 4; punkte[2].X := panel3.Left + 4; punkte[2].Y := panel3.TOP + 4; punkte[3].X := panel4.Left + 4; punkte[3].Y := panel4.TOP + 4; image1.canvas.pen.width := 3; PolyBezier(image1.canvas.handle, punkte[0], 4); end;

Übergeben Sie an die Funktion PolyBezier den HDC, das Punkte-Array sowie dessen Größe in Punkten. Was noch fehlt ist eine Animation, d.h., wenn ein Kontrollpunkt bewegt wird, soll auch die Kurve neu gezeichnet werden. Bevor wir jetzt umständlich eine eigene Routine zum Verschieben der Kontrollpunkte schreiben, nutzen wir doch einfach die Möglichkeit, Komponenten mittels Message in den DragMove-Modus zu schalten, d.h., Sie können eine Komponente wie zur Entwurfszeit verschieben. Alles, was Sie dazu brauchen, ist der folgende Aufruf im MouseDown-Event: (Sender As TPanel).Perform(WM_SysCommand, SC_DragMove, 0);

Das Ganze noch einmal im Zusammenhang: const SC_DRAGMOVE = $F012; procedure TForm1.Panel1MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin (Sender As TPanel).Perform(WM_SysCommand, SC_DRAGMOVE, 0); beep; image1.canvas.pen.color := clwhite;

1142

Kapitel 19

How-to: Grafikprogrammierung

Löschen der bisherigen Linie durch Überzeichnen in der Hintergrundfarbe: PolyBezier(image1.canvas.handle, punkte[0], 4); punkte[0].X := panel1.Left + 4; punkte[0].Y := panel1.TOP + 4; punkte[1].X := panel2.Left + 4; punkte[1].Y := panel2.TOP + 4; punkte[2].X := panel3.Left + 4; punkte[2].Y := panel3.TOP + 4; punkte[3].X := panel4.Left + 4; punkte[3].Y := panel4.TOP + 4; image1.canvas.pen.color := clblack; PolyBezier(image1.canvas.handle, punkte[0], 4); image1.refresh; end;

Test Starten Sie das Programm und verschieben Sie die Ankerpunkte.

19.23 Spezialeffekte erzeugen Zum Erzeugen von speziellen Effekten wie Einblenden von Bitmaps in Schriftarten oder Polygone verwendet man so genannte Clipping-Bereiche. Diese lassen sich unter Win32 auf einfache Weise mittels Path erstellen. Sie erzeugen quasi eine Schablone, legen diese über den Ausgabebereich und zeichnen die Füllmuster ohne Rücksicht auf den restlichen Hintergrund. Durch die "Schablone" beschränken sich die Ausgaben auf den definierten Bereich.

Oberfläche Sie brauchen nur einen Button und eine Image-Komponente, in die Sie eine Bitmap Ihrer Wahl laden (Picture-Eigenschaft). Die Bitmap sollte so breit sein wie der auszugebende Text. Möchten

19.23 Spezialeffekte erzeugen

1143

Sie Speicher sparen, wäre es auch denkbar, dass Sie die Bitmap mehrfach nebeneinander einblenden, in diesem Fall muss sich das Muster jedoch wiederholen. HINWEIS: Zu einigen Grafikprogrammen (z.B. Corel Draw) werden Hintergrundgrafiken mitge-

liefert. Diese lassen sich ohne Musterversatz nebeneinander kopieren.

Quelltext Nach dem Klick auf den Button geht es los: procedure TForm1.Button1Click(Sender: TObject); var y, x : Integer; dc : HDC; begin dc := canvas.handle; SetBkMode(dc,transparent);

Normale Textausgabe ohne jeden Effekt: TextOut(dc, 10, 10, 'Test', 4);

Die Path-Definition: BeginPath(dc); TextOut(dc, 180, 180, 'Test', 4); EndPath(dc);

Auswahl des Path als Clipping-Bereich: SelectClipPath(dc, RGN_COPY);

1144

Kapitel 19

How-to: Grafikprogrammierung

Ausgabe einer Bitmap über dem Path: BitBlt(dc, 18, 180, Image1.clientWidth, image1.clientHeight, image1.picture.bitmap.canvas.handle, 0, 0, SRCCOPY);

Erneute Path-Definition: BeginPath(dc); TextOut(dc, 60, 60, 'Test', 4); EndPath(dc); SelectClipPath(dc, RGN_COPY); y := 0;

Zeichnen von horizontalen Linien: While y < clientHeight do begin inc(y,2); MoveToEx(dc, 0, y, nil); LineTo(dc, clientWidth, y) end; BeginPath(dc); TextOut(dc, 120, 120, 'Test', 4); EndPath(dc); SelectClipPath(dc, RGN_COPY); x := 0; While x < ClientWidth do begin inc(x,3); MoveToEx(dc, x, 0, nil); LineTo(dc, x, clientHeight) end end;

Test Das doch recht beeindruckende Ergebnis sehen Sie in der folgenden Abbildung:

19.24 Verschiedene Stifte erzeugen

1145

Bemerkung Um das Zurücksetzen des Path brauchen Sie sich im obigen Beispiel nicht zu kümmern, da wir einen Delphi-DC verwenden und Delphi den neu definierten Path automatisch zurücksetzt.

19.24 Verschiedene Stifte erzeugen Wer schon unter Win16 mit verschiedenen GDI-Stiften gearbeitet hat, wird sich sicher noch an die Beschränkungen erinnern. Linienenden waren immer rund, ab Linienstärke 2 gab es nur noch VollLinien, von Mustern in Linien ganz zu schweigen. Der Ausweg bestand darin, die Linien mühevoll Punkt für Punkt mit der Funktion LineDDA zu erzeugen. Ganz abgesehen davon ist dieser Weg auch noch recht langsam. Mit der ExtCreatePen-Funktion unter Win32 (nur Windows NT/2000) steht eine leistungsfähige Möglichkeit zum Erzeugen diverser Linientypen zur Verfügung.

Oberfläche Für ein kleines Testprogramm brauchen wir fünf Shape-Controls (die fünf Linien in der Abbildung), fünf ComboBoxen, eine UpDown-Komponente und ein paar Labels. Weiterhin können Sie eine kleine Grafik einfügen (Image), die wir später als Füllmuster verwenden werden.

Die Linien sind als Koordinatenanzeige gedacht, mit der eigentlichen Stiftdefinition haben sie nichts zu tun. Über die Comboboxen werden wir die verschiedenen Linien-Optionen zur Verfügung stellen (die Werte für die Items-Eigenschaft entnehmen Sie bitte dem Beispielprogramm).

1146

Kapitel 19

How-to: Grafikprogrammierung

Quelltext Die eigentliche Zeichenroutine: procedure TForm1.Button1Click(Sender: TObject); var lplb : TLOGBRUSH; newPen, oldpen : HPEN; l : longint; begin

Handelt es sich um einen Pattern-Brush, müssen wir die kleine Bitmap als Füllmuster zuweisen: if combobox5.itemindex = 3 then begin lplb.lbStyle := Combobox5.itemIndex; lplb.lbColor := 0; lplb.lbHatch := image2.picture.bitmap.handle; end else begin lplb.lbStyle := Combobox5.itemIndex; lplb.lbColor := 0; lplb.lbHatch := Combobox2.itemIndex end;

Erzeugen des Stiftes: newpen := ExtCreatePen(PS_GEOMETRIC + Combobox1.itemIndex + Combobox3.itemIndex * $100 + Combobox4.itemIndex * $1000, strtoint(edit1.text), lplb, 0, Nil);

Sollte ein Fehler auftreten, ist der Wert von HPen gleich null, es wird ein einfacher Stift verwendet. If newpen = 0 Then ShowMessage('Falsche Parameterzusammenstellung');

Auswahl des neuen Stifts und Merken des vorhergehenden: oldpen := SelectObject(image1.canvas.handle, newpen);

Die eigentliche Grafikausgabe: with Image1.Canvas do begin Brush.Color := clwhite; FillRect(image1.boundsrect); Rectangle(50, 50, 200, 200); MoveTo(50, 250); LineTo(200, 250) end;

Wiederherstellen des alten Stifts und Löschen des neuen: DeleteObject(SelectObject(image1.canvas.handle, oldpen)) end;

Test Probieren Sie die verschiedenen Kombinationen aus:

19.25 Im Formularkopf zeichnen

1147

19.25 Im Formularkopf zeichnen Bei aller Bescheidenheit und Windows-Konformität, manchmal möchte man sich doch mit seiner Anwendung bereits optisch von der Masse der Konkurrenz abheben. Wie Sie selbst erstaunliche Effekte programmieren können, zeigt Ihnen dieses Beispiel.

Quelltext Alles, was Sie brauchen, ist ein geeigneter DC. Der von Form.Canvas.Handle gelieferte Handle auf den Fenster-DC ist in diesem Fall ungeeignet, da er sich lediglich auf den Clientbereich des Formulars beschränkt. Mit GetWindowDC erhalten Sie einen DC, der die gesamte Fensterfläche beschreibt. Doch bevor es so weit ist, sollten Sie ermitteln, wie hoch eigentlich die Fensterkopfzeile ist. Diese Information können Sie mit GetSystemMetrics abrufen. var dc : HDC; x,y, dx,dy, i : Integer; procedure TForm1.FormCreate(Sender: TObject); begin dc := GetWindowDC(handle); x := GetSystemMetrics(SM_CXFRAME); y := GetSystemMetrics(SM_CYFRAME); dx := width - 2*x - 3 * GetSystemMetrics(SM_CXSIZE); dy := GetSystemMetrics(SM_CYCAPTION)-1; end;

1148

Kapitel 19

How-to: Grafikprogrammierung

Über einen Timer blenden wir Teile einer Bitmap ein: procedure TForm1.Timer1Timer(Sender: TObject); begin bitblt(dc,x,y,dx,dy,image1.picture.bitmap.canvas.handle,i,0,SRCCOPY); inc(i); if i = 550 then begin timer1.enabled := False; Form1.Perform(WM_NCPAINT ,CreateRectRgn(left,top,left+width,top+height),0); end; end;

Der Aufruf Form1.Perform ... sorgt dafür, dass die Titelleiste wieder in den Originalzustand gebracht wird. Dazu simulieren wir eine Message MW_NCPAINT. Zum Schluss nicht vergessen: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin ReleaseDC(Handle,dc) end;

Test Klicken Sie den "Start"-Button und staunen Sie über die Laufschrift, die von rechts nach links über die Titelleiste wandert!

Bemerkung Wollen Sie mehr Zeit in dieses Thema investieren, sollten Sie sich einmal die verschiedenen Parameter von GetSystemMetrics ansehen. Je nach Fenstertyp müssen Sie andere Konstanten übergeben, um die Rahmenbreite korrekt zu ermitteln.

19.26 Mehrzeiligen Text ausgeben Geht es darum, den Inhalt eines Memofeldes auf einem beliebigen Canvas auszugeben, bieten sich zwei Varianten an: ■ zeilenweise Ausgabe mit der Methode TextOut ■ Ausgabe mit der GDI-Funktion DrawText

19.26 Mehrzeiligen Text ausgeben

1149

Oberfläche Den Grundaufbau der Oberfläche entnehmen Sie bitte der folgenden Abbildung, auf der rechten Seite ist eine PaintBox eingefügt.

Quelltext Arbeiten Sie mit TextOut, müssen Sie vor der Ausgabe die Texthöhe bestimmen, um später einen entsprechenden "Zeilenvorschub" einfügen zu können. Verwenden Sie dazu die Methode TextHeight. BEISPIEL: Mehrzeilige Textausgabe mit TextOut var h,i : integer; begin bitmap.canvas.font := memo1.font; h := bitmap.canvas.textheight('Äquator'); for i := 0 to memo1.lines.count do bitmap.canvas.textout(0,i*h,memo1.lines[i]) end;

Wesentlich einfacher ist die Textausgabe mit DrawText. Neben der Beschränkung auf ein Ausgaberechteck können Sie noch diverse Optionen vorgeben. Die Tabelle im Anschluss an das Beispiel listet die wichtigsten Konstanten auf. BEISPIEL: Mehrzeilige Textausgabe mit DrawText var r : TRect; p : PChar;

Initialisieren des Ausgaberechtecks: procedure TForm1.FormCreate(Sender: TObject); begin r := Bounds(0,0,memo1.clientwidth, memo1.clientheight) end;

Löschen des Hintergrunds und Textausgabe: procedure TForm1.Memo1Change(Sender: TObject); begin p := PChar(memo1.text); paintbox1.canvas.FillRect(r);

1150

Kapitel 19

How-to: Grafikprogrammierung

DrawText(paintbox1.canvas.handle, p, length(p), r, DT_LEFT + DT_EXPANDTABS + DT_WORDBREAK) end;

Test Starten Sie das Programm und geben Sie einen Text in das Memofeld ein.

Ergänzung Hier noch die versprochene Zusammenstellung der DrawText-Konstanten: Konstante

Beschreibung

DT_BOTTOM

... Text wird am unteren Rand ausgerichtet (nur mit DT_SINGLELINE).

DT_CALCRECT

... berechnet lediglich die Höhe des Ausgabetextes, keine Textausgabe!

DT_CENTER

... Text wird horizontal zentriert.

DT_EXPANDTABS

... Tabulatoren werden mit acht Leerzeichen dargestellt.

DT_LEFT

... Text wird linksbündig ausgerichtet.

DT_NOPREFIX

... unterdrückt die Interpretation von "&" als Formatierung (Unterstreichen eines Zeichens).

DT_RIGHT

... Text wird rechtsbündig ausgerichtet.

DT_SINGLELINE

... einzeilige Ausgabe, Zeilenumbrüche werden ignoriert.

DT_TABSTOP

... Vorgabe der Anzahl von Leerzeichen pro Tab. Der Wert wird in Bits 15-8 übergeben. Beispiel: Festlegen der Tabs var tabwidth : word; Tabwidth := shl 8; DrawText(paintbox1.canvas.handle, p,length(p),r,DT_TABSTOP+tabwidth);

DT_TOP

... Text wird am oberen Rand ausgerichtet (nur mit DT_SINGLELINE).

DT_VCENTER

... Text wird vertikal zentriert (nur mit DT_SINGLELINE).

DT_WORDBREAK

... automatischer Zeilenumbruch, wenn der Text nicht in die Zeile passt.

19.27 Einen Farbverlauf erzeugen

1151

19.27 Einen Farbverlauf erzeugen Fehlt Ihren Programmen der letzte Schliff? Dann ist eine optische Aufwertung, z.B. durch einen Farbverlauf in der Kopfzeile oder im Hintergrund, dringend zu empfehlen. Das folgende Beispiel zeigt Ihnen, wie Sie sich mit relativ einfachen Mitteln diesen Wunsch erfüllen können.

Oberfläche Dazu gibt es nicht viel zu sagen, unser Programm enthält lediglich eine Scrollbox, die eine ImageKomponente enthält. Auf diese Weise können wir später das Image vergrößern, ohne dass der sichtbare Bereich zunimmt. Über die Scrollbar lässt sich dann der sichtbare Ausschnitt verschieben.

Quelltext Wie fast in allen Fällen üblich, greifen wir einmal wieder in die Trickkiste der GDI-Funktionen. Neben der Funktion zum Erzeugen von Pinseln (CreateSolidBrush) binden wir noch DeleteObject zum Löschen des Pinsels und FillRect für die eigentliche Ausgabe ein. Der eigentliche Ablauf ist mit wenigen Worten beschrieben: ■ Skalieren der Image-Komponente ■ Füllen der Rec-Variablen mit den Maßen des Füllbereichs (Streifen mit einem Pixel Breite) ■ Erzeugen des Pinsels (bei jedem Durchlauf werden eine oder auch zwei Farben verändert) ■ Grafikausgabe ■ Löschen des Pinsels Im Detail: procedure TForm1.Button1Click(Sender: TObject); var i : Integer; hb : HBrush; rec : TRECT; begin image1.Width := 3 * 255; application.processmessages; rec.Top := 0; rec.Bottom := image1.Height; For i := 0 To 255 do begin hB := CreateSolidBrush(RGB(i, 0, 255 - i)); rec.Left := i; rec.Right := (i + 1); FillRect (image1.Canvas.handle, rec, hB); DeleteObject(hB) end; for i := 0 To 255 do begin hB := CreateSolidBrush(RGB(255, i, 0)); rec.Left := i+255; rec.Right := (i + 256); FillRect (image1.Canvas.handle, rec, hB);

1152

Kapitel 19

How-to: Grafikprogrammierung

DeleteObject(hB) end; for i := 0 To 255 do begin hB := CreateSolidBrush(RGB(255 - i, 255, 0)); rec.Left := i+510; rec.Right := (i + 511); FillRect (image1.Canvas.handle, rec, hB); DeleteObject(hB) end end;

Test Starten Sie das Programm und klicken Sie auf den Button. Schade, dass die folgende Abbildung die herrlichen Regenbogenfarben nicht wiedergeben kann!

Ergänzungen Experimentieren Sie mit der Veränderung der Einzelfarben in der RGB-Funktion. Sie können sowohl nur eine Farbe ändern ... hb := CreateSolidBrush( RGB(255, i, 0)); ...

als auch gleichzeitig einen Farbanteil stärken und einen anderen schwächen: ... hB := CreateSolidBrush( RGB(i, 0, 255 - i)); ...

19.28 Mit Paletten arbeiten Wer seine Grafikkarte auf 256 Farben eingestellt hat, wird beim vorhergehenden Rezept festgestellt haben, dass bei Farbverläufen nicht der gewünschte Effekt von gleitenden Farbübergängen auftritt. Der Grund ist recht schnell gefunden, die gerade aktive Farbpalette (256 Einträge) weist lediglich die vordefinierten Farben auf. Sollen Farbverläufe dennoch dargestellt werden, müssen diese aus

1153

19.28 Mit Paletten arbeiten

den vorhandenen Grundfarben gemischt werden. Das Problem umgehen Sie, wenn Sie sich direkt mit den entsprechenden Paletteneinträgen beschäftigen, soll heißen, Sie definieren die Paletteneinträge so, dass aufeinander folgende Farbschattierungen auch in der Palette vorhanden sind. Allerdings ist diese Vorgehensweise auf maximal 256-20 Farbstufen beschränkt (die 20 Einträge bleiben dem System für Fenster etc. vorbehalten).

Oberfläche Platzieren Sie in einem Formular eine PaintBox und legen Sie deren Align-Eigenschaft auf alClient fest.

Quelltext Mit dem Start des Programms erzeugen wir uns eine neue Palette. Allerdings können wir den zur Verfügung stehenden Datentyp TLogPalette nicht direkt nutzen. const colorCount = 256; var Palette : ^TLogPalette; HP : HPALETTE;

// Sie können auch weniger wählen

Der Aufbau von TLogPalette: TLogPalette = packed record palVersion: Word; palNumEntries: Word; palPalEntry: array[0..0] of TPaletteEntry; end;

Wie ersichtlich ist, muss der variable Teil (palPalEntry) zur Laufzeit festgelegt werden (Anzahl der Paletteneinträge). Ohne dynamische Speicherverwaltung kommen wir hier nicht weiter. procedure TForm1.FormCreate(Sender: TObject); var i:integer; begin GetMem(Palette, SizeOf(TLogPalette) + SizeOf(TPaletteEntry) * colorCount);

In der Struktur müssen jetzt noch die Versionsnummer sowie die Anzahl der Einträge abgelegt werden: Palette^.palVersion := $0300; Palette^.palNumEntries := colorCount;

Das eigentliche Füllen der Palette übernimmt die folgende Schleife (während der Rotanteil gestärkt wird, schwächen wir gleichzeitig den Grünanteil): for i := 0 to colorCount - 1 do begin Palette^.palPalEntry[i].peFlags := pc_Reserved; Palette^.palPalEntry[i].peRed := i; Palette^.palPalEntry[i].peBlue := 0; Palette^.palPalEntry[i].peGreen := 255-i end;

1154

Kapitel 19

How-to: Grafikprogrammierung

Zum Schluss erzeugen wir ein Paletten-Handle: HP := CreatePalette(Palette^);

Für die Darstellung bzw. die Übernahme der Palette ist das OnPaint-Ereignis der Paintbox verantwortlich: procedure TForm1.PaintBox1Paint(Sender: TObject); var x,y:integer; begin with paintbox1.canvas do begin SelectPalette(handle,HP,False); RealizePalette(handle); for x:=0 to 15 do for y:=0 to 15 do begin brush.color:= $01000000 + x*16 + y; rectangle(x*20,y*20,(x+1)*20,(y+1)*20) end end end;

Nach der Auswahl der Palette für den aktuellen Gerätekontext (paintbox1.canvas) muss diese auch mit RealizePalette übernommen werden. Zur Auswahl eines Paletteneintrags soll laut SDK das Makro PALETTEINDEX verwendet werden. Auszug aus dem SDK: The PALETTEINDEX macro is defined as follows: #define PALETTEINDEX(i) / ((COLORREF) (0x01000000 | (DWORD) (WORD) (i)))

Bevor wir an dieser Stelle eine Funktion schreiben, setzen wir einfach den Wert direkt, indem wir den Offset zum gewünschten Index addieren. Bevor wir das Programm verlassen, sollte auch der durch die Palette belegte Speicher wieder freigegeben werden: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin FreeMem(Palette, sizeof(TLogPalette) + sizeof(TPaletteEntry) * colorCount) end;

Test Starten Sie das Programm, sollte sich Ihnen folgender Anblick einer Palette mit stufenlosem Übergang von Grün zu Rot bieten. Wie schon erwähnt, bleiben zwanzig Einträge den Systemfarben vorbehalten. Starten Sie an dieser Stelle einmal Paint und laden Sie eine 256-Farben-Grafik. Ihre Paletteneinträge werden jetzt (das Programm ist nicht die Vordergrundanwendung) einfach überschrieben. Nach dem Umschalten zu Ihrer Anwendung ist alles wieder o.k.

19.29 Eine eigene Fortschrittsanzeige programmieren

1155

19.29 Eine eigene Fortschrittsanzeige programmieren Nicht immer muss man mit aufwändigen ActiveX-Controls mit Kanonen auf Spatzen schießen, oft tun es auch einfachere Lösungen. Dies soll am Beispiel einer grafischen Balkenanzeige demonstriert werden. Hat man sein Grundwissen in Algebra nicht völlig verlernt, so genügen wenige Zeilen Code, um mit den Delphi-Grafikmethoden ein zwar optisch bescheidenes, aber trotzdem zufrieden stellendes Diagramm direkt auf den Canvas des Formulars zu zaubern.

Oberfläche Die folgende Laufzeitansicht dürfte für sich sprechen:

1156

Kapitel 19

How-to: Grafikprogrammierung

Quelltext Alles ist in einer einzigen Prozedur verpackt: procedure balkenAnzeige(x1, y1, breite: Word; min, max, ist: Single); // x1,y1 = linke obere Ecke; min = Minimalwert, max = Maximalwert, ist = Istwert var x: Word; s: string; w:Single; const hoehe =25; // ... des Anzeigerechtecks begin with Form1.Canvas do begin w := (ist-min)/(max-min); // das Verhältnis berechnen (Dreisatz-Aufgabe!) Pen.Color := clBlack; Pen.Width := 1; Brush.Style := bsSolid; Brush.Color := clBtnFace; Rectangle(x1, y1, x1+breite+2, y1+hoehe); // Rahmen if (ist=0) or (max=0) then Exit; Brush.Color := clRed; x := x1 + Round(w * breite); Rectangle(x1-2,y1, x, y1 + hoehe); // Balken // Beschriftungen: Brush.Color := clBtnFace; Str(min:3:1, s); TextOut(x1-5, y1+hoehe+5, s); Str(max:3:1, s); TextOut(x1-5+breite, y1+hoehe+5, s); Str(w*100:3:1, s); TextOut(x1 + breite div 2, y1 + hoehe div 4, s + '%') end end;

Nun zum Aufruf der Prozedur: procedure TForm1.Button1Click(Sender: TObject); var min, max, ist: Single; code: Integer; begin try Val(Edit1.Text, min, code); Val(Edit2.Text, max, code); Val(Edit3.Text, ist, code); if (ist < min) or (ist > max) then begin ShowMessage('Istwert liegt außerhalb des Intervalls!'); Exit end; balkenAnzeige(50,150,Width-100, min, max, ist) except end end;

Test Verschwenden Sie nicht gar zu viel Zeit mit dem Ausprobieren, setzen Sie die Prozedur lieber gleich in einer eigenen und sinnvollen Anwendung ein!

19.30 Einen Markierungsrahmen erzeugen

1157

Bemerkung Wem die Anzeige gar zu spartanisch aussieht, der kann sie durchaus noch mit 3-D-Effekten aufpeppen. Der nüchterne Mathematiker wird allerdings auf derlei Firlefanz verzichten können.

19.30 Einen Markierungsrahmen erzeugen In fast jedem Zeichenprogramm ist folgendes praktische Problem anzutreffen: Durch Klick auf die Maustaste und anschließendes Bewegen der Maus öffnet sich ein Rechteck, das man bei gedrückt gehaltener Maustaste auf die gewünschte Größe zieht, um damit irgendein Objekt einzurahmen oder zu kennzeichnen. Besonders professionell wirkt der Rahmen, wenn er animiert wird (scheinbare Bewegung des Rahmens).

Oberfläche Zur Oberfläche gibt es nicht viel zu sagen, außer einem Panel zur Anzeige der aktuellen Mauskoordinaten und einem Timer für den Animationseffekt brauchen Sie keine weiteren Komponenten.

Quelltext Grundlage des Verfahrens ist die Erkenntnis, dass die zweimalige XOR-Verknüpfung zweier Werte (in diesem Fall handelt es sich um Farben) den ursprünglichen Zustand wiederherstellt. Den XOR-Zeichenmodus erreichen Sie über die Mode-Eigenschaft des Pen-Objekts. Dies kann zum Beispiel beim Erzeugen des Fensters geschehen: procedure TForm1.FormCreate(Sender: TObject); begin canvas.pen.mode := pmNotXor; canvas.pen.Style := psDot; end;

Innerhalb der Unit deklarieren Sie die folgenden Variablen: var x1,y1,x2,y2 :Integer;

Wird die linke Maustaste gedrückt, können wir die Anfangskoordinaten speichern und das Rechteck zum ersten Mal zeichnen: procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; x, y: Integer); begin If shift = [ssLeft] then begin timer1.enabled:=False; canvas.brush.style:=bsclear; x1 := X; y1 := Y; x2 := X;

1158

Kapitel 19

How-to: Grafikprogrammierung

y2 := Y; canvas.rectangle (x1, y1,x2, y2) end end;

Jede weitere Bewegung der Maus löst das Ereignis MouseMove aus, in dem wir zum einen die Koordinatenanzeige aktualisieren, zum anderen das bisherige Rechteck löschen und neu zeichnen. procedure TForm1.FormMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer); begin panel1.caption := IntToStr(x)+ ':' + IntToStr(Y); If shift = [ssLeft] then begin canvas.rectangle (x1, y1,x2, y2); x2 := X; y2 := Y; canvas.rectangle (x1, y1,x2, y2) end end;

Mit dem Loslassen der Maustaste ist die Zeichenaktion abgeschlossen, es geht jetzt nur noch darum, mit den gespeicherten Koordinaten das Rechteck zyklisch neu zu zeichnen. Dazu wird der Timer eingeschaltet: procedure TForm1.FormMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin timer1.enabled:=True end;

Durch den Wechsel zwischen psSolid und psDot für die Eigenschaft Pen.Style entsteht eine scheinbare Bewegung der einzelnen Rahmenpunkte:

procedure TForm1.Timer1Timer(Sender: TObject); begin canvas.pen.Style := psSolid; canvas.rectangle(x1, y1,x2, y2); canvas.pen.Style := psDot; end;

19.31 Grafiken mit Drag & Drop manipulieren

1159

Test Klicken Sie mit der Maus auf das Formular und ziehen Sie den Rahmen auf:

19.31 Grafiken mit Drag & Drop manipulieren Delphi verfügt über ausgereifte Drag & Drop-Funktionalitäten, die sich aber leider nur auf die "hauseigenen" Komponenten beziehen, siehe z.B. Ä 18.64 Drag & Drop in der Anwendung realisieren Wenn es aber darum geht, unsere auf dem Canvas gezeichneten Grafikfiguren durch "Anfassen" mit der Maus zu verschieben bzw. zu verändern, so lässt uns Delphi im Regen stehen, und wir müssen uns auf unsere eigenen Programmierfähigkeiten besinnen. In der vorliegenden Demo soll gezeigt werden, wie ein Kreis mittels Drag & Drop manipuliert werden kann.

Oberfläche Das nackte Formular genügt!

Quellcode Zum interface-Abschnitt von Unit1: In der Typdeklaration des Formulars ergänzen wir die Methode drawCircle: type TForm1 = class(TForm) ... private procedure drawCircle; end;

1160

Kapitel 19

How-to: Grafikprogrammierung

Der implementation-Abschnitt: const dc = 2; // halbe Länge des Mittelpunktkreuzes var x0:Integer = 200; y0:Integer = 150; // Kreismittelpunkt mit Anfangsposition r:Integer = 50; // Radius mit Anfangsgröße

Der Programmablauf wird durch eine so genannte "Zustandsvariable" gesteuert, welche die Werte 0 ("Normal"), 1 ("Radius verändern") und 2 ("Position verändern") annehmen kann. zMode: Integer = 0;

// Startzustand = "Normal"

In der übersichtlichen Methoden-Implementation von TForm1.drawCircle zeigt sich der Vorteil gegenüber der ebenfalls möglichen Verwendung einer einfachen Prozedur drawCircle (z.B. Canvas.Ellipse... anstatt Form1.Canvas.Ellipse...): procedure TForm1.drawCircle; begin with Canvas do begin Ellipse(x0-r,y0-r,x0+r,y0+r); MoveTo(x0-dc, y0); LineTo(x0+dc+1, y0); MoveTo(x0, y0-dc); LineTo(x0, y0+dc+1) end end;

Die Anfangseinstellungen für die Zeichenoperationen: procedure TForm1.FormCreate(Sender: TObject); begin Form1.Color := clWhite; with Canvas do begin Brush.Style := bsClear; // transparent (kein Füllmuster für Kreis) Pen.Width := 3;

Der XOR-Zeichenmodus bietet eine elegante Möglichkeit, den alten Kreis durch nochmaliges Überzeichnen zu löschen (dadurch vermeidet man das lästige Flackern, das durch Löschen der gesamten Zeichenfläche mittels Refresh entstehen würde): Pen.Mode := pmXOR; // XOR-Zeichenmodus Pen.Color := Form1.Color xor clRed // ergibt rote Zeichenfarbe end end;

Das Regenerieren der Zeichnung nach dem Verdecken durch ein anderes Formular: procedure TForm1.FormPaint(Sender: TObject); begin drawCircle end;

Das Verändern des Kreises geschieht als logische Aufeinanderfolge der drei Mausoperationen "Anklicken", "Ziehen" und "Loslassen":

19.31 Grafiken mit Drag & Drop manipulieren

Kreiselement anklicken: procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);

Die erste Hilfsfunktion testet, ob der Mausklick den Rand des Kreises trifft: function hitBorder: Boolean; const dr = 2; // Randverbreiterung für bequemeres "Anfassen" var q: Integer; // Hilfsvariable begin Result := False; q := (X-x0) * (X-x0) + (Y-y0) * (Y-y0); if (q > (r-dr) * (r-dr)) and (q < (r+dr) * (r+dr)) then Result := True end;

Die zweite Hilfsfunktion testet, ob der Mausklick den Mittelpunkt des Kreises trifft: function hitCenter: Boolean; begin Result := False; if (X > (x0-dc)) and (X < (x0+dc+1)) and (Y > (y0-dc)) and (Y < (y0+dc+1)) then Result := True end;

Die Auswertung des "Maustreffers" bestimmt den neuen Zustand: begin if hitBorder then zMode := 1; // neuer Zustand "Radius verändern" if hitCenter then zMode := 2 // neuer Zustand "Kreis verschieben" end;

Kreiselement bei gedrückter Maustaste "ziehen": procedure TForm1.FormMouseMove(Sender: TObject; Shift: TShiftState; X,Y: Integer); var dx, dy: Single; begin if zMode = 0 then Exit; // kein Zeichnen im Zustand "Normal" drawCircle; // alten Kreis löschen durch Überzeichnen if zMode = 1 then begin // Radius verändern dx := (X-x0); dy := (Y-y0); // neue relative Koordinaten r := Round(Sqrt(dx * dx + dy * dy)) // neuer Radius end; if zMode=2 then begin // Kreis verschieben x0 := X; y0 := Y // neuen Mittelpunkt end; drawCircle // neuen Kreis zeichnen end;

Maustaste loslassen: procedure TForm1.FormMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);

1161

1162

Kapitel 19

begin zMode := 0 end;

How-to: Grafikprogrammierung

// zurück "Normal"-Zustand

Test

Bemerkung Das Beispiel ist konventionell programmiert. Wenn Sie mit mehreren Kreisen arbeiten wollen oder gar mit beliebigen Grafikfiguren, werden Sie schnell merken, dass der Quelltext ausufert und unübersichtlich wird. Hier hilft Ihnen die objektorientierte Programmierung weiter.

19.32 Einen Desktop-Screenshot anfertigen Sie sind es sicherlich gewohnt, Screenshots mittels der Druck- oder Alt+Druck-Taste zu realisieren. Die folgende Demo zeigt zwei Möglichkeiten, dies programmgesteuert zu erledigen.

Oberfläche

Wichtig ist, dass Sie die BorderStyle-Eigenschaft von Form1 auf bsDialog ändern, ansonsten könnte es zu Schwierigkeiten beim vorübergehenden Entfernen von Form1 während des Screenshots kommen (siehe unten).

1163

19.32 Einen Desktop-Screenshot anfertigen

Quelltext (Variante 1) Bei dieser Variante benutzen wir die CopyRect-Methode des Bitmap-Canvas, um Bildausschnitte zu bewegen, doch der Reihe nach ... Im Interface-Abschnitt von Unit1 fügen Sie dem privaten Abschnitt der Typdeklaration von TForm1 folgende Methode hinzu: procedure TForm1.takeScreenShot;

Im implementation-Abschnitt: procedure TForm1.takeScreenShot; var aHDC: HDC; aCanvas: TCanvas; aBM: TBitmap; aRect: TRect; breit, hoch: Integer; begin

Zunächst brauchen wir eine neue Zeichenfläche (Canvas), die wir mit dem Bildschirm (ScreenObjekt) verbinden: aCanvas := TCanvas.Create; aHDC := GetDC(0); aCanvas.Handle := aHDC;

// Handle auf den Bildschirm wird besorgt

Der zu kopierende Ausschnitt wird auf die Bildschirmabmessungen festgelegt: breit := Screen.Width; hoch := Screen.Height; aRect := Rect(0, 0, breit, hoch);

Nun kann ein Bitmap-Objekt entsprechender Größe erzeugt werden, um den Screenshot zwischenzuspeichern: aBM := TBitmap.Create; aBM.Height := hoch; aBM.Width := breit;

Die Methode CopyRect kopiert den durch aRect definierten Ausschnitt aus der Zeichenfläche aCanvas in den Canvas der Bitmap: aBM.Canvas.CopyRect(aRect, aCanvas, aRect);

Der Kopiervorgang erfolgt in dem durch CopyMode festgelegten Modus. Nun werden die Bitmap abgespeichert und die Ressourcen freigegeben: aBM.SaveToFile('Test.bmp'); aBM.Free; ReleaseDC(GetDeskTopWindow, aHDC); ReleaseDC(0, aCanvas.Handle) end;

1164

Kapitel 19

How-to: Grafikprogrammierung

Bevor der Screenshot ausgelöst wird, muss die störende Form1 vorübergehend entfernt werden. Leider ist es den Autoren nicht gelungen, diese Aufgabe durch die simple Aufeinanderfolge von Self.Hide; takeScreenShot; Self.Show

zu lösen, denn irgendwelche "Reste" von Form1 nervten und verschandelten immer wieder den schönen Screenshot. Auch das Einfügen von Application.ProcessMessages nach Self.Hide führte nicht zum gewünschten Erfolg. Letztlich blieb nichts anderes übrig, als die folgende "Trickserei" anzuwenden, die außerdem BorderStyle = bsDialog voraussetzt: procedure TForm1.Button1Click(Sender: TObject); var w, h: Integer; begin w := Self.Width; h := Self.Height; Self.Width := 0; Self.Height := 0; Self.Hide; Application.ProcessMessages; takeScreenShot; Self.Width := w; Self.Height := h; Self.Show end;

// Screenshot starten

Test Nach Klick auf den "Start"-Button signalisieren das Verschwinden und Wiedererscheinen von Form1 den erfolgreichen Verlauf des Screenshots. Jetzt können Sie sich die Datei Test.bmp, die sich im Projektverzeichnis befindet, betrachten.

Quelltext (Variante 2) Diese zweite Variante ist an Einfachheit nicht mehr zu unterbieten. Benutzt wird diesmal die GDIFunktion BitBlt, mit der Bitmaps auf direktem Weg zwischen zwei Gerätekontexten bewegt werden können. procedure TForm1.takeScreenShot; var aHDC: HDC; aBM: TBitmap; begin aHDC := GetDC(0); aBM := TBitmap.Create; aBM.Width := Screen.Width; aBM.Height := Screen.Height; BitBlt(aBM.Canvas.Handle, 0, 0, Screen.Width, Screen.Height, aHDC, 0, 0, SRCCOPY); aBM.SaveToFile('Test.bmp'); ReleaseDC(0, aHDC); aBM.Free end;

Der übrige Quelltext (Starten des Screenshots) entspricht vollständig Variante 1.

19.33 Einen Fenster-Screenshot erzeugen

1165

Bemerkungen ■ Um die Screenshots unter einem frei wählbaren Dateinamen abspeichern zu können, empfiehlt sich das Einfügen einer SaveDialog-Komponente nebst folgender Quelltextänderung: if SaveDialog1.Execute then aBM.SaveToFile(SaveDialog1.Filename);

■ Wollen Sie schnell hintereinander mehrere Screenshots Test1.bmp, Test2.bmp, Test3.bmp, ... anfertigen, so sollten Sie eine globale Zählvariable benutzen. ■ Um den Screenshot nicht als Datei zu speichern, sondern ihn in der Zwischenablage zu hinterlegen, ist lediglich folgende Änderung erforderlich (Unit Clipbrd einbinden!): Clipboard.Assign(aImage.Picture);

19.33 Einen Fenster-Screenshot erzeugen Das vorliegende Rezept stellt zwei Möglichkeiten gegenüber, um Screenshots für ein bestimmtes Fenster aufzunehmen: ■ nur Clientbereich ■ gesamte sichtbare Fläche (inklusive Menü und Kopfzeile) Während sich die erste Variante mit Hilfe der Methode GetFormImage einfach realisieren lässt, kommt man bei der zweiten Variante, ähnlich wie im Vorgängerrezept, nicht ohne die Hilfe von GDI-Funktionen und Kenntnissen des internen Aufbaus von Bitmaps aus.

Oberfläche Form1 ist gewissermaßen unser "Steuerpult", von dem aus wir beide Arten von Screenshots "schießen" wollen:

Das zweite Formular, das Sie mit beliebigen Komponenten bestücken können, dient als Testobjekt für die Screenshots:

1166

Kapitel 19

How-to: Grafikprogrammierung

Variante 1 procedure TForm1.takeScreenShot1; var aBM: TBitmap; begin aBM := Form2.GetFormImage; aBM.SaveToFile('Test1.bmp'); aBM.Free end;

// Var. 1 (Clientbereich)

Der Aufruf: procedure TForm1.Button1Click(Sender: TObject); // Variante 1 (Clientbereich) begin Self.Hide; Form2.Show; Application.ProcessMessages; takeScreenShot1; Self.Show end;

Variante 2 Auf weiterführende Erklärungen wird verzichtet, da dies zum überwiegenden Teil bereits im Vorgängerbeispiel geschehen ist. Um die Vielfalt zu demonstrieren, wird statt eines TBitmap- diesmal ein TImage-Objekt als Zwischenspeicher verwendet. Dem Quellcode können Sie unter anderem entnehmen, dass eine Bitmap neben dem Speicherabbild (Array aller Pixel) auch aus einer Palette mit den benötigten Farbinfos besteht. procedure TForm1.takeScreenShot2; // Var. 2 (komplettes Fenster) var sysPal : logPal; aImage: TImage; // Unit ExtCtrls!

1167

19.33 Einen Fenster-Screenshot erzeugen

hPal: HPalette; aHDC: HDC; aCanvas: TCanvas; aRect: TRect; begin aHDC := GetWindowDC(Form2.Handle); sysPal.lPal.palVersion:=$300; sysPal.lPal.palNumEntries:=256; GetSystemPaletteEntries(aHDC,0,256,SysPal.lpal.PalpalEntry); hPal:=CreatePalette(sysPal.lpal); aCanvas := TCanvas.Create; aCanvas.Handle := aHDC; aRect := Rect(0,0,Screen.Width,Screen.Height); aImage:=TImage.Create(Self); with aImage do begin Height := Form2.Height; Width := Form2.Width; Canvas.CopyRect(aRect,aCanvas,aRect); ReleaseDC(GetDeskTopWindow,aHDC); Picture.Bitmap.Palette:=hPal end; aImage.Picture.SavetoFile('Test2.bmp'); aImage.Free; ReleaseDC(GetDeskTopWindow, aHDC); ReleaseDC(Form2.Handle, aCanvas.Handle) end;

Durch Modifikation des im obigen Code fett hervorgehobenen Objektbezeichners können Sie beliebige Screenshots anfertigen. Voraussetzung ist lediglich, dass das betreffende Objekt über ein Handle verfügt. Der Aufruf: procedure TForm1.Button3Click(Sender: TObject); begin Self.Hide; Form2.Show; Application.ProcessMessages; takeScreenShot2; Self.Show end;

// Variante 2

(komplette Form)

Test Nach Programmstart und Betätigen der beiden Buttons können Sie sich anhand der Dateien Test1.bmp und Test2.bmp, die sich im Projektverzeichnis befinden müssen, vom Ergebnis überzeugen:

1168

Kapitel 19

How-to: Grafikprogrammierung

19.34 Ein Testbild programmieren Vielleicht haben Sie sich endlich die neue Grafikkarte gekauft und den dazu passenden Monitor und möchten beides optimal aufeinander abstimmen. Dann dürfte dieser Beitrag genau der richtige für Sie sein. Statt irgendein Testprogramm zu bemühen, schreiben Sie sich doch einfach selbst eins! Der Aufwand ist relativ gering, mit Delphi lässt sich schon nach ein paar Minuten ein Testbild auf den Monitor zaubern:

19.34 Ein Testbild programmieren

1169

Die Geschwindigkeit spielt eine untergeordnete Rolle. Eine Forderung an unser Programm soll jedoch nicht vergessen werden: Automatische Größenanpassung, unabhängig von der Bildschirmauflösung.

Oberfläche Der Aufwand ist minimal: Setzen Sie die Color-Eigenschaft des Formulars auf clBlack und BorderStyle auf bsNone (im Gegensatz zu obiger Abbildung sollte der Bildschirmhintergrund schwarz sein, das Formular hat weder Titelleiste noch Rand). Außer einer PopUpMenu-Komponente brauchen wir noch einen Timer für den Pump-Test.

Quelltext var Form1: TForm1; x,y,i,hoehe,breite,h,abstand : Integer; n : Boolean;

Eine Größenänderung des Formulars verändert unsere Eck-Koordinaten: procedure TForm1.FormResize(Sender: TObject); begin hoehe := ClientHeight-1; breite := ClientWidth-1; with canvas do begin pen.color := clwhite; brush.style := bsclear end; end;

Ein Gitter einblenden: procedure gitter; begin with form1.canvas do begin For x := 0 To 16 do begin MoveTo (x * breite div 16, 0); Lineto (x * breite div 16, hoehe); end; For y := 0 To 12 do begin MoveTo (0, y * hoehe div 12); LineTo (breite, y * hoehe div 12) end; MoveTo (0,0); LineTo (breite,hoehe); MoveTo (breite,0); LineTo (0,hoehe) end end;

1170

Kapitel 19

How-to: Grafikprogrammierung

Kreise zeichnen: procedure kreise(n:byte); begin with form1.canvas do begin brush.style := bsClear; for i := 1 to hoehe div n do begin h := i * n; ellipse (breite div 2 -h,hoehe div 2 -h,breite div 2 + h,hoehe div 2 +h) end end end;

Ein Interferenzbild erzeugen: procedure TForm1.Interferenz1Click(Sender: TObject); begin inc(abstand); if abstand > 5 then abstand := 2; form1.refresh; with form1.canvas do begin for x := 0 to breite div abstand do begin MoveTo (x*abstand, 0); Lineto (x*abstand, hoehe) end end end;

Die Weißfläche testen: procedure TForm1.Weissflche1Click(Sender: TObject); begin form1.refresh; with form1.canvas do begin brush.style := bsSolid; rectangle(0,0,breite,hoehe); brush.style :=bsClear end end;

16 Grundfarben festlegen: function qbcolor(i:integer):longint; begin case i of 0 : qbcolor:=clblack; 1 : qbcolor:=clMaroon; 2 : qbcolor:=clGreen; 3 : qbcolor:=clOlive; 4 : qbcolor:=clNavy; 5 : qbcolor:=clPurple; 6 : qbcolor:=clTeal; 7 : qbcolor:=clGray; 8 : qbcolor:=clSilver; 9 : qbcolor:=clRed; 10 : qbcolor:=clLime; 11 : qbcolor:=clBlue; 12: qbcolor:=clFuchsia; 13: qbcolor:=clAqua; 14: qbcolor:=clyellow; 15: qbcolor:=clWhite end; end;

19.34 Ein Testbild programmieren

Die Grundfarben darstellen: procedure farben; begin form1.canvas.brush.style := bssolid; For i := 0 To 7 do with form1.canvas do begin brush.color := qbcolor(i); pen.color := qbcolor(i); rectangle(round((i + 4) * breite / 16), hoehe div 4, round((i + 4) * breite / 16)+ breite div 16,hoehe div 4+ hoehe div 12); brush.color := qbcolor(i*2+1); pen.color := qbcolor(i*2+1); rectangle(round((i + 4) * breite / 16), round(hoehe * 8 / 12), round((i + 4) * breite / 16)+breite div 16, round(hoehe * 8 / 12) +hoehe div 12) end end;

Das Pumpbild darstellen: procedure TForm1.Timer1Timer(Sender: TObject); begin form1.refresh; if n then begin with form1.canvas do begin brush.style := bssolid; rectangle(0,0,breite,hoehe); brush.style :=bsclear end end n := not n end;

Das komplette Testbild anzeigen: procedure TForm1.Alles1Click(Sender: TObject); var i :integer; s : string; begin form1.refresh; farben; gitter; kreise(100); i := 0; while i <= round(breite / 16) do begin canvas.moveto(i, 0);canvas.lineto(i, hoehe div 12); canvas.moveto(breite - i, 0);canvas.moveto(breite - i, hoehe div 12); canvas.moveto(i, hoehe);canvas.moveto(i, hoehe - hoehe div 12); canvas.moveto(breite - i, hoehe);canvas.moveto(breite - i, hoehe - hoehe div 12); inc(i,2) end; i := 0; while i <= round(breite / 16) do begin

1171

1172

Kapitel 19

How-to: Grafikprogrammierung

canvas.moveto(i, 0);canvas.lineto(i, hoehe div 12); canvas.moveto(breite - i, 0);canvas.lineto(breite - i, hoehe div 12); canvas.moveto(i, hoehe);canvas.lineto(i, hoehe - hoehe div 12); canvas.moveto(breite - i, hoehe);canvas.lineto(breite - i, hoehe - hoehe div 12); inc(i,2) end; i := round(breite / 16); while i <= round(breite / 8) do begin canvas.moveto(i, 0);canvas.lineto(i, hoehe div 12); canvas.moveto(breite - i, 0);canvas.lineto(breite - i, hoehe div 12); canvas.moveto(i, hoehe);canvas.lineto(i, hoehe - hoehe div 12); canvas.moveto(breite - i, hoehe);canvas.lineto(breite - i, hoehe - hoehe div 12); inc(i,3) end; i := round(breite / 8); while i <= round(breite * 3 / 16) do begin canvas.moveto(i, 0);canvas.lineto(i, hoehe div 12); canvas.moveto(breite - i, 0);canvas.lineto(breite - i, hoehe div 12); canvas.moveto(i, hoehe);canvas.lineto(i, hoehe - hoehe div 12); canvas.moveto(breite - i, hoehe);canvas.lineto(breite - i, hoehe - hoehe div 12); inc(i,4) end; canvas.brush.style:=bsClear; s := 'abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890'; canvas.textout((breite-canvas.textwidth(s)) div 2,hoehe div 2+10,s) end;

Test Starten Sie das Programm und klicken Sie mit der rechten Maustaste auf den Bildschirm. Wählen Sie im PopUp-Menü eine Option aus. Das Ergebnis (siehe Screenshot am Anfang) zeigt recht anschaulich die Verwendung der verschiedenen Grafikmethoden sowie die in diesem Zusammenhang interessanten Eigenschaften von Screen- und Form-Objekt.

20

How-to: Multimedia

Kapitel

20

How-to: Multimedia 20.1 Zeitmessungen durchführen Wer hatte nicht schon einmal das Problem, die Ausführungsgeschwindigkeit von Programmteilen messen zu müssen? Sei es nur, um einen Vergleich durchzuführen oder um die Performance zu verbessern. Unter Windows bieten sich verschiedene Varianten an, von denen jedoch nur eine als geeignet angesehen werden kann. Viele Programmierer verwenden nach wie vor die Funktion GetTickCount, die jedoch eine völlig unzureichende Genauigkeit aufweist. Ursache ist nicht etwa die Funktion an sich, sondern der abgefragte Counter. Dieser wird lediglich alle 55 ms (Win 3.11), 15 ms (NT 3.1) bzw. 10 ms (>NT 3.5) aktualisiert. Geht es darum, die Ausführungsgeschwindigkeit mehrerer Anweisungen zu ermitteln, dürfte die Ungenauigkeit viel zu groß sein. Eine Alternative bietet sich mit der Funktion QueryPerformanceCounter, die einen "High Resolution Counter" mit einer Genauigkeit von 0.00083 ms (!!!) abfragt. Um die genaue Auflösung zu ermitteln, bedienen Sie sich der Funktion QueryPerformanceFrequency, welche die Frequenz in einer Variablen vom Datentyp TLargeInteger zurückgibt (seit Delphi 4 wird dieser Datentyp direkt unterstützt, Sie brauchen nicht mehr mit einem Record zu arbeiten). Um die Verwendung der Funktionen zu demonstrieren, wollen wir die Zeit messen, die zum "Vollschmieren" des Canvas eines Form-Objekts benötigt wird.

Oberfläche

1174

Kapitel 20

How-to: Multimedia

Quellcode procedure TForm1.Button1Click(Sender: TObject); var c, n1, n2 : TLargeInteger; i : Integer; begin QueryPerformanceFrequency(c); QueryPerformanceCounter(n1); for i := 1 to 10000 do Canvas.LineTo(Random(300), Random(300)); QueryPerformanceCounter(n2); Label1.Caption := Format('Zeit: %g',[(n2-n1)/ c]) end;

Test

20.2 Einen Screen-Saver programmieren Genügen Ihnen die zu Windows mitgelieferten Screen-Saver nicht mehr, oder wollen Sie gar einen Screen-Saver mit Ihrem Firmenlogo programmieren? Dann bietet sich Ihnen mit Delphi eine recht einfache Möglichkeit, Ihrer Kreativität freien Lauf zu lassen.

Grundlagen Ein Screen-Saver ist im Grunde genommen eine ganz normale Windows-Anwendung, die in der Lage sein sollte, einige Startparameter auseinander zu halten. Sie brauchen sich weder um den Zeitpunkt des Aufrufs noch um den eigentlichen Programmstart zu kümmern, das alles erledigt Windows für Sie. Doch bevor es so weit ist, muss der Screen-Saver installiert werden. Dazu bietet sich unter anderem der Dialog "Display Properties" an:

20.2 Einen Screen-Saver programmieren

1175

Forderungen an den Screen-Saver: ■ Benennen Sie die .EXE-Anwendung in .SCR um, sonst wird die Anwendung nicht als ScreenSaver erkannt. ■ Kopieren Sie die .SCR-Datei in das Systemverzeichnis, nur dort werden die ScreenSaver durch obigen Konfigurationsdialog aufgespürt. ■ Der Screen-Saver sollte eine String-Table mit dem Eintrag "1" enthalten (ein kurzer Text, der in der Listbox angezeigt wird). ■ Die Anwendung sollte die Übergabeparameter "/S" und "/C" unterscheiden1. Mit "/S" wie "Start" oder "Show" sollten Sie die Routine zur Anzeige des eigentlichen Screen-Savers starten. Der Parameter "/C", wie "Config", ist die Aufforderung an die Anwendung, einen eventuell vorhandenen Konfigurationsdialog anzuzeigen. ■ Tastatur- und Mausereignisse müssen den Screen-Saver beenden. ■ Die letzte und eigentlich wichtigste Forderung an einen Screen-Saver: Der Bildschirm sollte möglichst dunkel sein.

1

Eigentlich noch "/P" für Preview

1176

Kapitel 20

How-to: Multimedia

Oberfläche Zur Oberfläche ist eigentlich nicht allzu viel zu sagen, alles, was Sie brauchen, ist ein schwarzer Hintergrund (Form.Color := clBlack). Die weitere Funktionalität hängt lediglich von Ihrer Kreativität ab. Für die Konfiguration können Sie eine Dialogmaske erzeugen.

Quelltext Das Hauptprogramm muss die verschiedenen Übergabeparameter auseinander halten, weiterhin ist die Ressource (Beschreibung) zu importieren: program Screen; uses Forms, SysUtils, Dialogs, Unit1 in 'Unit1.pas' {Form1}, Unit2 in 'Unit2.pas' {Form2}; {$R *.RES} {$R titel.res} var param: String;

// Die Beschreibung

begin param := copy(upperCase(paramstr(1)),1,2); if param = '/C' then begin Application.Initialize; Application.CreateForm(TForm2, Form2); Application.Run end else if param = '/S' then begin Application.Initialize; Application.CreateForm(TForm1, Form1); Application.Run; end; end.

Nun können wir uns der eigentlichen "Spielerei" zuwenden. Unser Screen-Saver will die Hintergrundbitmap des Bildschirms sichern, das Bild nach unten scrollen und dann über einen Timer zufällige Bildschirmausschnitte darstellen. Um das Beispiel nicht ganz trivial werden zu lassen, finden Sie gleich noch eine Anwendung für Regions, die darzustellenden Ausschnitte werden in kreisförmigen Regionen ausgegeben. var b : TBitmap; i : Integer; procedure TForm1.FormCreate(Sender: TObject); var dc : HDC; begin windowstate := wsmaximized; b := TBitmap.Create; dc := GetDC(0);

20.2 Einen Screen-Saver programmieren

1177

b.width := screen.Width; b.height := screen.Height;

Sichern der Bitmap: BitBlt(b.canvas.handle, 0, 0, screen.Width, screen.Height, DC, 0, 0, SRCCopy); ReleaseDC(0,dc); i := 0; cursor := -1; end;

Die gesicherte Bitmap wird im Formular angezeigt: procedure TForm1.FormPaint(Sender: TObject); begin canvas.draw(0,0,b) end;

Reaktion auf Maus und Tastatur mit Reaktionsschwelle, um Tastaturprellen etc. auszuschließen: procedure TForm1.FormMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer); begin if i > 5 then close end; procedure TForm1.FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState); begin if i > 5 then close end;

Die Hintergrund-Bitmap langsam nach unten scrollen: procedure TForm1.Timer1Timer(Sender: TObject); var rec, rec1 : TRect; begin rec := bounds(0,i,width,height-i); scrolldc(canvas.handle,0,1,rec,rec,0,@rec1); canvas.moveto(0,i); canvas.lineto(width,i); inc(i); if i > height then begin timer1.enabled := False; timer2.enabled := True end end;

Zufällige Ausschnitte der Bitmap einblenden: procedure TForm1.Timer2Timer(Sender: TObject); var x,y,dx : integer; r : THandle; begin

1178

Kapitel 20

How-to: Multimedia

dx := 50 + random(100); x := random(width+dx)-dx; y := random(height+dx)-dx; r := CreateEllipticRgn(x,y,x+dx,y+dx); SelectObject(canvas.handle,r);

Damit der Bildschirm relativ dunkel bleibt, werden die Bitmaps nur eingeblendet, wenn die xyKoordinate durch 4 teilbar ist (im Mittel 1/4 aller Ausgabeoperationen), anderenfalls wird ein schwarzer Kreis gezeichnet. if dx mod 4 = 0 then bitblt(canvas.handle,x,y,dx,dx,b.canvas.handle,x,y,SRCCOPY) else bitblt(canvas.handle,x,y,dx,dx,b.canvas.handle,x,y,BLACKNESS); DeleteObject(r) end;

Test Compilieren Sie die Anwendung und benennen Sie diese in *.SCR um. Danach können Sie den Screen-Saver im Systemverzeichnis speichern. Über den Eigenschaften-Dialog des Desktops wählen Sie den neuen Screen-Saver aus.

20.3 Einen Joystick abfragen

1179

Bemerkungen ■ Verfügt Ihr Screensaver über einen Konfigurationsdialog, sollten Sie die Einstellungen unter HKEY_CURRENT_USER\SOFTWARE\\\ in der Registry sichern. ■ Weitere Informationen zu diesem Thema finden Sie in Ä 27.7 Mit der Registrierdatenbank arbeiten ■ Weitere Informationen zum Thema "Grafikausgabe" finden Sie in Ä 19.18 Eine Lupenfunktion programmieren Ä 19.11 Eine RGB-Grafik manipulieren Ä 19.13 Mit großen Grafiken arbeiten

20.3 Einen Joystick abfragen Als ambitionierter Spieler wird man heute wohl kaum noch ohne Joystick auskommen. Leider bietet Delphi dem Programmierer in dieser Beziehung nicht viel, und Produkte von Drittanbietern sind meist teuer. Wir schaffen Abhilfe und programmieren eine entsprechende Komponente. Doch vorher zeigen wir Ihnen noch, wie Sie auch ohne Komponente durch direkten Zugriff auf die API-Funktionen zum Ziel gelangen können.

Direkte Joystick-Abfrage Das folgende kleine Programm (den Aufbau der Oberfläche entnehmen Sie bitte der Grafik) bietet zum einen eine Abfrage der Joystick-Position sowohl im Polling-Modus (über einen Timer) als auch über Windows-Botschaften.

1180

Kapitel 20

How-to: Multimedia

Quelltext Für die Auswertung der Windows-Botschaften überschreiben wir die WndProc-Methode des Formulars, weitere Informationen zu diesem Thema finden Sie in Ä 27.3 Windows-Botschaften verarbeiten type TForm1 = class(TForm) .... private { Private-Deklarationen } procedure WndProc(var Msg: TMessage); override; public { Public-Deklarationen } JoyInfoEx: TJoyInfoEx; JoyCaps: TJoyCaps; MaxX, MaxY, MinX, MinY: Integer; procedure JoyMove(var Msg: TMessage) end;

Auswerten der Botschaft und Aufruf der Ereignisprozedur: procedure TForm1.WndProc(var Msg: TMessage); begin if Msg.Msg = MM_JOY1MOVE then JoyMove(Msg); inherited WndProc(Msg) end;

Ereignisprozedur zur Anzeige der Joystick-Position: procedure TForm1.JoyMove(var Msg: TMessage); begin TrackBarX.Position:= Msg.lParamLo; TrackBarY.Position:= Msg.lParamHi end;

Ermitteln von Informationen (Auflösung etc.) über den Joystick und Initialisieren der Trackbars: procedure TForm1.FormCreate(Sender: TObject); begin joyGetDevCaps(JOYSTICKID1, @JoyCaps, SizeOf(JoyCaps)); TrackBarX.Min:= JoyCaps.wXmin; TrackBarX.Max:= JoyCaps.wXmax; TrackBarX.Frequency:= (JoyCaps.wXmax - JoyCaps.wXmin) div 1000; TrackBarY.Min:= JoyCaps.wYmin; TrackBarY.Max:= JoyCaps.wYmax; TrackBarX.Frequency:= (JoyCaps.wYmax - JoyCaps.wYmin) div 1000 end;

Kalibrieren des Joysticks: procedure TForm1.Button1Click(Sender: TObject); begin

1181

20.3 Einen Joystick abfragen

JoyInfoEx.dwFlags:= JOY_RETURNCENTERED; JoyInfoEx.wXpos:= (JoyCaps.wXmax - JoyCaps.wXmin) div 2; JoyInfoEx.wYpos:= (JoyCaps.wYmax - JoyCaps.wYmin) div 2; joyGetPosEx(JOYSTICKID1, @JoyInfoEx); TrackBarX.Position:= JoyInfoEx.wXpos; TrackBarY.Position:= JoyInfoEx.wYpos; Canvas.TextOut(0, 0, 'X:' + IntToStr(JoyInfoEx.wXpos) + ' IntToStr(JoyInfoEx.wYpos)) end;

Y:' +

Einschalten der Joystick-Abfrage: procedure TForm1.Button2Click(Sender: TObject); begin joySetCapture(Handle, JOYSTICKID1, 200, False) end;

Ausschalten der Joystick-Abfrage: procedure TForm1.Button3Click(Sender: TObject); begin joyReleaseCapture(JOYSTICKID1) end; procedure TForm1.Button4Click(Sender: TObject); begin JoyInfoEx.dwFlags:= JOY_CAL_READ3; JoyInfoEx.dwSize:= SizeOf(JoyInfoEx); JoyInfoEx.wXpos:= (JoyCaps.wXmax); JoyInfoEx.wYpos:= (JoyCaps.wYmax); joyGetPosEx(JOYSTICKID1, @JoyInfoEx); TrackBarX.Position:= JoyInfoEx.wXpos; TrackBarY.Position:= JoyInfoEx.wYpos; Canvas.TextOut(0, 0, 'X:' + IntToStr(JoyInfoEx.wXpos) + ' end; procedure TForm1.Button5Click(Sender: TObject); begin JoyInfoEx.dwFlags:= JOY_CAL_READ3; JoyInfoEx.dwSize:= SizeOf(JoyInfoEx); JoyInfoEx.wXpos:= (JoyCaps.wXmin); JoyInfoEx.wYpos:= (JoyCaps.wYmin); joyGetPosEx(JOYSTICKID1, @JoyInfoEx); TrackBarX.Position:= JoyInfoEx.wXpos; TrackBarY.Position:= JoyInfoEx.wYpos; Canvas.TextOut(0, 0, 'X:' + IntToStr(JoyInfoEx.wXpos) + ' IntToStr(JoyInfoEx.wYpos)) end;

Y:' + IntToStr(JoyInfoEx.wYpos))

Y:' +

1182

Kapitel 20

How-to: Multimedia

Abfrage des Joysticks über den Polling-Mode (Timer): procedure TForm1.Timer1Timer(Sender: TObject); begin beep; JoyInfoEx.dwFlags:= JOY_RETURNX or JOY_RETURNY; JoyInfoEx.dwSize:= SizeOf(JoyInfoEx); joyGetPosEx(JOYSTICKID1, @JoyInfoEx); TrackBarX.Position:= JoyInfoEx.wXpos; TrackBarY.Position:= JoyInfoEx.wYpos; Canvas.TextOut(0, 0, 'X:' + IntToStr(JoyInfoEx.wXpos) + ' end;

Y:' + IntToStr(JoyInfoEx.wYpos))

Die Komponente TJoystick Wie Sie sicher bemerkt haben, ist die Abfrage eines Joysticks nur mit relativ hohem Programmieraufwand möglich. Aus diesem Grund ist es sicher wünschenswert, die Funktionalität in eine Komponente zu verlagern, die über entsprechende Properties initialisiert und abgefragt werden kann. Zum Hintergrund der Programmierung nur so viel: Da mehrere Botschaften abgefangen werden müssen, ist es erforderlich, ein "unsichtbares" Fenster zu erstellen, an das diese Botschaften durch das System gesendet werden können. Die Botschaftsbehandlung (WndProc) ruft dann die entsprechenden Event-Methoden in der Komponente auf.

Quelltext uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, MMSystem, CPL_API; type TJoy = (jJOY1, jJOY2); TJoyButtons = set of (Btn1, Btn2, Btn3, Btn4); TJoyButtonChanged = (cBtn1, cBtn2, cBtn3, cBtn4);

Deklaration der beiden Ereignistypen: TJoyMoveEvent = procedure(Sender: TObject; x, y, z: Integer; Button: TJoyButtons) of Object; TJoyButtonEvent = procedure(Sender: TObject; x, y, z:Integer; Button: TJoyButtons; ButtonChanged: TJoyButtonChanged) of Object;

Die Klassendefinition: TJoystick = class(TComponent) private { Private-Deklarationen } FWindowHandle: HWND; FEnabled: Boolean; FJoy: TJoy; FJoyID: Integer; FJoyCaps: TJoyCaps;

20.3 Einen Joystick abfragen

FPeriod: Integer; FEventBased: Boolean; FThreshold: Cardinal; FOnJoyMove: TJoyMoveEvent; //Bewegungsereignisse FOnJoyButtonDown, FOnJoyButtonUp: TJoyButtonEvent; //Tastenereignisse FX, FY, FZ: Integer; Fdx, Fdy, Fdz: Integer; FMax, FMin: Integer; protected { Protected-Deklarationen } procedure WndProc(var Msg: TMessage); procedure UpdateState; function UpdateJoy(x, y, z: Integer; Buttons: LongInt): TJoyButtons; function TranslateButtonChanged(Buttons: LongInt): TJoyButtonChanged; procedure SetEnabled(Value: Boolean); procedure SetJoy(Value: TJoy); procedure SetPeriod(Value: Integer); procedure SetEventBased(Value: Boolean); procedure SetThreshold(Value: Cardinal); procedure SetMax(Value: Integer); procedure SetMin(Value: Integer); procedure DoJoyMove(x, y, z: Integer; Buttons: LongInt); procedure DoJoyButtonDown(x, y, z: Integer; Buttons: LongInt); procedure DoJoyButtonUp(x, y, z: Integer; Buttons: LongInt); public constructor Create(AOwner: TComponent); override; destructor Destroy; override; procedure Calibrate; property dx: Integer read Fdx; property dy: Integer read Fdy; Property dz: Integer read Fdz; published property Joystick: TJoy read FJoy write SetJoy; property Period: Integer read FPeriod write SetPeriod; property EventBased: Boolean read FEventBased write SetEventBased; property Threshold: Cardinal read FThreshold write SetThreshold; property Max: Integer read FMax write SetMax; property Min: Integer read FMin write SetMin; property Enabled: Boolean read FEnabled write SetEnabled; property OnJoyMove: TJoymoveEvent read FOnJoyMove write FOnJoyMove; property OnJoyButtonDown: TJoyButtonEvent read FOnJoyButtonDown write FOnJoyButtonDown; property OnJoyButtonUp: TJoyButtonEvent read FOnJoyButtonUp write FOnJoyButtonUp; end; procedure Register; implementation

1183

1184

Kapitel 20

Unsichtbares Fenster erzeugen, Parameter initialisieren: constructor TJoystick.Create(AOwner: TComponent); begin inherited Create(AOwner); FWindowHandle:= AllocateHWnd(WndProc); Min:= -10; Max:= 10; Threshold:= 1; Period:= 100; EventBased:= True; Enabled:= True; end;

Fenster wieder zerstören: destructor TJoystick.Destroy; begin FEnabled:= False; UpdateState; DeallocateHWnd(FWindowHandle); inherited Destroy; end;

Joystick kalibrieren: procedure TJoystick.Calibrate; var LibInst: THandle; CPlApplet: TCPlApplet; NewCPLInfo: TNewCPLInfo; begin joyReleaseCapture(FJoyID); LibInst:= LoadLibrary('joy.cpl'); try CPlApplet:= TCPlApplet(GetProcAddress(LibInst, 'CPlApplet')); if Longint(@CPlApplet)<>0 then begin if CPlApplet(FWindowHandle, CPL_INIT, 0, 0)<>0 then CPlApplet(FWindowHandle, CPL_DBLCLK, 0, Longint(@NewCPLInfo)); CPlApplet(FWindowHandle, CPL_STOP, 0, LongInt(@NewCPLInfo)); CPlApplet(FWindowHandle, CPL_EXIT, 0, 0); end; finally FreeLibrary(LibInst); joyGetDevCaps(FJoyID, @FJoyCaps, sizeof(FJoyCaps)); UpdateState; end; end;

Fensterprozedur (empfängt Nachrichten) mit Aufruf der Ereignismethoden: procedure TJoystick.WndProc(var Msg: TMessage); begin

How-to: Multimedia

1185

20.3 Einen Joystick abfragen

with Msg do case Msg of MM_JOY1MOVE, MM_JOY2MOVE: DoJoyMove(LParamLo, LParamHi, FZ, WParam); MM_JOY1ZMOVE, MM_JOY2ZMOVE: DoJoyMove(FX, FY, LParamLo, WParam); MM_JOY1BUTTONDOWN, MM_JOY2BUTTONDOWN: DoJoyButtonDown(LParamLo, LParamHi, FZ, WParam); MM_JOY1BUTTONUP, MM_JOY2BUTTONUP: DoJoyButtonUp(LParamLo, LParamHi, FZ, WParam); else Result := DefWindowProc(FWindowHandle, Msg, wParam, lParam) end end; procedure TJoystick.UpdateState; begin joyReleaseCapture(JOYSTICKID1); joyReleaseCapture(JOYSTICKID2); if FEnabled and (FWindowHandle <> 0) and not(csDesigning in ComponentState) then joySetCapture(FWindowHandle, FJoyID, FPeriod, FEventBased) end; function TJoystick.UpdateJoy(x, begin Fdx:= x - FX; FX:= x; Fdy:= y - FY; FY:= y; Fdz:= z - FZ; FZ:= z; Result:=[]; if (Buttons and JOY_BUTTON1)= if (Buttons and JOY_BUTTON2)= if (Buttons and JOY_BUTTON3)= if (Buttons and JOY_BUTTON4)= end;

y, z: Integer; Buttons: LongInt): TJoyButtons;

JOY_BUTTON1 JOY_BUTTON2 JOY_BUTTON3 JOY_BUTTON4

then then then then

Include(Result, Include(Result, Include(Result, Include(Result,

Btn1); Btn2); Btn3); Btn4)

function TJoystick.TranslateButtonChanged(Buttons: LongInt): TJoyButtonChanged; begin Result:= cBtn1; if (Buttons and JOY_BUTTON2CHG)= JOY_BUTTON2CHG then Result:= cBtn2; if (Buttons and JOY_BUTTON3CHG)= JOY_BUTTON3CHG then Result:= cBtn3; if (Buttons and JOY_BUTTON4CHG)= JOY_BUTTON4CHG then Result:= cBtn4 end;

Es folgen die Property-Methoden: procedure TJoystick.SetEnabled(Value: Boolean); begin if Value <> FEnabled then begin FEnabled:= Value; UpdateState end end;

1186

Kapitel 20

How-to: Multimedia

procedure TJoystick.SetJoy(Value: TJoy); begin if Value <> FJoy then begin FJoy:= Value; case FJoy of jJoy1: FJoyID:= JOYSTICKID1; jJoy2: FJoyID:= JOYSTICKID2 end; UpdateState end end; procedure TJoystick.SetPeriod(Value: Integer); begin if Value <> FPeriod then begin joyGetDevCaps(FJoyID, @FJoyCaps, sizeof(FJoyCaps)); if (Value >= FJoyCaps.wPeriodMin) and (Value <= FJoyCaps.wPeriodMax) then begin FPeriod:= Value; UpdateState; end; if csDesigning in ComponentState then FPeriod:= Value end end; procedure TJoystick.SetEventBased(Value: Boolean); begin if Value <> FEventBased then begin FEventBased:= Value; UpdateState end end; procedure TJoystick.SetThreshold(Value: Cardinal); begin if csDesigning in ComponentState then FThreshold:= Value else if (JoySetThreshold(FJoyID, Value) = JOYERR_NOERROR) then FThreshold:= Value end; procedure TJoystick.SetMax(Value: Integer); begin if Value <> FMax then if Value > FMin then FMax:= Value else Raise ERangeError.Create('Der Maximalwert muss größer als der' + 'Minimalwert sein!') end; procedure TJoystick.SetMin(Value: Integer); begin if Value <> FMin then if Value < FMax then FMin:= Value else

20.3 Einen Joystick abfragen

Raise ERangeError.Create('Der Minimalwert muss kleiner als der' + 'Maximalwert sein!') end;

Die Ereignisanbindung: procedure TJoystick.DoJoyMove(x, y, z: Integer; Buttons: LongInt); var JoyButtons: TJoyButtons; begin if Assigned(FOnJoyMove) then begin JoyButtons:= UpdateJoy(x, y, z, Buttons); FOnJoyMove(Self, x, y, z, JoyButtons) end end; procedure TJoystick.DoJoyButtonDown(x, y, z: Integer; Buttons: LongInt); var JoyButtons: TJoyButtons; JoyButtonChanged: TJoyButtonChanged; begin if Assigned(FOnJoyButtonDown) then begin JoyButtons:= UpdateJoy(x, y, z, Buttons); JoyButtonChanged:= TranslateButtonChanged(Buttons); FOnJoyButtonDown(Self, x, y, z, JoyButtons, JoyButtonChanged) end end; procedure TJoystick.DoJoyButtonUp(x, y, z: Integer; Buttons: LongInt); var JoyButtons: TJoyButtons; JoyButtonChanged: TJoyButtonChanged; begin if Assigned(FOnJoyButtonUp) then begin JoyButtons:= UpdateJoy(x, y, z, Buttons); JoyButtonChanged:= TranslateButtonChanged(Buttons); FOnJoyButtonUp(Self, x, y, z, JoyButtons, JoyButtonChanged) end end;

Das Interface der Komponente (Eigenschaften, Ereignisse):

1187

1188

Kapitel 20

How-to: Multimedia

Es versteht sich natürlich, dass Sie die Komponente vor ihrer Benutzung erst noch installieren müssen (Menü Komponente|Komponente installieren...). Entsprechende Hinweise dazu finden Sie beispielsweise in den Rezepten Ä 25.10 Aus einer Unit eine Komponente machen Ä 25.11 Eine Farbauswahl-Komponente programmieren

Testprogramm für TJoystick Zum Testen der Komponente und zur Demonstration finden Sie auf der Buch-CD ein kleines Programm. Einschalten des Ereignis-Modus: procedure TForm1.CheckBox1Click(Sender: TObject); begin Joystick1.EventBased:= Checkbox1.Checked end;

Das JoyButtonDown-Ereignis der Komponente nutzen wir dazu, je nach Button einen Timer zu starten, der wiederum eine Sounddatei im asynchronen Modus abspielt (wenn Sie das Programm testen, werden Sie sehr schnell den tieferen Sinn dieses Vorgehens erkennen): procedure TForm1.Joystick1JoyButtonDown(Sender: TObject; x, y, z: Integer; Button: TJoyButtons; ButtonChanged: TJoyButtonChanged); begin if ButtonChanged = cBtn1 then Timer1.Enabled:= True else Timer2.Enabled:= True end;

Nach dem Loslassen der Taste wird der Timer wieder ausgeschaltet: procedure TForm1.Joystick1JoyButtonUp(Sender: TObject; x, y, z: Integer; Button: TJoyButtons; ButtonChanged: TJoyButtonChanged); begin if ButtonChanged = cBtn1 then begin Timer1.Enabled:= False; PlaySound('..\Sound\querschl.wav', 0, SND_ASYNC); end else Timer2.Enabled:= False; end;

Jede Joystick-Bewegung führt dazu, dass die Position der Trackbars entsprechend angepasst wird: procedure TForm1.Joystick1JoyMove(Sender: TObject; x, y, z: Integer; Button: TJoyButtons); begin Trackbar1.Position:= x * Trackbar1.Max div $7FFF; Trackbar2.Position:= y * Trackbar2.Max div $7FFF end;

20.4 Testen, ob eine Soundkarte installiert ist

1189

Joystick kalibrieren: procedure TForm1.Button4Click(Sender: TObject); begin Joystick1.Calibrate; end;

Die Timer-Ereignisse: procedure TForm1.Timer1Timer(Sender: TObject); begin PlaySound('..\Sound\schuss.wav', 0, SND_ASYNC) end; procedure TForm1.Timer2Timer(Sender: TObject); begin PlaySound('..\Sound\laser.wav', 0, SND_ASYNC); end;

Test Experimentieren Sie ausgiebig mit den Beispielprogrammen, um die Möglichkeiten und Probleme der Joystick-Programmierung (Zentrieren, Drift-Erscheinungen etc.) kennen zu lernen und zu würdigen!

20.4 Testen, ob eine Soundkarte installiert ist Für Multimedia-Programme, die auch auf eine Soundkarte angewiesen sind, ist es sicher nützlich zu testen, ob auch eine Soundkarte installiert ist. Die WaveOutGetNumDevs-Funktion gibt True zurück, wenn im System mindestens eine Soundkarte installiert ist.

Oberfläche Ein Formular und ein Button genügen.

Quellcode uses MMSystem; ... function Soundkarte:Boolean; begin Result := WaveOutGetNumDevs > 0 end; procedure TForm1.Button1Click(Sender: TObject); begin if SoundKarte then ShowMessage('Eine Soundkarte ist installiert!') end;

1190

Kapitel 20

How-to: Multimedia

Test Es dürfte heute wohl kaum noch einen PC geben, bei dem die folgende Meldung nicht erscheint:

20.5 Töne mit bestimmten Frequenzen ausgeben Möchten Sie Ihrem PC-Speaker Töne mit bestimmten Frequenzen entlocken, so lässt Sie das alte Windows 95/98 im Regen stehen. Windows NT/2000/XP-Nutzer haben es da wesentlich einfacher: Mit der API-Funktion Beep (setzen Sie sicherheitshalber den Namen der Unit Windows davor) ist es problemlos möglich, Töne über den PC-Speaker auszugeben. Als Parameter erwartet die Funktion neben der Frequenz (in Hertz) auch die Zeitdauer in Millisekunden. Windows 95/98 kennt zwar auch die Funktion, das Resultat ist allerdings nur ein gequälter Standard-Piepton. Mit einer eigenen Funktion WinSound wollen wir diesem Missstand abhelfen.

Oberfläche Zum Testen genügen zwei Buttons, mit denen zum einen die Windows NT/2000/XP-Variante, zum anderen die Windows 95/98-Variante aufgerufen werden kann.

Quelltext Der Aufruf der Funktion unter Windows NT/2000/XP ist an Einfachheit nicht zu unterbieten: procedure TForm1.Button1Click(Sender: TObject); begin Windows.Beep(500, 1000) end;

HINWEIS: Die Funktion arbeitet synchron, d.h., die Kontrolle wird erst nach dem Ablauf der ge-

wünschten Zeit an das Programm zurückgegeben. Mit den beiden folgenden Funktionen können wir den Zugriff auf die PC-Ports realisieren, auch wenn Delphi ab der Version 2 den entsprechenden Port-Befehl nicht mehr zur Verfügung stellt: function GetPort(address:word):byte; asm mov dx, address in al, dx mov result, al end;

20.5 Töne mit bestimmten Frequenzen ausgeben

procedure SetPort(address: word; Value:byte); var b : byte; begin b := (value and 255); asm mov dx, address mov al, b out dx, al end; end;

Die neue Funktion zur Soundausgabe: procedure WinSound(freq,time:word); var li : LongInt; b : Byte; begin if freq > 18 then begin freq := Word(1193181 div LongInt(Freq)); B := GetPort($61); if (B and 3) = 0 then begin SetPort($61,B or 3); SetPort($43,$B6); end; SetPort($42,Freq); SetPort($42,Freq shr 8); end; li:=GetTickCount; repeat Application.ProcessMessages; until ((GetTickCount-li) >= LongInt(time)); SetPort($61,GetPort($61) and $FC); end;

Der eigentliche Aufruf: procedure TForm1.Button2Click(Sender: TObject); begin WinSound(1500,1000) end;

Test

1191

1192

Kapitel 20

How-to: Multimedia

Der Aufruf der unteren Funktion unter Windows NT/2000/XP führt, wie sicher nicht anders zu erwarten, zu Problemen. Eventuell sollten Sie deshalb vor dem Aufruf der Funktion das aktuelle Betriebssystem testen.

20.6 WAV-Dateien abspielen Im Multimedia-Zeitalter darf auch die Sound-Unterstützung Ihrer Programme nicht fehlen. Für kurze Musikeinlagen empfiehlt sich das WAVE-Format1. Statt des Media-Players wollen wir in diesem Fall direkt mit API-Funktionen arbeiten2.

Oberfläche Den grundsätzlichen Aufbau der Oberfläche können Sie der Abbildung entnehmen. DriveComboBox, DirectoryListBox und FileListBox verknüpfen Sie über die Eigenschaften DirList und FileList.

Die Aufschrift der Buttons dürfte alles über deren Funktion sagen. Mit den Checkboxen bestimmen Sie, wie die Sound-Dateien abgespielt werden: SYNC

Während die WAV-Datei abgespielt wird, "steht" die Anwendung.

ASYNC

Die Datei wird unabhängig vom Programm abgespielt. Sie können die Anwendung auch beenden, ohne dass dies irgendeinen Einfluss auf die Ausgabe der WAV-Datei hätte.

LOOP

Die wohl beste Methode, um jemanden in den Wahnsinn zu treiben! Kombiniert mit dem asynchronen Abspielen der Dateien können Sie das Programm beenden und einen Rechner zurücklassen, der ununterbrochen Lärm verbreitet. Die Soundorgie kann erst durch eine Anweisung gestoppt werden.

1

Ein Microsoft-Standard-Dateiformat zum Speichern von Audiodaten. WAVE-Dateien haben die Extension .WAV.

2

Es versteht sich wohl von selbst, dass Ihr PC über eine Soundkarte verfügen muss.

20.7 Sound-Ressourcen in ein Programm einbinden

1193

Quelltext Einbindung der API-Funktion: uses MMSystem;

Der Ursprung allen Lärms: var flag :word; begin flag := 0; if checkbox1.checked then flag := flag OR SND_SYNC; if checkbox2.checked then flag := flag OR SND_ASYNC; if checkbox4.checked then flag := flag OR SND_LOOP; sndPlaySound(PChar(FileListBox1.filename),flag) end;

Diese Funktion sorgt für Ruhe im Rechner: procedure TForm1.Button1Click(Sender: TObject); begin sndPlaySound(nil,0) end;

Test Ein unmittelbares Klangerlebnis kann Ihnen dieses Buch leider nicht vermitteln, es sei denn, Sie wählen eine der WAV-Dateien (die Sie auf der Buch-CD finden) aus und spielen diese ab.

20.7 Sound-Ressourcen in ein Programm einbinden Wollen Sie Ihre Applikationen akustisch aufpeppen, bietet sich die Möglichkeit an, WAV-Dateien über die API-Funktion sndPlaySound auszugeben (siehe vorhergehendes Rezept). Doch leider hat diese Variante auch einen Nachteil: Soll das Programm weitergegeben werden, ist es sehr umständlich, wenn Sie dazu Dutzende WAV-Dateien kopieren müssen. Das folgende Beispiel zeigt Ihnen, wie Sie WAV-Dateien als Ressource in Ihre Anwendung linken.

Oberfläche Die Oberfläche besteht lediglich aus einem Listenfeld sowie einem Button. In das Listenfeld werden die Namen der Klänge so eingetragen, wie in der Ressourcendatei definiert.

Quelltext Neben der Unit MMSystem müssen Sie auch die Ressourcen-Datei einbinden: uses mmsystem; {$R sound.res}

1194

Kapitel 20

How-to: Multimedia

Die Ressourcendatei hat folgenden Aufbau (interner Name, Ressourcentyp, Datei): EXPLOSION WAVE SCHUSS WAVE QUER WAVE

explos.wav schuss.wav querschl.wav

Wie Sie Ressourcendateien compilieren, ist in Ä 30.10 Ressourcen einbinden beschrieben. Die Prozedur zum Abspielen der Klänge: procedure TForm1.Button1Click(Sender: TObject); var Res : THandle; Reshandle : THandle; begin

Versuch, die Ressource über ihren Namen zu finden: Res := FindResource(HInstance, PChar(Listbox1.items[listbox1.itemindex]),'WAVE'); if Res <> 0 then begin

Falls wir Erfolg gehabt haben, laden der Ressource: Reshandle := LoadResource(HInstance, Res); if Reshandle <> 0 then begin

Bevor wir die Ressource abspielen, müssen wir diese im Speicher sperren (LockResource): sndPlaySound(LockResource(Reshandle), SND_ASYNC or SND_MEMORY);

Welche Optionen für das Abspielen von Sounds verwendet werden können, ist im vorhergehenden Abschnitt beschrieben, wichtig ist nur, dass Sie die Option SND_MEMORY verwenden. Freigeben und Löschen der Ressource: UnlockResource(Reshandle); FreeResource(Reshandle) end end end;

Test Erfreuen Sie sich an den auf der Buch-CD enthaltenen martialischen Klängen!

1195

20.8 Sound-Dateien aufnehmen

20.8 Sound-Dateien aufnehmen Möchten Sie endlich Ihre verborgenen Talente auf dem Gebiet des Gesangs unter Beweis stellen, dann bietet Ihnen das vorliegende Rezept eine hervorragende Möglichkeit, die Ergebnisse Ihres Schaffens in digitaler Qualität für die Nachwelt zu konservieren. Spaß beiseite, denn im Folgenden wollen wir uns mit der Aufnahme von WAV-Dateien ernsthaft auseinander setzen. Die MultimediaKomponente von Delphi hilft uns da leider nicht weiter, also müssen wir uns wieder mit Funktionen des Windows-API herumschlagen.

Oberfläche Drei Tasten werden benötigt: eine zur Aufnahme, eine zum Anhalten und eine zum Abspeichern der WAV-Datei:

Quelltext Binden Sie zunächst die Unit mmSystem in Ihr Projekt ein. Nachfolgend müssen Sie sich zwischen guter Klangqualität mit immensem Speicherbedarf oder mäßiger Tonqualität bei mäßigem Speicherbedarf entscheiden. Folgende Tabelle gibt einen kurzen Überblick: Frequenz (Hz)

Bits/Sample

Mono/Stereo

Bemerkung

8000

8

Mono

das untere Ende der Qualitätsskala (480 KByte/min)

22050

16

Stereo

schon recht brauchbare Qualität (5,3 MByte/min)

An dieser Stelle noch einmal im Schnelldurchlauf die wichtigsten Begriffe und deren Bedeutung: Begriff

Bemerkung

BitsPerSample

Mit diesem Wert (meist 8 oder 16) beschreiben Sie, wie genau ein analoger Wert abgetastet wird (256 oder 65535 mögliche Werte).

Channels

Mono (1) oder Stereo (2)

SamplesPerSec

Abtastungen pro Sekunde (8000, 11025, 22050, 44100)

1196

Kapitel 20

How-to: Multimedia

Begriff

Bemerkung

BytesPerSec

Die Angabe dieses Wertes scheint nicht ganz sinnvoll, ist doch mit obigen Werten die Digitalisierung schon ausreichend definiert. Lassen Sie diesen Wert jedoch weg, gibt es Probleme. Es bleibt also nichts anderes übrig, als die schon bekannten Tatsachen noch einmal zusammenzufassen: BytesPerSec := (BitsPerSample div 8) * Channels * SamplesPerSec

Doch zurück zu unserer Aufgabenstellung: Bevor wir mit der Aufnahme beginnen, müssen wir ein Audio-Gerät öffnen: procedure TForm1.Button1Click(Sender: TObject); // Record-Taste begin mciSendString('OPEN NEW TYPE WAVEAUDIO ALIAS mysound', nil, 0, handle);

An die Funktion mciSendString übergeben Sie neben dem Befehl einen leeren Puffer für die Rückgabewerte (nil), die Größe des Puffers (0) und das Handle des aktuellen Fensters. Beachten Sie im Kommandostring den Alias "mysound". Über diesen Alias steuern Sie ab sofort das Audio-Gerät. mciSendString('SET mysound TIME FORMAT MS '+ // Zeitformat 'BITSPERSAMPLE 8 '+ // 8 Bit 'CHANNELS 1 '+ // MONO 'SAMPLESPERSEC 8000 '+ // 8 KHz 'BYTESPERSEC 8000', // 8000 Bytes/s nil, 0, handle);

Jetzt beginnt die Aufnahme: mciSendString('RECORD mysound', nil, 0, handle) end;

Im Weiteren können Sie Ihre musikalischen Talente frei entfalten. Dem Treiben wird mit der StopTaste ein Ende bereitet: procedure TForm1.Button2Click(Sender: TObject); begin mciSendString('STOP mysound', nil, 0, handle) end;

// Stop

Soll alles gespeichert werden, verwenden Sie die Save-Taste. procedure TForm1.Button3Click(Sender: TObject); var verz: string; begin

// Save

Die Sounddatei soll im aktuellen Verzeichnis abgespeichert werden: GetDir(0, verz);

Beachten Sie, dass der Übergabeparameter der mciSendString-Routine vom Typ PChar ist! mciSendString(PChar('SAVE mysound ' + verz + '\test.wav'), nil, 0, handle);

20.9 AVI-Dateien anzeigen

1197

Zum Schluss sollten Sie nicht vergessen, das "Gesangsstudio" wieder fein säuberlich aufzuräumen: mciSendString('CLOSE mysound', nil, 0, handle) end;

Test Bevor Sie die "Record"-Taste klicken, vergewissern Sie sich, dass das Mikrofon richtig an die Soundkarte angeschlossen ist. Beginnen Sie nun mit Ihren gesanglichen Darbietungen und beenden Sie diese mit der "Stop"-Taste. Klicken Sie anschließend auf "Save" und schauen Sie nach, ob sich tatsächlich eine neue Datei test.wav im aktuellen Verzeichnis befindet. Wenn Sie auf diese Datei doppelklicken, hören Sie sich im standardmäßig zugewiesenen Audiogerät "singen". Ansonsten verwenden Sie den Audio-Recorder aus dem Windows-MultimediaZubehör.

Bemerkungen ■ Experimentieren Sie einmal mit verschiedenen Einstellungen. Weitere MCI-Befehle sind unter anderem play, wait, load etc. Mehr zu diesem Thema finden Sie in der mm.hlp-Datei. ■ Durch Einbinden einer SaveDialog-Komponente können Sie Verzeichnis und Namen der WAV-Datei frei bestimmen. ■ Falls keine WAV-Datei erzeugt wird, kann die Ursache ein nicht erkannter Verzeichnisnamen sein (langer Dateinamen, Leerzeichen etc.). Verschieben Sie das Programm in ein anderes Verzeichnis und testen Sie erneut. ■ Nicht jede Soundkarte bzw. deren Treiber unterstützt alle gewünschten Formate. Welche Kombinationen realisierbar sind, können Sie über das im Windows-Zubehör enthaltene Programm AudioRecorder abfragen.

20.9 AVI-Dateien anzeigen Im Multimedia-Zeitalter (was immer das auch heißen mag) ist die Einbindung von Bild und Ton in Programme eine Selbstverständlichkeit. Windows unterstützt mit dem AVI-Dateiformat das Abspielen kurzer Video-Sequenzen. Kurz deshalb, weil schon Video-Clips mit nur wenigen Sekun-

1198

Kapitel 20

How-to: Multimedia

den Spieldauer mehrere Megabyte auf der Festplatte konsumieren. Für bestimmte Einsatzfälle ist die Unterstützung dieses Formates dennoch sinnvoll.

Oberfläche Im Wesentlichen brauchen Sie nur eine MediaPlayer-Komponente, über die Sie unter anderem auch AVI-Dateien abspielen können.

Wichtig ist die folgende Eigenschaft: Display = panel1

Parametrieren Sie diese Eigenschaft nicht, öffnet Delphi den AVI-Player von Windows für die Videoausgabe. Sie haben jedoch die Möglichkeit, diese Ausgabe in eine Komponente bzw. in ein Formular umzuleiten. Neben dem Panel1 ist die Ausgabe noch in mehreren anderen Komponenten zulässig. Über die Anzeige der Buttons entscheiden Sie mit der VisibleButtons-Eigenschaft: VisibleButtons = [btPlay,btPause,btStop,btBack]

Einige der Tasten sind nur im Zusammenhang mit anderen Ausgabegeräten sinnvoll (Eject, Record). Die restlichen Komponenten sind eigentlich Beiwerk, sie ermöglichen lediglich die Auswahl einer AVI-Datei zur Laufzeit, mit einer Ausnahme: Über das Timer-Intervall blenden wir zyklisch die Anzahl der angezeigten Einzelbilder ein.

1

Diese Komponente ist nach Meinung der Autoren noch die sinnvollste Möglichkeit. In einem Memofeld sollte man besser keine Grafiken anzeigen, obwohl es funktioniert!

20.9 AVI-Dateien anzeigen

1199

Quelltext procedure TForm1.Laden1Click(Sender: TObject); begin if opendialog1.execute then begin with mediaplayer1 do begin filename := opendialog1.filename; open; timer1.enabled:=True; label2.caption := inttostr(Length); display := panel1; play end end end; procedure TForm1.Timer1Timer(Sender: TObject); begin Label1.Caption := IntToStr(MediaPlayer1.Position) end;

Test Laden Sie eine .AVI-Datei und spielen Sie sie ab (wie z.B. den rotierenden Globus von der BuchCD)!

1200

Kapitel 20

How-to: Multimedia

20.10 Die Ausgabefläche für AVIs anpassen Dieses Rezept baut prinzipiell auf dem vorhergehenden Beispiel auf, allerdings mit einem wesentlichen Unterschied: Die Größe des Panels wird an die Abmessungen des Videos angepasst. Dazu muss aber ein etwas höherer Aufwand betrieben werden als bisher. Laden Sie das vorhergehende Beispiel und nehmen Sie folgende Anpassungen vor:

Quelltext Zur Abfrage der Videogröße müssen wir wieder einmal das API bemühen. Binden Sie deshalb die Unit mmsystem mit der Uses-Klausel in das Projekt ein. Die eigentlichen Erweiterungen betreffen das Laden der AVI-Datei (Kommentare sind eingefügt): procedure TForm1.Laden1Click(Sender: TObject); var dwParam2 : TMCI_OVLY_RECT_PARMS; Retval : longint; begin if OpenDialog1.execute then begin with mediaplayer1 do begin filename := OpenDialog1.filename; open; timer1.enabled:=True; label2.caption := inttostr(Length); display := panel1; dwParam2.dwCallback := mediaplayer1.handle; dwParam2.rc.Left := 0; dwParam2.rc.Top := 0; dwParam2.rc.Right := 0; dwParam2.rc.Bottom := 0;

Die Kommunikation mit der Multimedia-Schnittstelle erfolgt über die MCI-Commands, der folgende Aufruf ermittelt die originalen Abmessungen des Videos (Rückgabe in dwParam2). Retval := mciSendCommand(mediaplayer1.DeviceID, MCI_WHERE, MCI_OVLY_WHERE_SOURCE, integer(@dwParam2));

Die Übergabe des vierten Parameters sieht etwas eigenartig aus, das liegt aber daran, dass in der Unit mmsystem eine etwas seltsame Interpretation des API-Aufrufs deklariert wurde (laut SDKHandbuch wird ein Pointer auf die Datenstruktur erwartet und nicht ein Integerwert). Sollte ein Fehler aufgetreten sein: if Retval <> 0 then begin ShowMessage('Problem'); end else begin

1201

20.11 Eine AVI- Komponente programmieren

Andernfalls passen wir das Formular und damit auch das Panel an die neuen Abmessungen an: self.ClientWidth := dwParam2.rc.Right - dwParam2.rc.Left; self.ClientHeight := dwParam2.rc.Bottom - dwParam2.rc.Top+ panel2.height;

Damit auch das Formular neu gezeichnet werden kann: Application.ProcessMessages;

Abspielen des Videos: play; ...

Test Unmittelbar nach Programmstart erscheint das Fenster noch in ursprünglicher Größe und schrumpft erst nach dem Laden der Videodatei auf das gewünschte Format:

20.11 Eine AVI- Komponente programmieren Zum Problem "AVI" möchten wir Ihnen eine Komplettlösung in Form einer selbst programmierten Delphi-Komponente vorstellen. Vorteile: Sie können auf die Multimedia-Komponente von Delphi verzichten, unsere Komponente passt sich automatisch den Abmessungen des Videos an, gleichzeitig haben Sie wesentlich mehr Einfluss auf den Ablauf des Videos (z.B. Standbild etc.).

Quelltext (Komponente) Beginnen wir mit dem (doch ziemlich anspruchsvollen) Quellcode der Komponente: Unit MMVideo; interface uses windows, Messages, SysUtils, Classes, DsgnIntf, ExtCtrls, Graphics, MMSystem, Controls, Forms, Dialogs; const MCIWNDM_NOTIFYMODE = WM_USER + 200;

// wp = hwnd, lp = mode

1202

Kapitel 20

How-to: Multimedia

Die Klassendefinition der Komponente (Basisklasse ist ein TPanel): type TMMVideo = class(TPanel) private { Private Declarations } FAVIHandle : THandle; FMaxFrames : integer; FOnMouseEnter : TNotifyEvent; FOnMouseLeave : TNotifyEvent; procedure setframe(value : integer); Procedure CMMouseEnter(var Message: TMessage); message Procedure CMMouseLeave(var Message: TMessage); message protected { Protected Declarations } public { Public Declarations } constructor Create(AOwner: TComponent); override; destructor Destroy; override; function Load(FileName:string): Boolean; procedure Play; procedure Stop; procedure Halt; procedure Rewind; property Frames:Integer read FMaxFrames; property Frame:Integer write SetFrame; published property OnMouseEnter: TNotifyEvent read FOnMouseEnter property OnMouseLeave: TNotifyEvent read FOnMouseLeave end;

CM_MOUSEENTER; CM_MOUSELEAVE;

write FOnMouseEnter; write FOnMouseLeave;

Vielleicht haben Sie sich über die beiden Ereignisse OnMouseEnter und OnMouseLeave gewundert? Diese dienen lediglich der Reaktion auf das Hinein- bzw. Hinausbewegen der Maus, eine Funktion, die man gerade in Multimedia-Anwendungen häufig benötigt. Weitere Informationen dazu finden Sie in: Ä 18.32 Auf Mausbewegungen reagieren Nach der Definition einiger Konstanten: procedure Register; implementation const VFWDLL = 'MSVFW32.DLL'; MCIWND_START = -1 ; MCIWND_END = -2 ; MCIWNDF_NOAUTOSIZEWINDOW = $0001; // die Abmessungen des Videos ändern sich MCIWNDF_NOPLAYBAR = $0002; // keine Toolbar MCIWNDF_NOAUTOSIZEMOVIE = $0004; // die Fensterabmessungen ändern sich MCIWNDF_NOMENU = $0008; // kein Popup-Menü der rechten Maustaste

20.11 Eine AVI- Komponente programmieren

1203

MCIWNDF_SHOWNAME = $0010; // Name in Titelleiste anzeigen MCIWNDF_SHOWPOS = $0020; // Position in Titelleiste anzeigen MCIWNDF_SHOWMODE = $0040; // Modus anzeigen MCIWNDF_SHOWALL = $0070; // alles zeigen MCIWNDF_NOTIFYSIZE = $0400; // Parent bei Größenänderungen benachrichtigen MCIWNDM_GET_SOURCE = WM_USER + 140; MCIWNDM_GETLENGTH = WM_USER + 104; MCIWNDF_NOTIFYMODE = $0100; // Parent bei Modusänderungen benachrichtigen

binden wir noch eine API-Funktion der MSVFW32.DLL ein: function MCIWndCreate(hwndParent: HWND; hInstance: HINST; dwStyle: DWORd; szFile: LPCSTR): HWND; cdecl; external VFWDLL name 'MCIWndCreateA';

Die folgenden Funktionen sind in den original C-Quelltexten (API-Interface) als Makros definiert. Delphi bietet an dieser Stelle lediglich die Möglichkeit von Funktionsaufrufen: function MCIWndSM(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): DWORD; begin Result := SendMessage(hWnd, Msg, wParam, lParam) end; function MCIWndPlay(hwnd: HWND): DWORD; begin Result := MCIWndSM(hwnd, MCI_PLAY, 0, 0) end; function MCIWndClose(hwnd: HWND): DWORD; begin Result := MCIWndSM(hwnd, MCI_CLOSE, 0, 0) end; procedure MCIWndDestroy(hwnd: HWND); begin MCIWndSM(hwnd, WM_CLOSE, 0, 0) end; function MCIWndGetSource(hwnd: HWND; prc: PRECT): DWORD; begin Result := MCIWndSM(hwnd, MCIWNDM_GET_SOURCE, 0, LPARAM(prc)) end; function MCIWndPause(hwnd: HWND): DWORD; begin Result := MCIWndSM(hwnd, MCI_PAUSE, 0, 0) end; function MCIWndSeek(hwnd: HWND; lPos: LongInt): LongInt; begin Result := MCIWndSM(hwnd, MCI_SEEK, 0, lPos) end; function MCIWndHome(hwnd: HWND): LongInt; begin Result := MCIWndSeek(hwnd, MCIWND_START) end;

Der Konstruktor unserer Komponente: constructor TMMVideo.Create(AOwner: TComponent); begin inherited Create(AOwner); FAVIHandle := 0; color := clBlack;

1204

Kapitel 20

How-to: Multimedia

BevelOuter := bvNone end;

Der Destruktor: destructor TMMVideo.Destroy; begin if FAVIHandle <> 0 then MCIWndDestroy(FAVIHandle); inherited Destroy end;

Aufwändigste Operation ist das Laden des Videos sowie die Größenanpassung der Komponente: function TMMVideo.Load; var rect : TRect; begin if FAVIHandle <> 0 then MCIWndDestroy(FAVIHandle); if FileExists(fileName) then begin FAVIHandle := MCIWndCreate(Self.Handle,HINSTANCE, MCIWNDF_NOPLAYBAR + MCIWNDF_NOTIFYMODE, pChar(fileName)); Result := FAVIHandle <> 0; if FAVIHandle <> 0 then begin // Größe anpassen FMaxFrames := MCIWndSM(FAVIHandle, MCIWNDM_GETLENGTH, 0, 0); MCIWndGetSource(FAVIHandle,@RECT); Self.Width := rect.Right-rect.Left+2; Self.Height := rect.Bottom-rect.Top+2 end; end else Result := False end;

Licht aus, Vorhang auf, die Show beginnt! procedure TMMVideo.Play; begin if FAVIHandle <> 0 then MCIWndPlay(FAVIHandle) end;

Die weiteren Methoden dürften selbst erklärend sein: procedure TMMVideo.Stop; begin if FAVIHandle <> 0 then MCIWndClose(FAVIHandle) end; procedure TMMVideo.Halt; begin if FAVIHandle <> 0 then MCIWndPause(FAVIHandle) end; procedure TMMVideo.Rewind; begin if FAVIHandle <> 0 then MCIWndHome(FAVIHandle) end;

20.11 Eine AVI- Komponente programmieren

1205

Mit der folgenden Methode können Sie einen einzelnen Frame (sprich ein Einzelbild) aus dem Video auswählen: procedure TMMVideo.Setframe(value : Integer); begin if FAVIHandle <> 0 then begin if value <= FMaxFrames then MCIWndSM(FAVIHandle, MCI_SEEK, 0, value) else MCIWndSM(FAVIHandle, MCI_SEEK, 0, MCIWND_END) end; end;

Verwendungszweck dieser Funktion: Sie kopieren mehrere Bitmaps (diese müssen gleiche Farbtabellen besitzen) in ein AVI und können diese später mit einem Timer nacheinander einblenden. Der Vorteil: Sie müssen lediglich eine Datei kopieren. Gleichzeitig sind AVI-Dateien gepackt, was auch Ihre Festplatte dankbar zur Kenntnis nimmt. procedure TMMVideo.CMMouseEnter(var Message: TMessage); begin if Assigned(OnMouseEnter) then OnMouseEnter(Self) end; procedure TMMVideo.CMMouseLeave(var Message: TMessage); begin if Assigned(OnMouseLeave) then OnMouseLeave(Self) end; procedure register; begin RegisterComponents('MM', [TMMVideo]) end;

Quelltext (Testprogramm) Um Ihnen den Test so einfach wie möglich zu gestalten, binden wir die Komponente erst zur Laufzeit ein. HINWEIS: Sie brauchen deshalb die Komponente für den Test nicht zu installieren!

Wir müssen die Komponente zunächst mit Create erzeugen: procedure TForm1.FormCreate(Sender: TObject); begin mmVideo1 := TMMVideo.Create(Self); mmVideo1.Left := 0; mmVideo1.Top := 34; mmVideo1.Visible := True; mmVideo1.Parent := Self end;

Nach dem Laden eines Videos können Sie bereits alle Methoden und Eigenschaften der Komponente nutzen. Über die Eigenschaft Frames ermitteln Sie beispielsweise, aus wie vielen Einzelbildern das Video besteht. procedure TForm1.Button1Click(Sender: TObject); begin mmVideo1.Load('internet.avi');

1206

Kapitel 20

How-to: Multimedia

Trackbar1.Max := mmVideo1.Frames end;

Umgekehrt können Sie mit der Eigenschaft Frame festlegen, welches Einzelbild momentan dargestellt werden soll. Wir verwenden dazu die Trackbar-Komponente, durch einfaches Verschieben des Reglers können Sie das gewünschte Bild einblenden: procedure TForm1.TrackBar1Change(Sender: TObject); begin mmVideo1.Frame := Trackbar1.Position end;

Die weiteren Methodenaufrufe dürften für sich sprechen: procedure TForm1.Button2Click(Sender: TObject); begin mmVideo1.Play end; procedure TForm1.Button3Click(Sender: TObject); begin mmVideo1.Halt end; procedure TForm1.Button4Click(Sender: TObject); begin mmVideo1.rewind end; procedure TForm1.Button5Click(Sender: TObject); begin mmVideo1.Stop end;

Test Vergewissern Sie sich, ob sich vor dem Programmstart eine AVI-Datei mit dem Namen internet.avi im Projektverzeichnis befindet. Starten Sie das Programm. Lassen Sie sich von dem zunächst erscheinenden schwarzen Kasten nicht erschrecken, sondern klicken Sie auf den "Load"-Button. Nachfolgend können Sie alle weiteren Funktionen der Komponente ausprobieren.

20.12 AVI-Videos im Vollbildmodus abspielen

1207

20.12 AVI-Videos im Vollbildmodus abspielen Geht es einfach darum, ein Video bildschirmfüllend abzuspielen, hilft Ihnen die MCI-Schnittstelle weiter. Mit wenigen Zeilen Quellcode haben Sie die Sache im Griff, ohne gleich mit der Multimedia-Komponente arbeiten zu müssen.

Oberfläche Lediglich ein Formular und ein Button, um das Video zu starten.

Quelltext Nehmen Sie die Unit MMSystem in die uses-Klausel auf und erweitern Sie die Klassendeklaration des Formulars um einen neuen Message-Handler: uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, MMSystem; type TForm1 = class(TForm) Button1: TButton; procedure Button1Click(Sender: TObject); private procedure MMNotify(var Message: TMessage); message MM_MCINOTIFY; ...

Mit dem Klick auf den Button öffnen wir zunächst mit Hilfe der MCI-Schnittstelle das gewünschte Video und deklarieren gleichzeitig einen Alias, über den im Folgenden die Schnittstelle verwaltet wird: procedure TForm1.Button1Click(Sender: TObject); begin mciSendString('open test.avi alias testvideo', nil, 0, 0); mciSendString('window testvideo handle 0', nil, 0, 0);

Maximieren des Videos und abspielen (notify bestimmt, dass beim Beenden eine Message an die Anwendung gesendet wird): mciSendString('window testvideo state show maximized', nil, 0, 0); mciSendString('play testvideo notify', nil, 0, handle); end;

Auf das Ende des Videos (auch User-Abbruch) reagieren wir mit Hilfe des folgenden MessageHandlers: procedure TForm1.MMNotify(var Message: TMessage); begin mciSendString('close testvideo', nil, 0, 0); end;

1208

Kapitel 20

How-to: Multimedia

Eine zweite Variante, wenn Sie das Video synchron abspielen wollen: mciSendString('open test.avi alias testvideo', nil, 0, 0); mciSendString('play testvideo fullscreen wait', nil, 0, handle); mciSendString('close testvideo', nil, 0, 0);

20.13 Hotspots realisieren Für grafische Bedienoberflächen (Menüs, Spiele etc.) braucht man häufig "aktive Flächen", die reagieren, wenn sie mit der Maus angeklickt oder berührt werden. Die Abfrage der Mauskoordinaten zu diesem Zweck ist recht umständlich.

Quelltext Sollten sich für Ihren Anwendungsfall rechteckige Hotspots nicht eignen, bietet sich mit den Windows-Regions eine gute Alternative. Wie Sie im Weiteren feststellen werden, sind Regionen nicht nur für die Ausgabe, sondern auch für die Auswertung von Mausereignissen interessant. BEISPIEL: Die Abbildung zeigt das Ergebnis von Grafikausgaben in einer Region:

Als Beispiel erzeugen wir einen runden Hotspot. Beim Laden des Formulars wird die Region erzeugt, gleichzeitig zeichnen wir an der gleichen Position einen Kreis zur Orientierung: var rh1 : HRGN; procedure TForm1.FormCreate(Sender: TObject); begin RH1 := CreateEllipticRgn(10, 10, 210, 210) end; procedure TForm1.FormPaint(Sender: TObject); begin canvas.Ellipse(10, 10, 210, 210) end;

Bei einem Mausklick wird nur dann ein Text ausgegeben, wenn sich der Mauszeiger in der Region befindet: procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);

20.14 Hotspots auf Grafiken erzeugen

1209

begin if PtInRegion(RH1, x,y) then begin canvas.Pixels[x,y]:= clblack; canvas.TextOut(x+1,y+1,'In Region') end end;

Jede Mausbewegung über der Region zeichnet einen Punkt: procedure TForm1.FormMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer); begin If PtInRegion(RH1,x,y) then canvas.Pixels[X, Y]:= clRed end;

Test

Bemerkung Auf ähnliche Weise könnten Sie auch ein vektororientiertes Zeichenprogramm realisieren. Beim Klicken auf die Zeichenfläche wird eine Liste von Regionen durchlaufen, tritt eine Übereinstimmung auf, wird das betreffende Zeichenobjekt markiert.

20.14 Hotspots auf Grafiken erzeugen Für Informationssysteme, Electronic Books oder Spiele braucht man häufig "aktive Flächen", die reagieren, wenn sie mit der Maus angeklickt oder berührt werden. Die Abfrage der Mauskoordinaten zu diesem Zweck ist meist umständlich und langwierig. Viel einfacher geht es mit einer Shape-Komponente, deren Brush.Style auf bsClear festgelegt ist.

Oberfläche Auf dem Formular platzieren Sie eine Image-Komponente mit Grafik und Text. Mit mehreren Shape-Komponenten werden die maussensitiven Flächen eingerahmt.

1210

Kapitel 20

How-to: Multimedia

Soll auch der verbleibende Rahmen entfallen, setzen Sie die Eigenschaft Pen.Style auf psClear.

Quelltext Reaktionen auf die Maus: procedure TForm1.Shape3MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin Close // Formular schließen end; procedure TForm1.Shape4MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin Form2.Show // irgendein Formular aufrufen end; ...

Test Starten Sie das Programm und testen Sie die Reaktion auf Mausklicks. Weiterhin lassen sich die Hints der einzelnen Shapes zur Anzeige von Zusatzinformationen verwenden. Im Demo-Programm auf der Buch-CD wird z.B. bei Klick auf die Grafik eine CopyrightMeldung ausgegeben:

20.15 Runde Fenster erzeugen

1211

20.15 Runde Fenster erzeugen Viele hoffnungsvolle Programmiertalente enden als Opfer des eigenen Spieltriebs: Es genügt nicht mehr, dass die Fenster mit diversen 3-D-Effekten überfrachtet werden, nein, jetzt müssen es auch noch beliebig geformte Fenster sein. Aber auch die Autoren wollten diesem Treiben nicht länger tatenlos zusehen. Voilà, hier unser Beitrag:

Quelltext Grundprinzip des Beispielprogramms ist das Verändern der Fenster-Region, die im Normalfall rechteckig ist. HINWEIS: Da es sich bei Buttons etc. auch um Fenster handelt, lassen sich die folgenden Aus-

führungen auch auf derartige Komponenten anwenden. Es ist also kein Problem, einen runden Button zu erzeugen. Allerdings ist es jetzt Ihre Aufgabe, eine sinnvolle Oberfläche (3D) zu realisieren. Dieses Fenster hat zwar auch vier Ecken, aber ... procedure TForm1.FormCreate(Sender: TObject); var HR: HRgn; n : array [0..3] of TPoint; begin n[0] := Point(Width div 2, 1); n[1] := Point(1, Height div 2);

1212

Kapitel 20

How-to: Multimedia

n[2] := Point(Width div 2, Height); n[3] := Point(Width, Height div 2); HR := CreatePolygonRgn(n, 4, ALTERNATE); SetWindowRgn(Handle, HR, True) end;

Ein rundes Fenster, das teilweise durchsichtig ist: procedure TForm2.FormCreate(Sender: TObject); var r1,r2 : HRgn; begin r1 := CreateEllipticRgn(1, -1, Width - 1, Height); r2 := CreateEllipticRgn(50, 50, Width - 50, Height - 50); CombineRgn(r2, r1, r2, RGN_XOR); SetWindowRgn(handle, r2, True) end;

Test Wie Sie der folgenden Abbildung entnehmen können, fehlt einem Fenster ein Teil des Hintergrundes, aber auch mit den äußeren Abmessungen scheint etwas nicht zu stimmen:

20.16 Ein CD-Laufwerk sicher erkennen

1213

20.16 Ein CD-Laufwerk sicher erkennen Ist ein CD-Laufwerk im Netz freigegeben, wird dieses von der Funktion GetDriveType nur als Netzlaufwerk erkannt. Für eine sichere Bestimmung sollten Sie die folgende Funktion verwenden.

Oberfläche Auf das Startformular setzen Sie lediglich eine ListBox-Komponente.

Quelltext Nach der Einbindung der Unit windows definieren wir zunächst einen neuen Datentyp, der als Rückgabewert der Funktion IsCDDrive Verwendung findet. uses windows; type TCDDrive = (cdError, cdNone, cdAudio, cdData); function IsCDDrive(drive:String):TCDDrive; var VolumeName, FileSystemName : PChar; Seriennummer, MaxLen,SysFlags : DWord; begin result := cdNone; VolumeName := StrAlloc(256); FileSystemName := StrAlloc(256); if (not GetVolumeInformation(PChar(drive),VolumeName,255, @Seriennummer,MaxLen,SysFlags,FileSystemName,255)) then Result:= cdError else begin if (Volumename='Audio CD') then result := cdAudio else if (FileSystemName='CDFS')then result := cdData end; StrDispose(VolumeName); StrDispose(FileSystemName) end;

Der folgende Quellcode zeigt die Verwendung der Funktion. Der Einfachheit halber erfolgt der Aufruf beim Laden des Formulars. procedure TForm1.FormCreate(Sender: TObject); var i : Byte; s : string;

1214

Kapitel 20

How-to: Multimedia

begin for i := 65 to 90 do begin // Buchstabencodes A ... Z case iscdDrive(Chr(i) + ':\') of cdError : s := 'Fehler'; cdData : s := 'Daten-CD'; cdAudio : s := 'Audio-CD'; cdNone : s := 'Kein CD-Laufwerk' end; Listbox1.Items.Add(Format('%s : %s',[Chr(i),s])) end end;

Test Nach dem Programmstart werden alle Laufwerksbezeichner nacheinander geprüft. Wie z.B. bei einem normalen Diskettenlaufwerk muss auch im CD-Laufwerk eine CD eingelegt sein, um es zu erkennen, ansonsten erscheint "Fehler". Beim folgenden Beispielcomputer wird E: als CD-Laufwerk mit einer Daten-CD identifiziert. In Laufwerk D: befindet sich eine Musik-CD.

20.17 Eine Audio-CD erkennen Nachdem Sie mit Hilfe des vorhergehenden Beispiels festgestellt haben, dass es sich um ein CDLaufwerk handelt, besteht die Frage, ob eine Daten-CD oder eine Musik-CD eingelegt ist. Beispielsweise könnte ein CD-Player-Programm bei einer Musik-CD automatisch die Tracks einlesen oder mit dem Abspielen beginnen. Zwei Varianten sind möglich: ■ Sie ermitteln den Volumename der CD, dieser ist bei einer Musik-CD immer "Audio CD". ■ Sie kontrollieren, ob auf der CD so genannte CDA-Files vorhanden sind, ein relativ sicheres Zeichen, dass es sich um eine Musik-CD handelt. Der Inhalt einer Musik-CD:

20.17 Eine Audio-CD erkennen

1215

Oberfläche Erforderlich sind lediglich ein Label, zwei Buttons und eine DriveComboBox (diesen Veteranen entnehmen Sie der "Win 3.1"-Seite) zur Auswahl des gewünschten Laufwerks:

Quelltext Die Suche nach den CDA-Dateien: procedure TForm1.Button1Click(Sender: TObject); var SearchRec : TSearchRec; begin if FindFirst(DriveComboBox1.Drive+':\*.cda',faAnyFile,SearchRec) = 0 then Label1.Caption := 'MUSIK-CD' else Label1.Caption := 'DATEN-CD'; FindClose(SearchRec) end;

Die Bestimmung des Volumenames: procedure TForm1.Button2Click(Sender: TObject); var dw : DWORD;

1216

Kapitel 20

How-to: Multimedia

VolumeNameBuffer : string; begin SetLength(VolumeNameBuffer, 64); GetVolumeInFormation(PChar(DriveComboBox1.drive + ':\'), PChar(VolumeNameBuffer), Length(VolumeNameBuffer), nil, dw, dw, nil, 0); if lStrCmp(PChar(VolumeNameBuffer),'Audio CD') = 0 then Label1.Caption := 'MUSIK-CD' else Label1.Caption := 'DATEN-CD' end;

Test Legen Sie nacheinander eine Audio- und eine Daten-CD ein. Das Programm sollte beide CDTypen richtig unterscheiden können.

20.18 Ein Audio-CD-Laufwerk auswählen Haben Sie mehr als ein CD-Laufwerk (z.B. CD-Wechsler oder Virtual-CD) installiert und möchten Sie auf eine Audio-CD in einem speziellen Laufwerk zugreifen, haben Sie ein kleines Problem: Die MCI-Befehle versuchen immer auf das Laufwerk mit dem niedrigsten Laufwerksbuchstaben zuzugreifen. Wir zeigen eine Lösung, mit welcher ein beliebiges Laufwerk ausgewählt werden kann.

Oberfläche Eine DriveComboBox (von der Seite "Win3.1") und ein Button genügen.

Quellcode Einbinden der Unit MMSystem: uses MMSystem; ... procedure TForm1.Button1Click(Sender: TObject);

20.19 Die Autorun-Funktion von CDs nutzen

1217

var lw: String; begin

Auswahl des Laufwerks und Zuweisen eines Aliasnamens: lw := DriveComboBox1.Drive; MCISendString(PChar('open ' + lw + ' type cdaudio alias cdplayer'), nil, 0, 0);

Wiedergabeformat festlegen (Tracks, Minuten, Sekunden und Frames): MCISendString('set cdplayer time format tmsf', nil, 0, 0);

Wiedergabe des ersten Songs: MCISendString('play cdplayer from 1 to 2', nil, 0, 0);

Ausgabegerät schließen: MCISendString('close cdplayer', nil, 0, 0) end;

Test

20.19 Die Autorun-Funktion von CDs nutzen Obwohl manchmal fast schon lästig, bietet die Autorun-Funktion von CDs doch einige Vorteile. So wird in vielen Fällen die Installation einer Anwendung vereinfacht, der Anwender muss sich nicht erst für ein Programm entscheiden. Die Vorgehensweise ist einfach: Erzeugen Sie im Root-Verzeichnis der CD eine AUTORUN.INF (eine normale Textdatei) mit folgendem Inhalt: [AutoRun] OPEN=projekt1.exe ICON=bild.ico

Nach dem Einlegen der CD prüft Windows das Vorhandensein dieser Datei, ordnet dem Laufwerk das festgelegte Icon zu und startet die mit Open spezifizierte Anwendung. Sie können auch das Icon der Anwendung verwenden, nutzen Sie dazu die folgende Syntax: ICON=projekt1.exe,1

1218

Kapitel 20

How-to: Multimedia

20.20 Das CD-Laufwerk öffnen und schließen Wieder einmal bedienen wir uns der Multimedia-API. Deren Funktion mciSendString ermöglicht eine recht einfache Steuerung von Multimedia-Geräten unter Windows.

Oberfläche Zum Testen des Öffnens und Schließens brauchen wir ein Formular mit zwei Buttons.

Quelltext Die Parameter der mciSendString-Funktion im Einzelnen: Kommando, Puffer für Rückgabewert, Größe des Puffers, Fenster-Handle für Notify-Botschaften. Die Anweisung WAIT im MCI-Kommando bewirkt eine synchrone Ausführung der Anweisung, d.h., die Funktion wird erst beendet, wenn das Kommando ausgeführt ist. uses mmSystem;

// Multimedia-Unit

procedure TForm1.Button1Click(Sender: TObject); // Öffnen begin mciSendString('SET CDAUDIO DOOR OPEN WAIT', nil, 0, Self.Handle) end; procedure TForm1.Button2Click(Sender: TObject); // Schließen begin mciSendString('SET CDAUDIO DOOR CLOSED WAIT', nil, 0, Self.Handle) end;

Test Wie von Geisterhand lässt sich nun Ihr CD-Laufwerk "per Fernsteuerung" bedienen.

21

How-to: Dateien/Verzeichnisse

Kapitel

21

How-to: Dateien/Verzeichnisse 21.1 Kontrollieren, ob eine Diskette eingelegt ist Mit der folgenden Funktion können Sie überprüfen, ob sich eine Diskette im Laufwerk befindet. Gegebenenfalls können Sie sich auch gleich Fehler- bzw. Statusmeldungen anzeigen lassen.

Oberfläche Ein Formular mit einer DriveComboBox (Seite "Win3.1") und ein Button genügen.

Quelltext function DiskInDrive(lw: Char; Statusanzeige: Boolean ): Boolean; var sRec: TSearchRec; i: Integer; begin result := False; {$I-} i := FindFirst(lw + ':\*.*', faAnyfile, SRec ); FindClose(SRec); // wichtig ab Delphi 2!!!!! {$I+} case i of 0 : result := True; // Diskette mit Dateien 2, 18 : begin // Leere Diskette if Statusanzeige then showmessage('Diskette im Laufwerk ' + lw + ' ist leer !'); Result := True; end; 21,3 : if Statusanzeige then ShowMessage('Keine Diskette im Laufwerk ' + lw); else if Statusanzeige then ShowMessage('Diskette nicht formatiert!' + IntToStr(i)) end end;

1220

Kapitel 21

How-to: Dateien/Verzeichnisse

So rufen wir die Funktion auf: procedure TForm1.Button1Click(Sender: TObject); begin if DiskInDrive(DriveComboBox1.Drive, True) then ShowMessage('Diskette vorhanden ...') end;

Test Wählen Sie das Laufwerk aus und probieren Sie verschiedene Möglichkeiten!

Bemerkung Beachten Sie, dass bei 32-Bit-Delphi-Programmen eine FindFirst/FindNext-Sequenz unbedingt mit FindClose abzuschließen ist, da sonst verwendeter Speicherplatz nicht wieder freigegeben wird. Siehe dazu auch: Ä 21.12 Nach Dateien rekursiv suchen

21.2 Eine Diskette kopieren Bevor Sie sich damit herumquälen, eine eigene Routine zum Kopieren von Disketten zu schreiben, nutzen Sie doch einfach die entsprechende Windows-Funktion! Diese ist allerdings etwas versteckt und hat eine recht eigenartige Aufrufkonvention.

Oberfläche Alles, was Sie brauchen, ist ein Button zum Starten des Kopierprozesses. Alle weiteren Dialogfelder werden vom Windows-API bereitgestellt.

Quelltext Prinzipiell rufen Sie ein externes Windows-Programm mit Hilfe der ShellExecute-Funktion auf. Wir wollen das Programm RundDll.exe verwenden, mit dem sich einige (nicht alle) DLLs starten lassen. Verwendung findet in unserem Fall die DLL DiskCopy mit der enthaltenen Funktion DiskCopyRunDll. Die beiden Parameter können wir vernachlässigen, da eine entsprechende Dialogbox angezeigt wird.

21.3 Eine Diskette formatieren

1221

uses shellAPI; // nicht vergessen! procedure TForm1.Button1Click(Sender: TObject); // Start begin ShellExecute(handle,'open','rundll32.exe','diskcopy.dll, DiskCopyRunDll 0,0','',sw_show) end;

Test Nach dem Programmstart können Sie über eine Dialogbox Quelle und Ziel auswählen:

Weitere Dialogboxen fordern Sie zum Einlegen der Disketten auf. Eine Fortschrittsanzeige informiert über den aktuellen Stand des Kopiervorgangs.

21.3 Eine Diskette formatieren Auch wenn es unter Windows kaum ein Problem ist, eine Diskette zu formatieren, so möchte man vielleicht doch diese Funktion auch in einem eigenen Programm anbieten (z.B. ein DateiManager). Verwendung findet die Funktion SHFormatDrive aus SHELL32.DLL.

Oberfläche Alles, was Sie brauchen, ist ein Formular mit einem Button zum Starten des Formatierungsprozesses. Alle weiteren Dialogfelder werden vom Windows-API bereitgestellt.

Quelltext Leider müssen wir uns selbst um die Einbindung kümmern, die wir hier beispielsweise zu Beginn des Implementation-Abschnitts von Unit1 vornehmen: function SHFormatDrive(Wnd: HWnd; Drive, Size, Options: Integer): Integer; stdcall; external 'SHELL32.DLL';

Der eigentliche Aufruf: procedure TForm1.Button1Click(Sender: TObject); begin SHFormatDrive(Self.handle, 0, 0, 0) end;

1222

Kapitel 21

How-to: Dateien/Verzeichnisse

Übergabeparameter sind neben dem Handle des aktuellen Fensters die Laufwerksnummer (A = 0 usw.) sowie die Mediengröße und die Format-Optionen. Folgende Werte sind als Optionen zulässig: Wert

Beschreibung

0

Quick-Format, in diesem Fall wird lediglich die FAT (File Allocation Table) gelöscht.

1

Vollständiges Format (entspricht z.B. Format C:)

2

Systemdateien auf den Datenträger übertragen (nur Windows 95/98). Die Funktion ist gleichbedeutend mit dem SYS-Befehl von der Kommandozeile.

Test Es erscheint die bekannte Dialogbox aus der Shell (Windows 2000/XP):

21.4 Die Laufwerkstypen bestimmen Sie wollen eine Datei anlegen und prüfen, ob das Laufwerk im lokalen Rechner installiert ist oder ob es sich um ein Netzlaufwerk handelt? Das folgende Beispiel zeigt Ihnen, wie Sie mit Hilfe einer API-Funktion den Laufwerkstyp ermitteln können.

Oberfläche Neben einem Button zum Beenden brauchen Sie lediglich eine ImageList- und eine ListViewKomponente zur Anzeige der einzelnen Laufwerkstypen.

21.4 Die Laufwerkstypen bestimmen

1223

Folgende Icons werden in die Imagelist geladen:

Quellcode Mit dem Laden des Formulars wird für alle 25 möglichen Laufwerke getestet, ob sie vorhanden sind bzw. um welchen Typ es sich handelt. procedure TForm1.FormCreate(Sender: TObject); var i, typ : Integer; s : String; NewItem : TListItem; begin For i := 0 To 25 do begin s := Chr(i + 65) + ':\'; typ := GetDriveType(PChar(s)); If Typ <> 0 Then Case Typ of DRIVE_REMOVABLE : begin NewItem := ListView1.Items.Add; NewItem.Caption := Chr(i + 65) + ': Diskette'; NewItem.ImageIndex := 0; end; DRIVE_FIXED : begin NewItem := ListView1.Items.Add; NewItem.Caption := Chr(i + 65) + ': Festplatte'; NewItem.ImageIndex := 1; end; DRIVE_CDROM : begin NewItem := ListView1.Items.Add;

1224

Kapitel 21

DRIVE_RAMDISK

DRIVE_REMOTE

How-to: Dateien/Verzeichnisse

NewItem.Caption := Chr(i + 65) + ': CDROM'; NewItem.ImageIndex := 4; end; : begin NewItem := ListView1.Items.Add; NewItem.Caption := Chr(i + 65) + ': RAMDisk'; NewItem.ImageIndex := 2; end; : begin NewItem := ListView1.Items.Add; NewItem.Caption := Chr(i + 65) + ': Netzlaufwerk'; NewItem.ImageIndex := 3; end

end end end;

Test

Bemerkung Beachten Sie, dass CD-Laufwerke, die als Netzlaufwerke eingebunden sind, nicht erkannt werden. Der Rückgabewert ist in diesem Fall DRIVE_REMOTE und nicht DRIVE_ CDROM.

21.5 Laufwerksinformationen ermitteln Das folgende Rezept ist eine Fortsetzung seines Vorgängers. Neben dem Laufwerkstyp interessieren uns in diesem Fall noch ■ Volumenname ■ Dateisystem

1225

21.5 Laufwerksinformationen ermitteln

■ maximale Länge von Dateinamen ■ Seriennummer ■ freier Speicher ■ Gesamtgröße Wir werden uns dazu der API-Funktionen GetVolumeInformation bzw. GetDiskFreeSpace bedienen. Die Funktion GetDiskFreeSpace liefert keinen Wert, sondern lediglich Informationen über den Festplattenaufbau sowie die Anzahl der freien Sektoren. Wir werden also etwas rechnen müssen. Die Abbildung auf der folgenden Seite zeigt das Grundprinzip der Festplattenverwaltung. Ein Cluster verwaltet mehrere Sektoren, diese wiederum bestehen aus einer bestimmten Anzahl von Bytes (meist 512). Die Anzahl der Sektoren pro Cluster ist abhängig vom Dateisystem und der Festplatten- bzw. Partitionsgröße. Eine 1,6 GByte große Festplatte, die mit dem FAT-Dateisystem formatiert ist, verwaltet 64 Sektoren pro Cluster zu je 512 Byte. Da jede Datei mindestens einen Cluster belegt, ergibt sich aus obigen Beziehungen ein minimaler Platzbedarf von 32.768 Bytes. Dies gilt auch, wenn die Datei leer ist (eine ungeheure Platzverschwendung!). 1

2

3

4

5

6

...

Cluster

1

2

3

4

5

6

...

Sektoren

1

2

3

4

5

6

...

Bytes

Wer seine Festplatte effektiver verwalten will, sollte eine kleinere Partitionsgröße wählen oder die Festplatte mit dem NTFS- oder dem FAT32-Dateisystem formatieren (weniger Sektoren pro Cluster).

Oberfläche Erweitern Sie das Formular um ein StringGrid zur Anzeige der Detailinformationen und um eine ProgressBar (Seite "Win32"). Wir nehmen die Laufzeitansicht vorweg:

1226

Kapitel 21

How-to: Dateien/Verzeichnisse

Quelltext Auf die Funktion zum Füllen der ListView-Komponente wollen wir an dieser Stelle nicht noch einmal eingehen (siehe dazu vorhergehendes Rezept). Mit dem Klick auf eines der dargestellten Laufwerkssymbole werden die Detailinformationen angezeigt: procedure TForm1.ListView1Click(Sender: TObject); var root : string; VolumeNameBuffer, FileSystemNameBuffer : PChar; VolumeSerialNumber, FileSystemFlags, MaximumComponentLength : DWORD; SectorsPerCluster, BytesPerSector, NumberOfFreeClusters, TotalNumberOfClusters : DWORD; begin root := copy(listview1.selected.caption, 1,1) + ':\';

Die beiden Puffer müssen initialisiert werden: VolumeNameBuffer:= StrAlloc(256); FileSystemNameBuffer := StrAlloc(256); if GetVolumeInformation(PChar(root), VolumeNameBuffer, 255, @VolumeSerialNumber, MaximumComponentLength, FileSystemFlags, FileSystemNameBuffer, 255) then begin GetDiskFreeSpace(PChar(root), SectorsPerCluster, BytesPerSector, NumberOfFreeClusters, TotalNumberOfClusters);

21.5 Laufwerksinformationen ermitteln

1227

StringGrid1.cells[0,0]:= 'Volumename'; StringGrid1.cells[1,0]:= VolumeNameBuffer; StringGrid1.cells[0,1]:= 'Filesystem'; StringGrid1.cells[1,1]:= FileSystemNameBuffer; StringGrid1.cells[0,2]:= 'Seriennummer'; StringGrid1.cells[1,2]:= IntToStr(VolumeSerialNumber); StringGrid1.cells[0,3]:= 'Länge Dateiname'; StringGrid1.cells[1,3]:= IntToStr(MaximumComponentLength); StringGrid1.cells[0,4]:= 'Sektoren/Cluster'; StringGrid1.cells[1,4]:= IntToStr(SectorsPerCluster); StringGrid1.cells[0,5]:= 'Bytes/Sektor'; StringGrid1.cells[1,5]:= IntToStr(BytesPerSector); StringGrid1.cells[0,6]:= 'Freie Cluster'; StringGrid1.cells[1,6]:= IntToStr(NumberOfFreeClusters); StringGrid1.cells[0,7]:= 'Cluster gesamt'; StringGrid1.cells[1,7]:= IntToStr(TotalNumberOfClusters); StringGrid1.cells[0,8]:= 'frei '; frei := SectorsPerCluster * BytesPerSector; frei := frei * NumberOfFreeClusters; StringGrid1.cells[0,8]:= 'frei '; StringGrid1.cells[1,8]:= format('%-20.0n',[frei]); gesamt:=SectorsPerCluster * BytesPerSector; gesamt := gesamt * TotalNumberOfClusters; StringGrid1.cells[0,9]:= 'gesamt '; StringGrid1.cells[1,9]:= format('%-20.0n',[gesamt]); ProgressBar1.Position := Round(100.0 * NumberOfFreeClusters / TotalNumberOfClusters);

Falls auf das Laufwerk nicht zugegriffen werden kann, soll die Liste gelöscht werden: end else for i := 0 to 9 do begin StringGrid1.cells[0,i]:= '';StringGrid1.cells[1,i]:= '' end;

Nicht vergessen, den Speicher wieder freizugeben: StrDispose(VolumeNameBuffer); StrDispose(FileSystemNameBuffer) end;

Bemerkung Natürlich hätten wir den verfügbaren und den freien Speicher auch mit den Delphi-Funktionen DiskFree und DiskSize ermitteln können, aber so haben wir gleich noch einen Blick auf die Struktur des Dateisystems geworfen.

1228

Kapitel 21

How-to: Dateien/Verzeichnisse

21.6 Testen, ob ein Verzeichnis existiert Möchten Sie prüfen, ob ein Verzeichnis tatsächlich vorhanden ist, verwenden Sie die folgende Funktion: function DirExists(s: string): Boolean; var i: Integer; begin i := GetFileAttributes(PChar(s)); Result := (i <> -1) and (FILE_ATTRIBUTE_DIRECTORY and i <> 0) end;

Oberfläche Zum Austesten der Funktion platzieren Sie eine Edit-Komponente und einen Button auf dem Startformular.

Quelltext Außer der obigen Funktion kopieren Sie noch folgenden Code: procedure TForm1.Button1Click(Sender: TObject); // Test begin if not DirExists(Edit1.Text) then if MessageDlg('Das Verzeichnis ist nicht vorhanden!' + #10 + 'Wollen Sie es neu anlegen?', mtConfirmation, [mbYes, mbNo],0) = mrYes then MkDir(Edit1.Text) end;

Test

21.7 Ein Verzeichnis anlegen

1229

21.7 Ein Verzeichnis anlegen Delphi stellt zwar den Befehl MkDir zur Verfügung, das gleichzeitige Erstellen mehrerer Verzeichnisse ist damit jedoch nicht möglich. BEISPIEL: Die folgende Anweisung führt zu einem Fehler: MkDir('C:\Test\TestA\test1');

In einigen Fällen braucht man jedoch eine derartige Funktion (Installationsprogramm).

Oberfläche Ein Edit-Feld und ein Button genügen.

Quellcode Die folgende Routine ermöglicht das Erstellen von mehreren Unterverzeichnissen: function MkDirEx(bez: string): boolean; var verz : string; er : integer; begin if copy(bez,length(bez),1) <> '\' then bez := bez + '\'; result := False; verz := copy(bez,1,2); delete(bez,1,3); while length(bez) > 0 do begin verz := verz + '\' + copy(bez,1,pos('\',bez)-1); delete(bez,1,pos('\',bez)); {$i-} mkdir(verz); {$i+} case IOresult of 0, 183 : begin end; else exit end end; result := True end; procedure TForm1.Button1Click(Sender: TObject); begin if not MkDirEx(Edit1.Text) then ShowMessage('Verzeichnis konnte nicht erstellt werden !') end;

Test Schauen Sie nach und überzeugen Sie sich, ob die Verzeichnisstruktur tatsächlich angelegt wurde.

1230

Kapitel 21

How-to: Dateien/Verzeichnisse

21.8 Das Anwendungsverzeichnis bestimmen Mit der Prozedur GetDir (Unit System) lässt sich dieses Problem in den Griff bekommen.

Oberfläche Auf einem Formular platzieren Sie ein Label.

Quelltext procedure TForm1.FormCreate(Sender: TObject); var verz: string; begin GetDir(0, verz); Label1.Caption := 'Das aktuelle Verzeichnis ist ' + #10 + verz end;

Der erste Parameter, welcher der Funktion GetDir übergeben wird, kann außer 0 (aktuelles Laufwerk) auch folgende Werte annehmen: 1 = Laufwerk A, 2 = Laufwerk B, 3 = Laufwerk C. HINWEIS: GetDir führt keine Fehlerprüfung durch!

Test Bei Programmstart wird das aktuelle Verzeichnis angezeigt:

21.9 Einen Verzeichnisbaum darstellen

1231

Bemerkung Eine weitere Variante zur Bestimmung des aktuellen Verzeichnisses ist der Einsatz der Funktion ExtractFilePath, siehe dazu Ä 22.18 Auf den Alias verzichten

21.9 Einen Verzeichnisbaum darstellen Möchten Sie den Nutzern Ihrer Programme auch eine komfortable Treeview des Verzeichnisbaums zur Verfügung stellen, statt die recht triste DirectoryListbox zu verwenden? Dann sind Sie hier genau richtig. Das folgende Beispiel zeigt Ihnen, wie Sie einerseits alle verfügbaren Laufwerke anzeigen und andererseits die Baumansicht aufbauen und später auswerten können. An dieser Stelle möchten wir Ihnen allerdings zwei Varianten anbieten, eine, die vollständig auf Delphi-Komponenten beruht, die zweite nutzt die Möglichkeiten des Windows-Shell-Interface. Die jeweiligen Vorteile dürften auf der Hand liegen: Die Delphi-Variante ist etwas aufwändiger, bietet dafür jedoch eine vollständige Integration in Ihre Anwendung. Die Shell-Variante bietet sich für einfache Dialoge an.

Oberfläche (Delphi-Variante) Platzieren Sie in einem Formular eine TreeView-Komponente (Align=alClient) sowie zwei Panels (Align = alBottom bzw. alTop) und einen Button, mit dem später die Anzeige aktualisiert werden kann.

Alternativ könnten Sie auch das Rezept Ä 21.10 Änderungen in einem Verzeichnis überwachen entsprechend anpassen, um den Baum zu aktualisieren.

Quelltext (Delphi-Variante) Wie Sie dem Umfang der folgenden Listings entnehmen können, ist die Lösung des Problems nicht ganz trivial, etwas Code müssen Sie schon schreiben. Wer Lust hat, kann den folgenden Quellcode auch dazu verwenden, eine entsprechende Komponente zu programmieren.

1232

Kapitel 21

How-to: Dateien/Verzeichnisse

Die folgende Hilfsfunktion ermöglicht uns, den kompletten Pfad aus der Baumansicht auszulesen. function getdirstr(node:TTreeNode):string; var s:string; nx: TtreeNode; begin result := ''; if node = nil then exit; s := node.text; nx := node; while nx.parent <> nil do begin nx := nx.parent; s := nx.text + '\' + s; end; result := s + '\'; end;

Dazu werden, ausgehend vom gerade aktuellen TreeNode-Objekt, alle übergeordneten TreeNodeObjekte (Parent) durchlaufen, bis die Wurzel (Nil) erreicht ist. Der Rückgabewert ist ein String mit dem gewählten Verzeichnis. Bevor es jedoch so weit ist, muss der Baum erst einmal aufgebaut werden. Den ersten Schritt macht die folgende Prozedur, die alle Laufwerke ermittelt und in den Baum einträgt. Vielleicht wundern Sie sich über die ChildItems, die jedem Laufwerk zugeordnet werden. Die Antwort ist recht einfach: Damit erreichen wir, dass sich die entsprechenden Knoten später expandieren lassen (vor dem Expandieren löschen wir später den Dummy und tragen die real existierenden Unterverzeichnisse ein). procedure TForm1.baumEinlesen; var nc : TTreeNode; i,typ : integer; s :string; begin Treeview1.items.clear; For i := 0 To 25 do begin s := Chr(i + 65) + ':\'; typ := GetDriveType(PChar(s)); If Typ <> 0 Then Case Typ of DRIVE_REMOVABLE : begin nc := Treeview1.items.AddChild(nil,Chr(i + 65) + ':'); nc.imageindex := 4; nc.selectedindex := 4; Treeview1.items.AddChild(nc,'y'); end; DRIVE_FIXED : begin nc := Treeview1.items.AddChild(nil,Chr(i + 65) + ':'); nc.imageindex := 1; nc.selectedindex := 1; Treeview1.items.AddChild(nc,'y'); end;

21.9 Einen Verzeichnisbaum darstellen

DRIVE_CDROM

DRIVE_RAMDISK

DRIVE_REMOTE

1233

: begin nc := Treeview1.items.AddChild(nil,Chr(i + 65) + ':'); nc.imageindex := 2; nc.selectedindex := 2; Treeview1.items.AddChild(nc,'y'); end; : begin nc := Treeview1.items.AddChild(nil,Chr(i + 65) + ':'); nc.imageindex := 1; nc.selectedindex := 1; Treeview1.items.AddChild(nc,'y'); end; : begin nc := Treeview1.items.AddChild(nil,Chr(i + 65) + ':'); nc.imageindex := 3; nc.selectedindex := 3; Treeview1.items.AddChild(nc,'y'); end;

end; end; end;

Ausgehend vom ausgewählten TreeNode-Objekt und damit vom gerade gewählten Verzeichnis werden mit der folgenden Prozedur die Unterverzeichnisse bestimmt. Procedure TForm1.FillTree(n : TTreeNode); var path : string; search : TSearchrec; nc : TTreeNode; begin if n = nil then exit; path := Getdirstr(n); if findfirst(path + '*.*',faDirectory,search) = 0 then repeat if ((search.attr and fadirectory)=fadirectory)and (search.name <> '.')and(search.name <> '..') then begin nc := Treeview1.items.AddChild(n,search.name); nc.imageindex := 0; nc.selectedindex := 0; // nc.overlayindex := 1; Treeview1.items.AddChild(nc,'y'); end; until findnext(search)<>0; findClose(search) end;

HINWEIS: Vergessen Sie nicht, die FindFist/FindNext-Sequenz mit FindClose abzuschließen.

1234

Kapitel 21

How-to: Dateien/Verzeichnisse

Beim Programmstart werden zuerst einmal alle Laufwerke eingelesen: procedure TForm1.FormShow(Sender: TObject); begin baumEinlesen end;

Vor dem Expandieren eines Baumzweiges wird der enthaltene Dummy gelöscht, gleichzeitig werden die eigentlichen Unterverzeichnisse ermittelt (auf diese Weise werden immer nur die unbedingt nötigen Unterverzeichnisse eingelesen). procedure TForm1.TreeView1Expanding(Sender: TObject; Node: TtreeNode; var AllowExpansion: Boolean); begin Treeview1.items.BeginUpdate; node.DeleteChildren; filltree(node); Treeview1.items.EndUpdate; if node.parent = nil then exit; node.selectedindex := 5; node.imageindex := 5 end;

Jeder Wechsel im Baum hat eine Aktualisierung der Pfad-Anzeige zur Folge: procedure TForm1.TreeView1Change(Sender: TObject; Node: TTreeNode); begin panel1.caption := GetDirStr(node) end;

Der Refresh-Button: procedure TForm1.SpeedButton2Click(Sender: TObject); begin baumEinlesen end;

Test (Delphi-Variante) Starten Sie das Programm, sollte der Baum bereits eingelesen werden.

21.9 Einen Verzeichnisbaum darstellen

1235

Ergänzung Sollen die Baumeinträge sortiert ausgegeben werden, kommen Sie um etwas zusätzliche Arbeit nicht herum: Procedure TForm1.FillTree_Version2(n : TTreeNode); var path : string; search : TSearchrec; nc : TTreeNode; s : TStringlist; i : integer; begin if n = nil then exit; s := TStringlist.Create; s.Sorted := True; path := Getdirstr(n); if findfirst(path + '*.*',faDirectory,search) = 0 then repeat if ((search.attr and fadirectory)=fadirectory)and (search.name <> '.')and(search.name <> '..') then s.Add(search.Name); until findnext(search)<>0; findclose(search); for i := s.Count-1 downto 0 do begin nc := Treeview1.items.AddChild(n,s.Strings[i]); nc.imageindex := 0; nc.selectedindex := 0; Treeview1.items.AddChild(nc,'y'); end; s.Free; end;

Mit Hilfe einer StringList und deren Sorted-Eigenschaft ist es problemlos möglich, eine alphabetisch sortierte Liste von Einträgen zu erzeugen. Die entsprechenden Stellen sind im obigen Quellcode fett hervorgehoben.

Oberfläche (Shell-Variante) An dieser Stelle können wir uns sehr kurz fassen, Sie brauchen lediglich einen Button, um die im Folgenden vorgestellte Funktion starten zu können.

Quelltext (Shell-Variante) Dreh- und Angelpunkt ist einmal wieder die Einbindung der Unit Shlobj (der Name lässt schon darauf schließen, dass wir es mit OLE-Objekten zu tun bekommen): uses shlobj;

Übergabewerte an unsere Funktion ist das Root-, d.h. das Ausgangsverzeichnis für die Baumansicht sowie die Beschriftung der Dialogbox. Der Rückgabewert ist entweder leer (AbbruchButton) oder er enthält den Pfad, der in der Baumansicht gewählt wurde.

1236

Kapitel 21

How-to: Dateien/Verzeichnisse

function Getfolder(root:integer; Caption :string): string; var bi : TBROWSEINFO; lpBuffer : PChar; pidlPrograms, pidlBrowse : PItemIDList; begin

Nach dem Erzeugen einer Item-Identifier-List (siehe dazu auch R51) können wir die BROWSEINFO-Struktur mit Daten füllen: if (not SUCCEEDED(SHGetSpecialFolderLocation(getactivewindow, root, pidlPrograms))) then exit; lpBuffer := StrAlloc(max_path); bi.hwndOwner := getactivewindow; bi.pidlRoot := pidlPrograms; bi.pszDisplayName := lpBuffer; bi.lpszTitle := pChar(caption); bi.ulFlags := BIF_RETURNONLYFSDIRS; bi.lpfn := nil; bi.lParam := 0;

Die eigentliche Anzeige der Dialogbox erfolgt mit SHBrowseForFolder: pidlBrowse := SHBrowseForFolder(bi); if (pidlBrowse <> nil) then begin

Ist der Aufruf erfolgreich gewesen, kann die zurückgegebene Item-Identifier-List in einen normalen String umgewandelt werden. if (SHGetPathFromIDList(pidlBrowse, lpBuffer)) then result:=lpBuffer; end; StrDispose(lpBuffer); end;

Für den Aufruf der obigen Funktion können als root die folgenden Konstanten genutzt werden (die Bedeutung dürfte aus dem Namen ersichtlich sein): CSIDL_DESKTOP CSIDL_PROGRAMS CSIDL_CONTROLS CSIDL_PRINTERS CSIDL_PERSONAL CSIDL_FAVORITES CSIDL_STARTUP CSIDL_SENDTO CSIDL_BITBUCKET CSIDL_STARTMENU CSIDL_DESKTOPDIRECTORY CSIDL_DRIVES CSIDL_NETWORK CSIDL_NETHOOD CSIDL_FONTS

= = = = = = = = = = = = = = =

$0000; $0002; $0003; $0004; $0005; $0006; $0007; $0009; $000a; $000b; $0010; $0011; $0012; $0013; $0014;

21.10 Änderungen in einem Verzeichnis überwachen

CSIDL_TEMPLATES CSIDL_COMMON_STARTMENU CSIDL_COMMON_PROGRAMS CSIDL_COMMON_STARTUP CSIDL_COMMON_DESKTOPDIRECTORY CSIDL_APPDATA CSIDL_PRINTHOOD

= = = = = = =

1237

$0015; $0016; $0017; $0018; $0019; $001a; $001b;

Beim Füllen der Struktur BROWSEINFO sollten Sie den Parameter ulFlags nicht übersehen. Dieser entscheidet darüber, welche Auswahlen als gültig anzusehen sind. (Ist beispielsweise der Parameter BIF_RETURNONLYFSDIRS gewählt, lassen sich nur gültige Verzeichnisse, aber keine Computer oder Drucker auswählen, auch wenn diese angezeigt werden.) Aufschluss über die möglichen Parameter gibt die Online-Hilfe. BEISPIEL: Verwendung der Funktion procedure TForm1.Button2Click(Sender: TObject); begin caption := getfolder(CSIDL_DRIVES,'Wählen Sie einen Folder aus:'); end;

Test (Shell-Variante) BEISPIEL: Parameter root = CSIDL_DRIVES

21.10 Änderungen in einem Verzeichnis überwachen Wollen Sie Ihren eigenen Norton-Commander schreiben, ist es sicher wünschenswert, Veränderungen im aktuell angezeigten Pfad zu überwachen. Neben dem Löschen, Hinzufügen bzw. Umbenennen einer Datei könnte auch die Dateigröße von Interesse sein. Was in den 16-Bit-Versionen von Windows nicht oder nur sehr umständlich möglich war, stellt für ein 32-Bit-Programm kein Problem dar, bietet doch die API bereits fertige Funktionen an. Allerdings bringt der Einsatz dieser Funktionen einige Besonderheiten mit sich, beispielsweise werden

1238

Kapitel 21

How-to: Dateien/Verzeichnisse

wir auf einen Thread nicht verzichten können, es sei denn, Sie wollen unnötig viel Rechenzeit verschwenden. HINWEIS: Ab Borland Delphi 6 können Sie sich die Arbeit wesentlich vereinfachen: Mit der

ShellChangeNotifier-Komponente erreichen Sie mittels Event das gleiche Resultat.

Oberfläche Von der "Win3.1"-Seite der Komponentenpalette holen Sie sich eine DriveComboBox, eine DirectoryListBox und eine FileListBox:

Quellcode Die Programmierung des Thread: unit Unit2; interface uses Classes,windows,dialogs; type TWatch = class(TThread) private changehandle:THandle; watchpath : String; protected procedure Execute; override; procedure RefreshListbox; destructor Destroy; public constructor Create(path : String); end; implementation

1239

21.10 Änderungen in einem Verzeichnis überwachen

uses unit1; constructor TWatch.Create(path : String); begin inherited Create(False); watchpath:= path; FreeOnTerminate := True; end; procedure TWatch.Execute; begin changehandle:=FindFirstChangeNotification(PChar(watchpath), FALSE,FILE_NOTIFY_CHANGE_FILE_NAME); if changehandle <> INVALID_HANDLE_VALUE then while True do begin if WaitForSingleObject(changehandle,500)= WAIT_OBJECT_0 then synchronize(RefreshListbox); FindNextChangeNotification(changehandle); if Terminated then break; end; end; procedure TWatch.RefreshListbox; begin form1.FileListBox1.update; end; destructor TWatch.Destroy; begin inherited Destroy end;

Was passiert? In der Execute-Methode erstellen wir mit FindFirstChangeNotification ein Überwachungsobjekt, das auf das Umbenennen, Erstellen bzw. Löschen von Dateien reagiert. Mit WaitForSingleObject warten wir 500 ms auf ein eventuell eintretendes Ereignis. Tritt dieses ein, wird die Listbox aktualisiert. Dazu müssen wir uns der Synchronize-Funktion bedienen. Sollte der Vordergrundprozess die Variable Terminate gesetzt haben, müssen wir danach die Endlosschleife verlassen. Die folgende Tabelle zeigt die zulässigen Konstanten für die Funktion FindFirstChangeNotification: Konstante

Ereignis beim ...

FILE_NOTIFY_CHANGE_FILE_NAME

... Umbenennen, Erstellen bzw. Löschen von Dateien.

FILE_NOTIFY_CHANGE_DIR_NAME

... Umbenennen, Erstellen bzw. Löschen von Verzeichnissen.

FILE_NOTIFY_CHANGE_ATTRIBUTES

... Ändern der Dateiattribute.

FILE_NOTIFY_CHANGE_SIZE

... Ändern der Dateigröße.

FILE_NOTIFY_CHANGE_LAST_WRITE

... Ändern beim Schreiben einer Datei.

FILE_NOTIFY_CHANGE_SECURITY

... Ändern der Security-Einstellungen.

1240

Kapitel 21

How-to: Dateien/Verzeichnisse

Der Vordergrundprozess: procedure TForm1.BitBtn1Click(Sender: TObject); begin kontrolle.terminate end; procedure TForm1.DirectoryListBox1Change(Sender: TObject); begin if kontrolle <> NIL then kontrolle.terminate; Kontrolle := TWatch.Create(DirectoryListBox1.directory) end;

Test Nach dem Programmstart wählen Sie ein Verzeichnis, das überwacht werden soll. Wechseln Sie dann zum Explorer und benennen Sie eine Datei um. Sie werden feststellen, dass die FileListBox automatisch aktualisiert wird.

21.11 Die Größe einer Datei ermitteln Möchten Sie die Größe einer Datei bestimmen, bieten sich drei Varianten an: ■ Sie öffnen die Datei als FileStream und fragen die Size-Eigenschaft ab. ■ Sie öffnen die Datei als File of Byte und nutzen die FileSize-Funktion. ■ Sie verwenden die FindFirst-Funktion und lesen die Dateigröße aus der TSearchRec-Struktur aus. Wir zeigen Ihnen im Folgenden alle drei Varianten.

Oberfläche Sie brauchen lediglich ein Formular mit drei Buttons.

Quelltext Die Variante mit dem FileStream: procedure TForm1.Button1Click(Sender: TObject); var fs : TFileStream; begin fs := TFileStream.Create(ParamStr(0), fmOpenRead + fmShareDenyNone); ShowMessage(IntToStr(fs.Size) + ' Bytes'); fs.Free end;

21.11 Die Größe einer Datei ermitteln

1241

Die Variante "File of Byte": procedure TForm1.Button2Click(Sender: TObject); var f : File of Byte; begin AssignFile(f,ParamStr(0)); Filemode := 0; // nur Lesen!!! Reset(f); ShowMessage(IntToStr(FileSize(f)) + ' Bytes'); CloseFile(f) end;

Die Variante mit FindFirst: procedure TForm1.Button3Click(Sender: TObject); var SearchRec : TSearchRec; begin if FindFirst(paramstr(0), faAnyFile, SearchRec)= 0 then begin ShowMessage(IntToStr(SearchRec.Size) + ' Bytes'); FindClose(SearchRec) // Wichtig!!! end end;

Test Starten Sie das Programm und testen Sie alle Varianten.

Ergänzung Die Version mit TSearchRec hat den Vorteil, dass Sie neben der Größe gleich noch weitere Informationen über die Datei abfragen können: TSearchRec = record Time: Integer; Size: Integer; Attr: Integer; Name: TFileName; ExcludeAttr: Integer; FindHandle: THandle; FindData: TWin32FindData; end;

1242

Kapitel 21

How-to: Dateien/Verzeichnisse

21.12 Nach Dateien rekursiv suchen Haben Sie eine Datei "verlegt" oder möchten Sie z.B. alle BAK-Dateien eines Laufwerks oder eines Verzeichnisses löschen, dann benötigen Sie das folgende Programm.

Oberfläche Die Oberfläche gliedert sich in Verzeichnisauswahl (TreeView) und die Such-/Löschfunktionen (Listbox, drei BitButtons und eine Edit-Komponente). Wie Sie die TreeView-Komponente mit Verzeichnis- und Laufwerksnamen füllen, ist in Ä 21.9 Einen Verzeichnisbaum darstellen ausführlich beschrieben. Die Verzeichnisauswahl bestimmt lediglich das Startverzeichnis für den Suchvorgang. Das Programm durchsucht alle Unterverzeichnisse nach Dateien, die der Suchmaske in Edit1 entsprechen. Zulässige Platzhalter sind "?" und "*".

Quelltext Die Vorbereitung des Suchvorganges: procedure TForm1.SpeedButton2Click(Sender: TObject); var directory: string; begin count := 0; screen.cursor := crHourGlass; ListBox1.items.clear; directory := directoryListBox1.directory;

21.12 Nach Dateien rekursiv suchen

1243

if directory[length(directory)]<>'\' then directory := directory + '\'; getAllFiles(directory+edit1.text); screen.cursor := crDefault; MessageDlg(IntToStr(count)+' Datei(en) gefunden!',mtInformation, [mbOk],0) end;

Die eigentliche Suchfunktion ruft sich selbst rekursiv auf, wenn ein Unterverzeichnis gefunden wurde. Der Code hätte noch kürzer ausfallen können, im Interesse der Lesbarkeit wurden jedoch einige zusätzliche Anweisungen eingefügt: procedure GetAllFiles(mask:string); var Search: TSearchrec; verz : string; such : string; begin such := ExtractFileName(mask); verz := ExtractFilepath(mask); if verz[length(verz)]<>'\' then verz := verz + '\'; { alle Dateien suchen } if FindFirst(mask, $23, Search)= 0 then repeat form1.ListBox1.items.add(verz+Search.Name); inc(count); until FindNext(Search)<>0; { Unterverzeichnisse durchsuchen } if FindFirst(verz + '*.*',fadirectory, Search)= 0 then begin repeat if((search.attr and fadirectory)=fadirectory)and(search.name[1]<>'.') then GetAllFiles(verz+ Search.Name + '\' + such); until FindNext(Search) <> 0; FindClose(Search); end; end;

HINWEIS: Ab Windows 95 müssen Sie eine FindFirst/FindNext-Sequenz mit einem FindClose

beenden, sonst wird wertvoller Arbeitsspeicher nicht wieder freigegeben! Wurden Dateien gefunden, werden diese im Listenfeld angezeigt. Da die MultiSelect-Eigenschaft auf True gesetzt ist, können Sie eine oder mehrere Dateien auswählen und löschen. Das Löschen der Dateien bereitet keinerlei Schwierigkeiten, die Aktualisierung des Listenfeldes hingegen ist etwas diffizil. Löschen Sie einen Eintrag, ist die Gesamtzahl der Einträge natürlich kleiner geworden, der nächste Item "rutscht" auf die aktuelle Position. Würden wir in einer For-Schleife die Liste auf "Selected" prüfen, wird jeder zweite Eintrag ausgelassen. procedure TForm1.SpeedButton1Click(Sender: TObject); var i : word; f : file; s : TStrings; begin

1244

Kapitel 21

How-to: Dateien/Verzeichnisse

if messageBox(0,'Alle markierten Dateien löschen?','Frage',36)= 6 then begin i := 0; while i < ListBox1.items.count do begin if ListBox1.selected[i] then begin if not Deletefile(ListBox1.items.strings[i]) then begin MessageDlg('Datei ' + ListBox1.items.strings[i] + ' konnte nicht gelöscht werden!', mtError, [mbOk], 0); inc(i); end else ListBox1.Items.Delete(i) end else inc(i); end; ListBox1.Update end end;

Test Überzeugen Sie sich von der Leistungsfähigkeit der Suchfunktion (siehe obige Abbildung).

Bemerkung Das Programm um weitere Funktionen zu erweitern, dürfte keine Schwierigkeit sein. Sie könnten zum Beispiel auch die Ausführung eines Programms für alle selektierten Dateien ermöglichen (Datei-Konverter etc.).

21.13 Einen Dateibetrachter realisieren Geht es Ihnen auch so, Sie haben Dutzende Grafiken auf diversen Festplatten und in verschiedenen Unterverzeichnissen abgespeichert und finden nicht die richtige? Um diesem Missstand abzuhelfen, wurde das Programm "Fileviewer" geschrieben, das neben den oben erwähnten Funktionen zum Betrachten auch das gezielte Löschen bzw. den Datenaustausch über die Zwischenablage unterstützt. Angezeigt werden folgende Dateitypen: WMF, BMP, JPG, ICO, TXT, INI, PAS, BAS, BAT, CMD.

Oberfläche Der grundsätzliche Aufbau der Oberfläche lässt sich der folgenden Abbildung entnehmen:

21.13 Einen Dateibetrachter realisieren

1245

Sie brauchen eine FileListbox, eine DirectoryListbox und eine DriveCombobox. Verknüpfen Sie diese über die Eigenschaften FileList und DirList. Zur Anzeige verwenden Sie eine Image-Komponente (AutoSize=False, Stretch=True) oder ein Memofeld (ScrollBars=ssVertical, WordWrap =True). Die Image-Komponente schließen Sie in eine ScrollBox ein, um auch größere Grafiken darstellen zu können. Da Memofeld und Image übereinander liegen, muss eine Komponente zeitweilig ausgeblendet sein. Setzen Sie die Visible-Eigenschaft des Memofeldes auf False. Für die Werkzeugleiste benötigen Sie zwei SpeedButtons (Seite "Zusätzlich" der Komponentenpalette), mit denen wir Dateien löschen bzw. Inhalte in die Zwischenablage kopieren können.

Quelltext Mit dem Klick auf einen Eintrag in der FileListbox soll die Datei angezeigt werden. Je nach Typ laden wir die Datei in das Image bzw. in das Memo. procedure TForm1.FileListBox1Click(Sender: TObject); var FileExt: string[4]; begin FileExt := UpperCase(ExtractFileExt(FileListBox1.Filename)); if (FileExt='.BMP')or(FileExt='.ICO')or(FileExt='.WMF')or(FileExt='.JPG') then begin Memo1.Visible := False; try Image1.Picture.LoadFromFile(FileListBox1.Filename); if (FileExt = '.BMP') then Form1.Image1.Picture := Image1.Picture; if FileExt = '.ICO' then Icon := Image1.Picture.Icon; if FileExt = '.WMF' then Form1.Image1.Picture.Metafile := Image1.Picture.Metafile;

Auf eine Fehlerbehandlung können wir auf keinen Fall verzichten, da beim Laden der Grafikdateien reichlich Fehlermöglichkeiten vorhanden sind. except MessageBox(0,'Grafik fehlerhaft','Problem',16)

1246

Kapitel 21

How-to: Dateien/Verzeichnisse

end end; if (FileExt='.TXT') Or (FileExt='.PAS') Or (FileExt='.INI') Or (FileExt='.BAT') Or (FileExt='.CMD') Or (FileExt='.BAS') then begin Memo1.Visible := True; try Memo1.Lines.Clear; Memo1.Lines.LoadFromFile(FileListBox1.Filename) except MessageBox(0,'Datei fehlerhaft','Problem',16) end end end;

Beim Kopieren aus dem Memofeld ist zu beachten, dass entweder schon Text markiert ist (dann wird nur dieser kopiert) oder dass alles kopiert werden soll (keine Auswahl). procedure TForm1.SpeedButton2Click(Sender: TObject); // Kopieren in Zwischenablage begin if Memo1.Visible then begin { Text } if Memo1.SelLength= 0 then Memo1.SelectAll; Memo1.CopyToClipboard; end else begin { grafik } Clipboard.Assign(Image1.Picture) end end;

Das Löschen von Dateien gestaltet sich naturgemäß etwas aufwändiger. Ist die Frage nach dem Löschen mit Ja beantwortet worden, wird die gesamte Dateiliste durchlaufen. Jeder markierte Eintrag (Selected[i] = True) kann gelöscht werden. HINWEIS: Verzichten Sie nicht auf die Fehlerprüfung, denn die Datei kann z.B. auch schreibge-

schützt sein. procedure TForm1.SpeedButton1Click(Sender: TObject); // Dateien löschen var i : Word; f : File; verz : string; begin verz := DirectoryListBox1.Directory; if verz[Length(verz)] <> '\' then verz := verz + '\'; if MessageBox(0,'Alle markierten Dateien löschen?','Frage',36)= 6 then begin for i:= 0 to FilelistBox1.Items.Count-1 do begin if FileListBox1.Selected[i] then begin AssignFile(F, verz + FileListBox1.Items.strings[i]); try Erase(F) except MessageDlg('File I/O error.', mtError, [mbOk], 0) end

21.14 Datei-Verknüpfungen nutzen

1247

end end; FileListBox1.Update end end; end.

Test Besichtigen Sie nicht nur diverse Text- und Grafikdateien, sondern probieren Sie auch das Kopieren von Grafiken bzw. selektiertem Text in die Zwischenablage:

21.14 Datei-Verknüpfungen nutzen Wohl jeder kennt die mehr oder weniger sinnvollen Verknüpfungen aus dem Datei-Manager. Klicken Sie beispielsweise eine HLP-Datei an, wird die zugehörige Anwendung WINHELP mit der Datei als Parameter ausgeführt. Wie auch Sie diese Verknüpfungen einsetzen können, lesen Sie in diesem Rezept.

Oberfläche Fügen Sie in ein Formular eine DriveCombobox, eine DirectoryListbox und eine FileListbox ein. Verknüpfen Sie diese über die Eigenschaften DirList und FileList. Label2 dient der Anzeige der Verknüpfung.

1248

Kapitel 21

How-to: Dateien/Verzeichnisse

Quelltext Beim Klicken im Dateilistenfeld wird, so vorhanden, die zugehörige Verknüpfung angezeigt. procedure TForm1.FileListBox1Click(Sender: TObject); var dok, dir:string; res : array[1..250] of char; i:integer; begin dok:=FileListbox1.Filename + #0; dir:=DirectoryListBox1.Directory + #0; fillchar(res, SizeOf(res), ' '); res[250]:=#0; i:=FindExecutable(@dok[1],@dir[1],@res[1]); if i <= 32 then label2.caption :='' else label2.caption := res end;

Test Starten Sie das Programm und wählen Sie z.B. eine .DPR-Datei aus. Im unteren Labelfeld sollte Delphi als verknüpfte Anwendung angezeigt werden. Für das Programm sind weitere Anpassungen denkbar. Kombinieren Sie z.B. diese Funktionalität mit dem Shell-Programm aus Ä 27.5 Ein anderes Programm starten

21.15 Die Shell-Funktionen zum Kopieren nutzen Wer seine Programme um eine Kopier- oder Löschfunktion bereichern möchte, braucht nicht unbedingt das Rad neu zu erfinden, denn es geht auch einfacher. Die Windows-Shell bzw. der Explorer stellen über die API-Schnittstelle die wohl jedem bekannten Dialoge zum Kopieren, Verschieben und Löschen von Dateien und Verzeichnissen zur Verfügung.

21.15 Die Shell-Funktionen zum Kopieren nutzen

1249

Alle oben genannten Aufgaben werden über die Funktion SHFileOperation abgewickelt, die Optionen, Dateinamen etc. übergeben Sie in einem Record mit folgendem Aufbau: TSHFileOpStructA = record Wnd : HWND; wFunc : UINT; pFrom : PAnsiChar; pTo : PAnsiChar; fFlags : FILEOP_FLAGS; fAnyOperationsAborted: BOOL; hNameMappings : Pointer; lpszProgressTitle : PAnsiChar; end;

Die Parameter im Einzelnen: ■ Handle des übergeordneten Fensters (Ihre Anwendung) ■ Konstante für die Funktion (FO_MOVE, FO_COPY, FO_DELETE, FO_RENAME) ■ Quelle (ein oder mehrere nullterminierte Strings, die mit einem leeren String abgeschlossen werden) ■ Ziel (siehe Quelle) ■ spezielle Optionen (siehe Online-Hilfe) ■ Rückgabe von True bei vorzeitigem Abbruch der Operation ■ Zeiger auf ein Array, mit dem überprüft werden kann, welche Dateien kopiert oder verschoben wurden ■ Titel für eine Dialogbox mit dem Fortschrittsbalken

Oberfläche Den Aufbau der Oberfläche entnehmen Sie bitte der Grafik. DriveComboBox, DirectoryListbox und FileListbox werden jeweils über die Eigenschaften DirList und FileList miteinander verknüpft. Für die FileListbox setzen Sie die Eigenschaft Multiselect auf True.

1250

Kapitel 21

How-to: Dateien/Verzeichnisse

Quellcode Bevor es losgeht, sollten Sie nicht die Einbindung der Unit ShellAPI vergessen. Die Kopierfunktion: procedure var i files begin files

TForm1.Button1Click(Sender: TObject); : integer; : string; := '';

An dieser Stelle wird die Liste aus nullterminierten Strings erzeugt: for i := 0 to FileListBox1.items.count-1 do if FileListBox1.selected[i] then files := files + FileListBox1.items[i] + #0;

Zum Schluss nicht vergessen, noch einen leeren String anzuhängen, sonst erkennt die API-Funktion das Ende der Liste nicht: files := files + #0;

Festlegen der Parameter: fillchar(shellinfo, sizeof(shellinfo),0); with shellinfo do begin wnd := handle; wfunc := FO_COPY; pFrom := PChar(files); pTo := PChar(directoryListBox2.directory); end;

Ausführen der Funktion: SHFileOperation(shellinfo); FileListBox1.update; end;

21.15 Die Shell-Funktionen zum Kopieren nutzen

1251

Das Verschieben von Dateien und Verzeichnissen funktioniert analog: procedure TForm1.Button3Click(Sender: TObject); var i : integer; files : string; begin files := ''; for i := 0 to FileListBox1.items.count-1 do if FileListBox1.selected[i] then files := files + FileListBox1.items[i] + #0; files := files + #0; fillchar(shellinfo, sizeof(shellinfo),0); with shellinfo do begin wnd := handle; wfunc := FO_MOVE; pFrom := PChar(files); pTo := PChar(directoryListBox2.directory); end; SHFileOperation(shellinfo); FileListBox1.update; end;

Löschen: procedure TForm1.Button2Click(Sender: TObject); var i : integer; files : string; begin files := ''; for i := 0 to FileListBox1.items.count-1 do if FileListBox1.selected[i] then files := files + FileListBox1.items[i] + #0; files := files + #0; FillChar(shellinfo, sizeof(shellinfo),0); with shellinfo do begin wnd := handle; wfunc := FO_DELETE; pFrom := PChar(files); pTo := nil end; SHFileOperation(shellinfo); FileListBox1.Update end;

Einer der wesentlichsten Vorteile der beschriebenen Funktion ist die automatische Anzeige von Zusatzdialogboxen (z.B. Überschreiben von Dateien, Erzeugen von Verzeichnissen etc.).

1252

Kapitel 21

How-to: Dateien/Verzeichnisse

21.16 Eine Datei-Komponente entwickeln Im Zusammenhang mit den Komponenten DriveComboBox und DirectoryListBox vermisst man eine Möglichkeit, diese gleich an eine weitere Komponente zu binden, um z.B. eine Datei zu kopieren oder zu verschieben. Wir programmieren eine Komponente, die ■ Dateien kopieren, ■ Laufwerkstypen anzeigen und ■ Volume-Label bestimmen kann. Folgende Eigenschaften und Methoden sollen implementiert werden: Eigenschaft

Beschreibung/Beispiel

Source

Pfad (Lw : Pfad : Name|Platzhalter), aus dem die Dateien kopiert werden.

Destination

Pfad (Lw : Pfad), in den die Dateien kopiert werden, das Verzeichnis muss vorhanden sein!

Overwrite

True: Bereits vorhandene Dateien werden gnadenlos überschrieben!

SourceDirListbox

Verknüpfung mit einer DirectoryListbox. Zusätzlich muss eine FilterCombobox verknüpft sein! Ist diese Eigenschaft gesetzt, wird die Source-Eigenschaft ignoriert.

DestinationDirListbox Siehe SourceListbox, entspricht dem Ziel des Kopiervorgangs. FilterCombobox

Verknüpfung mit einer FilterComboBox.

BufferSize

Vorgabe für die Kopierpuffer (1 ... 65.000). Je kleiner der Wert, desto häufiger wird OnChange-Event aufgerufen, der Kopiervorgang dauert länger.

Max

Der Maximumwert für eine Fortschrittsanzeige (entspricht 100 %).

Value

Der aktuelle Wert für die Fortschrittsanzeige.

21.16 Eine Datei-Komponente entwickeln

1253

Methode

Beschreibung/Beispiel

Copy

... kopiert die durch Source/Destination bzw. SourceDirListbox/ DestinationDirListbox vorgegebenen Dateien.

DriveType

... ermittelt für einen Laufwerksbuchstaben den Laufwerkstyp. Die möglichen Rückgabewerte: ' ', 'FloppyDisk', 'HardDisk', 'Network', 'CDROM', 'RAMDrive'.

VolumeName

... ermittelt den Namen des gewählten Volume.

Ereignis

Beschreibung/Beispiel

OnStart

... wird vor dem Beginn eines Kopiervorgangs aufgerufen, kann zum Anzeigen eines Dialogs verwendet werden.

OnChange

... wird nach der Übertragung eines Datenblocks aufgerufen. Verwendung: Aktualisieren einer Fortschrittsanzeige und Anzeige des Dateinamens.

OnEnd

... wird nach dem Kopiervorgang aufgerufen.

Quelltext Eigentlich benötigen Sie gar kein Projekt. Erstellen Sie dennoch eins, denn wir wollen gleichzeitig auch ein Testprogramm für unsere Komponente schreiben! Die Komponente wird in einer gesonderten Unit erstellt. Damit Sie sich nicht um formale Schritte kümmern müssen (Registrierung, Ableiten der Klasse), verwenden Sie zum Erstellen der Unit den "Komponenten-Experten". Den Klassennamen legen Sie mit TFileTools fest, als Vorfahrtyp wählen Sie TComponent1. Der Experte hinterlässt Ihnen folgenden Code: unit Unit1; interface uses SysUtils, Windows, Messages, Classes, Graphics, Controls, Forms, Dialogs; type TFileTools = class(TComponent) private { Private-Deklarationen } protected { Protected-Deklarationen } public { Public-Deklarationen } published { Published-Deklarationen } end;

1

Mit TComponent als Vorfahren können Sie nicht sichtbare Komponenten programmieren.

1254

Kapitel 21

How-to: Dateien/Verzeichnisse

procedure Register; implementation procedure Register; begin RegisterComponents('Beispiele', [TFileTools]); end; end.

Wie Sie sehen, ist die Klasse bereits abgeleitet. Die Prozedur sorgt für die Einbindung der Komponente in die Delphi-Entwicklungsumgebung. Das ist aber auch schon alles, was Ihnen der so genannte "Experte" abnehmen kann. Der Rest ist mühselige Tipparbeit, auch der Test ist etwas umständlich, da Sie jedesmal das entsprechende Package neu compilieren müssen. Es gibt zwar eine Möglichkeit, das Runtime-Verhalten der Komponente ohne Einbindung in die Delphi-Library zu testen, das Entwurfszeit-Verhalten lässt sich damit jedoch nicht überprüfen. Beginnen wir mit dem Deklarations-Abschnitt: Für unser OnChange-Event benötigen wir einen neuen Typ, der neben dem obligatorischen Sender auch noch die oben genannten Parameter übergibt: HilfsEvent = procedure (Sender: TObject;value:Word; max:Word; dateiName:string) of object; TFileTools = class(TComponent) private

Im private-Abschnitt deklarieren Sie lokale Variablen, die mit den Eigenschaften aus dem published-Abschnitt verbunden werden. Programme, die diese Komponente einsetzen, haben keinen Zugriff auf diesen Abschnitt. FBuffersize FQuelle FZiel FMax FValue FOverwrite

: : : : : :

Word; string; string; Word; Word; Boolean;

{ Dateiname inkl. Pfad + Extension } { Dateiname inkl. Pfad + Extension }

Die interne Definition unseres OnChange-Events: FOnChange

: Hilfsevent;

TNotifyEvent ist ein vordefiniertes Ereignis, das lediglich das Sender-Objekt übergibt, für die beiden folgenden Events genügt das jedoch. FOnStart FOnEnd

: TNotifyEvent; : TNotifyEvent;

Objekte als Eigenschaften: FSourceDirListbox : TDirectoryListbox;

21.16 Eine Datei-Komponente entwickeln

1255

FFilterCombobox : TFilterComboBox; FDestinationDirListbox : TDirectoryListbox;

ermöglichen die Verknüpfung mit den jeweiligen Komponenten. Für die interne Verwaltung benötigen wir den Dateinamen: dateiname

: string;

Die eigentliche Kopierroutine binden wir als Methode ein: function KopiereDatei(von,nach:string):boolean; { Private-Deklarationen } protected { Protected-Deklarationen }

Die folgende Prozedur vereinfacht den Aufruf unseres OnChange-Events: procedure Change; dynamic;

Auf alle im public-Abschnitt deklarierten Methoden kann von außen, d.h. von einem Programm aus, zugegriffen werden. public

Den Konstruktor Create werden wir dazu verwenden, die Eigenschaften mit sinnvollen Werten zu initialisieren. Vergessen Sie den Zusatz override nicht, andernfalls wird der Konstruktor nicht erweitert, sondern einfach überschrieben. constructor Create(AOwner: TComponent); override;

Die Definition der Komponenten-Methoden: procedure Copy; function DriveType(lw:Char):string; function VolumeName(lw:Char):string;

Die äußere Schnittstelle für die Entwicklungsumgebung deklarieren Sie im published-Abschnitt. Ob eine Eigenschaft im Objektinspektor angezeigt wird, hängt davon ab, wie sie definiert ist. Haben Sie nur read-Rechte vergeben, ist die Eigenschaft nur zur Laufzeit verfügbar. published { Published-Deklarationen } property Source: string read FQuelle write FQuelle; property Destination: String read FZiel write FZiel; property BufferSize: word read FBuffersize write FBuffersize; property Overwrite: boolean read FOverwrite write FOverwrite; property Max: word read FMax; { der Endwert eines Balkens } property Value: word read FValue; { der aktuelle Wert des Balkens } property SourceDirListbox: TDirectoryListbox read FSourceDirListbox write FSourceDirListbox; property Filtercombobox:TFilterCombobox read FFilterCombobox write FFilterCombobox; property DestinationDirListbox: TDirectoryListbox read FDestinationDirListbox write FDestinationDirListbox;

1256

Kapitel 21

How-to: Dateien/Verzeichnisse

Die Ereignisse sind auch Properties: property OnChange: Hilfsevent read FOnChange write FOnChange; property OnStart: TNotifyevent read FOnStart write FOnStart; property OnEnd: TNotifyevent read FOnEnd write FOnEnd;

Die Schnittstellendefinition unserer Komponente ist damit abgeschlossen. Die Implementierung unterscheidet sich nicht von der Programmierung einer normalen Unit, der einzige Unterschied ist der Klassenname vor den Methoden. Den Konstruktor Create wollen wir um die Initialisierung der Eigenschaften erweitern. Bevor dies möglich ist, muss jedoch die bisherige Routine abgearbeitet werden. Dies geschieht mit inherited Create(AOwner): constructor TFileTools.Create(AOwner: TComponent); begin inherited Create(AOwner); FBuffersize := 4096; FMax := 0; FValue := 0 end;

Die Ermittlung des Laufwerktyps stellt in einem 32-Bit-Programm kaum noch eine Hürde dar (im Gegensatz zur 16-Bit-Variante, wo weder CD-ROM noch Netzlaufwerke unterschieden werden konnten). function TFileTools.DriveType(lw:char):String; var s : string; begin s := lw + ':\'; case GetDriveType(PChar(s)) of 0,1 : drivetype DRIVE_REMOVABLE : drivetype DRIVE_FIXED : drivetype DRIVE_REMOTE : drivetype DRIVE_CDROM : drivetype DRIVE_RAMDISK : drivetype end; end;

:= := := := := :=

''; 'FloppyDisk'; 'HardDisk'; 'Network'; 'CDROM'; 'RAMDrive';

Mehr zum Thema "Laufwerkstypen" finden Sie in: Ä 21.4 Den Laufwerkstyp bestimmen Den Laufwerksbezeichner (VolumeID) ermitteln Sie mit FindFirst. Wichtig ist nur die korrekte Angabe des Flags faVolumeID. Sollte der Rückgabewert ungleich null sein, ist das Laufwerk nicht verfügbar (keine Diskette, nicht vorhanden), oder das Volume hat keinen Namen. function TFileTools.VolumeName(lw:char):string; var SearchRec:TSearchRec; begin

21.16 Eine Datei-Komponente entwickeln

1257

result := ''; try if FindFirst(lw + ':\*.*', faVolumeID, SearchRec)= 0 then result := SearchRec.Name; finally end end;

Die Hilfsroutine Change prüft bei jedem Aufruf mit Assigned, ob das OnChange-Event auch belegt ist, d.h., ob die Ereignisroutine im Programm genutzt wird. Diese Prüfung sollten Sie immer vor dem Auslösen von Events vornehmen. procedure TFileTools.Change; begin if Assigned(FOnChange) then FOnChange(Self,fValue,Fmax,dateiname) end;

Lassen Sie sich nicht vom Umfang der folgenden Routine abschrecken, sie sieht komplizierter aus, als sie es ist! procedure TFileTools.copy; var SearchRec: TSearchRec; begin

Ist das OnStart-Event belegt, wird es aufgerufen: if Assigned(FOnStart) then FOnStart(Self); { Quelle aus DirListBox und Filtercombobox, ignoriert Eigenschaft Quelle }

Sollte die Komponente mit einer DirectoryListbox und einer FilterCombobox verknüpft sein, ignorieren wir die Eigenschaft Source und verwenden stattdessen die Eigenschaften der beiden Komponenten. Die "String-Bastelei" ist nötig, da die Komponenten sonst einerseits "C:\", aber andererseits auch "C:\test" zurückgeben könnten. Am Ende muss ein Backslash stehen, damit wir den Filter anhängen können: if (Assigned(FSourceDirListbox))and(Assigned(FFilterCombobox))then begin fQuelle := FSourceDirListBox.directory; if fQuelle[length(fQuelle)]<>'\' then fQuelle := fQuelle + '\'; fQuelle := fQuelle + FFilterCombobox.Mask end; if Assigned(FDestinationDirListbox)then begin fZiel := FDestinationDirListbox.directory; if fZiel[length(fZiel)]<>'\' then fZiel := fZiel + '\' end;

Noch ein Hinweis zu Assigned: Da es sich bei Objekt-Eigenschaften um Zeiger handelt, kann die Initialisierung auf diese Weise geprüft werden. Der Kopierpuffer sollte mindestens 1000 Byte groß sein, alles andere wäre Spielerei (der Speicherplatz wird ohnehin nur dynamisch belegt). if fBuffersize < 1000 then fBuffersize := 1000; if (FQuelle = '') or (uppercase(FQuelle) = uppercase(FZiel)) then begin if Assigned(FOnEnd) then FOnEnd(Self);

1258

Kapitel 21

How-to: Dateien/Verzeichnisse

exit; end;

Sollte sich in der Quelle ein Platzhalter finden, müssen wir die eigentliche Kopierroutine mehrfach aufrufen, andernfalls genügt der einmalige Aufruf: if (pos('*',FQuelle) = 0)and(pos('?',FQuelle) = 0) then begin if not kopiereDatei(FQuelle,FZiel) then messagebox(0,'Datei konnte nicht kopiert werden','Problem',16); end else begin { mehrere Dateien }

Mit dem folgenden Konstrukt können Sie alle Dateien ermitteln, die einem bestimmten Suchkriterium entsprechen. Die Platzhalter vergeben Sie nach DOS-Konvention (*,?): if FindFirst(FQuelle,faReadOnly+faArchive, SearchRec)<> 0 then begin if Assigned(FOnEnd) then FOnEnd(Self); exit; end; repeat if not kopiereDatei(extractfilepath(FQuelle)+ SearchRec.Name,extractfilepath(FZiel)+ SearchRec.Name) then begin MessageBox(0,'Datei konnte nicht kopiert werden','Problem', 16+mb_taskmodal); exit; end until FindNext(SearchRec) <> 0 end; if Assigned(FOnEnd) then FOnEnd(Self) end;

Die Kopierroutine ist sicherlich nicht ganz optimal programmiert, sie erfüllt jedoch ihre Aufgabe. An dieser Stelle können Sie Ihrer Programmiererfahrung freien Lauf lassen. Mögliche Anregungen (für Änderungen): ■ Löschen von ReadOnly-Attributen ■ erweiterte Fehlerprüfung (Platte voll ...) ■ Dialoge ... Die Funktionsweise soll hier nicht detailliert erläutert werden, da die Programmierung der Komponente im Vordergrund steht. Nur so viel: Öffnen von Quell- und Zieldatei, dynamische Reservierung des Pufferspeichers, Lesen/Schreiben bis zum letzten Byte, Freigeben des Pufferspeichers und immer wieder Fehlerprüfungen. Nach jedem kopierten Block: Aufruf des OnChange-Events! function TFileTools.KopiereDatei(von,nach:string):Boolean; var f1,f2 : file; buffer : pointer; buffersize, gel, ges, fehler, i : word; begin

21.16 Eine Datei-Komponente entwickeln

buffersize := FBuffersize; dateiname := uppercase(von); if (fileexists(nach))and(not foverwrite) then begin result :=True; exit; end; AssignFile(f1,von); AssignFile(f2,nach); {$i-} reset(f1,1); rewrite(f2,1); {$i+} if ioresult <> 0 then begin result :=False; exit; end; gel:=0; ges:=0; GetMem(buffer,buffersize); fMax:=filesize(f1) div buffersize; if fMax = 0 then fmax := 1; fvalue := 0; change; repeat; {$i-} blockread(f1,buffer^,buffersize,gel); blockwrite(f2,buffer^,gel,ges); inc(fvalue); change; {$i+} fehler:=ioresult; application.processmessages; {!!!!! wichtig !!!!!!!} until (gel=0)or(ges<>gel)or(fehler<>0); if fehler<>0 then begin FreeMem(buffer,buffersize); kopieredatei :=False; exit; end; CloseFile(f1); CloseFile(f2); FreeMem(buffer,buffersize); fValue:=0; dateiname := ''; change; { ein letzter OnChange-.Aufruf } kopieredatei := True; end;

Damit wäre die Programmierung abgeschlossen, kommen wir zur Oberfläche.

1259

1260

Kapitel 21

How-to: Dateien/Verzeichnisse

Oberfläche Eigentlich stimmt die Überschrift nicht, unsere Komponente hat ja gar keine Oberfläche. Für die Entwurfsansicht müssen wir jedoch ein Icon erstellen, das in die Werkzeugleiste eingeblendet werden kann. Laden Sie den zu Delphi mitgelieferten Bildeditor und erstellen Sie eine neue Ressource. Die benötigte Datei hat die Extension .DCR. Zeichnen Sie eine neue Bitmap, die Sie nach der Bearbeitung in "TFILETOOLS" umbenennen. Der Name entspricht dem Komponentenbezeichner! Die Bitmap sollte 24 x 24 Pixel groß sein. Wählen Sie 256 Farben, die Autoren hatten mit anderen Auflösungen Probleme. Speichern Sie die Ressource unter dem Namen FILETOOL.DCR. Die Unit mit der Komponente muss den gleichen Namen haben.

Test Speichern Sie die Unit im gleichen Verzeichnis, in dem Sie auch die Ressourcendatei abgelegt haben. Wählen Sie Komponente|Installieren ... Nehmen Sie entweder ein schon vorhandenes oder ein neues Package, in das die Komponente integriert werden soll. Danach werden Sie gefragt, ob das Package compiliert werden soll.

Wenn alles gut geht, finden Sie in der Werkzeugleiste unter "Beispiele" eine neue Komponente, die Sie wie jede andere Komponente verwenden können. Platzieren Sie eine Komponente im Formular und prüfen Sie, ob alle Eigenschaften und Ereignisse richtig angezeigt werden:

21.16 Eine Datei-Komponente entwickeln

1261

Ein kleines Test-/Demo-Programm für die Komponente finden Sie auf der Buch-CD. Allein mit dem Aufruf FileTools.Copy und ein paar Mausklicks können Sie beliebige Dateien zwischen zwei Verzeichnissen kopieren.

Über das OnChange-Event haben Sie die Möglichkeit, eine Fortschrittsanzeige und ein Label zu aktualisieren. Auf diese Weise ist auch dann etwas zu sehen, wenn gerade kopiert wird: procedure TForm1.FileTools1Change(Sender: TObject; value, max: Word; dateiname: String); begin gauge1.maxvalue := max; gauge1.progress := value; label1.caption := dateiname; end;

Anzeige der Laufwerkstypen: procedure TForm1.Button2Click(Sender: TObject); var i : integer; begin for i := 65 to 90 do begin ListBox1.Items.Add(Chr(i)+':'+FileTools2.DriveType(Chr(i))) end end;

1262

Kapitel 21

How-to: Dateien/Verzeichnisse

Ergänzungen ■ Erweitern Sie die Komponente um Funktionalitäten zum Verschlüsseln bzw. Packen von Dateien. Sie brauchen lediglich eine neue Methode hinzuzufügen. ■ Verwenden Sie statt der selbst geschriebenen Methode zum Kopieren die Möglichkeiten von Windows. Siehe dazu Ä 21.15 Die Shell-Funktionen zum Kopieren nutzen

21.17 Eine ASCII-ANSI-Konvertierung realisieren Was tun, wenn man die Aufgabe bekommt, ASCII-Textdateien in einem Delphi-Programm auszuwerten? Spätestens bei den Umlauten wird es zu Problemen kommen. Ein einfaches Beispielprogramm zeigt, wie es geht.

Oberfläche Auf dem Formular platzieren Sie eine Memo-Komponente und einen Button.

Quelltext procedure TForm1.Button1Click(Sender: TObject); var s:String; l:TStringList; begin l := TStringList.Create; // Stringliste zur Aufnahme der ASCII-Textdatei l.LoadFromFile('test.txt'); // laden der ASCII-Datei // an dieser Stelle müsste Ihr Programm beginnen s := l.text; // der Inhalt der Textdatei wird der Variablen s zugewiesen

Übergabe des Strings (Konvertierung ASCII ... ANSI), der zweite Parameter ist der Rückgabewert. Da dieser genauso groß wie der erste Parameter ist, können wir auf einen extra Puffer verzichten. OEMtoChar(PChar(s),PChar(s)); // Anzeige in einem Memofeld Memo1.text := s end;

Test Starten Sie das Programm und laden Sie über den Button die ASCII-Datei, die sich im gleichen Verzeichnis befindet. Die Umlaute sollten korrekt angezeigt werden.

21.18 Einen eindeutigen TEMP-Dateinamen erzeugen

1263

21.18 Einen eindeutigen TEMP-Dateinamen erzeugen In vielen Anwendungen stehen Sie vor dem Problem, Daten während des Programmablaufs in einer Datei sichern zu müssen, die bei Programmende wieder gelöscht wird. Aber welchen Namen sollen Sie der Datei geben, damit nicht andere Daten überschrieben werden? Eine universelle Lösung bietet die folgende Funktion, die Ihnen einen eindeutigen Dateinamen zurück gibt.

Quelltext Neben dem Dateinamen wird auch gleich noch der Temp-File-Pfad des Computers ermittelt: function CreateTempFileName:String; var p : PChar; d : PChar; begin

Speicher reservieren: p := StrAlloc(MAX_PATH+1); d := StrAlloc(MAX_PATH+1); GetTempPath(MAX_PATH,d); GetTempFileName(d,'$',0, p); Result := String(p);

Nicht vergessen, den Speicher wieder freizugeben: StrDispose(p); StrDispose(d) end;

Test Das auf der Buch-CD enthaltene Testprogramm in Aktion:

1264

Kapitel 21

How-to: Dateien/Verzeichnisse

HINWEIS: Nach dem Aufruf der Funktion befindet sich diese TEMP-Datei bereits im angezeig-

ten \Temp-Verzeichnis, Sie sollten sie bei Programmende wieder löschen!

21.19 Kurze Dateinamen ermitteln Haben Sie es ab und zu noch mit DOS oder 16-Bit-Anwendungen zu tun, stellt sich häufig die Frage nach dem entsprechenden Dateinamen, da DOS mit langen Dateinamen nichts am Hut hat.

Oberfläche Holen Sie sich von der "Win3.1"-Seite der Komponentenpalette eine FileListBox. Außerdem brauchen Sie noch einen Button und ein Label oder Panel.

Quellcode function GetShortFilename(filename : string):string; var p : PChar; begin result := ''; if not FileExists(filename) then Exit; p := StrAlloc(MAX_PATH+1); if GetShortPathName(PChar(filename),p,MAX_PATH+1) <> 0 then result := p; StrDispose(p) end;

Der Aufruf: procedure TForm1.FileListBox1Change(Sender: TObject); begin Panel1.Caption := getShortFilename(FileListBox1.FileName) end;

Test

1265

21.20 Records in einem statischen Array speichern

21.20 Records in einem statischen Array speichern Dieses Beispielprogramm ist das erste einer Serie von Rezepten, die sich mit der Problematik des Abspeicherns statischer und dynamischer Arrays, Recordstrukturen, dynamischem Speicherzugriff, Streams etc. beschäftigen. Bewusst wurden komplexere Objekte (TList, ...) vermieden und stattdessen im Sinne einer Grundlagenvermittlung weitestgehend auf elementare Bausteine zurückgegriffen. Da die einzelnen Rezepte systematisch aufeinander aufbauen, ist ein schrittweises Durcharbeiten zwar empfehlenswert, aber nicht Bedingung. Durchgängige Grundlage für alle Beispiele ist eine kleine Personaldatenbank, in welcher der Name, das Geburtsdatum, das Geschlecht und die Telefonnummer abgespeichert werden sollen. Bei der Umsetzung werden wir auf kein Standard-Datenbankformat (Paradox, dBase) zurückgreifen, sondern auf einen benutzerdefinierten Datentyp (Record). Die einzelnen Records werden in einem eindimensionalen Array abgespeichert, auf das bekanntlich über einen Feldindex (entspricht einer lfd. Nummer) zugegriffen werden kann. BEISPIEL: Stellen Sie sich eine solche Recordstruktur wie ein Regal vor, das aus mit 1, 2, 3 ... durchnumme-

rierten Schubkästen besteht. Jeder Person entspricht ein Schubkasten, dieser wiederum ist in einzelne Fächer für Name, Geburtsdatum ... aufgeteilt. Feldindex name geburt geschlecht nr

1 Wagner 28.11.54 w 03447 90580

2 Maier 8.2.71 m 02762 89670

3 Schultze 3.4.75 m 04288 30024

4 Richter 30.9.81 w 31575 45600

... ... ... ... ...

Oberfläche Platzieren Sie auf dem Formular fünf Labels, drei Editierfelder, eine CheckBox und fünf Buttons:

1266

Kapitel 21

How-to: Dateien/Verzeichnisse

Quelltext Fügen Sie in den Private-Abschnitt von TForm1 die folgenden drei Methodendeklarationen ein: private { Private-Deklarationen } procedure dsInit; // nutzerdefinierte Methode zum Initialisieren aller Datensätze procedure dsSpeichern; // dto. zum Speichern eines Datensatzes procedure dsAnzeigen; // dto. zum Anzeigen

Wir hätten auch auf obige Methodendeklarationen verzichten können und stattdessen drei ganz normale Prozeduren in den Implementation-Abschnitt einfügen können. Die gewählte Vorgehensweise ist aber eleganter und übersichtlicher (insbesondere im Hinblick auf die objektorientierte Programmierung). Im Implementation-Abschnitt definieren wir zunächst unseren Record, um dann eine eindimensionale Array-Variable mit der gewünschten Anzahl von Feldern (10) zu deklarieren: type TPerson = record name: string[20]; geburt: TDateTime; geschlecht: Boolean; nr: Integer end;

// // // // //

Typ der Strukturvariablen max. 20 Buchstaben Geburtsdatum männlich = True, weiblich = False Telefonnummer

const pmax = 10; // max. Anzahl von Personen = Größe des Arrays var personen: array[1..pmax] of TPerson; // Array-Variable index: Byte = 1; // aktueller Feldindex

Nun zu den Methoden-Implementationen: procedure TForm1.FormCreate(Sender: TObject); // Programmstart begin dsInit; // initialisiert alle Datensätze dsAnzeigen // und zeigt den ersten an end;

Es folgen die drei nutzerdefinierten Methoden: procedure TForm1.dsInit; // setzt alle Personen auf Standardwerte var i: Integer; begin for i := pmax downto 1 do with personen[i] do begin name := ''; geburt := StrToDate('31.12.99'); geschlecht := False; nr := 9999999 end end; procedure TForm1.dsSpeichern; begin

// Anzeige => Speicher

1267

21.20 Records in einem statischen Array speichern

personen[index].name := Edit1.Text; if Edit2.Text <> '' then personen[index].geburt := StrToDate(Edit2.Text); personen[index].geschlecht := CheckBox1.Checked; personen[index].nr := StrToInt(Edit3.Text) end; procedure TForm1.dsAnzeigen; // Speicher => Anzeige begin Label1.Caption := IntToStr(index); // Index anzeigen Edit1.Text := personen[index].name; Edit2.Text := DateToStr(personen[index].geburt); CheckBox1.Checked := personen[index].geschlecht; Edit3.Text := IntToStr(personen[index].nr) end;

Nun zu den vier Bewegungstasten: procedure TForm1.Button3Click(Sender: TObject); // vorwärts (>) begin if index < pmax then begin dsSpeichern; Inc(index); dsAnzeigen end end; procedure TForm1.Button2Click(Sender: TObject); // rückwärts (<) begin if index > 1 then begin dsSpeichern; Dec(index); dsAnzeigen end end; procedure TForm1.Button1Click(Sender: TObject); begin dsSpeichern; index := 1; dsAnzeigen end;

// zum Anfang (|<)

procedure TForm1.Button4Click(Sender: TObject); // zum Ende (>|) begin dsSpeichern; index := pmax; dsAnzeigen end;

Test Nach dem Programmstart können die Standardwerte mit den Daten einzelner Personen überschrieben werden. Wie bei einem "richtigen" Datenbankprogramm bewegen Sie sich mit den Tasten durch die Datensätze. Damit enden aber schon die Gemeinsamkeiten, denn leider ist die ganze Mühe umsonst gewesen, wenn Sie das Programm verlassen. Dann wird auch der Inhalt des Arbeitsspeichers gelöscht, und die mühselig eingegebenen Personen sind beim Neustart auf Nimmerwiedersehen verschwunden. Abhilfe zeigt das nächste Rezept, wo wir die Daten auf die Festplatte auslagern werden.

1268

Kapitel 21

How-to: Dateien/Verzeichnisse

Bemerkung Ein Nachteil statischer Arrays ist es, dass die maximale Anzahl von Datensätzen bereits vor dem Compilieren feststehen muss. Sie haben also keine Möglichkeit, zur Laufzeit weitere Personen hinzuzufügen. Hier schafft das folgende Rezept Abhilfe: Ä 21.26 Records in einem dynamischen Array speichern

21.21 Records in einem Stream-Objekt speichern Um Informationen auf der Festplatte abzulegen, gibt es in Delphi eine elegante Alternative zur herkömmlichen Datei: das Speichern in einem FileStream-Objekt.

Typisierte Datei versus Stream-Objekt Im Unterschied zu einer typisierten Datei braucht beim Stream die Datensatzlänge nicht konstant zu sein, alles kann ohne Rücksicht auf die Datenstruktur "hintereinanderweg" abgespeichert werden. Allerdings kann man sich dann auch nicht mehr datensatzweise, sondern muss sich byteweise vorwärts bewegen. Das erschwert zwar den Direktzugriff auf die in der Datei abgespeicherten Werte, was aber nicht als Nachteil zu werten ist, da man die Datei sowieso komplett in den Arbeitsspeicher lädt und nur zu Beginn bzw. am Ende der Sitzung den Inhalt wieder auf die Festplatte auslagert. Beim folgenden Vergleich beziehen wir uns wieder auf den strukturierten Typ TPerson: type TPerson = record name : string[20]; geburtstag : TDateTime end; var person: TPerson;

1269

21.21 Records in einem Stream-Objekt speichern

typisierte Datei (klassische Methode)

Streamobjekt (moderne Methode)

var f: File of TPerson;

var f: TFileStream;

AssignFile(f,'C:\Test.dat');

try

Reset(f);

f := TFileStream.Create('C:\Test.dat',

if IOResult <> 0 then Rewrite(f);

fmOpenReadWrite)

... wenn Öffnungsversuch fehlschlägt, wird neue Datei angelegt.

except f := TFileStream.Create('C:\Test.dat', fmCreate) end;

... wenn Öffnungsversuch fehlschlägt, wird neue Datei angelegt. Read(f, person);

f.ReadBuffer(person,SizeOf(person));

... nur Daten vom Typ TPerson können gelesen werden.

... hier können weitere Leseoperationen für andere Datentypen folgen.

Write(f, person);

f.WriteBuffer(person,SizeOf(person));

... nur Daten vom Typ TPerson können geschrieben werden!

... hier könnten weitere Schreiboperationen für andere Datentypen folgen!

CloseFile(f);

f.Free;

... die Assign-Zuordnung wird aufgehoben.

... das Objekt wird freigegeben.

Oberfläche Die Bedienoberfläche entspricht exakt dem Vorgängerrezept.

Quelltext Es werden nur die Ergänzungen gegenüber dem Vorgängerrezept gezeigt (den vollständigen Code finden Sie auf der Buch-CD): Zur Klassendeklaration TForm1 werden drei neue Methodenköpfe hinzugefügt: procedure dateiNeu; procedure dateiSchreiben; procedure dateiLesen;

// neue Datei anlegen // Array in Datei speichern // Array aus Datei füllen

Die benötigten zusätzlichen Variablen: var f: TFileStream; pfad: string;

// Dateipfad

const datName = 'Personen.dat';

// Dateiname

Nun zur Implementierung der drei Datei-Methoden. Beim Anlegen einer neuen Datei leisten wir uns einmal den Luxus einer Fehlerbehandlung, auf welche wir im Weiteren aus Übersichtlichkeitsgründen verzichtet haben:

1270

Kapitel 21

How-to: Dateien/Verzeichnisse

procedure TForm1.dateiNeu; begin try f := TFileStream.Create(pfad, fmCreate); dsInit; except ShowMessage('Fehler beim Erzeugen der neuen Datei!'); Exit end; f.Free end;

Alle Datensätze des Arrays werden in der Datei abgespeichert: procedure TForm1.dateiSchreiben; var i: Integer; begin f := TFileStream.Create(pfad, fmOpenWrite); for i := pmax downto 1 do f.WriteBuffer(personen[i],SizeOf(TPerson)); f.Free end;

Alle Datensätze werden aus der Datei in das Array eingelesen: procedure TForm1.dateiLesen; var i: Integer; begin f := TFileStream.Create(pfad, fmOpenRead); for i := pmax downto 1 do f.ReadBuffer(personen[i],SizeOf(TPerson)); f.Free end;

Beim Programmstart muss überprüft werden, ob sich bereits eine Datei Personen.dat im Anwendungsverzeichnis befindet. Falls nicht, muss eine neue angelegt werden. procedure TForm1.FormCreate(Sender: TObject); var i: Integer; begin pfad := ExtractFilePath(ParamStr(0)) + datName; // Dateipfad ist aktuelles Verzeichnis try dateiLesen except MessageBeep(0); i := Application.MessageBox('Die Datei ' + datName + ' befindet sich nicht' + #10 + 'im aktuellen Verzeichnis!' + #10 + 'Soll sie neu angelegt werden?', 'Datei nicht gefunden!', 52); if i = 6 then dateiNeu else Exit // Ja-Button oder Programmabbruch end; // bei vorhandener oder neuer Datei: dsAnzeigen; // ersten Datensatz anzeigen Form1.Caption := datName // Dateinamen in Titelleiste des Formulars end;

21.22 Einen Dateidialog realisieren

1271

Erst beim Beenden des Programms können die Daten auf der Festplatte gesichert werden: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); var i: Integer; begin i := Application.MessageBox('Sollen die Änderungen gespeichert werden?','Frage', 36); if i = 6 then // Ja-Button gedrückt begin dsSpeichern; // aktuellen Datensatz sichern dateiSchreiben // ab auf die Festplatte! end end;

Test Diesmal gehen Ihnen keine Dateien verloren, wenn Sie das Programm beenden und anschließend wieder neu starten. HINWEIS: Beachten Sie, dass die Telefonnummer hier ein Integer ist, Sie dürfen also keine

Leerzeichen etc. verwenden, da dies einen Fehler erzeugt!

Bemerkungen ■ Ein analoges Beispiel, allerdings unter Verwendung einer herkömmlichen typisierten Datei, finden Sie im folgenden Rezept. ■ Nachteilig bei unserem einfachen Beispiel ist, dass immer nur eine einzige Datei mit festem Standort zur Verfügung steht. Auch hier zeigt das folgende Rezept einen Ausweg.

21.22 Einen Dateidialog realisieren Welches Programm benötigt ihn nicht, den Menüpunkt Datei! Auf der Seite "Dialoge" der Komponentenpalette finden Sie OpenDialog und SaveDialog. Damit können Sie auf relativ einfache Weise die Windows-typischen Dialogfenster zum Öffnen und Speichern von Dateien realisieren. Allerdings ist noch einiges an zusätzlicher Arbeit zu investieren. Wir wollen dies, genauso wie im Vorgängerrezept, an einer Datei Personen.dat demonstrieren. Allerdings soll diese Datei diesmal als klassische typisierte Datei angelegt werden. Da ein Dateidialog in dieser oder ähnlicher Form sehr häufig zu programmieren ist, soll das folgende, allgemein gefasste Ereignisdiagramm zunächst einen Überblick über die wichtigsten logischen Abläufe der Dateioperationen verschaffen.

1272

Kapitel 21

How-to: Dateien/Verzeichnisse

Start CloseFile(f) DateiNeu := Wahr Datei Öffnen Daten bearbeiten

Datei Speichern unter

Datei Beenden Änderungen speichern?

ja

Datei Speichern

OpenDialog Pfad auswählen Assign(f, pfad) Reset(f) Read(f,Daten) DateiNeu := Falsch

SaveDialog Pfad auswählen Assign(f,pfad) Rewrite(f) DateiNeu := Falsch

ja

DateiNeu?

Reset(f) Write(f, Daten)

Oberfläche Die Oberfläche entsteht als Erweiterung des Vorgängerrezepts. Fügen Sie neben OpenDialog und SaveDialog auch eine MainMenu-Komponente hinzu. Letztere entspricht einem typischen DateiMenü mit den Einträgen Datei|Öffnen, Datei|Speichern, Datei|Speichern unter und Datei|Beenden.

1273

21.22 Einen Dateidialog realisieren

Quelltext Wir beschränken uns auf die Wiedergabe der dateispezifischen Prozeduren, der übrige Teil entspricht dem Rezept Ä 21.20 Records in einem statischen Array speichern var f: File of TPerson; pfad: string; procedure TForm1.FormCreate(Sender: TObject); // Programmstart var i: Integer; begin // einen Standard-Dateinamen zuweisen: pfad := ExtractFilePath(ParamStr(0)) + 'Personen.dat'; Caption := pfad; dsAnzeigen; // ersten Datensatz anzeigen

Da zu Beginn der endgültige Dateiname noch nicht feststeht, erscheint der Menüpunkt Datei| Speichern zunächst gesperrt. Er übernimmt damit gewissermaßen die Funktion des DateiNeu-Flags aus obigem Ereignisdiagramm. fSave.Enabled := False;

// Datei existiert noch nicht

Es soll verhindert werden, dass eine bereits existierende Datei versehentlich überschrieben wird: SaveDialog1.Options := [OFOverwritePrompt];

Beim Speichern soll zunächst der Standard-Dateiname vorgeschlagen werden: SaveDialog1.FileName := pfad end;

Das Klicken auf den Menüpunkt Datei|Öffnen: procedure TForm1.fOpenClick(Sender: TObject); // Datei öffnen var i: Integer; begin if OpenDialog1.Execute then begin pfad := OpenDialog1.FileName; AssignFile(f, pfad); // Zuordnen Dateipfad zur Dateivariablen f {$I-} Reset(f); {SI+} // Versuch, die Datei zu öffnen if IOResult <> 0 then // wenn keine Datei da ist begin Application.MessageBox('Datei konnte nicht geöffnet werden!', 'Fehler', 52); Exit end else // alle Datensätze von f einlesen: for i := pmax downto 1 do Read(f, personen[i]); dsAnzeigen; // ersten Datensatz anzeigen Form1.Caption := pfad; // Anzeige Dateipfad in Titelleiste

1274

Kapitel 21

fSave.Enabled := True end end;

How-to: Dateien/Verzeichnisse

// Freigabe Menüpunkt Datei|Speichern

Bei Datei|Speichern unter ist stets eine neue Dateivariable f anzulegen: procedure TForm1.fSaveAsClick(Sender: TObject); // D.speichern unter begin if SaveDialog1.Execute then begin pfad := SaveDialog1.FileName; AssignFile(f, pfad); // Zuweisen f zu Dateiname

Rewrite legt eine neue (leere) Datei an und öffnet sie: {$I-} Rewrite(f); {$I+} if IOResult <> 0 then ShowMessage('Fehler beim Erzeugen der neuen Datei!'); fSave.Enabled := True; fSaveClick(Self); // weiter mit dem Menüpunkt: Datei speichern Caption := pfad end end;

Das Anklicken des Menüpunktes Datei|Speichern ist nur möglich, wenn bereits eine Dateivariable f existiert (sonst erscheint dieser Menüpunkt gesperrt): procedure TForm1.fSaveClick(Sender: TObject); // Datei speichern var i: Integer; begin {$I-} Reset(f); {SI+} // Dateivariable zurücksetzen if IOResult <> 0 then ShowMessage('Fehler beim Speichern!'); // alle Datensätze nach f schreiben: for i := pmax downto 1 do Write(f,personen[i]) end;

Wenn auf den "Beenden"-Button gedrückt wird oder wenn man das Formular auf andere Weise schließt, sind die üblichen Schlussabfragen durchzuführen, die man zweckmäßigerweise in den OnClose-Event-Handler verpackt: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); var i: Integer; begin i := Application.MessageBox('Änderungen speichern?','Frage', 35); if i = 6 then // Ja-Button gedrückt begin dsSpeichern; // aktuellen Datensatz sichern if fSave.Enabled then fSaveClick(Self) else fSaveAsClick(Self) end; if i = 3 then Exit; // Abbrechen gedrückt

1275

21.23 Dateinamen filtern

Um einen Fehler beim Beantworten von "Änderungen speichern?" mit "Nein" unmittelbar nach Programmstart zu vermeiden (zu diesem Zeitpunkt existiert noch keine Dateivariable f ), muss der Aufruf von CloseFile an diese Bedingung geknüpft werden: if fSave.Enabled then CloseFile(f) end;

Test Probieren Sie erbarmungslos alle Eventualitäten eines Dateidialogs aus, wie z.B. das Überschreiben einer bereits vorhandenen Datei oder das Beenden des Programms unmittelbar nach dem Starten. HINWEIS: Falls Sie den Menüpunkt Datei|Neu vermissen: Er ist nicht notwendig, denn Sie

können jederzeit mit Datei|Speichern unter eine neue Datei anlegen.

Bemerkungen ■ Wenn Sie das Programm um ein so genanntes dirtyFlag ergänzen, welches beim ersten Tastatur-Ereignis von False auf True gesetzt wird, so brauchen Sie die Abfrage "Änderungen übernehmen?" nur dann einblenden, wenn Sie tatsächlich etwas geändert haben. ■ Die Options-Eigenschaft von OpenDialog und SaveDialog ist eine Aufzählung, der Sie zahlreiche weitere Verhaltensmerkmale beim Öffnen und Schließen von Dateien zuweisen können (siehe Objektinspektor).

21.23 Dateinamen filtern Die Komponenten OpenDialog und SaveDialog verfügen über die Eigenschaften DefaultExt, Filter, FilterIndex, mit denen Sie den Dateinamen standardmäßige Erweiterungen hinzufügen können. Außerdem lässt sich damit erreichen, dass Sie beim Öffnen eines Dateidialogs nur die für die jeweilige Applikation in Frage kommenden "herausgefilterten" Dateien sehen. Die Eigenschaften sind schnell erklärt: DefaultExt legt die standardmäßige Dateierweiterung fest, Filter die im Dialogfeld verfügbaren Dateimasken, und FilterIndex gibt den beim Öffnen des Dialogfeldes ausgewählten Filter an. In unserem Beispiel wollen wir das Vorgängerrezept so ergänzen, dass die erzeugten Personaldateien automatisch die Extension *.dat erhalten und nur als solche zu öffnen sind.

Oberfläche ... entspricht dem Vorgängerbeispiel!

1276

Kapitel 21

How-to: Dateien/Verzeichnisse

Quelltext ... entspricht ebenfalls dem Vorgängerrezept, denn wir können alles im Objektinspektor erledigen! Die folgenden Anweisungen gelten gleichermaßen für OpenDialog1 und SaveDialog1. Weisen Sie die Eigenschaften DefaultExt (dat) und FilterIndex(1) direkt zu:

! ! ! Klicken Sie dann auf die Filter-Eigenschaft und öffnen Sie den Filter-Editor:

Als Filtername geben Sie eine entsprechende Beschreibung des Dateityps ein, rechts daneben den Dateifilter (*.dat).

Test Beim Öffnen eines Verzeichnisses werden Sie nur mit den Einträgen konfrontiert, welche die datExtension tragen. Wenn Sie bei "Speichern unter" den Dateinamen ohne Extension eintragen, werden Sie später feststellen, dass diese automatisch ergänzt wurde.

21.24 Records dynamisch auf dem Heap ablegen

1277

Bemerkung Sie können natürlich auch mehrere Filter mit dem Filter-Editor zuweisen, um dann im Quelltext den FilterIndex auf den jeweils gültigen Eintrag zu setzen.

21.24 Records dynamisch auf dem Heap ablegen Gravierender Nachteil der in den vorhergehenden Rezepten benutzten Personaldatenbank war, dass die maximale Anzahl von Datensätzen zur Laufzeit nicht mehr geändert werden konnte. Wir wollen dazu eine erste Verbesserungsmöglichkeit vorschlagen, zunächst aber aus Übersichtlichkeitsgründen auf ein Ablegen der Datensätze in eine Datei verzichten. Da seit Delphi 2 dynamischer Heap-Speicherplatz reichlich zur Verfügung steht, ist es für den fortgeschrittenen Programmierer kein Problem, sich mit etwas "Handarbeit" seine Wünsche nach einem dynamischen Speicherzugriff zu erfüllen. Wem dies aber zu kompliziert erscheint, der sollte dieses Rezept überspringen und zum nächsten übergehen.

Oberfläche Dieses Rezept ist quasi das Pendant zu Ä 21.20 Records in einem statischen Array speichern mit dem Vorteil, dass sich Datensätze zur Laufzeit neu hinzufügen und löschen lassen. Die Oberfläche ähnelt also obigem Rezept, nur dass die Buttons "Neu" und "Löschen" hinzugekommen sind.

1278

Kapitel 21

How-to: Dateien/Verzeichnisse

Quelltext Die Typdeklarationen von TForm1 und TPerson entsprechen dem oben genannten Rezept. Den implementation-Abschnitt von Unit1 schreiben wir komplett neu: type TPersonen = array[1..1] of TPerson; // stat. Array-Typ var pP, puP: ^TPersonen; // Zeiger auf Original- und // gepuffertes Array pmax: Word; // max. Anzahl von Personen = Größe des Arrays index: Byte = 1; // aktueller Feldindex

Zunächst sind einige Routinen zur Speicherverwaltung hinzuzufügen: procedure dimPersonen(anz:Word); // dyn. Speicher reservieren begin GetMem(pP,SizeOf(pP^[1]) * anz) end; procedure freePersonen; begin FreeMem(pP) end;

// dyn. Speicherplatz freigeben

procedure dimPuPersonen(anz:Word); // dyn. Puffer reservieren begin GetMem(puP,SizeOf(puP^[1]) * anz) end; procedure freePuPersonen; begin FreeMem(puP) end;

// dyn. Puffer freigegeben

Nun kann es endlich losgehen: procedure TForm1.FormCreate(Sender: TObject); begin pmax:=1; dimPersonen(pmax);

// Programmstart

21.24 Records dynamisch auf dem Heap ablegen

1279

dsInit; dsAnzeigen end;

Die folgenden Routinen ähneln bis auf den dynamischen Pointer-Zugriff den bekannten "statischen" Realisierungen: procedure TForm1.dsInit; // setzt akt. Person auf Standardwerte begin with pP^[index] do begin name := 'Mustermann'; geburt := Now; geschlecht := True; nr := 9999999 end end;

Das dynamische Speichern eines Datensatzes: procedure TForm1.dsSpeichern; begin pP^[index].Name := Edit1.Text; if Edit2.Text<>'' then pP^[index].geburt:= StrToDate(Edit2.Text); pP^[index].geschlecht := CheckBox1.Checked; pP^[index].nr := StrToInt(Edit3.Text) end;

Das Auslesen aus dem dynamischen Speicher: procedure TForm1.dsAnzeigen; begin Label1.Caption := IntToStr(index); Edit1.Text := pP^[index].Name; Edit2.Text := DateToStr(pP^[index].geburt); CheckBox1.Checked := pP^[index].geschlecht; Edit3.Text := IntToStr(pP^[index].nr) end;

Auch die Programmierung der Bewegungstasten entspricht komplett der bereits bekannten "statischen" Realisierungsvariante, der Quelltext braucht deshalb hier nicht nochmals wiedergegeben zu werden. Die beiden neu hinzugekommenen Buttons "Neu" und "Löschen" haben es allerdings in sich: procedure TForm1.Button6Click(Sender: TObject); // Neu var i: Word; begin dsSpeichern; // aktuellen Datensatz abspeichern Edit1.Text := ''; Edit2.Text := ''; // Anzeige säubern Edit3.Text := ''; CheckBox1.Checked := False; dimPuPersonen(pmax); // gleich großen Pufferspeicher reservieren for i := 1 to pmax do puP^[i] := pP[i]; // Original => Puffer freePersonen; // Originalspeicher freigeben

1280

Kapitel 21

How-to: Dateien/Verzeichnisse

dimPersonen(pmax+1); // Originalspeicher vergrößern, dabei wird alter Inhalt zerstört! for i := 1 to pmax do pP^[i] := puP[i]; // Puffer => Original freePuPersonen; // Pufferspeicher freigeben Inc(pmax); index := pmax; // Datenzeiger auf neuen Datensatz einstellen Label1.Caption := IntToStr(pmax); dsInit; dsAnzeigen end;

Das Löschen eines Datensatzes: procedure TForm1.Button7Click(Sender: TObject); var i,j: Word; begin if pmax = 1 then Application.MessageBox('Der letzte Datensatz kann nicht gelöscht werden!','Problem',0) else if MessageDlg('Wollen Sie den Datensatz wirklich löschen?', mtWarning,[mbYes,mbNo],0) = mrYes then begin dimPuPersonen(pmax-1); // Pufferspeicher bereitstellen j := 1; for i:=1 to pmax do if i <> index then // Original => Puffer begin // ... außer dem zu löschenden Eintrag puP^[j] := pP[i]; Inc(j) end; freePersonen; // Originalspeicher freigeben dimPersonen(pmax-1); // Originalspeicher um eins verkleinern // ... dabei wird alter Inhalt zerstört! for i := 1 to pmax-1 do pP^[i] := puP[i]; // Puffer => Original ohne gelöschtes Feld! freePuPersonen; // Pufferspeicher freigeben Dec(pmax); if index > 1 then Dec(index); // index zeigt vorhergehenden DS dsAnzeigen end end;

Test Nachdem Sie das Programm gestartet haben, erwartet Sie zunächst nur ein einziger Datensatz mit dem standardmäßigen "Mustermann". Sie können diesen Eintrag überschreiben und dann weitere hinzufügen bzw. löschen. Aus Gründen einer zweckmäßigen Programmierung können Sie den letzten verbliebenen Datensatz nicht löschen.

Bemerkung Der in diesem Rezept demonstrierte Zugriff auf den dynamischen Speicher gehört zum Handwerkszeug des "guten alten" Delphi-Programmierers. Mittlerweile geht das Ganze aber auch erheblich einfacher, wie es das folgende Rezept zeigt.

21.25 Records in einem dynamischen Array speichern

1281

21.25 Records in einem dynamischen Array speichern Ähnlich wie es in Microsofts Visual Basic schon immer möglich war, können in den neueren Delphi-Versionen nun auch dynamische Arrays dimensioniert werden. In diesem Rezept wollen wir die gleiche Funktionalität erzielen wie im Vorgängerrezept, allerdings mit einfacheren Mitteln.

Oberfläche Diese entspricht 1 : 1 dem Vorgängerbeispiel.

Quelltext Als Vorbild eignet sich das Listing des Rezepts Ä 21.20 Records in einem statischen Array speichern besser als das des Vorgängerrezepts. Es braucht nur relativ geringfügig modifiziert und ergänzt zu werden. Im Folgenden werden nur die notwendigen Anpassungen angegeben. var pmax: Word = 1;

// max. Anzahl von Personen = Größe des Arrays

Die Variablendeklaration dynamischer Arrays entspricht der bei statischen Arrays, nur dass die Felddimensionen weggelassen werden: var personen: array of TPerson; puffer : array of TPerson; index : Word = 0;

// dyn. Array-Variable für Personenliste // dto. zum Zwischenspeichern // aktueller Feldindex, beginnt mit 0!

Beim Programmstart wird mittels SetLength das dynamische Array mit einem Feld dimensioniert: procedure TForm1.FormCreate(Sender: TObject); // Programmstart begin SetLength(personen, pmax); // Array mit einem Feld wird angelegt dsInit; dsAnzeigen end;

Unkompliziert ist das Anhängen eines neuen (leeren) Datensatzes an das Ende des Arrays, dabei bleibt der alte Inhalt erhalten: procedure TForm1.Button6Click(Sender: TObject); // Neu begin dsSpeichern; Inc(pmax); // Anzahl um eins erhöhen index := pmax-1; // letzter Datensatz hat Index pmax-1 SetLength(personen, pmax); // Dimension anpassen dsAnzeigen end;

Etwas umfangreicher gestaltet sich das Löschen von Datensätzen. Um den Code überschaubar zu halten, ist das Löschen des letzten Datensatzes nicht möglich.

1282

Kapitel 21

How-to: Dateien/Verzeichnisse

procedure TForm1.Button7Click(Sender: TObject); // Löschen var i: Word; j: Integer; begin if pmax = 1 then Application.MessageBox('Der letzte Datensatz kann nicht gelöscht werden!','Problem',0) else if MessageDlg('Wollen Sie den Datensatz wirklich löschen?', mtWarning,[mbYes,mbNo],0) = mrYes then begin SetLength(puffer, pmax-1); j := -1; for i := 0 to pmax-1 do if i <> index then begin Inc(j); Puffer[j] := Personen[i] end;

Jetzt befinden sich die restlichen Datensätze in dem um eins verkürzten Puffer-Array und brauchen bloß noch in das Original-Array zurückkopiert zu werden. Da dessen Länge nun um eins "übersteht", muss es mit Copy verkürzt werden: Dec(pmax); for i:= 0 to pmax-1 do personen[i] := puffer[i]; // zurück kopieren personen := Copy(personen,0,pmax); // letzten Datensatz abschneiden if index > 0 then Dec(index); dsAnzeigen end end;

Die Abbildung soll noch einmal das Prinzip des Löschens von Datensätzen demonstrieren: 0

1

2

3

4

Müller

Meyer

Schultze

Lehmann

Schneider

Löschen

0

1

Müller

Kopieren 2

Meyer

Originalarray

3

Lehmann

Pufferarray

Schneider

Kopieren 0

1

2

3

4

Müller

Meyer

Lehmann

Schneider

Schneider

Originalarray

Abschneiden 0

1

2

3

Müller

Meyer

Lehmann

Schneider

Originalarray

21.25 Records in einem dynamischen Array speichern

1283

Zum Schluss sollte der von Original-Array und Puffer-Array dynamisch belegte Speicherplatz wieder freigegeben werden: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin personen := nil; puffer := nil end;

Test Nach dem Programmstart können Sie beliebig Datensätze hinzufügen und löschen. Lediglich der letzte Datensatz muss im Array verbleiben. Nach jeder Löschoperation erhalten die nachfolgenden Datensätze einen um eins verringerten Index.

Bemerkungen ■ Bei den angezeigten Indizes handelt es sich um eine fortlaufende Nummerierung der Datensätze entsprechend dem Feldindex plus eins (da ein dynamisches Array immer mit dem Feldindex 0 beginnt). ■ Das einfache Zuweisen des Pufferspeicherinhalts zum Originalinhalt puffer := personen

ist nicht möglich, da es sich hier um Zeiger handelt und demzufolge beide Variablen das gleiche Array referenzieren würden. ■ Auch das Einfügen neuer Datensätze könnte an der aktuellen Position erfolgen anstatt am Ende (siehe folgendes Rezept).

1284

Kapitel 21

How-to: Dateien/Verzeichnisse

21.26 Einen FileStream als BDE-Ersatz verwenden Die hervorragende Unterstützung, die Delphi für Datenbankanwendungen bereitstellt, verleitet dazu, selbst für die winzigsten datenspezifischen Applikationen die Dienste der integrierten BDE (Borland Database Engine) in Anspruch zu nehmen. Der Programmierer setzt sich dabei nicht nur dem Vorwurf aus, "mit Kanonen auf Spatzen zu schießen", sondern verkompliziert auch noch die Weitergabe seiner Applikation, da auch noch die recht umfangreiche BDE auf den Installationsdisketten mitzuliefern ist, die dann den Zielrechner mit vielen unnötigen Routinen vollstopft. Wir wollen zeigen, wie Sie auch das ersehnte Ziel mit weniger Aufwand erreichen. Bereits mit relativ einfachen Mitteln sind wir in der Lage, ein robustes und "schlankes" Datenbankprogramm zu erstellen, falls dessen Komplexität sich auf relativ einfache Verknüpfungen zwischen wenigen Tabellen beschränkt und auf SQL-Abfragen verzichtet werden kann. Die vorhergehenden Rezepte Ä 21.25 Records in einem dynamischen Array speichern Ä 21.21 Records in einem Stream-Objekt speichern haben das Terrain dazu vorbereitet. Im Folgenden brauchen wir nur noch beide Technologien, nämlich die "in-memory"-Speicherung in ein dynamisches Array und die persistente Speicherung in einen FileStream, miteinander zu kombinieren, und schon haben wir eine einfache Datenbankapplikation, welche die modernen Features von Delphi voll ausnutzt.

Oberfläche

Quelltext Die Typdeklaration TForm1 wird um zwei Methoden bereichert: type TForm1 = class(TForm) ...

1285

21.26 Einen FileStream als BDE-Ersatz verwenden

private procedure dsSpeichern; procedure dsAnzeigen; end;

// Methode zum Speichern eines Datensatzes // Methode zum Anzeigen ...

Zu Beginn des implementation-Abschnitts wird die Struktur eines Datensatzes definiert, vergleichbar mit dem Tabellenentwurf bei einer "echten" Datenbank: type TPerson = record name: string[20]; geburt: TDateTime; geschlecht: Boolean; nr: Integer end;

// // // // //

Typ der Strukturvariablen max. 20 Buchstaben Geburtsdatum männlich = True, weiblich = False Telefonnummer

Diese Variablen bestimmen das in-memory und das persistente Speichern: var pmax: Word = 1; // max. Anzahl von Personen ( 1 = Anfangsgröße des Arrays) personen: array of TPerson; // dynamische Datenhaltung puffer: array of TPerson; // dto. zum Zwischenspeichern index: Byte = 0; // aktueller Feldindex, beginnt mit 0! f: TFileStream; // persistente Datenhaltung pfad: string; // Dateipfad

Nun zu den Methoden-Implementationen: procedure TForm1.dsSpeichern; // Anzeige => dyn. Speicher begin personen[index].name := Edit1.Text; if Edit2.Text <> '' then personen[index].geburt := StrToDate(Edit2.Text); personen[index].geschlecht := CheckBox1.Checked; personen[index].nr := StrToInt(Edit3.Text) end; procedure TForm1.dsAnzeigen; // dyn. Speicher => Anzeige begin Label1.Caption := IntToStr(index+1); // Index anzeigen Edit1.Text := personen[index].name; Edit2.Text := DateToStr(personen[index].geburt); CheckBox1.Checked := personen[index].geschlecht; Edit3.Text := IntToStr(personen[index].nr) end;

Die Bedienfunktionen der Navigatorleiste: procedure TForm1.Button3Click(Sender: TObject); // vorwärts (>) begin if index < pmax-1 then begin dsSpeichern; Inc(index); dsAnzeigen end end; procedure TForm1.Button2Click(Sender: TObject); // rückwärts (<) begin if index > 0 then begin dsSpeichern; Dec(index); dsAnzeigen end end; procedure TForm1.Button1Click(Sender: TObject); begin dsSpeichern; index := 0; dsAnzeigen end;

// zum Anfang

1286

Kapitel 21

How-to: Dateien/Verzeichnisse

procedure TForm1.Button4Click(Sender: TObject); // zum Ende begin dsSpeichern; index := pmax-1; dsAnzeigen end;

Ein neuer Datensatz wird an der aktuellen Position eingefügt: procedure TForm1.Button6Click(Sender: TObject); // Neu var i,j: Integer; begin dsSpeichern; SetLength(puffer, pmax+1); // Anlegen eines um eins vergrößerten Pufferarrays j := -1; for i := 0 to pmax-1 do begin Inc(j); Puffer[j] := Personen[i]; if i = index then Inc(j) // hier neuen DS einfügen end; Inc(pmax); SetLength(personen, pmax); // Vergrößern des Originalarrays um eins for i:= 0 to pmax-1 do personen[i] := puffer[i]; // zurück kopieren if index < pmax-1 then Inc(index); dsAnzeigen end;

Die folgende Abbildung verdeutlicht die Vorgänge beim Einfügen eines neuen Datensatzes: 0

1

2

3

Müller

Meyer

Lehmann

Schneider

Originalarray

Neu

0 Müller

1

Kopieren 2

3

Meyer

Lehmann

4 Schneider

Pufferarray

Kopieren 0 Müller

1 Meyer

2

3 Lehmann

4 Schneider

Originalarray

Das Löschen des aktuellen Datensatzes verwendet eine ähnliche Technologie wie das Hinzufügen: procedure TForm1.Button7Click(Sender: TObject); var i: Word; j: Integer; begin if pmax = 1 then Application.MessageBox('Der letzte Datensatz kann nicht gelöscht werden!','Problem',0) else if MessageDlg('Wollen Sie den Datensatz wirklich löschen?', mtWarning,[mbYes,mbNo],0) = mrYes then begin SetLength(puffer, pmax-1); j := -1; for i := 0 to pmax-1 do if i <> index then begin Inc(j); Puffer[j] := Personen[i] end;

1287

21.26 Einen FileStream als BDE-Ersatz verwenden

Dec(pmax); for i:= 0 to pmax-1 do personen[i] := puffer[i]; // zurück kopieren personen := Copy(personen,0,pmax); // letzten Datensatz abschneiden if index > 0 then Dec(index); dsAnzeigen end end;

Nun kommen wir zu den Prozeduren, die mit der persistenten Datenspeicherung im Zusammenhang stehen: procedure TForm1.FormCreate(Sender: TObject); // Programmstart begin SetLength(personen, pmax); // Array mit einem Feld wird angelegt dsAnzeigen; pfad := ExtractFilePath(ParamStr(0)) + 'Personaldatei'; // Standard-Dateinamen Caption := pfad; dsAnzeigen; // ersten Datensatz anzeigen fSave.Enabled := False; // Datei existiert noch nicht SaveDialog1.Options := [OFOverwritePrompt]; // Warnung vor Überschreiben SaveDialog1.FileName := pfad end;

Die einzelnen Menüfunktionen: procedure TForm1.fOpenClick(Sender: TObject); // Datei öffnen var i: Word; begin if OpenDialog1.Execute then begin pfad := OpenDialog1.FileName; try f := TFileStream.Create(pfad, fmOpenRead) except Application.MessageBox('Die Datei konnte nicht geöffnet werden!','Fehler', 52); Exit end; f.ReadBuffer(pmax, SizeOf(Word)); SetLength(personen, pmax); for i := pmax-1 downto 0 do f.ReadBuffer(personen[i],SizeOf(TPerson)); index := 0; dsAnzeigen; // ersten Datensatz anzeigen Form1.Caption := pfad; // Anzeige Dateipfad in Titelleiste des Formulars fSave.Enabled := True; // freigeben zum Speichern f.Free end end; procedure TForm1.fSaveAsClick(Sender: TObject); begin if SaveDialog1.Execute then begin pfad := SaveDialog1.FileName; try

// Datei speichern unter

1288

Kapitel 21

How-to: Dateien/Verzeichnisse

f := TFileStream.Create(pfad, fmCreate) except ShowMessage('Fehler beim Erzeugen der neuen Datei!'); Exit end; f.Free; fSaveClick(Self); // zum Menüpunkt: Datei speichern Caption := pfad; fSave.Enabled := True end end; procedure TForm1.fSaveClick(Sender: TObject); // Datei speichern var i: Integer; begin try f := TFileStream.Create(pfad, fmOpenWrite) except ShowMessage(' Fehler beim Speichern von ' + pfad); Exit end; f.WriteBuffer(pmax, SizeOf(Word)); for i := pmax-1 downto 0 do f.WriteBuffer(personen[i],SizeOf(TPerson)); f.Free end;

Die routinemäßige Sicherheitsabfrage beim Schließen des Formulars sollte nicht fehlen: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); var i: Integer; begin i := Application.MessageBox('Sollen die Änderungen gespeichert werden?','Frage', 36); if i = 6 then begin // Ja-Button gedrückt dsSpeichern; // aktuellen Datensatz sichern if fSave.Enabled then fSaveClick(Self) else fSaveAsClick(Self) end;

Bei dieser Gelegenheit sollte auch das "Aufräumen" der dynamischen Arrays nicht vergessen werden: personen := nil; puffer := nil end; end.

Test Starten Sie das Programm und experimentieren Sie damit! Fügen Sie einige Datensätze hinzu und speichern Sie diese auf der Festplatte ab. Löschen Sie Datensätze und speichern Sie die Datei unter einem anderen Namen ab. Achten Sie beim Abspeichern der Telefonnummer auf den Datentyp (Integer), da sonst ein Fehler auftritt!

22

How-to: Datenbanken

Kapitel

22

How-to: Datenbanken 22.1 In einem Datenbank-Memofeld suchen Bekannterweise lassen sich mit Hilfe der Locate-Methode keine Memofelder durchsuchen, auch die Verwendung des OnFilterRecord-Ereignisses bringt uns nicht weiter. Was also bleibt uns anderes übrig, als diese Funktion nachzuprogrammieren? Als Erstes müssen wir eine Funktion realisieren, die zwei Strings (nichts anderes sind Memofelder) mit Hilfe von Platzhaltern ("*" und "?") miteinander vergleicht. Ist die Suche erfolgreich, soll der betreffende Abschnitt hervorgehoben werden (rote fette Schrift). Alternativ soll eine Möglichkeit bestehen, weitere Datensätze mit dem Suchstring zu finden.

Oberfläche Den Grundaufbau der Oberfläche entnehmen Sie bitte der folgenden Abbildung.

1290

Kapitel 22

How-to: Datenbanken

Die Table-Komponente binden Sie mittels DataBaseName-Eigenschaft an die Datenbank "DBDemos" und mittels TableName an die Tabelle "Biolife.db". Das DBGrid dient uns lediglich zur Darstellung der Datensätze, binden Sie es mittels seiner DataSource-Eigenschaft an DataSource1, diese Komponente wiederum über DataSet an Table1. Das am unteren Fensterrand befindliche RichEdit ist nicht datengebunden. Setzen Sie die Active-Eigenschaft von Table1 auf True, um bereits jetzt Datensätze im Gitter zu sehen.

Quelltext Zunächst kümmern wir uns um eine Suchfunktion, die unseren Ansprüchen gerecht wird. Die Funktion Like erwartet als Übergabeparameter den zu durchsuchenden String und die Suchmaske mit dem Suchbegriff. function Like(s, pattern: PChar): Boolean; begin if StrComp(pattern,'*') = 0 then Result := True else if (s^ = #0) and (pattern^ <> #0) then Result := False else if s^ = #0 then Result := True else case pattern^ of '*': if Like(s,@pattern[1]) then Result := True else Result := Like(@s[1],pattern); '?': Result := Like(@s[1],@pattern[1]) else if s^ = pattern^ then Result := Like(@s[1],@pattern[1]) else Result := False end end;

Wie Sie sehen, ruft sich die Funktion im Bedarfsfall rekursiv auf, wobei jeweils das erste Zeichen abgeschnitten wird (die Übergabe von @s[1] ist ein Pointer auf das zweite Zeichen!). Die folgende Funktion übernimmt das Füllen der RichEdit-Komponente mit den Daten des Memofeldes und die Markierung der Fundstellen. procedure markiere; var s, was : string; i, i1 : Integer; start : Integer; begin

22.1 In einem Datenbank-Memofeld suchen

1291

Laden aus der Tabelle: Form1.RichEdit1.ext := Form1.Table1.FieldByName('Notes').AsString;

Der Suchstring wird von den Platzhaltern "befreit": was := ''; s := Form1.Edit1.Text; for i := 1 to Length(s) do if (s[i] <> '*')and(s[i] <> '?') then was := was + s[i]; start := 0;

Suchen der ersten Fundstelle im RichEdit: with Form1.RichEdit1 do begin repeat i := FindText(was, start, Length(Text), [stMatchCase]);

HINWEIS: Sie sollten in jedem Fall die FindText-Methode einsetzen, da nur in diesem Fall

sichergestellt ist, dass Sie auch im RTF-Text die richtige Suchposition finden. Markieren des gefundenen Textteils: if i <> -1 then begin if start = 0 then i1 := i; SelStart := i; SelLength := Length(was); SelAttributes.Color := clred; SelAttributes.Style := [fsBold]; start := i + 1 end;

Solange etwas gefunden wird: until (i = -1);

Der Cursor wird auf die erste Fundstelle gesetzt: SelStart SelLength end end;

:= i1; := 0

Der Code für den Button "Start Suche": procedure TForm1.Button1Click(Sender: TObject); begin RichEdit1.Clear;

Satzzeiger auf den ersten Datensatz positionieren: Table1.First;

1292

Kapitel 22

How-to: Datenbanken

Suchen, bis der letzte Datensatz erreicht ist oder der gewünschte Text gefunden wurde: while not Table1.Eof do begin if Like(PChar(Table1.FieldByName('Notes').AsString), PChar(Edit1.Text)) then begin markiere; Break end; Table1.Next end end;

Beim "Weitersuchen" gehen wir einfach nur von der bisherigen Satzzeigerposition aus, alle anderen Aufgaben sind die gleichen: procedure TForm1.Button2Click(Sender: TObject); begin RichEdit1.Clear; Table1.Next; while not Table1.Eof do begin if Like(PChar(Table1.FieldByName('Notes').AsString), PChar(Edit1.Text)) then begin markiere; Break end; Table1.Next end end;

Test Starten Sie das Programm und geben Sie einen Suchbegriff mit Platzhaltern ein.

22.2 Ein StringGrid mit Abfrageergebnissen füllen

1293

22.2 Ein StringGrid mit Abfrageergebnissen füllen Nicht in jedem Fall möchte man gleich ein gebundenes Grid für die Anzeige von Tabellendaten einsetzen. Dies könnte zum Beispiel der Fall sein, wenn man die Datenbankverbindung trennen muss. Sollen die Daten jedoch weiterhin angezeigt werden, bleibt nur ein "gewöhnliches" StringGrid für die Anzeige. Ein kleines Beispiel zeigt die Vorgehensweise.

Oberfläche Setzen Sie auf das Formular ein StringGrid, einen Button und eine Query-Komponente (Seite "BDE"), die Sie über DateBaseName an die Datenbank DBDEMOS binden. Als SQL-Eigenschaft tragen Sie die folgende Anweisung ein: SELECT * FROM Employee

Quelltext Mit dem Klick auf den Button wird zunächst geprüft, ob überhaupt Daten von der Query abgerufen wurden. Ist dies der Fall, wird die Anzahl der Spalten und Zeilen bestimmt: procedure TForm1.Button1Click(Sender: TObject); var x,y : Integer; begin if not Query1.IsEmpty then begin StringGrid1.ColCount := Query1.FieldCount; StringGrid1.RowCount := Query1.RecordCount + 1; StringGrid1.FixedCols := 0; StringGrid1.FixedRows := 1;

Nachfolgend können wir uns um das Füllen des Tabellenkopfes kümmern: For x := 0 To Query1.FieldCount-1 Do StringGrid1.Cells[x,0] := Query1.Fields[x].FieldName; y := 0;

1294

Kapitel 22

How-to: Datenbanken

Last but not least werden noch die eigentlichen Daten in das Grid eingetragen: While Not Query1.Eof do Begin for x := 0 to Query1.FieldCount-1 do StringGrid1.Cells[x, y + 1] := Query1.Fields[x].AsString; Query1.Next; Inc(y) end end end;

Test Läuft alles korrekt, sollte sich Ihnen der folgende Anblick bieten:

22.3 Hierarchische Datenstrukturen darstellen Wollen Sie den Anwendern Ihrer Programme mehr bieten als nur langweilige Listendarstellungen und simple Eingabemasken? Falls ja, dann kommen Sie beim Darstellen hierarchischer Daten nicht um die Verwendung der TreeView-Komponente herum. Ganz abgesehen davon, dass hier eine Baumdarstellung wesentlich übersichtlicher ist als eine Tabelle, können Sie durch den Einsatz solcher grafischer Elemente auch noch reichlich Eindruck schinden1.

Oberfläche Neben einer TreeView-Komponente brauchen wir noch eine ProgressBar für die Fortschrittsanzeige beim Einlesen, eine ImageList, drei Query-Komponenten, eine Table-Komponente sowie einige gebundene Eingabefelder. Die Abbildung zeigt die Entwurfsansicht:

1

Vergessen Sie derartige Spielereien aber, wenn es sich um Tausende von Datensätzen handelt. In diesem Fall dürfte der Schaden größer als der Nutzen sein.

22.3 Hierarchische Datenstrukturen darstellen

1295

Die DataBaseName-Eigenschaft der drei Query- und der Table-Komponente wird mit der MITARBEITER-Datenbank verbunden (siehe Buch-CD). Der TableName-Eigenschaft der TableKomponente weisen Sie die Tabelle Personen.db zu. Mit ihr werden wir einerseits die Anzahl der Datensätze bestimmen (Endwert für die ProgressBar), andererseits suchen wir mit Hilfe der Komponente den Datensatz, der gerade in der Baumansicht ausgewählt wurde, und stellen die Details in den gebundenen Eingabefeldern dar. Die drei Query-Komponenten sind für jeweils eine Hierarchieebene verantwortlich, der jeweils übergeordnete Datensatz wird über eine Parametervariable in die SQL-Eigenschaft eingefügt: SELECT nr, anrede, nachname + ', ' + vorname AS Bez FROM personen WHERE vorgesetzter = :nrvorgesetzter

Vergessen Sie nicht, die ImageList über die Eigenschaft Images an die TreeView-Komponente zu binden, wir wollen je nach Geschlecht eine andere Grafik in den Baum einblenden.

Quellcode In unserer Beispieldatenbank haben wir drei Hierarchieebenen: ■ Chef ■ Abteilungsleiter ■ Personal

1296

Kapitel 22

How-to: Datenbanken

die wir über die drei getrennten Query-Komponenten auslesen. Mit der Ergebnismenge der einen Abfrage wird der Parameter für die nächste Abfrage bestimmt. Ein Problem bleibt aber im Zusammenhang mit der TreeView-Komponente ungelöst: Wollen Sie nach dem Klick auf einen Eintrag den zugehörigen Datensatz aus der Tabelle heraussuchen, fehlt Ihnen die Möglichkeit, einen eindeutigen Schlüssel zu speichern. Der Name (die Beschriftung der Einträge) genügt für die Suche in der Tabelle natürlich nicht, sinnvoller wäre da schon das Feld "Nr". Mit der Eigenschaft Data scheint sich eine Lösung für das Problem zu bieten, doch leider handelt es sich lediglich um einen Pointer. Wir werden einfach eine dynamische Variable vom Typ Integer erzeugen, den Pointer darauf können wir problemlos der Data-Eigenschaft zuweisen. Aber aufgepasst: Beim Auslesen der DataEigenschaft müssen wir den Data-Pointer dereferenzieren und typisieren. Einige globale Variablen und Typen: procedure TForm1.Button1Click(Sender: TObject); var anzahl : Integer;

Das eigentliche Einlesen der Datensätze: var Node1, Node2, Node3 : TTreeNode; i : Integer; begin i := 0; Table1.open; anzahl :=Table1.recordcount; progressbar1.max :=anzahl;

Nach dem Bestimmen der Gesamtzahl aller Mitarbeiter (Max-Eigenschaft für den Fortschrittsbalken) ermitteln wir (was sonst?) als Erstes den Chef: Node1:= TreeView1.Items.AddChild(TreeView1.Selected, Query1['bez']); if Query1['anrede']= 'Herr' then node1.imageindex := 2 else node1.imageindex := 1; new(id); id^:= Query1['nr']; node1.data := id; inc(i); progressbar1.position := i; node1.SelectedIndex := node1.imageindex;

Mit den Daten können wir sowohl die Beschriftung (Name + Vorname) als auch die Grafik bestimmen (abhängig vom Feld "Anrede"). Nach dem Erzeugen und Initialisieren des Integer-Pointers weisen wir den Wert der Data-Eigenschaft zu. Weiterhin ist der Fortschrittsbalken zu aktualisieren. Nächster Schritt ist die Bestimmung der Abteilungsleiter: query2.Active := False;

22.3 Hierarchische Datenstrukturen darstellen

1297

query2.parambyname('nrvorgesetzter').value := Query1['nr']; query2.Active:=True;

Da es sicherlich mehr als einen Abteilungsleiter gibt, verwenden wir eine while-Schleife: while not query2.eof do begin Node2:= TreeView1.Items.addChild(Node1, query2['bez']); if query2['anrede']= 'Herr' then node2.imageindex := 2 else node2.imageindex := 1; node2.SelectedIndex := node2.imageindex; new(id); id^:= query2['nr']; node2.data := id; inc(i); query3.Active := False; query3.parambyname('nrvorgesetzter').value := query2['nr']; query3.Active:=True; progressbar1.position := i;

Danach können die zugehörigen Mitarbeiter ausgewählt und angezeigt werden (natürlich auch wieder in einer Schleife): while not query3.eof do begin Node3:= TreeView1.Items.addChild(Node2, query3['bez']); if query3['anrede']= 'Herr' then node3.imageindex := 2 else node3.imageindex := 1; node3.SelectedIndex := node3.imageindex; new(id); id^:= query3['nr']; node3.data := id; query3.next; inc(i); progressbar1.position := i end; query2.next end;

Zum Schluss bleiben nur noch das Schließen der Abfragen sowie die Auswahl des ersten Eintrags in der Baumansicht: Query1.Active := False; query2.Active := False; query3.Active := False; TButton(sender).enabled := False; treeview1.selected := node1;

Mit jedem Wechsel in der Baumansicht soll der zugehörige Datensatz in der Tabelle gesucht und angezeigt werden. Die Schlüsselwerte für die Suche hatten wir ja bereits gespeichert: procedure TForm1.TreeView1Change(Sender: TObject; Node: TTreeNode); begin

1298

Kapitel 22

How-to: Datenbanken

Table1.findkey([Integer(treeview1.selected.data^)]) end;

Was wir natürlich nicht vergessen sollten: Das Freigeben der dynamischen Variablen. procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); var i : Integer; begin for i := treeview1.Items.Count-1 downto 0 do begin progressbar1.position := i; dispose(treeview1.items[i].data) end end;

Test Erfreuen Sie sich an der netten, fein nach Männlein und Weiblein getrennten Baumansicht:

22.4 Daten in einer ListView darstellen Wollen Sie Daten lieber grafisch darstellen statt in einer tristen Tabelle, sollten Sie die ListViewKomponente in Betracht ziehen. Ein besonders interessanter Verwendungszweck ist die Realisierung von Drag & Drop-Operationen innerhalb einer Datenbank, d.h., der Anwender muss nicht mehr Einträge in einer Tabelle ändern, sondern kann einfach mit der Maus arbeiten. In unserem kleinen Beispielprogramm werden in einer Listbox alle Räume einer Verwaltung dargestellt. Wählen Sie einen Raum aus, erscheinen im rechten Feld alle Mitarbeiter, die sich in diesem Raum befinden (je nach Geschlecht wird ein anderes Icon eingeblendet). Soll nun ein Mitarbeiter umbesetzt werden, genügt es, wenn Sie diesen mittels Drag & Drop in den neuen Raum ziehen.

22.4 Daten in einer ListView darstellen

1299

Oberfläche Neben einer ListView- (links) und einer TreeView-Komponente (rechts) brauchen Sie lediglich noch zwei Table- und eine ImageList-Komponente.

Quelltext Verbinden Sie die beiden Table-Komponenten mit der Datenbank "Verwaltung" bzw. den Tabellen Personen.db und Raeume.db. Wird das Formular erzeugt, füllen wir die Listbox mit allen verfügbaren Räumen: procedure TForm1.FormCreate(Sender: TObject); var NewItem : TListItem; begin anzahl := 1; GetMem(zeiger, sizeof(Integer) * anzahl); while not Table1.eof do begin NewItem := ListView1.Items.Add; NewItem.Caption := IntToStr(Table1['nr']); Table1.Next end end;

Als Beschriftung wählen wir die Raumnummer, diese werden wir für die spätere Drag & DropOperation noch benötigen. Wird in der ListView ein Eintrag ausgewählt, beginnt die Arbeit: procedure TForm1.ListView1Click(Sender: TObject); var node : TTreeNode; nr,i : Integer;

1300

Kapitel 22

How-to: Datenbanken

begin if ListView1.Selected = nil then Exit;

Löschen der TreeView-Komponente: Treeview1.items.Clear;

Table2 neuen Filter setzen: Table2.filter := 'raum = ' + ListView1.Selected.Caption; FreeMem(zeiger, sizeof(Integer) * anzahl); anzahl := Table2.RecordCount; GetMem(zeiger, sizeof(Integer) * anzahl); nr := 0;

Alle Datensätze durchlaufen und neue Einträge erzeugen: while not Table2.eof do begin node := Treeview1.Items.Add(treeview1.selected, Table2['vorname'] + ' ' + Table2['nachname']); if Table2['anrede']= 'Frau' then node.imageindex := 2 else node.imageindex := 1; zeiger^[nr]:= table2['nr']; node.data := Pointer(zeiger^[nr]); node.SelectedIndex := node.imageindex; Table2.Next; inc(nr) end end;

Damit wäre erst einmal die Darstellung realisiert, als Nächstes müssen wir die Drag & DropOperation vorbereiten. Dazu ist einerseits die DragMode-Eigenschaft der TreeView-Komponente auf dmAutomatic zu setzen, andererseits muss das Drag & Drop-Ziel auch auf die Aktion reagieren: procedure TForm1.ListView1DragOver(Sender, Source: TObject; X, Y: Integer; State: TDragState; var Accept: Boolean); begin accept := True end;

Die eigentliche Routine wird nach dem Loslassen über dem Ziel ausgeführt: procedure TForm1.ListView1DragDrop(Sender, Source: TObject; X, Y: Integer); var nr, i : Integer; begin

Falls kein Icon angewählt wurde: if listview1.DropTarget = nil then Exit;

Eine Sicherheitsabfrage sollten Sie auf keinen Fall vergessen: if Application.MessageBox(PChar(Format('%s in Raum %s umbesetzen?', [Treeview1.selected.text, ListView1.DropTarget.Caption])), 'Frage', 36) = idyes then begin

22.4 Daten in einer ListView darstellen

1301

In der Tabelle "Personen" wird der Eintrag gesucht, der von der Drag & Drop-Operation betroffen ist: table2.findkey([Integer(treeview1.selected.data)]); val(listview1.DropTarget.Caption,nr,i);

Edit-Modus einschalten, Raumnummer ändern und speichern: Table2.edit; Table2['raum'] := nr; Table2.post; listview1.selected := listview1.DropTarget; ListView1Click(self) end end;

Test "Öffnen" Sie links eine Tür und schon sehen Sie rechts, wer alles in dem Raum sitzt.

So richtig Spaß macht es, wenn Sie selbst Chef spielen und Mitarbeiter per Drag & Drop in einen anderen Raum verfrachten:

1302

Kapitel 22

How-to: Datenbanken

22.5 Mit Lookup-Feldern Tabellen verknüpfen Als Alternative zur DBLookupComboBox/-ListBox können so genannte Lookup-Felder eingesetzt werden.

Oberfläche Orientieren Sie sich an folgender Abbildung. Zum Anbinden der Detailtabelle ist lediglich Table2 erforderlich (DataSource2 fehlt). An den Platz einer DBLookupComboBox1 treten zwei weitere DBEdit-Komponenten.

Lookup-Felder hinzufügen Lookup-Felder werden grundsätzlich der Master-Tabelle (Table1) hinzugefügt. Um zwei Felder aus der Detail-Tabelle anzuzeigen (Name und Adresse des Kunden), müssen wir zwei Lookup-Felder verwenden. orders.db

customer.db 1

OrderNo AmountPaid SaleDate

CustNo Contact

N

Adress1

Lookup-Felder

CustNo xKuName xKuAdr

Detailtabelle

Mastertabelle

Setzen Sie zunächst die Active-Eigenschaft von Table1 und Table2 auf False. Durch Doppelklick auf Table1 (Master-Tabelle!) öffnet sich das (zunächst leere) Fenster des Felder-Editors.

1303

22.5 Mit Lookup-Feldern Tabellen verknüpfen

Beginnen Sie mit dem Hinzufügen des ersten Lookup-Felds (xKuName). Klicken Sie dazu mit der rechten Maustaste in den Felder-Editor und wählen Sie im Kontextmenü Neues Feld. Es erscheint folgendes Dialogfeld, das Sie "zeilenweise" (d.h. von links oben nach rechts unten) so ausfüllen, wie es die folgende Abbildung zeigt. Feld-Datentyp

Name des neuen Feldes

Fremdschlüssel

Lookup-Tabelle

Primärschlüssel der Lookup-Tabelle

Anzeigefeld (Lookup-Field)

Nach dem Schließen der Dialogbox verfügt Table1 über ein zusätzliches Feld xKuName. Wiederholen Sie den Vorgang für das zweite Lookup-Feld (xKuAdr). Allerdings müssen Sie gleich zu Beginn im Kontext-Menü des Felder-Editors zunächst den Eintrag Alle Felder hinzufügen... wählen, ehe Sie mit Neues Feld... fortfahren. Jetzt dürfen Sie die Active-Eigenschaft beider Table-Komponenten wieder auf True setzen. Binden Sie nun DBEdit3 und DBEdit4 an die beiden Lookup-Felder an. Die Vorgehensweise unterscheidet sich nicht von dem Anbinden der übrigen Felder.

1304

Kapitel 22

How-to: Datenbanken

Test Im Unterschied zum Vorgängerrezept kann mehr als ein Feld der Detailtabelle angezeigt werden. Allerdings dürften Sie die ComboBox schmerzlich vermissen, ein Editieren der Kunden-Felder ist nicht möglich (Abhilfe siehe Bemerkungen).

Bemerkungen ■ Sie können mittels DBLookupComboBox einen anderen Kunden zuweisen, während Sie seine Adresse wie gehabt aus einem Lookup-Feld gewinnen. ■ Ausführliche Informationen zur DBLookupComboBox entnehmen Sie unserem Buch "Borland Delphi – Datenbankprogrammierung" (auf Buch-CD enthalten!).

22.6 Mit Lookup-Feld und DBGrid Tabellen verknüpfen Dieses Rezept zeigt eine elegante Möglichkeit zum Verknüpfen von zwei Tabellen, wobei (im Gegensatz zu den beiden Vorgängerrezepten) ein DBGrid zum Einsatz kommt. In unserem Beispiel sollen die Tabellen orders.db und customer.db aus der Beispieldatenbank DBDEMOS miteinander verknüpft werden. Der Clou: Die Auswahl des Kunden ist über eine vom DBGrid bereitgestellte Klappbox möglich!

Oberfläche Gestalten Sie die nachfolgend gezeigte Oberfläche, bestehend aus zwei Table-, einer DataSource-, einer DBGrid- und einer DBNavigator-Komponente. Verbinden Sie Table1 und Table2 mit den Tabellen orders.db und customer.db aus der DBDEMOS-Datenbank. Das DBGrid und den DBNavigator binden Sie über DataSource1 an Table1 (wer mit diesen Routinearbeiten überfordert ist, sollte sich zunächst an einem der Vorgängerrezepte versuchen). Für den Einsteiger empfiehlt es sich, die ShowHint-Eigenschaft des DBNavigators auf True zu setzen.

22.6 Mit Lookup-Feld und DBGrid Tabellen verknüpfen

1305

Doppelklicken Sie auf Table1, öffnen Sie den Felder-Editor und fügen Sie das Lookup-Feld xKuName hinzu (genaue Beschreibung der Vorgehensweise siehe Vorgängerrezept). Über das Popup-Menü Felder hinzufügen... fügen Sie dann das Feld CustNo und wahlweise noch andere Felder hinzu, so dass der Felder-Editor schließlich folgenden Anblick bietet:

Setzen Sie die Active-Eigenschaft von Table1 auf True.

Test Nach zweimaligem Klicken (kein Doppelklick!) auf einen Kunden öffnet sich eine Klappbox, in der Sie einen bestimmten Kunden zuweisen können:

1306

Kapitel 22

How-to: Datenbanken

Lassen Sie sich nicht davon irritieren, dass der Kundenname scheinbar nicht übernommen wird (wenn Sie genauer hinschauen, sehen Sie aber, dass sich der Fremdschlüssel CustNo bereits auf den neuen Kunden eingestellt hat). Erst nach Klick auf die rechte Schaltfläche des DBNavigator ("Daten aktualisieren") erscheint auch die Änderung des Kundennamens.

Bemerkungen ■ Auch das Hinzufügen von Datensätzen dürfte funktionieren, allerdings müssten Sie dann über den Felder-Editor alle Felder von orders.db hinzufügen und auch die übrigen Fremdschlüssel mit einbeziehen. ■ Das Löschen von Datensätzen ist nur dann möglich, wenn die Regeln der referenziellen Integrität nicht verletzt werden. Sie sollten für derlei Versuche besser mit einer abgespeckten Kopie von DBDEMOS arbeiten.

22.7 Vermeiden, dass im DBGrid gelöscht wird Wer kennt es nicht, das leidige Problem, dass Anwender in einem DBGrid mit Strg+Entf einfach Datensätze löschen können? Das vorliegende Rezept schafft Abhilfe.

Oberfläche Die abgebildete Oberfläche bedarf wohl keines weiteren Kommentars. Als Beispieldatenbank musste BAUFINANZ herhalten (Tabelle Konten.db).

22.8 Eine bestimmte DBGrid-Zelle markieren

1307

Quellcode Das Problem wird im OnKeyDown-Event-Handler des DBGrid gelöst: procedure TForm1.DBGrid1KeyDown(Sender: TObject; var Key: Word; Shift: TShiftState); begin if CheckBox1.Checked then if (ssctrl in Shift) and (key = VK_DELETE) then key:= 0 end;

Test Nach Programmstart dürfen Sie zunächst hemmungslos löschen (um die Datenbank ist es nicht schade). Aktivieren Sie nun die Löschsperre. Drückt der Anwender nun die Tastenkombination Strg+Entf, kommt die leidige Dialogbox (Löschen: Ja/Nein) erst gar nicht zum Zuge. HINWEIS: Nachdem Sie die Löschfunktion geändert haben, müssen Sie den Datensatz erneut

anklicken.

22.8 Eine bestimmte DBGrid-Zelle markieren Möchten Sie aus dem Programm heraus eine bestimmte Zelle im DBGrid aktivieren, hilft Ihnen die Eigenschaft SelectedField weiter. Übergeben Sie ein gültiges, d.h. vorhandenes Field-Objekt, um den Fokus in die gewünschte Zelle zu verschieben.

Oberfläche

Quellcode Der Eingabefokus wird auf die fünfte Zeile und die Spalte "LastName" verschoben. procedure TForm1.Button1Click(Sender: TObject); begin

1308

Kapitel 22

How-to: Datenbanken

Table1.recno := 5; DBGrid1.SelectedField := Table1.FieldByName('LastName'); DBGrid1.SetFocus; DBGrid1.EditorMode := True end;

Mit der letzten Anweisung wird in den Edit-Mode umgeschaltet, der Bearbeiter kann den Inhalt der Zelle sofort editieren.

Test

22.9 Die Spalteneigenschaften eines DBGrid ändern Über die DataSource-Eigenschaft können Sie bekanntlich im Handumdrehen ein DBGrid mit einer Datenquelle verbinden und sich bereits zur Entwurfszeit vom Erfolg Ihrer Bemühungen überzeugen. Ehe Sie sich aber darüber ärgern, dass die Spaltenbreite zu groß ist oder dass das Schreibrecht für bestimmte Spalten nicht eingeschränkt werden kann, sollten Sie einen Blick hinter die Kulissen der Columns-Eigenschaft werfen, die im Objektinspektor gern übersehen wird. Diese Property enthält die so genannten persistenten Spalten des DBGrid (standardmäßig sehen Sie die dynamischen Spalten). Columns kann während des Entwurfs mit dem Spalteneditor, aber auch zur Laufzeit im Programm eingestellt werden. Wir wollen die Vorgehensweise anhand eines Datengitters, das mit der Tabelle Kosten.DB aus der Baufinanz-Datenbank verbunden ist, erläutern.

Oberfläche Die Abbildung dürfte für genügend Klarheit sorgen. Setzen Sie für die Table-Komponente folgende Eigenschaften: DatabaseName = BaufinanzDB, TableName = Kosten.DB und Active = True. Verbinden Sie die DBGrid-Komponente auf gewohnte Weise über eine DataSource-Komponente mit Table1. Fügen Sie vier CheckBox-Controls hinzu, drei davon umrahmen Sie mit einer GroupBox, deren Visible-Eigenschaft Sie auf False setzen:

22.9 Die Spalteneigenschaften eines DBGrid ändern

1309

Persistente Spalten mit dem Spalteneditor hinzufügen Öffnen Sie für das DBGrid den Objektinspektor. Klicken Sie rechts auf den Columns-Eintrag, und es öffnet sich das (vorerst noch leere) Fenster des Spalteneditors. Wählen Sie den Button "Alle Felder hinzufügen". Nun können Sie eine bestimmte persistente Spalte auswählen und deren spezifische Eigenschaften im Objektinspektor einstellen. Das soll anhand einiger Beispiele erläutert werden: BEISPIEL: Spaltenbreite ändern

1310

Kapitel 22

How-to: Datenbanken

Durch Ändern der Width-Eigenschaft kann so z.B. die Spaltenbreite angepasst werden (Maßeinheit Pixel). Das können Sie aber auch direkt im Entwurfsmodus tun. Schreibzugriff unterbinden Setzen Sie ReadOnly auf True, so bleibt der Schreibzugriff verwehrt. Spalte ausblenden Da die Nr-Spalte (Primärschlüssel!) keinerlei Informationswert für Sie besitzt, können Sie diese auch aus dem DBGrid ausblenden. Klicken Sie im Objektinspektor auf den Editor der ColumnsEigenschaft (rechts) und löschen Sie die gewünschte Spalte. HINWEIS: Das gleiche Ergebnis wie zur Entwurfszeit mit dem Spalteneditor könnten Sie auch

per Codeprogrammierung erreichen (siehe folgender Quelltext). Allerdings werden dann die Änderungen erst zur Laufzeit sichtbar.

Quelltext Persistente Spalten hinzufügen: procedure TForm1.CheckBox1Click(Sender: begin with DBGrid1 do begin if CheckBox1.Checked then begin Columns.Add; Columns[0].FieldName := Columns.Add; Columns[1].FieldName := Columns[1].ReadOnly := True; Columns.Add; Columns[2].FieldName := GroupBox1.Visible := True end else begin Columns.State := csDefault; GroupBox1.Visible := False end end end;

TObject);

'Datum'; 'Betrag'; // Schreibschutz einstellen 'Bemerkung';

// es werden nur noch dynamische Spalten angezeigt

Betrag editieren: procedure TForm1.CheckBox2Click(Sender: TObject); begin if CheckBox3.Checked then DBGrid1.Columns[1].ReadOnly := False else DBGrid1.Columns[1].ReadOnly := True end; procedure TForm1.CheckBox3Click(Sender: TObject); // Betrag-Spalte verbreitern begin if CheckBox2.Checked then DBGrid1.Columns[1].Width := DBGrid1.Columns[1].Width + 30 else DBGrid1.Columns[1].RestoreDefaults // auf Standardwert zurücksetzen end;

22.9 Die Spalteneigenschaften eines DBGrid ändern

1311

Bemerkung ausblenden: procedure TForm1.CheckBox4Click(Sender: TObject); begin if CheckBox4.Checked then DBGrid1.Columns[2].Free else DBGrid1.Columns.Add; DBGrid1.Columns[2].FieldName := 'Bemerkung'; end;

Test Nach Programmstart fügen Sie die persistenten Spalten hinzu und doktern ein wenig an den Eigenschaften herum:

Ergänzung Möchten Sie aus dem Programm heraus eine bestimmte Zelle im DBGrid aktivieren, hilft Ihnen die Eigenschaft SelectedField weiter. Übergeben Sie ein gültiges, d.h. vorhandenes Field-Objekt, um den Fokus in die gewünschte Zelle zu verschieben. BEISPIEL: Der Eingabefokus wird auf die fünfte Zeile und die Spalte "Betrag" verschoben. Table1.RecNo := 5; DBGrid1.SelectedField := Table1.FieldByName('Betrag'); DBGrid1.SetFocus; DBGrid1.EditorMode := True;

1312

Kapitel 22

How-to: Datenbanken

Mit der letzten Anweisung wird in den Edit-Mode umgeschaltet, der Bearbeiter kann den Inhalt der Zelle sofort editieren.

22.10 Die Sortierreihenfolge einer Tabelle ändern Normalerweise werden alle Datensätze in der Reihenfolge angezeigt, in der sie in die Tabelle eingegeben wurden (entspricht im Allgemeinen dem Primärschlüssel bzw. Hauptindex, soweit vorhanden). Will man die Anzeigereihenfolge ändern, dann muss das Feld, nach dem sortiert werden soll, indiziert sein (siehe dazu Kapitel 4). Anschließend stellen Sie im Objektinspektor die IndexName-Eigenschaft des Table-Objekts auf den gewünschten Sekundärindex ein. Um z.B. in der Tabelle Kosten der Baufinanz-Datenbank die Anzeige nach aufsteigendem Datum zu sortieren, legen Sie zunächst für das Feld Datum einen Sekundärindex an, dem Sie z.B. den Namen DatumIndex geben.

Oberfläche Wir brauchen eine Table- und eine DataSource-Komponente sowie ein Datengitter (DBGrid), die wir auf die übliche Weise mit der Kosten-Tabelle verbinden. Außerdem benötigen wir eine CheckBox zum An- und Abschalten des Index.

Zuweisen im Objektinspektor Für die IndexName-Eigenschaft des Table-Objekts werden im Objektinspektor alle verfügbaren Sekundärindizes angezeigt. Wählen Sie den gewünschten Index (DatumIndex) aus. Bereits zur Entwurfszeit werden Sie feststellen, dass sich mit dem Zuweisen des Index die Sortierreihenfolge im Datengitter nach aufsteigendem Datum ordnet.

22.11 Den Hauptindex einer Tabelle ermitteln

1313

Zuweisen per Quelltext Wenn Sie die Sortierreihenfolge per Code ändern wollen, dann fügen Sie z.B. in das OnClickEvent der CheckBox die folgenden Anweisungen ein: procedure TForm1.CheckBox1Click(Sender: TObject); begin if CheckBox1.Checked then Table1.IndexName := 'DatumIndex' else Table1.IndexName := '' end;

Test Nach dem Programmstart können Sie die Sortierreihenfolge beliebig umschalten. Wenn Sie nach fallendem Datum sortieren wollen, müssen Sie den Index im Programm "Datenbankoberfläche" in "Absteigend" ändern, oder Sie fügen einen weiteren Index zu, den Sie alternativ zuordnen können.

22.11 Den Hauptindex einer Tabelle ermitteln Die Antwort ist relativ einfach: über die IndexDefs-Auflistung des Table-Objekts. Die einzige Schwierigkeit ist die Unterscheidung von einem normalen Index. Wir nutzen dazu die OptionsEigenschaft.

Oberfläche Ein Formular, eine Table-Komponente und ein Button genügen. Verbinden Sie z.B. die Table1 mit der Customer-Tabelle der DBDEMOS-Beispieldatenbank.

1314

Kapitel 22

How-to: Datenbanken

Quellcode procedure TForm1.Button1Click(Sender: TObject); var i: Integer; begin Table1.IndexDefs.Update; for i := 0 to Table1.IndexDefs.Count - 1 do begin if (Table1.IndexDefs.Items[i].Options * [ixPrimary]) = ([ixPrimary]) then ShowMessage(Table1.IndexDefs.Items[i].Fields) end end;

Test Der Hauptindex bzw. Primärschlüssel der Customer-Tabelle wird angezeigt:

22.12 Prüfen, ob die BDE installiert ist Mit einer kleinen Routine prüfen Sie vor der Ausführung Ihres Programms, ob beim Anwender die BDE (Borland Database Engine) korrekt installiert ist.

Oberfläche Ein Formular und ein Button genügen.

Quellcode uses BDE; procedure TForm1.Button1Click(Sender: TObject); begin if dbiInit(nil) = 0 then Panel1.Caption := 'NEIN' else Panel1.Caption := 'JA' end;

Test

22.13 Ein Datenbankverzeichnis auswählen

1315

22.13 Ein Datenbankverzeichnis auswählen Im vorliegenden Rezept wollen wir Ihnen eine weniger bekannte Möglichkeit zur Auswahl eines beliebigen Verzeichnisses vorstellen: die SelectDirectory-Funktion aus der Unit FileCtrl. Ganz am Rande demonstrieren wir dem Einsteiger noch einmal die Laufzeitanbindung einer Paradox-Datenbank.

Oberfläche Außer einem "normalen" Editierfeld und einigen Buttons brauchen Sie noch eine Table-, eine DataSource-, eine DBNavigator- und zwei DBEdit-Komponenten, die Sie den Seiten "BDE", "Datenzugriff" und "Datensteuerung" der Komponentenpalette entnehmen. Da Verzeichnisnamen mitunter lang wie ein Bandwurm sein können, sollte man bezüglich der Breite von Edit1 nicht geizen.

Verbinden Sie im Objektinspektor die DataSet-Eigenschaft von DataSource1 mit Table1 und die DataSource-Eigenschaft von DBEdit1/DBEdit2 mit DataSource1. Da die DatabaseName-Eigenschaft der Table-Komponente erst zur Laufzeit zugewiesen werden kann, sind die Bound Controls zur Entwurfszeit noch leer, und die DBNavigator-Komponente erscheint deaktiviert.

Quellcode Am Anfang des implementation-Abschnitts binden Sie die Unit FileCtrl ein: uses FileCtrl;

Die Schaltfläche "Durchsuchen" : procedure TForm1.Button1Click(Sender: TObject); var s: string; begin SelectDirectory(s, [], 0); Edit1.Text := s end;

1316

Kapitel 22

How-to: Datenbanken

Das Öffnen der Datenbank und die Laufzeitanbindung der Bound Controls bieten keinerlei Besonderheiten: procedure TForm1.Button2Click(Sender: TObject); begin Table1.DatabaseName := Edit1.Text; Table1.TableName := 'Kunden'; DBEdit1.DataField := 'Name'; DBEdit2.DataField := 'Straße'; Table1.Active := True end;

Test Nach Klick auf die "Durchsuchen"-Schaltfläche öffnet sich der Dialog. Suchen Sie ein Verzeichnis mit der Paradox-Datenbank FirmaDB (befindet sich auf der Buch-CD):

Nach dem "OK" können Sie die Datenbank öffnen:

1317

22.14 Eine Datenbank mit Passwort schützen

Bemerkung Eine weitere Variante, um eine beliebige Datenbank zur Laufzeit mit einer Delphi-Anwendung zu verbinden, wäre die Verwendung einer OpenDialog-Komponente ("Dialoge"-Seite der Komponentenpalette).

22.14 Eine Datenbank mit Passwort schützen Um es gleich vorwegzunehmen: Im Folgenden ist ausschließlich von Paradox-Datenbanken die Rede. Die Vergabe von Passwörtern für SQL-Server-Tabellen ist herstellerspezifisch und kann deshalb nicht Gegenstand der Betrachtung sein. Haben Sie mittels CreateTable (Table-Komponente) oder LocalSQL (Query-Komponente) eine neue Tabelle erstellt, kann jeder, der ein geeignetes Programm besitzt, die Inhalte der Tabelle betrachten oder verändern. Möchten Sie Ihre Anwendungen verkaufen, ist es nicht immer angebracht, auch die Tabellenstruktur dem Anwender offen zu legen. Allerdings werden Sie an dieser Stelle von Delphi etwas allein gelassen, eine fertige Methode zum Setzen des Tabellenpassworts werden Sie nicht finden. Unser kleines Beispielprogramm zeigt Ihnen, wie Sie mit Hilfe von BDE-Funktionen ein Administrator-Passwort setzen können.

Oberfläche Unser Programm nimmt sich recht bescheiden aus, platzieren Sie lediglich einen Button im Formular, alle anderen Komponenten erzeugen wir dynamisch.

Quelltext Mit dem Klick auf den Button wird folgende Funktion aufgerufen: procedure TForm1.Button1Click(Sender: TObject); var T : TTable; begin

Erzeugen eines Unterverzeichnisses für die neue Datenbank: CreateDirectory(PChar('DB'),nil);

// Unterverzeichnis erstellen

Dynamisches Erzeugen einer Table-Komponente: T := TTable.Create(self); T.DatabaseName := '.\DB'; T.TableName := 'Test1'; T.TableType := ttParadox;

Definieren der Tabellenstruktur: with T.FieldDefs do begin Clear;

// // // //

Objekt erzeugen Datenbank zuweisen Tabellenname zuweisen Typ festlegen

1318

Kapitel 22

Add('Nr',ftAutoInc,0,True); Add('Name', ftString, 30,True); Add('Vorname', ftString, 30,False); Add('Anrede', ftString, 10,False); Add('Straße', ftString, 40,False); Add('PLZ', ftString, 5,False); Add('Ort', ftString, 40,False); Add('Telefon', ftString, 20,False); Add('Bemerkung', ftMemo, 40,False) end;

How-to: Datenbanken

// Zählerfeld

Erzeugen der Tabelle: try T.CreateTable // Versuch, die Tabelle zu erzeugen except ShowMessage('Tabelle konnte nicht erzeugt werden!') Exit end;

Bis jetzt ist die Tabelle noch nicht passwortgeschützt, mit einer eigenen Funktion werden wir diesem Missstand abhelfen: if TablePasswort(T, 'AAAA') then ShowMessage('Passwort gesetzt!') end;

Die Funktion TablePasswort erwartet als Übergabeparameter ein initialisiertes Table-Objekt und das Passwort. Damit Sie die Funktion auch in anderen Projekten leichter einbinden können, haben wir eine eigene Unit erzeugt (wichtig ist die Einbindung der Unit BDE): unit Unit2; interface uses bde,SysUtils,dbtables,windows; Function TablePasswort(var table: ttable; password:string): Boolean; implementation

Eine Konvertierungsfunktion ermöglicht uns die Umwandlung von ANSI- in ASCII-Zeichen: function StrToOem(const AnsiStr: string): string; begin SetLength(Result, Length(AnsiStr)); if Length(Result) > 0 then CharToOem(PChar(AnsiStr), PChar(Result)) end;

Die eigentliche Funktion fällt erwartungsgemäß etwas komplexer aus: Function TablePasswort(var table: TTable; password:string): Boolean; var pTblDesc : pCRTblDesc; hDb : hDBIDb;

22.14 Eine Datenbank mit Passwort schützen

1319

begin Result := False;

In einem ersten Schritt versuchen wir kurzzeitig, die Tabelle exklusiv zu öffnen, eine der Grundvoraussetzungen, um Änderungen an der Tabellenstruktur vorzunehmen: with Table do begin if Active and (not Exclusive) then Close; if (not Exclusive) then Exclusive := True; if (not Active) then Open; hDB := DBHandle; Close end;

Ist sichergestellt, dass kein anderer User Zugriff auf die Tabelle hat, können wir damit beginnen, einen Speicherbereich für die CRTblDesc-Struktur (aus der Unit BDE) zu reservieren und mit NULL-Zeichen zu füllen: GetMem(pTblDesc,SizeOf(CRTblDesc)); FillChar(pTblDesc^,SizeOf(CRTblDesc),0 );

Danach tragen wir in die Felder szTblName, szTblType, szPassword, bPack und bProtected die gewünschten Werte ein. Alle anderen Felder können Sie leer lassen, diese sind nur bei Änderungen an der Satzstruktur etc. von Interesse. with pTblDesc^ do begin StrPCopy(szTblName, StrToOem(table.tablename)); szTblType:= szParadox; StrPCopy(szPassword, StrToOem(Password)); bPack := True; bProtected := True end;

Der eigentliche Funktionsaufruf (es handelt sich um eine BDE-Funktion): if DbiDoRestructure (hDb, 1, pTblDesc, nil, nil, nil, FALSE )<> DBIERR_NONE then Exit; if pTblDesc <> nil then FreeMem(pTblDesc, SizeOf(CRTblDesc)); Result := True end;

Test Nach dem Aufruf des Programms muss zunächst eine Meldung erscheinen:

1320

Kapitel 22

How-to: Datenbanken

Schauen Sie nun im Unterverzeichnis "\DB" nach. Dort müssten Sie die neu angelegte Tabelle "Test" vorfinden, die sich nur mit dem Passwort "AAAA" (Groß-/Kleinschreibung beachten!) öffnen lässt.

22.15 Detaildaten anzeigen Meist sind durch entsprechende Verknüpfungen (Relationen) bestimmte Abhängigkeiten zwischen einzelnen Tabellen vorhanden, die aus einer vorhergehenden Normalisierung entstanden sind. Die Aufgabe für den Programmierer besteht darin, diese Daten in einer ansprechenden und zusammenhängenden Form wieder darzustellen. Das vorliegende Rezept soll die Vorgehensweise beschreiben. Ausgangspunkt unserer Überlegungen ist eine Tabellenstruktur mit folgender Abhängigkeit: Raeume Nr RaumNr

1:N

Personen Nr Name Vorname Raum Telefon Gehalt

Wie Sie sehen, handelt es sich um eine klassische 1:n-Beziehung. In einem Raum können sich mehrere Personen befinden. Das Feld Raeume.RaumNr enthält einen String, der aus Haus- bzw. Etagenbezeichner und einer Raumnummer besteht, gleichzeitig könnten in der Tabelle Raeume noch Informationen über die Raumgröße, Telefonanschlüsse etc. gespeichert sein. Für uns genügt an dieser Stelle jedoch die einfache obige Beziehung, die wir ohne eine einzige Zeile Quellcode in einem Formular darstellen wollen.

Aufgabenstellung In einem Listenfeld sind alle verfügbaren Räume abzubilden. Nachfolgend sollen in einer zweiten Liste alle Mitarbeiter angezeigt werden, die sich im gerade markierten Raum befinden bzw. dort ihren Arbeitsplatz haben.

Oberfläche Alles, was wir für die Darstellung brauchen, sind zwei Table-, zwei DataSource- und zwei DBGrid-Komponenten (und natürlich auch ein Formular). HINWEIS: Das linke DBGrid könnte auch durch eine DBLookupListbox ersetzt werden. In die-

sem Fall sind die Eigenschaften ListSource, ListField, KeyField zu belegen. Die Grundstruktur können Sie der folgenden Abbildung entnehmen:

22.15 Detaildaten anzeigen

1321

Wählen Sie für Table1 die Tabelle Raeume.db (siehe Buch-CD). Table1 und DataSource1 verbinden Sie über die Eigenschaft DataSet. Zum Schluss muss nur noch DBGrid1 mit DataSource1 über die Eigenschaft DataSource verknüpft werden. Damit ist die erste Aufgabe (Anzeige der Räume) gelöst. Verknüpfen Sie auf die gleiche Art und Weise Table2 (Tabelle Personen.db), DataSource2 und DBGrid2. Zu diesem Zeitpunkt besteht zwischen Table1 und Table2 keinerlei Verknüpfung, Änderungen im DBGrid1 wirken sich nicht auf den Inhalt von DBGrid2 aus. Diesem Missstand können Sie durch die Zuweisung der MasterField- und MasterSource-Eigenschaften von Table2 abhelfen. Voraussetzung ist allerdings eine Indizierung des Feldes Personen.raum (Sekundärindex). Legen Sie als Erstes die MasterSource-Eigenschaft auf DataSource1 fest. Nachfolgend öffnen Sie den Property-Editor der Eigenschaft MasterField (kleiner Button). Es erscheint folgende Dialogbox:

1322

Kapitel 22

How-to: Datenbanken

Wählen Sie das Feld "raum" und das Feld "nr" und klicken Sie auf den Button "Hinzufügen". HINWEIS: Als verfügbaren Index wählen Sie den Sekundärindex des Feldes, das als Fremd-

schlüssel fungiert (Personen.Raum). Danach sind beide Tabellen miteinander verknüpft, Änderungen im DBGrid1 wirken sich auf den Inhalt von DBGrid2 aus. Der interne Ablauf: ■ Auswahl eines Feldes in Tabelle 1 (Raeume) ■ Bestimmen des Primärschlüssels ■ Suche in Tabelle 2 (Personen) über den Sekundärindex (Fremdschlüssel) nach Werten, die dem Primärindex von Tabelle 1 entsprechen ■ Rückgabe einer Datenmenge an Table2

Test Klicken Sie links auf einen Raum, so werden rechts die entsprechenden Mitarbeiter aufgelistet.

22.16 Einen zufälligen Datensatz auswählen Wohin sollen wir dieses Jahr in den Urlaub fahren? Wen muss ich als Nächsten entlassen? Quälende Überlegungen dieser Art kann der Chef in Zukunft dem Computer überlassen, denn nach dem Zufallsprinzip wird wahllos auf Datensätze innerhalb eines Recordsets zugegriffen. Im folgenden Beispiel können, unter Benutzung von Datenobjekten, zufällige Datensätze aus einer Datenbank ausgewählt werden, wobei wir uns auf einen relativ harmlosen Fall (Ort und PLZ) aus einer Datenbank TELEFON.DB beschränken wollen.

22.16 Einen zufälligen Datensatz auswählen

1323

Oberfläche Den Grundaufbau der Oberfläche entnehmen Sie bitte der folgenden Abbildung:

Quelltext Beim Laden des Formulars wird zuerst einmal der Zufallszahlen-Generator von Delphi initialisiert: procedure TForm1.FormCreate(Sender: TObject); begin Randomize end;

Jeder Klick auf den Button löst die Suche nach einem neuen Ort aus: procedure TForm1.Button1Click(Sender: TObject); begin Table1.First; Table1.MoveBy(Random(Table1.RecordCount)) end;

Wir verzichten an dieser Stelle darauf, die Eigenschaft RecNo zum Auswählen eines Datensatzes zu verwenden, da es in gefilterten Datenmengen zu Problemen kommen kann. Obiges Konstrukt ist da etwas weniger wählerisch, nach dem Positionieren auf dem ersten Datensatz überspringen wir mit MoveBy einfach eine zufällige Anzahl von Datensätzen. Dazu wird der Zufallsfunktion Random die obere Grenze übergeben, die Zufallswerte bewegen sich dann alle zwischen 0 und Maximum.

Test Da gibt es nicht viel zu erklären – die zufällig ausgewählte Zeile erscheint blau markiert am unteren Rand des Gitters.

1324

Kapitel 22

How-to: Datenbanken

22.17 Die Datenbankstruktur bestimmen Nicht in allen Fällen ist Ihnen die Struktur einer Datenbank bekannt. Geht es beispielsweise darum, Fremddaten zu importieren oder eine bestehende Datenbank zu konvertieren, ist es für Sie wichtig, Informationen über den Datenbankaufbau zu erhalten. Welche Möglichkeiten Ihnen dazu die Delphi-Komponenten bieten, zeigt das folgende Rezept.

Oberfläche Neben einer ComboBox für die Auswahl eines Alias brauchen wir noch eine ImageList und eine TreeView-Komponente für die Anzeige der Datenbankstruktur, ein DBGrid und natürlich eine Table-Komponente mit zugehöriger DataSource. Gut versteckt hinter dem DBGrid findet sich noch eine einfache Listbox, in der alternativ Details zu Feldern oder Tabellen angezeigt werden.

Im oberen Teil des Formulars finden Sie weiterhin ein HeaderControl, mit dem Sie die Anzeigebreite von TreeView und DBGrid beeinflussen können. Verbinden Sie die Images-Eigenschaft der TreeView-Komponente mit der ImageList. Durch Doppelklick auf die ImageList können Sie die Icons editieren:

22.17 Die Datenbankstruktur bestimmen

1325

HINWEIS: Die Table-Komponente wird erst zur Laufzeit an eine Tabelle gebunden.

Quelltext Für die Anzeige der Feld-Datentypen brauchen wir einige Konstanten: const datentyp : array[0..21] of string = ('ftUnknown', 'ftString', 'ftSmallint', 'ftInteger', 'ftWord', 'ftBoolean', 'ftFloat', 'ftCurrency', 'ftBCD', 'ftDate', 'ftTime', 'ftDateTime', 'ftBytes', 'ftVarBytes', 'ftAutoInc', 'ftBlob', 'ftMemo', 'ftGraphic', 'ftFmtMemo', 'ftParadoxOle', 'ftDBaseOle', 'ftTypedBinary');

Mit dem Start des Programms werden die registrierten Aliase in die ComboBox eingelesen: procedure TForm1.FormCreate(Sender: TObject); begin session.GetAliasNames(ComboBox1.Items) end;

HINWEIS: Die Variable Session wird über die Unit DB importiert.

Mit der Auswahl eines Alias beginnt die Arbeit, die TreeView-Komponente wird schrittweise mit den relevanten Informationen gefüllt: procedure TForm1.ComboBox1Click(Sender: TObject); var alias : String; Tabellen,Felder, Indizes : TStringlist; i,j : Integer; root,Tab, help : TTreeNode; begin

Mit der Statusvariablen lock verhindern wir die Ausführung von Programmcode im OnChangeEreignis: lock := True; Screen.cursor := crHourGlass; Table1.Active := False; Treeview1.items.Clear;

Eine Stringliste für die Aufnahme der Tabellennamen erzeugen: Tabellen := TStringList.Create; alias := ComboBox1.text;

Auslesen der Tabellennamen mit der Methode GetTableNames: try Session.GetTableNames(alias,'',True,False,Tabellen); except end;

1326

Kapitel 22

How-to: Datenbanken

Die Root in der TreeView-Komponente erzeugen (Aliasname): root := Treeview1.Items.Add(Treeview1.Selected,Alias); root.imageindex := 2; root.selectedindex := 2;

Die Tabellennamen in den Baum einfügen: for i := 0 to Tabellen.Count-1 do begin Tab := Treeview1.Items.AddChild(root,Tabellen[i]); Table1.DatabaseName := alias; Table1.Tablename := Tab.Text;

Für jede Tabelle werden nachfolgend die vorhandenen Felder aufgelistet. Sicherheitshalber werden mögliche Fehler mit Try-Except abgefangen (wenn die Tabelle nicht geöffnet werden kann etc.): Felder := TStringList.Create; try Table1.GetFieldNames(Felder); except end; if Felder.Count > 0 then begin help := Treeview1.Items.AddChild(tab,'Felder'); help.imageindex := 1; help.selectedindex := 1; for j := 0 to Felder.Count-1 do begin with Treeview1.Items.AddChild(help,Felder[j]) do begin imageindex := 1; selectedindex := 1; end end end; Felder.Free;

Neben den Feldern lassen sich auch Informationen über die Indizes ermitteln: Indizes := TStringList.Create; try Table1.GetIndexNames(Indizes); except end; if Indizes.Count > 0 then begin help := Treeview1.Items.AddChild(tab,'Indizes'); help.imageindex := 1; help.selectedindex := 1; for j := 0 to Indizes.Count-1 do begin with Treeview1.Items.AddChild(help,Indizes[j]) do begin imageindex := 1; selectedindex := 1 end end end; Indizes.Free

22.17 Die Datenbankstruktur bestimmen

1327

end; Screen.cursor := crDefault; lock := False end;

Bei Auswahl eines Eintrags in der TreeView-Komponente wird das Change-Ereignis ausgelöst: procedure TForm1.TreeView1Change(Sender: TObject; Node: TTreeNode); var i : Integer; begin if lock then Exit; case node.level of

Der Aliasname wird ausgewählt: 0 : begin // Alias-Ebene DBGrid1.Visible := False; ListBox1.Visible := True; session.GetAliasParams(node.text,ListBox1.items) end;

Ein Tabellenname wurde gewählt: 1 : begin // Tabellen-Ebene ListBox1.Clear; ListBox1.Visible := False; DBGrid1.Visible := True; Table1.Active := False; Table1.TableName := node.text; Table1.Active := True end;

Ein Feldname wurde ausgewählt: 3 : if node.parent.text = 'Felder' then begin ListBox1.Visible := True; DBGrid1.Visible := False; ListBox1.Clear; Table1.Active := False; Table1.TableName := node.parent.parent.text; i := 0; while (i < Table1.fielddefs.count)and (Table1.fielddefs[i].name<>node.text) do inc(i); ListBox1.items.add(format('Feldnummer: %d', [Table1.fielddefs[i].fieldno]) ); ListBox1.items.add(format('Feldname: %s', [Table1.fielddefs[i].name]) ); if Table1.fielddefs[i].required then ListBox1.items.add ('Eingabe erforderlich : True'); ListBox1.items.add('Datentyp : ' + datentyp[Integer(Table1.fielddefs[i].datatype)]);

1328

Kapitel 22

How-to: Datenbanken

ListBox1.items.add(format('Größe: %d', [Table1.fielddefs[i].size]) ) end else begin ListBox1.Clear; ListBox1.Visible := False; Table1.Active := False; DBGrid1.Visible := False end end end;

Anpassen der Breite von TreeView1 über die HeaderControl-Komponente: procedure TForm1.HeaderControl1SectionResize(HeaderControl: THeaderControl; Section: THeaderSection); begin treeview1.width := HeaderControl1.Sections[0].width end;

Test Öffnen Sie eine Datenbank und erkunden Sie Inhalt und Struktur!

Wenn Sie einen bestimmten Feldnamen auswählen, tritt die verborgene Listbox in Aktion:

22.18 Auf den Alias verzichten

1329

Bemerkung Es dürfte kein Problem sein, mit einem zusätzlichen Dateidialog die Möglichkeit zu schaffen, auch Datenbanken ohne zugewiesenen Alias zu analysieren.

22.18 Auf den Alias verzichten Wollen Sie eine Datenbankapplikation an Dritte weitergeben, dann kann es dort böse Überraschungen geben, da sich das Verzeichnis der Datenbank geändert hat. Aus diesem Grund sollten Sie absolute Pfadangaben für die DatabaseName-Eigenschaft der Datenzugriffskomponenten vermeiden und stattdessen einen Alias zuweisen. Allerdings muss der Drittanwender dann ebenfalls diesen Alias einrichten, was für ihn äußerst lästig sein kann (Alias-Manager etc.). Im Folgenden wollen wir vier verschiedene Lösungsvorschläge unterbreiten. Wir benutzen die Tabelle Kunden aus der FIRMA-Datenbank.

Oberfläche Bevor Sie die folgende Oberfläche "zusammenschieben", sollten Sie die Tabelle Kunden.db in das Projektverzeichnis kopieren.

Sie werden feststellen, dass Sie die DatabaseName-Eigenschaft von Table1 nicht zuzuweisen brauchen, sie kann quasi "leer" bleiben.

Test Alles wird wunderbar funktionieren, bis Sie die Projekt-EXE in ein anderes Verzeichnis Ihres Rechners verschieben und von dort starten: Nichts geht mehr!

1330

Kapitel 22

How-to: Datenbanken

Zur Abhilfe des leidigen Problems werden vier Möglichkeiten vorgeschlagen:

Variante 1 Die Datenbank befindet sich im gleichen Verzeichnis wie die Projekt-EXE: procedure TForm1.FormCreate(Sender: TObject); var verz: string; begin verz := ExtractFilePath(ParamStr(0)); // oder: GetDir(0, verz); Table1.Active := False; try Table1.DatabaseName := verz; Table1.TableName := 'Kunden.DB'; Table1.Active := True except MessageBeep(0); ShowMessage('Die Tabelle Kunden.DB befindet' + #10#13 + ' sich nicht im aktuellen Verzeichnis!') end end;

Variante 2 Verschieben Sie die Datenbank in das Unterverzeichnis \DB der Projekt-EXE. Diesmal wollen wir es ganz ohne Quellcode realisieren. Weisen Sie einfach der DatabaseNameEigenschaft der Table-Komponente den Wert ".\DB" zu.

Variante 3 Verschieben Sie die Datenbank in das übergeordnete Verzeichnis der Projekt-EXE. Weisen Sie der DatabaseName-Eigenschaft der Table-Komponente den Wert "..\" zu.

Variante 4 Verschieben Sie die Datenbank in ein beliebiges Verzeichnis. Fügen Sie dem Formular eine OpenDialog-Komponente (Seite "Dialoge") hinzu und ergänzen Sie: procedure TForm1.FormCreate(Sender: TObject); var verz: string;

22.18 Auf den Alias verzichten

1331

begin verz := ExtractFilePath(ParamStr(0)); Table1.Active := False; try Table1.Active := True except MessageBeep(0); with OpenDialog1 do begin Title := 'Wählen Sie die Tabelle Kunden.db!'; Filter := 'Paradoxtabellen (*.db)|*.db'; DefaultExt := 'db'; if Execute then verz := Filename end end; Table1.DatabaseName := ExtractFilePath(verz); Table1.TableName := 'Kunden.DB'; Table1.Active := True end;

Test (Variante 4)

HINWEIS: Damit das Rezept auch in der IDE ohne Fehlermeldung läuft, müssen Sie im Menü

Tools|Debugger-Optionen... auf der Seite "Sprach-Exceptions" das Häkchen bei "Bei Delphi-Exceptions stoppen" entfernen!

Bemerkungen ■ Die Verwendung der ExtractFilePath-Funktion ist bei Datenbankapplikationen dem Einsatz von GetDir vorzuziehen, siehe Ä 22.18 Auf den Alias verzichten

1332

Kapitel 22

How-to: Datenbanken

■ Wir haben hier vorausgesetzt, dass auf dem Zielrechner ebenfalls Delphi installiert ist (oder zumindest die BDE). Andernfalls gestaltet sich die Weitergabe von Anwendungen etwas aufwändiger, siehe Ä 22.32 Ein Setup für Datenbankanwendungen erstellen ■ Die Varianten 2 und 3 haben den Vorteil, dass bereits zur Entwurfszeit eine Datenbankanbindung besteht. Eine Kombination zwischen beiden Varianten ist ebenfalls möglich.

22.19 Die Tabellenstruktur kopieren Sollen nicht Daten, sondern lediglich die Tabellenstruktur (inklusive Indizes) in eine weitere Tabelle übertragen werden, so können Sie dafür eine Kopierfunktion schreiben, die im Folgenden anhand eines Beispiels vorgestellt wird.

Oberfläche Für unsere Demo benötigen wir eine Table-, zwei DataSource- und zwei DBGrid-Komponenten.

Verbinden Sie die DataBaseName-Eigenschaft von Table1 mit der zu Delphi mitgelieferten Beispieldatenbank DBDEMOS und setzen Sie TableName auf customer.db. Auf bekannte Weise verbinden Sie DataSource1 mit Table1 und DBGrid1 mit DataSource1. Wenn Active von Table1 auf True gesetzt ist, dürfte sich bereits obiger Anblick bieten. Verbinden Sie noch DBGrid2 mit DataSource2. Da die zweite Tabelle erst zur Laufzeit angelegt wird, können Sie hier noch nichts sehen.

Quellcode Fügen Sie im Private-Abschnitt von TForm1 folgende Deklaration hinzu: ... private

22.19 Die Tabellenstruktur kopieren

1333

procedure CopyStructure(vorlage: TTable; Datenbank, Tabelle : string ); ...

Im implementation-Abschnitt ergänzen Sie: procedure TForm1.CopyStructure(vorlage: TTable; Datenbank, Tabelle : string ); var newTable: TTable; begin newTable := TTable.Create(self); newTable.DatabaseName := datenbank; newTable.TableName := Tabelle; newTable.FieldDefs.Assign(vorlage.FieldDefs); newTable.IndexDefs.Assign(vorlage.IndexDefs); newTable.CreateTable; newTable.Active := True; // nur zum Testen DataSource2.DataSet := newTable // dto. end;

Übergabewerte sind eine geöffnete Tabelle, der Name der Zieldatenbank und der Name der neuen Tabelle. Die beiden letzten Anweisungen haben Testcharakter und können später weggelassen werden. Der Aufruf: procedure TForm1.Button1Click(Sender: TObject); begin CopyStructure(Table1, 'DBDEMOS', 'LeereTabelle.db') end;

Test Nach Betätigen von "Kopieren" sehen Sie, dass die neue Tabelle leer ist und die gleiche Struktur wie die Ursprungstabelle hat.

Die neu erzeugte Datei LeereTabelle.db finden Sie am Standort des Alias DBDEMOS (c:\Programme\Gemeinsame Dateien\Borland Shared\Data).

1334

Kapitel 22

How-to: Datenbanken

22.20 Das Löschen von Datensätzen verhindern Die Antwort ist ebenso einfach wie universell: Im BeforeDelete-Event einer TTable- oder TQueryKomponente können Sie die Prozedur Abort aufrufen, um den Löschvorgang für den aktuellen Datensatz abzubrechen. Gekoppelt mit einer entsprechenden Sicherheitsabfrage lässt sich so ein unbeabsichtigtes Löschen (sowohl über den Navigator als auch über einen Methodenaufruf) verhindern.

Oberfläche Wir brauchen eine Table-, eine DataSource- und eine DBGrid-Komponente. Verbinden Sie Table1 über die DataBaseName-Eigenschaft mit der Datenbank "FirmaDB" (siehe Buch-CD) und setzen Sie die TableName-Eigenschaft auf "Kunden.db". Verbinden Sie die DataSet-Eigenschaft von DataSource1 mit Table1 und schließlich die DataSource-Eigenschaft des DBGrid1 mit DataSource1. Nachdem Sie die Active-Eigenschaft von Table1 auf True gesetzt haben, dürfte sich Ihnen folgender Anblick bieten:

Quellcode Wählen Sie auf der "Ereignis"-Seite des Objektinspektors für Table1 das BeforeDelete-Event aus und schreiben Sie dafür folgenden Event-Handler: procedure TForm1.Table1BeforeDelete(DataSet: TDataSet); begin if MessageDlg('Datensatz löschen ?', mtConfirmation, [mbYes, mbNo], 0) = mrNo then Abort end;

Test Wenn Sie nun mit Strg+Entf einen Datensatz löschen wollen, verordnet Ihnen das zwischengeschaltete Meldungsfenster eine Denkpause.

22.21 Gelöschte dBASE-Records anzeigen

1335

22.21 Gelöschte dBASE-Records anzeigen Bekanntlich können Sie in einer dBASE-Tabelle Datensätze löschen, ohne dass diese physisch gelöscht werden (es wird lediglich ein Löschflag gesetzt). Erst ein abschließender Pack-Befehl räumt die Tabelle wieder auf. Delphi unterstützt direkt weder die Anzeige von "gelöschten" Datensätzen noch das Packen der Datei. Beides lässt sich jedoch über die BDE-API realisieren.

Oberfläche Außer einem DBGrid, einer Table- und einer DataSource-Komponente brauchen wir lediglich zwei Buttons, alles andere ist verzichtbares Beiwerk. Im Feldeditor (Kontextmenü Table) fügen Sie ein berechnetes Feld "DEL" mit dem Datentyp Boolean ein. Über das OnCalcFields-Ereignis werden wir später die Werte entsprechend einblenden, doch vorher müssen wir erst einmal dafür sorgen, dass die gelöschten Datensätze in die Ergebnismenge aufgenommen werden.

Quelltext Das Herzstück des Programms ist die Funktion ShowDeleted, der Sie eine geöffnete Tabelle zuweisen: procedure ShowDeleted(Tabelle:TTable); // ShowDeleted begin Tabelle.DisableControls; try DbiSetProp(hDBIObj(Tabelle.Handle), curSOFTDELETEON, Longint(True)) except ShowMessage('Probleme') end; Tabelle.Refresh; Tabelle.EnableControls end;

1336

Kapitel 22

How-to: Datenbanken

HINWEIS: Möchten Sie mit BDE-Funktionen arbeiten, müssen Sie die Unit BDE in Ihr Pro-

gramm einbinden. Nach dem Öffnen der Tabelle rufen wir die Funktion auf: procedure TForm1.Table1AfterOpen(DataSet: TDataset); begin ShowDeleted(Table1) end;

Über das CalcFields-Ereignis kennzeichnen wir die gelöschten Datensätze (Feld "DEL"): procedure TForm1.Table1CalcFields(DataSet: TDataSet); var Eigenschaften : RecProps; begin DbiGetRecord(Table1.Handle, dbiNoLock, nil, @Eigenschaften); Table1Del.Value := Eigenschaften.bDeleteFlag end;

Natürlich möchte man die dBASE-Tabelle auch irgendwann von überflüssigem Ballast befreien und die "gelöschten" Datensätze endgültig entfernen. Alles, was Sie dazu brauchen, ist die Funktion DBIPackTable, der Sie neben dem Datenbank-Handle auch den Handle der Tabelle, den Tabellennamen sowie den Typ übergeben: procedure TForm1.Button2Click(Sender: TObject); // Pack begin DBIPackTable(Table1.DbHandle, Table1.Handle, 'Telefon.dbf', 'DBASE', TRUE); Table1.Refresh end;

Test

22.22 Mit Transaktionen arbeiten

1337

22.22 Mit Transaktionen arbeiten Delphi bietet die Möglichkeit, Änderungen an einer Datenbank mit Hilfe von Transaktionen wieder rückgängig zu machen. Das folgende kleine Testprogramm zeigt die Vorgehensweise.

Oberfläche Neben einer DataBase-Komponente benötigen wir eine Table- und eine DataSource-Komponente. Für die Anzeige verwenden wir ein DbGrid.

Über die Buttons werden wir die Transaktion steuern, d.h., eine Transaktion starten und diese später rückgängig machen (Rollback) oder die Daten übernehmen (Commit). HINWEIS: Binden Sie die Table-Komponente an die Database-Komponente, nicht direkt an die

Datenbank bzw. den Alias!

Quelltext Starten der Transaktion: procedure TForm1.Button1Click(Sender: TObject); begin Database1.TransIsolation := tiDirtyRead; Database1.StartTransaction end;

Übernahme: procedure TForm1.Button2Click(Sender: TObject); begin Database1.Commit end;

1338

Kapitel 22

How-to: Datenbanken

Rückgängig: procedure TForm1.Button3Click(Sender: TObject); begin Database1.Rollback; Table1.Refresh end;

Kompletter Ablauf: procedure TForm1.Button4Click(Sender: TObject); begin Database1.TransIsolation :=tiDirtyRead; Database1.StartTransaction; Table1.Edit; Table1['size'] := 12; Table1.next; Table1.delete; if Application.MessageBox('Änderungen übernehmen?', 'Frage', mb_YESNO)= IDYES then Database1.Commit else Database1.Rollback; Table1.Refresh end;

Test Starten Sie die Transaktion und löschen bzw. verändern Sie einige Datensätze. Probieren Sie, ob die Aktionen rückgängig gemacht werden können. Testen Sie das Verhalten, wenn zwei ProgrammInstanzen geöffnet sind. HINWEIS: Ist eine Transaktion gestartet und wird das Programm ohne Commit beendet, gehen

auch alle Änderungen nach dem Aufruf von StartTransaction verloren!

22.23 Die Lookup-Methode verwenden Ein kleines Beispielprogramm soll Ihnen demonstrieren, wie Sie mit Hilfe der Lookup-Methode Daten aus einer Tabelle abrufen können, ohne die Satzzeigerposition zu ändern. Im Unterschied zur Locate-Methode können Sie nicht die Eigenschaften und Methoden des Table-Objektes nutzen, um die Feldinhalte zu ermitteln. SYNTAX:

function Lookup(const KeyFields : String; const KeyValues : Variant; const ResultFields: String): Variant;

Alle benötigten Feldinhalte werden Ihnen von der Funktion im Erfolgsfall in einem Variant-Array zurückgegeben. Welche Felder Sie benötigen, müssen Sie im Parameter ResultFields vorher übergeben. In welchen Feldern wonach gesucht werden soll, bestimmen Sie mit den Parametern KeyFields und KeyValues.

22.23 Die Lookup-Methode verwenden

1339

Oberfläche Außer einer Table-Komponente und einer Listbox (von der "Standard"-Seite, also keine DBListbox!) zur Anzeige der Ergebnisse brauchen Sie nichts. Verbinden Sie die Table-Komponente mit der Datenbank "DBDemos" und der Tabelle "employee.db".

Quelltext Im Folgenden rufen wir den Nachnamen, Vornamen und die Telefonnummer des Mitarbeiters mit der Nummer 52 ab. Das zu durchsuchende Feld ist "CustNo". procedure TForm1.Button1Click(Sender: TObject); var werte: Variant; begin Table1.Open; werte := Table1.Lookup('EmpNo','52','Lastname;Firstname;PhoneExt');

Wurde der Datensatz gefunden? if not VarIsNull(werte) then begin ListBox1.Items.Add('Lastname: ' + werte[0]); ListBox1.Items.Add('Firstname: ' + werte[1]); ListBox1.Items.Add('Phone: ' + werte[2]) end else ShowMessage('Datensatz nicht gefunden!'); Table1.Close end;

Test Im Erfolgsfall sollte bei Ihnen folgendes Ergebnis zu sehen sein:

Bemerkung Möchten Sie in mehr als nur einer Spalte suchen, müssen Sie den folgenden Weg gehen: Table1.Lookup('CustNo;LastName', // wo VarArrayOf([66, 'Maier']), // was 'Lastname;Firstname;PhoneExt'); // Rückgabewerte

1340

Kapitel 22

How-to: Datenbanken

22.24 Zur Laufzeit ein Lookup-Feld erzeugen Nicht in jedem Fall steht die Struktur von Tabellen bzw. das komplette Datenbank-Layout schon zur Entwurfszeit der Anwendung fest. Für den professionellen Delphi-Programmierer stellt auch das keine Hürde dar. Wie Sie beispielsweise ein Lookup-Feld zur Laufzeit erstellen, zeigt Ihnen das folgende kleine Beispiel.

Oberfläche Erstellen Sie eine Oberfläche entsprechend folgender Abbildung.

Table1 und Table2 binden Sie an den Alias "DBDEMOS". Table1 verbinden Sie bitte nachfolgend mit der Tabelle "orders.db", Table2 mit der Tabelle "customer.db". An Table1 wird über die DataSource das DBGrid gebunden. Ziel des Programms ist die Darstellung des Firmennamens aus der Tabelle "customer.db" statt der einfachen Darstellung der CustNo.

Quelltext Mit dem Klick auf den Button werden, so noch nicht zur Entwurfszeit geschehen, zunächst alle Felder als persistente Felder deklariert, andernfalls wäre nur das neue Lookup-Feld sichtbar. procedure TForm1.Button1Click(Sender: TObject); var f: TField; i: Integer; begin Table1.FieldDefs.Update; Table1.Close; for i := 0 to Table1.FieldDefs.Count - 1 do if Table1.FindField(Table1.FieldDefs[i].Name) = nil then Table1.FieldDefs.Items[i].CreateField(Table1);

Nachfolgend erzeugen wir ein String-Feld f := TStringField.Create(Table1);

22.24 Zur Laufzeit ein Lookup-Feld erzeugen

1341

und setzen die wichtigsten Eigenschaften: f.size f.Name f.FieldName f.DisplayLabel

:= := := :=

50; 'Kunde'; 'Kunde'; 'Kunde (Firma)';

Wesentlich ist die Deklaration als Lookup-Feld: f.FieldKind

:= fkLookup;

Danach können wir die Datenquelle festlegen: f.DataSet f.lookupDataSet

:= Table1; := table2;

Den Fremdschlüssel auswählen: f.Keyfields

:= 'CustNo';

Den Primärschlüssel festlegen: f.LookupKeyFields

:= 'CustNo';

Das Anzeigefeld bestimmen: f.LookupResultField := 'Company';

Schließlich die Tabelle öffnen: Table1.Open end;

Test Starten Sie die Anwendung, fehlt noch die Spalte "Kunde (Firma)", aber nach dem Klick auf den Button sollte sich ganz rechts die unten gezeigte Lookup-Spalte einfinden:

1342

Kapitel 22

How-to: Datenbanken

22.25 Eine Tabelle zur Laufzeit erstellen Das vorliegende Beispiel soll sich nicht darauf beschränken, einfach eine Tabelle zur Laufzeit zu erzeugen (dafür genügen einige Zeilen SQL-Code), sondern ganz nebenbei ■ das Erzeugen von TFieldDefs, ■ das Handling von Berechneten Feldern, ■ das dynamische Erzeugen von Komponenten ■ und die Arbeit mit einem OnCalc-Event demonstrieren.

Oberfläche Keine, alle erforderlichen Komponenten und Verknüpfungen werden erst zur Laufzeit erzeugt!

Quelltext Erweitern Sie zunächst die Uses-Klausel der Unit1 (Hauptformular) um folgende Units: DBTables, DB, Grids, DBCtrls, DBGrids

Die Klassendeklaration des Formulars erweitern Sie um einige Komponenten und eine Ereignisprozedur: type TForm1 = class(TForm) procedure FormCreate(Sender: TObject); private procedure CalcFields(DataSet: TDataset); public tb : TTable; ds : TDataSource; DbGrid : TDBGrid; DbNav : TDBNavigator; CalcField :TFloatField end; ...

Mit dem Erzeugen des Formulars erstellen wir eine Tabelle (im Alias "DBDemos"), verbinden diese mit einem DBGrid und einem DBNavigator und zeigen diese im Formular an: procedure TForm1.FormCreate(Sender: TObject); begin

Instanz von TTable bilden: tb := TTable.Create(Self); with tb do begin

22.25 Eine Tabelle zur Laufzeit erstellen

1343

Zuweisen der wichtigsten Eigenschaften: AutoCalcFields DatabaseName TableName TableType

:= := := :=

True; 'DBDEMOS'; 'PrgTest'; ttParadox;

Zuweisen der Ereignisprozedur: OnCalcFields

:= CalcFields;

Deklarieren der Felder: with FieldDefs do begin Clear; Add('Id', ftAutoInc, 0, False); Add('Vorname', ftString, 20, False); Add('Nachname', ftString, 20, False); Add('GehaltInEuro', ftCurrency, 0, False);

Der "Ersatz" für den Feldeditor: FieldDefs[0].CreateField(tb); FieldDefs[1].CreateField(tb); FieldDefs[2].CreateField(tb); FieldDefs[3].CreateField(tb);

Verzichten wir auf diese Anweisungen, werden die Felder nicht angezeigt. Die Ursache ist das im Folgenden deklarierte "berechnete" Feld: CalcField := TFloatField.Create(tb); with CalcField do begin FieldName := 'GehaltInDM'; Calculated := True; Visible := True; DataSet := tb; DisplayFormat := '#,##0.00 DM'; Name := 'GehaltInDM'; tb.FieldDefs.Add(Name, ftFloat, 0, False) end end;

Das endgültige Erzeugen der Tabelle: tb.CreateTable end;

Damit sind alle tabellenrelevanten Operationen abgeschlossen, die Tabellenstruktur ist auf die Festplatte geschrieben worden. Was bleibt, ist die Anbindung der Bound Controls zur Darstellung der Daten: ds := TDataSource.Create(Self); ds.DataSet := tb;

1344

Kapitel 22

How-to: Datenbanken

DbNav := TDBNavigator.Create(self); with dbNav do begin Parent := Self; Align := alBottom; DataSource := ds end; DBGrid := TDBGrid.Create(Self); with DBGrid do begin Parent := Self; Align := alClient; DataSource := ds end;

Öffnen der Tabelle: tb.Active := True end;

Bevor wir es vergessen, wir hatten ja auch eine Ereignisprozedur für das OnCalc-Event zugewiesen: procedure TForm1.CalcFields(DataSet: TDataset); begin DataSet.FieldByName('GehaltInDM').AsFloat := DataSet.FieldByName('GehaltInEuro').AsFloat * 1.95583 end;

Test Nach dem Start sollten Sie zunächst einige Datensätze hinzufügen und das Gehalt in Euro eingeben. Das Gehalt in DM wird automatisch ergänzt (ist was für Nostalgiker).

HINWEIS: Die frisch angelegte Tabelle PrgTest.db finden Sie im Verzeichnis von DBDEMOS,

also meist unter C:\Programme\Gemeinsame Dateien\Borland Shared\Data.

22.26 Auf mehrere Datenbanken gleichzeitig zugreifen

1345

22.26 Auf mehrere Datenbanken gleichzeitig zugreifen Soll innerhalb einer SQL-Abfrage (BDE) auf zwei verschiedene Datenbanken zugegriffen werden, bieten sich zwei Varianten an: ■ Sie verwenden den Pfad zu den jeweiligen Tabellen innerhalb der SQL-Abfrage oder ■ Sie platzieren den Alias vor den Tabellennamen und schließen diesen in ":" ein. Ein kleines Beispielprogramm demonstriert die Realisierung. Aufgabe ist ein simpler Join über zwei Tabellen (Kunden und Bankleitzahlen), wobei zu einer Kunden-BLZ der Name der Bank und der Ort angezeigt werden sollen.

Oberfläche Lediglich ein Formular, eine Query-, eine DataSource- und eine DBGrid-Komponente sind erforderlich.

Binden Sie die Query an keine Datenbank (die DataBaseName-Eigenschaft bleibt leer). Die SQLEigenschaft legen Sie wie folgt fest: SELECT k.name AS Kundenname, k.blz As KundenBankleitzahl, b.n2 As Bank, b.n4 As Bank_Ort FROM 'kunden.db' k, '.\BLZ\bankleitzahlen.dbf' b WHERE k.blz = b.n1

HINWEIS: Die beiden zugehörigen Tabellen befinden sich im aktuellen Verzeichnis und im un-

tergeordneten Verzeichnis BLZ.

1346

Kapitel 22

How-to: Datenbanken

Test Nach dem Programmstart sollten die Daten aus beiden Tabellen/Datenbanken im DBGrid erscheinen:

Bemerkung Arbeiten Sie mit einem Alias, müssen Sie beispielsweise folgende Syntax verwenden: SELECT ... FROM ':DBDEMOS:employee.db' e, ':MYAlias:kontakte.db' k WHERE ...

22.27 Bound Controls ohne BDE verwenden Da schreiben Sie eine winzige Adressverwaltung, wollen diese weitergeben und stellen schockiert fest, dass Sie für das Installationsprogramm inklusive BDE schon zwei bis drei Disketten benötigen! Dabei bietet doch die ClientDataset-Komponente fast die gleiche Funktionalität wie eine TableKomponente und das ohne BDE! Für die Weitergabe genügen Ihre Anwendung und die Datei midas.dll. Weitere Vorteile: ■ Sie bestimmen selbst, wie die Daten gespeichert werden. Die Methode SaveToStream bietet zum Beispiel einen geeigneten Ansatzpunkt, um die Daten zu packen und zu verschlüsseln. ■ Daten lassen sich auf einfache Weise über ein Netzwerk verschicken (einfach in einem MemoryStream speichern und paketweise übertragen). Bei so viel Licht gibt es natürlich auch Schatten: ■ Die Daten werden im Speicher gehalten, große Datenbanken scheiden damit aus. ■ Indizes gehen beim Speichern der Daten verloren und müssen wieder aufgebaut werden.

22.27 Bound Controls ohne BDE verwenden

1347

Eine Beispielanwendung zeigt, wie Sie in vielen Fällen ohne BDE auskommen: Wir wollen eine kleine Adressverwaltung programmieren, beschränken uns aber auf die Eingabe über ein DBGrid, um den Aufwand nicht unnötig zu erhöhen.

Oberfläche Der Formularaufbau ist denkbar einfach, einziger Unterschied zu einer "traditionellen" DatenbankAnwendung ist die Verwendung einer ClientDataset-Komponente statt einer Table oder Query.

Über die Eigenschaft FieldDefs der ClientDataset-Komponente können Sie schon zur Entwurfszeit die Tabellenstruktur festlegen:

Gleiches trifft auch auf die Indexdefinition (IndexDefs) zu, wir werden den Index aber erst zur Laufzeit erzeugen.

Quelltext Der zugehörige Quellcode ist erfreulich kurz. Nach dem Öffnen des Formulars bestimmen wir den Dateinamen, unter dem die Tabelle abgelegt ist bzw. abgelegt werden soll. Schlägt der Aufruf der Methode Open fehl, erzeugen wir eine neue Tabelle (entsprechend der FieldDefs-Vorgaben): procedure TForm1.FormShow(Sender: TObject); begin ClientDataset1.FileName := ExtractFilePath(ParamStr(0)) + 'adressen.cds'; try ClientDataset1.Open except

1348

Kapitel 22

How-to: Datenbanken

ClientDataset1.CreateDataSet end; ClientDataset1.IndexDefs.Add('iid','id',[]); ClientDataset1.IndexDefs.Add('iname','name;vorname',[]) end;

Letzter Schritt ist das Erzeugen der Indizes, da diese in keinem Fall mitgespeichert werden. Über einen Klick auf die Spaltenköpfe der Tabelle können wir den Index und damit auch die Sortierfolge ändern. procedure TForm1.DBGrid1TitleClick(column: TColumn); begin if column.Field.FieldNo = 1 then ClientDataset1.IndexName := 'iid' else ClientDataset1.IndexName := 'iname' end;

Beim Schließen der Anwendung sollten Sie alle Änderungen im Dataset übernehmen, deshalb der Aufruf von MergeChangeLog. Close speichert bei vorgegebenem Filename die Tabelle in einer Datei. procedure TForm1.FormCloseQuery(Sender: TObject; var CanClose: Boolean); begin ClientDataset1.MergeChangeLog; ClientDataset1.Close end;

Test Starten Sie das Programm und beginnen Sie mit dem Eintragen von Datensätzen.

Bemerkungen ■ Legen Sie Wert auf Sicherheit (z.B. bei eigener Passwortverwaltung oder bei vertraulichen Daten), bietet sich zum Laden und Speichern ein etwas anderer Weg an. Speichern Sie die Daten der ClientDataset-Komponente in einem TMemoryStream. Über den Zeiger auf das erste Byte (Memory) können Sie jetzt nacheinander alle Bytes verschlüsseln (z.B. mit einem Stromchiffrierer wie RC40). Speichern Sie danach den MemoryStream mit SaveToFile ab. Beim Laden müssen Sie in umgekehrter Reihenfolge vorgehen. ■ Sollen die Daten über das Internet oder per E-Mail transportiert werden, bietet sich auch ein interner Pack-Algorithmus an (zlib).

22.28 Eine SoundEx-Funktion programmieren

1349

22.28 Eine SoundEx-Funktion programmieren Bei der Namenssuche in Datenbanken erweisen sich Operatoren wie "LIKE", "=" oder ">=" nicht immer als hilfreich. Zu viele verschiedene Schreibweisen bieten sich an. Aus diesem Grund bieten leistungsfähigere Suchmaschinen auch einen SoundEx-Operator, d.h. eine Funktion, die sich nicht am geschriebenen Wort, sondern an der Aussprache orientiert. Wie oft haben Sie schon überlegt, ob Sie ein "D" oder ein "T" schreiben müssen? Die im Folgenden vorgestellte Funktion reduziert ein eingegebenes Wort auf dessen Anfangsbuchstaben und einen dreistelligen Zahlencode, der sich an der Aussprache orientiert.

Oberfläche Den Grundaufbau der Oberfläche entnehmen Sie bitte der folgenden Abbildung:

In das Editfeld geben wir später den Suchbegriff ein, Label1 zeigt uns den zugehörigen SoundExCode an. Die Table1-Komponente binden Sie an die Datenbank DBDEMOS und die Tabelle Employee.db.

Quelltext Die eigentliche SoundEx-Funktion: function SoundEx(s : String) : String; var help : String; i : Integer; begin Result := '';

Zuerst einmal Leerzeichen entfernen und in Großbuchstaben umwandeln: s := Trim(UpperCase(s)); if s = '' then Exit;

1350

Kapitel 22

How-to: Datenbanken

Das erste Zeichen bleibt erhalten: Result := s[1]; help := s[1];

Alle Vokale, Leerzeichen und die Konsonanten H, W, Y entfernen: for i := 2 to Length(s) do if not(s[i] in ['A', 'E', 'I', 'O', 'U', ' ', 'H', 'W', 'Y']) then help := help + s[i]; s := help; help := '';

Umwandlung entsprechend der SoundEx-Tabelle: for i := 1 to Length(s) do begin case s[i] of 'B', 'F', 'P', 'V' : help := help 'C', 'G', 'J', 'K', 'Q', 'S', 'X', 'Z' : help := help 'D', 'T' : help := help 'L' : help := help 'M', 'N' : help := help 'R' : help := help else help := help + '0' end end;

+ + + + + +

'1'; '2'; '3'; '4'; '5'; '6';

Doppelte Zeichen entfernen: for i := 2 to Length(s) do if (help[i] <> help[i - 1]) then begin Result := Result + help[i]; if (Length(Result) >= 4) then Break end;

Gegebenenfalls auf einen vierstelligen Code auffüllen: while Length(Result) < 4 do Result := Result + '0' end;

Mit jeder Änderung in der Editbox berechnen wir einen neuen SoundEx-Wert: procedure TForm1.Edit1Change(Sender: TObject); begin Label1.Caption := SoundEx(Edit1.Text) end;

Wird auf den Button geklickt, wird die Tabelle gefiltert: procedure TForm1.Button1Click(Sender: TObject); begin Table1.Filtered := False; such := SoundEx(Edit1.Text); Table1.Filtered := True end;

1351

22.28 Eine SoundEx-Funktion programmieren

Dazu nutzen wir das OnFilterRecord-Ereignis: procedure TForm1.Table1FilterRecord(DataSet: TDataSet; var Accept: Boolean); begin Accept := SoundEx(DataSet.FieldByName('lastname').AsString) >= such end;

HINWEIS: Sie können statt ">=" auch "=" als Filterkriterium anwenden, in diesem Fall werden

jedoch wesentlich weniger Datensätze gefunden.

Test Geben Sie in die Editbox einen Suchbegriff (z.B. "Youn") ein. Nach dem Klick auf den Button sollten alle ähnlich klingenden Namen angezeigt werden.

BEISPIEL: Verschiedene Eingaben und deren Ergebnis Eingabe

Ergebnis

Mayer

M600

Meier

M600

Maier

M600

Meyer

M600

Schmidt

S530

Schmid

S530

Schmied

S530

1352

Kapitel 22

How-to: Datenbanken

22.29 Eine tolerante Suchfunktion realisieren Nicht in jedem Fall genügt die im vorhergehenden Beispiel gezeigte Funktion SoundEx den Anforderungen an Toleranz, bzw. die Funktion reagiert nicht flexibel genug auf Ähnlichkeiten zwischen zwei Wörtern. Mit dem so genannten Damerau-Levenstein-Maß können Sie eine Such- bzw. Vergleichsfunktion realisieren, die den Aufwand für die Umwandlung des einen Strings in den anderen als Kriterium nutzt. Dabei werden drei mögliche Operationen einzeln bewertet: ■ Änderung bzw. Ersetzen ■ Hinzufügen ■ Löschen

Oberfläche Den Grundaufbau der Oberfläche entnehmen Sie bitte der folgenden Abbildung:

In das Editfeld geben Sie später den Suchbegriff ein, mit der TrackBar können Sie den Grad der Toleranz zwischen 0 und 10 einstellen. Die Table1-Komponente binden Sie bitte an die Datenbank DBDEMOS und die Tabelle Employee.db.

Quelltext Die Konstanten für die Wichtung der einzelnen Operationen: const ws : wi : wd : th :

Integer Integer Integer Integer

= = = =

3; 1; 6; 4;

var such: string;

// Wichtung für das Ersetzen // Wichtung für das Einfügen // Wichtung für das Löschen

22.29 Eine tolerante Suchfunktion realisieren

Die eigentliche Funktion: function DamerauLevenstein(s1,s2:string;ws,wi,wd:Integer): Integer; var m, i, j : Integer; d : array of array of Integer; function Pp(x,y:Integer):Integer; begin if s1[x] = s2[y] then Result:= 0 else Result:= ws end; begin s1 := AnsiUpperCase(Trim(s1)); s2 := AnsiUpperCase(Trim(s2)); m := Max(Length(s1),Length(s2)); SetLength (d,m + 1,m + 1); d[0,0]:=0; for j:=1 to m do d[0,j]:=d[0 ,j-1] + wi; for i:=1 to m do d[i,0]:=d[i-1,0 ] + wd; for i:=1 to Length(s1) do for j:=1 to Length(s2) do d[i,j]:=MinIntValue([ d[i-1,j-1] + Pp(i,j), d[ i ,j-1] + wi, d[i-1, j] + wd]); Result := d[Length(s1),Length(s2)]; SetLength(d,0) end;

Mit jeder Eingabe wird die Suche erneut durchgeführt: procedure TForm1.Edit1Change(Sender: TObject); begin Table1.Filtered := False; such := Edit1.Text; Table1.Filtered := True end;

Das Gleiche gilt auch, wenn der Toleranzwert geändert wird: procedure TForm1.TrackBar1Change(Sender: TObject); begin Table1.Filtered := False; th := Trackbar1.Position; Table1.Filtered := True end;

Die Ereignisprozedur für die Filterfunktion: procedure TForm1.Table1FilterRecord(DataSet: TDataSet; var Accept: Boolean); var s : string; begin s := dataset.fieldbyname('lastname').AsString;

1353

1354

Kapitel 22

How-to: Datenbanken

setlength(s, Length(such)); Accept := DamerauLevenstein(s,such,ws,wi,wd)<=th end;

Test Geben Sie einen Suchbegriff (z.B. "for") ein. Nach dem Klick auf den Button sollten alle ähnlich klingenden Namen angezeigt werden. Variieren Sie den Toleranz-Wert mit der TrackBar.

22.30 Bound Controls selbst entwickeln Als Beispiel für eine datengebundene Komponente wollen wir einen absolut simplen Nachfahren von TEdit erzeugen, der sich an eine Tabellenspalte binden lässt. "Wozu das?", werden Sie vielleicht fragen, weil eine entsprechende Komponente TDBEdit (Seite "Datensteuerung") bereits existiert und uns bestens bekannt ist. Hier die Gründe, warum wir "das Fahrrad noch einmal neu erfinden" wollen: ■ Sie brauchen sich um die Funktionsbeschreibung der Komponente nicht weiter zu kümmern, sondern können gleich zu den Einzelheiten kommen. ■ Sie lernen die Grundlagen der Programmierung von Bound Controls kennen, denn wie Sie noch sehen werden, ist der Verwaltungsaufwand hinter den Kulissen relativ groß.

Komponentenexperte Ausgangspunkt ist wie immer der Komponentenexperte (Menü Komponente|Neue Komponente). Als Vorfahrtyp wählen wir TEdit, unsere neue Komponente bekommt die Bezeichnung TDBMyEdit und soll später auf der Seite "Beispiele" der Komponentenpalette ihren Platz finden.

22.30 Bound Controls selbst entwickeln

1355

Im Anschluss dürfen Sie die Finger über die Tastatur tanzen lassen, allein die Änderungen an der Klassendefinition (fett gedruckt) sind schon ziemlich umfangreich: type TDBMyEdit = class(TEdit) private FDataLink: TFieldDataLink; procedure DataChange(Sender: TObject); procedure EditingChange(Sender: TObject); procedure UpdateData(Sender: TObject); function GetDataField: string; function GetDataSource: TDataSource; function GetField: TField; procedure SetDataField(const value: string); procedure SetDataSource(value: TDataSource); procedure CMGetDataLink(var message: TMessage); message CM_GETDATALINK; protected procedure Change; override; procedure KeyPress(var Key: Char); override; procedure Notification(AComponent: TComponent; Operation: TOperation); override; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; property Field: TField read GetField; published property DataField: string read GetDataField write SetDataField; property DataSource: TDataSource read GetDataSource write SetDataSource; end; procedure Register; implementation

1356

Kapitel 22

How-to: Datenbanken

procedure Register; begin RegisterComponents('Beispiele', [TDBMyEdit]); end;

Lassen Sie sich nicht abschrecken, dieser Aufwand ist nur erforderlich, wenn Sie eine datengebundene Komponente aus einer nicht datengebundenen Komponente erzeugen. Wofür die einzelnen Methoden und Eigenschaften zuständig sind, wollen wir im Folgenden klären.

Konstruktor Mit dem Erstellen der Komponente müssen wir auch ein FieldDataLink-Objekt erstellen (private Variable). Über dieses Objekt wird die Kommunikation mit den anderen Datenbank-Komponenten hergestellt. Weisen Sie dem FieldDataLink-Objekt eine Datenquelle (DataSource) zu, wird Ihre Komponente bei jeder Änderung (Datensatzwechsel, Moduswechsel etc.) benachrichtigt. Als Schnittstellen dienen drei Methoden (OnDataChange, OnEditingChange, OnUpdateData), die Sie entsprechend auswerten müssen. constructor TDBMyEdit.Create(AOwner: TComponent); begin inherited Create(AOwner); FDataLink := TFieldDataLink.Create; FDataLink.Control := Self; FDataLink.OnDataChange := DataChange; FDataLink.OnEditingChange := EditingChange; FDataLink.OnUpdateData := UpdateData end;

Destruktor Beim "Zerstören" Ihrer Komponente müssen Sie natürlich auch die selbst erstellten Objekte deinitialisieren: destructor TDBMyEdit.Destroy; begin FDataLink.Free; FDataLink := nil; inherited Destroy end;

Eigenschaften DataSource und DataField Nächster Schritt ist die Realisierung der Eigenschaften DataSource und DataField mit Hilfe der Schnittstellen-Methoden: function TDBMyEdit.GetDataSource: TDataSource; begin Result := FDataLink.DataSource end;

22.30 Bound Controls selbst entwickeln

1357

Gespeichert werden die Werte im DataLink-Objekt: procedure TDBMyEdit.SetDataSource(value: TDataSource); begin FDataLink.DataSource := value; if value <> nil then value.FreeNotification(Self) end; function TDBMyEdit.GetDataField: string; begin Result := FDataLink.FieldName end; procedure TDBMyEdit.SetDataField(const Value: string); begin FDataLink.FieldName := Value end;

Die Notification-Methode Wie schon mehrfach erwähnt, müssen wir auch für den Fall vorsorgen, dass eine gebundene Komponente gelöscht wird: procedure TDBMyEdit.Notification(AComponent: TComponent; Operation: TOperation); begin inherited Notification(AComponent, Operation); if (Operation = opRemove) and (FDataLink <> nil) and (AComponent = DataSource) then DataSource := nil end;

Als Nächstes kümmern wir uns um die drei Ereignis-Methoden.

EditingChange, DataChange, UpdateData Jede Änderung des Bearbeitungsmodus (Browse zu Edit etc.) führt zu einem Aufruf von EditingChange. Sie könnten beispielsweise die Komponente farbig hinterlegen, um dem Bearbeiter den neuen Modus anzuzeigen. In der vorliegenden Komponente werden wir das Ereignis nicht weiter auswerten: procedure TDBMyEdit.EditingChange(Sender: TObject); begin inherited end;

Ganz anders das Ereignis DataChange. Hier reagieren wir auf die Änderung des Feldinhalts. Ursache könnte beispielsweise das Scrollen durch die Datenmenge sein. procedure TDBMyEdit.DataChange(Sender: TObject); begin if FDataLink.Field <> nil then begin if FDataLink.Field is TStringField then Text := FDataLink.Field.AsString; Modified:= False end else

1358

Kapitel 22

How-to: Datenbanken

if csDesigning in ComponentState then Text := Name else Text := '' end;

Sollte der Komponente zur Entwicklungszeit (if csDesigning in ComponentState) keine Datenquelle zugewiesen sein, zeigen wir den Namen der Komponente an, sonst einen Leerstring. Mit dem Ereignis UpdataData können Sie die Inhalte der Komponente in die Tabellenspalte übernehmen: procedure TDBMyEdit.UpdateData(Sender: TObject); begin FDataLink.Field.AsString:= Text end;

Damit haben wir eigentlich alle wesentlichen Funktionen realisiert, allerdings ist unsere Komponente noch nicht sehr kontaktfreudig. Was fehlt, ist die Meldung an die übergeordnete DataSource, dass sich in unserer Komponente etwas getan hat (Eingabe).

Benachrichtigen der übergeordneten Komponenten Jeder Tastendruck in unserer Komponente hat zur Folge, dass die Datenmenge in den Editiermodus umschaltet. Einzige Ausnahme: Die ESC-Taste führt dazu, dass der alte Feldinhalt wiederhergestellt wird: procedure TDBMyEdit.KeyPress(var Key: Char); begin inherited KeyPress(Key); if Key = #27 then FDataLink.Reset else FDataLink.Edit end;

Über Änderungen in der Komponente benachrichtigen wir die anderen Komponenten über das Change-Ereignis. Durch den Aufruf von Modified wird signalisiert: "Hier hat sich etwas geändert!" procedure TDBMyEdit.Change; begin inherited Change; if Modified then begin FDataLink.Modified end end;

Die gesamte Kommunikation mit den anderen Datenbank-Komponenten wird über das DataLinkObjekt abgewickelt.

Installieren Nachdem Sie die Unit DBMyEdit.pas abgespeichert haben wählen Sie den Menüpunkt Komponente|Komponente installieren... und entscheiden sich vorsichtigerweise für das Abspeichern "In neues Package". Tragen Sie den Namen der Unit DBMyEdit.pas ein ("Durchsuchen"-Schaltfläche) und geben Sie dem neuen Package irgendeinen Namen.

22.30 Bound Controls selbst entwickeln

1359

Nach dem "OK" müsste eine Erfolgsmeldung erscheinen. Werfen Sie nun einen Blick auf die Seite "Beispiele" der Komponentenpalette und Sie müssten den Neuankömmling dort entdecken:

Test Wir erstellen eine simple Eingabemaske für die Tabelle Customer.db aus DBDEMOS und verwenden dafür unsere "selbst gebastelte" Komponente:

Bemerkungen ■ Wie Sie gesehen haben, ist es nicht ganz trivial, eine datengebundene Komponente zu entwickeln. Auch das vorliegende Beispiel konnte nur einen kleinen (aber nicht unwesentlichen) Teil der Funktionalität aufzeigen. Wichtig ist an dieser Stelle nur, dass Sie mit obigem Grundgerüst die wesentlichen Aufgaben einer datengebundenen Komponente abdecken können. ■ Wenn Sie das Beispiel von der Buch-CD ausprobieren wollen, laden Sie das Projekt (trotz Fehlermeldung) und holen dann die Installation nach. Evtl. müssen Sie die beiden Komponenten erneut auf das Formular setzen.

1360

Kapitel 22

How-to: Datenbanken

22.31 Eine DBCheckList programmieren Für die Auswahl verschiedener Optionen (z.B. Führerschein Klasse A, B, C etc.) bietet sich eine DBCheckListbox geradezu an, kann doch bei Platzmangel im Formular jederzeit gescrollt werden. Leider ist keine derartige Komponente in Delphi enthalten, lediglich die DBCheckBox mit jeweils einem booleschen Wert ist vorhanden. Bei der Anbindung an eine Datenbank wird so pro Komponente ein Datenfeld (mindestens 1 Byte) verbraucht, eine ungeheure Verschwendung an Speicherplatz! Unsere neue Komponente soll einen anderen Weg gehen: Mit einem LongInt-Wert (32 Bit) lassen sich 32 boolesche Zustände (True/False) speichern! BEISPIEL: Speichern von fünf Zuständen

Um unser Ziel zu erreichen, wollen wir die CheckListbox-Komponente so erweitern, dass sie an ein LongInt-Datenbankfeld gebunden werden kann.

Quelltext Nachfolgend der Quelltext der Komponente (abgeleitet von TCheckListBox): unit DBChLBox; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, CheckLst, DBCtrls, DB; type TDBCheckListBox = class(TCheckListBox) private FDataLink: TFieldDataLink; procedure DataChange(Sender: TObject); procedure EditingChange(Sender: TObject); procedure UpdateData(Sender: TObject); function GetDataField: string; function GetDataSource: TDataSource; function GetField: TField; procedure SetDataField(const value: string);

22.31 Eine DBCheckList programmieren

procedure SetDataSource(value: TDataSource); procedure CMGetDataLink(var Message: TMessage); message CM_GETDATALINK; protected procedure Notification(AComponent: TComponent; Operation: TOperation); override; public procedure ClickCheck; override; constructor Create(AOwner: TComponent); override; destructor Destroy; override; property Field: TField read GetField; published property DataField: string read GetDataField write SetDataField; property DataSource: TDataSource read GetDataSource write SetDataSource; end; procedure Register; implementation procedure Register; begin RegisterComponents('Beispiele', [TDBCheckListBox]) end;

Initialisieren der Komponente: constructor TDBCheckListBox.Create(AOwner: TComponent); begin inherited Create(AOwner); FDataLink := TFieldDataLink.Create; FDataLink.Control := Self; FDataLink.OnDataChange := DataChange; FDataLink.OnEditingChange := EditingChange; FDataLink.OnUpdateData := UpdateData end;

Freigabe der Ressourcen: destructor TDBCheckListBox.Destroy; begin FDataLink.Free; FDataLink := nil; inherited Destroy end;

Die Bindung der Komponente hat sich möglicherweise verändert (Table gelöscht etc.): procedure TDBCheckListBox.Notification(AComponent: TComponent; Operation: TOperation); begin inherited Notification(AComponent, Operation); if (Operation = opRemove) and (FDataLink <> nil) and (AComponent = DataSource) then DataSource := nil end;

1361

1362

Kapitel 22

How-to: Datenbanken

In der Komponente hat sich etwas geändert (ein Item wurde markiert): procedure TDBCheckListBox.ClickCheck; begin FDataLink.Edit; FDataLink.Modified end; procedure TDBCheckListBox.CMGetDatalink(var Message: TMessage); begin Message.Result := Integer(FDataLink) end; function TDBCheckListBox.GetDataSource: TDataSource; begin Result := FDataLink.DataSource end; procedure TDBCheckListBox.SetDataSource(value: TDataSource); begin FDataLink.DataSource := value; if value <> nil then value.FreeNotification(Self) end; function TDBCheckListBox.GetDataField: string; begin result := FDataLink.FieldName end; procedure TDBCheckListBox.SetDataField(const value: string); begin FDataLink.FieldName := value end; function TDBCheckListBox.GetField: TField; begin result := FDataLink.Field end; procedure TDBCheckListBox.EditingChange(Sender: TObject); begin inherited end;

An dieser Stelle wird bitweise überprüft, welche Einträge in der Liste ein "Häkchen" bekommen. Dazu wird das betreffende Bit über eine UND-Operation maskiert und ausgewertet: procedure TDBCheckListBox.DataChange(Sender: TObject); var i:Integer; begin if FDataLink.Field <> nil then begin if FDataLink.Field is TIntegerField then begin for i := 0 to Items.Count-1 do Checked[i] := (FDataLink.Field.AsInteger and (1 shl i))= (1 shl i) end end end;

Der zu speichernde Wert wird aus den einzelnen Zeilen der Liste zusammengesetzt (True = 1, False = 0). procedure TDBCheckListBox.UpdateData(Sender: TObject); var i: Integer; value : Integer; begin value := 0;

22.31 Eine DBCheckList programmieren

1363

for i := 0 to Items.Count-1 do begin if Checked[i] then value := value or (1 shl i) end; FDataLink.Field.AsInteger := Value end;

HINWEIS: Beachten Sie, dass maximal 32 Einträge in der Listbox unterstützt werden!

Installieren Verwenden Sie dazu das Menü Komponente|Komponente installieren... Über die genauere Vorgehensweise informieren Sie sich bitte im Vorgängerrezept. Es ist zu empfehlen, die Komponente gleich mit in das dort neu angelegte Package zu compilieren. Schließlich wird die Komponente auf der Seite "Beispiele" der Palette erscheinen und kann von Ihnen verwendet werden:

Testoberfläche Zum Testen wollen wir unsere neue Komponente mit der Access-Datenbank Firma.mdb verbinden, die sich im Anwendungsverzeichnis befindet (siehe Buch-CD). Die Tabelle Kunden wurde bereits vorher von uns um ein weiteres Feld Fuehrerschein vom LongInteger-Datentyp ergänzt. Zur Datenbankanbindung verwenden wir ein ADODataSet. Die DBEdit- und DBNavigatorKomponenten werden auf bekannte Weise mit der Datenquelle verbunden. Genauso wird auch unsere DBCheckListBox (rechts) über ihre DataSource- und DataField-Eigenschaften an DataSource1 bzw. Fuehrerschein "angeklemmt".

1364

Kapitel 22

How-to: Datenbanken

Wenn Sie die Active-Eigenschaft von ADODataSet1 auf True setzen, erscheint der erste Datensatz in den Editierfeldern, unsere neue Listbox zeigt allerdings noch keinerlei Reaktion.

Quellcode Um unsere DBCheckListBox zum Leben zu erwecken, ist folgender Event-Handler hinzuzufügen: procedure TForm1.FormCreate(Sender: TObject); begin with DBCheckListBox1 do begin AddItem('Klasse A', Self); AddItem('Klasse B', Self); AddItem('Klasse C', Self); AddItem('Klasse D', Self); AddItem('Klasse E', Self) end; ADODataSet1.Requery() end;

Test Jetzt können Sie das Programm starten und jedem Kunden seine Häkchen verpassen:

Bemerkung Binden Sie zusätzlich eine normale DBEdit-Komponente an das Feld Fuehrerschein, so sehen Sie, welche LongInteger-Zahl dem jeweiligen Zustand der Checkboxen entspricht.

22.32 Ein Setup für Datenbankanwendungen erstellen

1365

22.32 Ein Setup für Datenbankanwendungen erstellen Haben Sie endlich die Delphi-Datenbankanwendung erstellt, die Ihrer Meinung nach der Allgemeinheit nicht weiter vorenthalten werden sollte? Wenn ja, dann können Sie dafür sogar professionelle Installationsdateien anfertigen, mit denen Sie Ihre erstaunten Bekannten endgültig von Ihren überragenden Programmierfähigkeiten überzeugen. Mit dem einfachen Kopieren der EXE-Datei ist es aber leider nicht getan1, da auch ein Delphi-Programm noch einiges an "Beiwerk" mit sich rumschleppen muss, vor allem wenn es um Datenbanken geht. Aber welche Dateien gehören noch mit dazu, wo stecken die und in welches Verzeichnis müssen sie beim Endanwender kopiert werden? Das Programm InstallShield nimmt Ihnen quälende Überlegungen dieser Art ab, mit wenigen Mausklicks haben Sie für Ihr Programm professionelle Installations-CDs2 angefertigt. Grundlage unseres Beispiels ist das Erstellen eines Setups für das BDE-basierte Beispielprogramm "Entfernungsbestimmung", welches Sie auf der Buch-CD finden.

Vorbereitungen Bevor Sie überhaupt beginnen können, muss das zu Delphi (Professional und Enterprise) mitgelieferte Programm InstallShieldExpress in einer quälend langen Tortur separat vom Hauptmenü der Delphi-CD nachinstalliert werden. Nach Abschluss der Installation starten Sie IS Express für Delphi vom Windows-Startmenü aus und wählen "Neues Projekt erstellen..." bzw. Datei|Neu. HINWEIS: Bei einem Setup-Projekt handelt es sich nicht um Ihr Delphi-Projekt, sondern ledig-

lich um die .ism-Datei, welche die Einstellungen von InstallShield speichert! Wählen Sie nun für das neue Installationsprojekt einen Namen (Testprojekt1.ism) und ein Verzeichnis (..\EntfernungsDB_Install) aus und klicken Sie auf OK.

Was Sie nun erwartet, ist eine gigantische Checkliste, von der Sie sich aber nicht abschrecken lassen sollten, sondern die stur Schritt für Schritt "abgehakt"3 werden muss:

1

Das gibt mit Sicherheit lange Gesichter auf der anderen Seite.

2

Bei Datenbank-Applikationen braucht man gar nicht erst von Installationsdisketten zu reden.

3

Das ist durchaus wörtlich zu nehmen, denn jeder abgearbeitete Punkt erhält zur Erinnerung ein dickes rotes Häkchen.

1366

Kapitel 22

How-to: Datenbanken

Aber nicht alle Punkte müssen Sie abarbeiten, bei vielen Punkten genügt die Übernahme der Standardeinstellungen. HINWEIS: Dass der zu Delphi mitgelieferte InstallShield Express lediglich eine abgerüstete Ver-

sion von InstallShield ist, erkennen Sie daran, dass einige Einstellungen in der Checkliste zwar angezeigt werden, aber für eine Benutzung gesperrt sind. Wir werden im Folgenden nur die für den Einstieg wirklich wichtigen Schritte erläutern. Insgesamt sind sechs Etappen zu bewältigen:

1. Ihr Setup organisieren Allgemeine Informationen Hierzu gibt es nicht viel zu erklären, tragen Sie ein Name des Autors, Produktname, Version, Internet-Adressen, Produktcode usw.

22.32 Ein Setup für Datenbankanwendungen erstellen

1367

Diese Angaben liefern auch die so genannten Supportinformationen, wie sie später auf dem Anwenderrechner abrufbar sind (Windows-Systemsteuerung|Software):

HINWEIS: Belassen Sie möglichst nicht den Produktnamen auf seinem Standardwert, denn

sonst haben Sie später Schwierigkeiten beim Auffinden des Programms.

1368

Kapitel 22

How-to: Datenbanken

Features Man versteht unter diesem sehr allgemein klingenden Begriff ganz konkret die Auswahlmöglichkeiten, die der Anwender bei einem benutzerdefinierten Setup vorfindet. Jedem Feature sind ganz bestimmte Dateien zugeordnet. Das wichtigste Feature "Immer installieren" ist immer vorhanden, darunter werden später die Dateien zusammengefasst, die in jedem Fall auf den Zielrechner zu kopieren sind. Weitere Features, die auf dem Zielrechner zusätzlich installiert werden können (aber nicht müssen), können Sie durch Anklicken des Features-Baums mit der rechten Maustaste hinzufügen. Denkbar wären z.B. die Features wie "Hilfesystem" oder "Landkarte". Setup-Typen Die folgende Abbildung dürfte für Klarheit sorgen, was wir unter einem Setup-Typ zu verstehen haben. Es geht jetzt darum, jedem dieser drei Setup-Typen bestimmte Features zuzuordnen. Für unser kleines Beispiel ergibt natürlich nur der "Standard"-Setup-Typ Sinn:

2. Anwendungsdaten eingeben Dateien Nun wird es endlich konkret. Sie sollen jetzt festlegen, zu welchen der im vorhergehenden Schritt festgelegten Features welche Dateien gehören. Für unser einziges Feature "Immer installieren" (Klappbox in der Abbildung oben links) suchen wir links den Ordner und rechts die erforderliche Delphi-Datei (Projekct1.exe) aus. In der unteren Hälfte legen Sie fest, in welche Ordner des Zielcomputers die Dateien abzulegen sind. Wenn Sie mit der rechten Maustaste auf das "Zielcomputer"-Icon klicken, haben Sie die Wahl zwischen einer Vielzahl bereits vorhandener Standardordner oder dem Anlegen eines eigenen Ordners. Unser Demo-Programm können Sie z.B. im \Programme-Verzeichnis von Windows unterbringen. Wählen Sie dafür den Menüeintrag [ProgramFilesFolder]:

22.32 Ein Setup für Datenbankanwendungen erstellen

1369

Legen Sie mit Hilfe der rechten Maustaste noch ein Unterverzeichnis \EntfernungsDB an und ziehen Sie dann per Drag & Drop die Anwendungsdatei Project1.exe auf diesen Ordner:

Drag&Drop

Natürlich brauchen wir außerdem noch unsere Paradox-Datenbank, die wir auf die gleiche Weise in den Ordner des Zielcomputers befördern:

1370

Kapitel 22

How-to: Datenbanken

Dateien und Features Dieser Punkt gibt noch einmal einen zusammenfassenden Überblick, welche Dateien wohin auf den Zielrechner zu installieren sind:

Objekte/Merge-Module Hier handelt es sich um zusätzliche Dateien, wie ActiveX-Komponente und Datenbank-Laufzeitsysteme. Für unser Beispiel müssen wir zusätzlich die BDE (Borland Database Engine) mitgeben, falls auf dem Zielrechner weder Delphi noch Paradox installiert sind. In der aufgeführten Liste von Modulen und ActiveX-Controls wählen wir BDE_ENT bzw. BDE_PRO.

Ungefragt bietet Ihnen ein neuer Assistent seine Dienste an und will Sie bei der Konfiguration der BDE-Installation unterstützen.

22.32 Ein Setup für Datenbankanwendungen erstellen

1371

Nach dem Anlegen der neuen Konfigurationsdatei (EntfernungsDB.ini) können Sie aus diesem Assistenten heraus einen weiteren Assistenten (BDE-Konfigurationsdienstprogramm) starten, der Ihnen die Auswahl zusätzlicher Treiber sowie das eventuelle Anlegen eines Alias ermöglicht 1. Für unsere einfache Datenbankanwendung brauchen wir allerdings hier nichts einzutragen (da sich die Datenbank im Anwendungsverzeichnis befindet, konnten wir auf einen Alias verzichten).

Damit sind die wesentlichen datenbankspezifischen Schritte ausgeführt. HINWEIS: Eine Einschränkung existiert jedoch: Sie können keine komprimierten Medien erstel-

len, da andernfalls die BDE-Installation fehlschlägt.

1

Warum nicht gleich ein Assistent zur Handhabung der Assistenten mitgeliefert wird, ist fraglich ...

1372

Kapitel 22

How-to: Datenbanken

3. Zielsystem konfigurieren In dieser Etappe geht es um spezielle Einstellungen, die das Setup-Programm am Zielcomputer vornimmt. Verknüpfungen/Ordner Sie können verschiedene Verknüpfungsarten bzw. Anzeigen einrichten (Taskleiste, Startmenü ...). Für unser Beispiel ist ein Eintrag im Windows-Startmenü vorgesehen. Das Hinzufügen zur Baumstruktur wird mittels Kontextmenü der rechten Maustaste erledigt:

HINWEIS: Tragen Sie im Eigenschaftendialog unter Ziel den vollständigen Pfadnamen ein

([ProgramFilesFolder]/EntfernungsDB/Projekt1.exe), ansonsten wird die Verknüpfung nicht generiert bzw. zeigt ins Leere. Registrierung Hier geht es um Einträge in der Windows-Registry des Zielrechners, die Sie nur im Bedarfsfall vorzunehmen brauchen (z.B. wenn ActiveX-Komponenten enthalten sind). Ähnlich wie bei dem Zuordnen von Dateien werden auch hier – in Abhängigkeit vom eingestellten Feature – komplette Registrierungsschlüssel per Drag & Drop aus dem Quell- in den Zielcomputer verschoben. ODBC-Ressourcen, INI-Datei-Änderungen, Dateierweiterungen Auch diese (weitgehend selbst erklärenden) Spezialeinstellungen müssen Sie nur im Bedarfsfall vornehmen.

4. Setup-Darstellung anpassen In dieser Etappe geht es eigentlich nur noch um Äußerlichkeiten, denn hier legen Sie das Erscheinungsbild Ihres Setup-Programms fest. Dialogfelder Alle Fenster bzw. Meldungen, die während des Installationsprozesses auf dem Bildschirm erscheinen sollen, können Sie hier festlegen:

22.32 Ein Setup für Datenbankanwendungen erstellen

1373

Billboards, Text und Meldungen Diese "Schmankerln" entziehen sich dem lüsternen Zugriff des "Nur-IS-Express-Besitzers" durch ein großes Vorhängeschloss. Das sollte Ihre Gier nach der InstallShield-Vollversion anheizen!

5. Setup-Anforderungen und -Aktionen festlegen Hier können Sie Ihr Setup z.B. an unterschiedliche Betriebssysteme des Zielrechners anpassen. Das meiste davon (z.B. Support-Dateien hinzufügen oder ausführbare Dateien während der Installation starten) bleibt allerdings der IS-Vollversion vorbehalten. Anforderungen

1374

Kapitel 22

How-to: Datenbanken

6. Release vorbereiten In dieser letzten Etappe wird es endlich ernst. Release erstellen Zunächst legen Sie das Vertriebsmedium fest. Hier haben Sie vielfältige Auswahlmöglichkeiten zwischen den Datenträgern und der Auswahl ihrer Eigenschaften:

HINWEIS: Das eigentliche Erstellen des Release wird ganz unspektakulär gestartet: Mit der

rechten Maustaste auf den gewünschten Datenträger (im Beispiel CD-ROM) klicken und Erstellen wählen. Während des Erstellens der Setup-Dateien wird ein schier unendlich langes Protokoll generiert, wovon die folgende Abbildung nur den letzten Teil zeigt:

Ein Blick in das Installationsverzeichnis zeigt die angelegten Dateien. Grämen Sie sich nicht, dass hier trotz angeblich gepackter Dateien erheblich mehr Speicherplatz zusammenkommt als bei der ursprünglichen (ungepackten) EXE-Datei. Bei umfangreicheren Applikationen dürfte sich das Verhältnis wieder normalisieren. Release testen Doppelklicken Sie auf das CD-ROM-Symbol und entscheiden Sie sich für eine Testvariante:

22.32 Ein Setup für Datenbankanwendungen erstellen

1375

HINWEIS: Endgültige Klarheit darüber, ob die Installationsdateien fehlerfrei sind, erhalten Sie

erst nach Installation auf verschiedenen "sauberen" Rechnern mit möglichst unterschiedlichen Betriebssystemen. Release verteilen Hier können Sie die erstellten Setup-Dateien von der Festplatte auf einen bestimmten Datenträger (CD-ROM) kopieren. Allerdings können Sie sich das auch sparen, denn das Brennen/Kopieren auf CD/Diskette und die anschließende Installation auf dem Zielrechner lässt sich "per Hand" doch viel praxisnäher erledigen, oder?

Schlussbemerkungen ■ Je nach Umfang der Datenbank können ein paar MByte mehr zusammenkommen als für "normale" Applikationen üblich. Bei den Autoren waren es für das vorliegende Beispiel "lediglich" 14 MByte (davon ca. 9 MB für die BDE). ■ Die Setup-Dateien für dieses Beispiel sind auf der Buch-CD enthalten, so dass Sie eine probeweise Installation/Deinstallation auf Ihrem PC vornehmen können. ■ Laden Sie sich die Datei EntfernungsDB.ism von der Buch-CD nach InstallShield Express und informieren Sie sich im Detail über alle vorgenommenen Einstellungen!

23

How-to: ADO/SQL

Kapitel

23

How-to: ADO/SQL 23.1 Mit ADO auf Access-Datenbanken zugreifen Die ADO-Komponenten gestatten einen bequemen Zugriff auf beliebige Datenbanken, sofern dafür ein entsprechender OLE DB-Treiber zur Verfügung steht. Für das Setzen der Verbindungszeichenfolge (ConnectionString-Eigenschaft) gibt es zwei Alternativen: ■ Zuweisen zur Entwurfszeit ■ Zuweisen zur Laufzeit Die erste Variante hat den Vorteil, dass man ohne eine einzige Zeile Quellcode zu einer funktionierenden Applikation kommt, die man bereits zur Entwurfszeit testen kann. Problematisch wird es allerdings, wenn man sein Programm an Dritte weitergeben möchte, denn dann stimmt im Allgemeinen der Datenbankpfad nicht mehr. Das Modifizieren einer UDL-Datenverknüpfungsdatei wäre ein gangbarer Ausweg, ist allerdings für den Anwender meist mit zusätzlicher Arbeit verbunden und kann deshalb lästig werden. Als Alternative empfiehlt sich deshalb die zweite Variante, das Hinzufügen einer Laufzeitanbindung. Interessant sind dafür folgende Möglichkeiten: ■ Verwendung einer OpenDialog-Komponente ■ Verlagern der Datenbank in den aktuellen Pfad Die letztgenannte Möglichkeit, die wir hier demonstrieren wollen, ist die einfachste und empfiehlt sich besonders bei kleineren Datenbanken. In unserem Beispiel verwenden wir die Datenbank PERSONAL.MDB, die vorher in das Anwendungsverzeichnis zu kopieren ist.

Oberfläche Auf das Startformular platzieren Sie eine ADOTable-, ein DataSource- und eine DBGrid-Komponente. Setzen Sie die DataSet-Eigenschaft von DataSource1 auf ADOTable1 und die DataSourceEigenschaft von DBGrid1 auf DataSource1.

1378

Kapitel 23

How-to: ADO/SQL

Anbinden zur Entwurfszeit Für die Verbindung zur Datenquelle ist die ConnectionString-Eigenschaft der ADO-Komponente verantwortlich. Beim Erstellen dieses Strings, der "lang wie ein Bandwurm" ist, hilft uns ein Assistent. Der Aufruf erfolgt, indem Sie auf im Objektinspektor klicken.

!

!

!

Nachdem der ConnectionString zugewiesen ist, wählen Sie noch als TableName-Eigenschaft den Namen der Tabelle "Personen" und setzen die Active-Eigenschaft auf True. Bereits jetzt müsste das DBGrid mit Datensätzen gefüllt sein.

23.1 Mit ADO auf Access-Datenbanken zugreifen

1379

Anbinden zur Laufzeit Ergänzen Sie den folgenden Event-Handler: procedure TForm1.FormCreate(Sender: TObject); var verz: string; begin verz := ExtractFilePath(ParamStr(0)); // Ermitteln des aktuellen Pfades with ADOTable1 do begin try ConnectionString := 'Provider=Microsoft.Jet.OLEDB.4.0;Data Source=' + verz + 'Personal.mdb;Mode=Read|Write|Share Deny None;Persist Security Info=False'; TableName := 'Personen'; Active := True except Beep; ShowMessage('Die Datenbank PERSONAL.MDB befindet sich nicht ' + #10#13 + 'im aktuellen Verzeichnis ' + verz) end end end;

Die ConnectionString-Eigenschaft erhalten Sie am einfachsten, wenn Sie zunächst, wie oben beschrieben, eine Verbindung zur Entwurfszeit herstellen. Kopieren Sie dann den ConnectionString einfach aus dem Objektinspektor heraus und fügen ihn in den Quelltext ein. Anschließend nehmen Sie die entsprechenden Modifikationen vor (Herausschneiden des absoluten Pfades und Ersetzen durch die verz-Stringvariable).

Test

Bemerkungen ■ Die Laufzeitanbindung sollten Sie erst dann hinzufügen, wenn die Anwendung endgültig fertig ist, denn Sie erhalten sonst keinerlei Unterstützung zur Entwurfszeit! ■ Durch Auswahl eines anderen OLE DB-Treibers (Microsoft OLE DB Provider for ODBC Drivers) erhalten Sie z.B. auch Zugriff auf das hauseigene Paradox-Datenbankformat.

1380

Kapitel 23

How-to: ADO/SQL

23.2 Mit ADO auf Microsoft SQL Server zugreifen Da ADO eine einheitliche Datenzugriffstechnologie darstellt, unterscheidet sich auch der Zugriff auf den Microsoft SQL Server vom Prinzip her nicht vom Vorgängerrezept. Ziel ist das Herstellen einer Verbindung zur NORTHWIND-Beispieldatenbank des SQL Servers, wobei wir diesmal (nur um verschiedene Möglichkeiten zu demonstrieren!) anstatt der ADOTableeine ADOQuery-Komponente verwenden wollen.

Oberfläche Platzieren Sie eine ADOQuery-, eine DataSource- und eine DBGrid-Komponente auf das Startformular. Weiterhin benötigen Sie ein Editierfeld und zwei Buttons.

Auch in diesem Rezept beginnen wir mit dem Zuweisen der ConnectionString-Eigenschaft von ADOQuery1. Nachdem Sie die Option "Verbindungs-String verwenden" gewählt und auf "Erstellen" geklickt haben, öffnet sich der bereits bekannte mehrblättrige Dialog, bei dem Sie auf der "Provider"-Seite zunächst den Eintrag Microsoft OLE DB Provider for SQL Server selektieren. Die erforderlichen Einträge auf der Seite "Verbindung" zeigt die Abbildung:

23.2 Mit ADO auf Microsoft SQL Server zugreifen

1381

Testen Sie nun die Verbindung. Natürlich sollte der SQL Server vorher gestartet worden sein! Anschließend widmen wir uns der SQL-Eigenschaft und tragen eine sinnvolle Abfrage ein:

Die übrigen Komponenten werden wie gewohnt angebunden (DataSource1: DataSet = ADOQuery1; DBGrid1: DataSource = DataSource1). Wenn Sie jetzt die Active-Eigenschaft von ADOQuery1 auf True setzen, müssten bereits Datensätze angezeigt werden.

1382

Kapitel 23

How-to: ADO/SQL

Test 1 Starten Sie das Programm und spielen Sie ein wenig damit herum (die Eingabe des Servernamens im Editierfeld hat noch keine Bedeutung).

Laufzeitanbindung Um zur Laufzeit den Namen des SQL Servers wahlfrei eingeben zu können, ist folgender EventHandler für den "Verbinden"-Button zu ergänzen: procedure TForm1.Button1Click(Sender: TObject); // Verbinden var verz: string; begin verz := ExtractFilePath(ParamStr(0)); with ADOQuery1 do begin Active := False; ConnectionString := 'Provider=SQLOLEDB.1;' + 'Integrated Security=SSPI;Persist Security Info=False;' + 'Initial Catalog=Northwind;Data Source=' + Edit1.Text; Active := True end end;

HINWEIS: Kopieren Sie den ConnectionString aus dem Objektinspektor in den Quelltext und

passen Sie ihn entsprechend an!

Test 2 Setzen Sie die Active-Eigenschaft von ADOQuery1 auf False und starten Sie das Programm. Tragen Sie den Namen Ihres SQL-Servers ein und stellen Sie die Verbindung her.

23.3 Eine UDL-Datei einrichten

1383

23.3 Eine UDL-Datei einrichten Unter ADO hat die BDE (Borland Database Engine) ihre Sonderrolle verloren, das Einrichten eines Datenbank-Alias hat demzufolge keine Bedeutung mehr. Gewissermaßen als Ersatz können Datenverknüpfungsdateien (.udl) eingesetzt werden, die eine anwenderseitige Anpassung der Datenquelle ermöglichen. In einer solchen UDL-Datei (Unique Data Link) werden die kompletten Informationen gespeichert, die zur Verbindungsaufnahme mit einem OLE DB-Provider erforderlich sind.

Erster Eindruck Nach Installation von Delphi dürfte die Beispiel-Data-Link-Datei DBDEMOS.udl vorhanden sein, die Sie normalerweise im Verzeichnis \\Programme\Gemeinsame Dateien\System\Ole DB\Data Links finden. Klicken Sie doppelt auf diese Datei (oder rechte Maustaste "Eigenschaften"), und Sie treffen auf ein aus den Vorgängerbeispielen bereits hinreichend bekanntes Dialogfeld:

Damit dürfte das Prinzip bereits klar sein. Andernfalls benutzen Sie den Hilfe-Button (unten rechts), um sich grundlegend zu informieren. Unser Beispiel zeigt das Einrichten der UDL-Datei für die Datenbank PERSONAL.MDB, wie sie sich mehrfach auf der Buch-CD befindet.

1384

Kapitel 23

How-to: ADO/SQL

Neue UDL-Datei erzeugen Da unter Delphi (im Unterschied zu z.B. Visual Basic) kein Tool verfügbar ist, um neue UDLDateien zu erzeugen1, machen wir von einem Trick Gebrauch: Wir kopieren die vorhandene DBDEMOS.udl in unser Anwendungsverzeichnis und benennen die Datei z.B. in Test.udl um. Dann öffnen wir diese Datei und richten die gewünschte Verbindung zum OLE DB-Provider ein (siehe Vorgängerbeispiele).

Oberfläche Zum Testen genügen eine ADOTable-, eine DataSource- und eine DBGrid-Komponente:

Für die ConnectionString-Eigenschaft von ADOTable1 genügt folgender Eintrag:

HINWEIS: Die ConnectionString-Eigenschaft heißt FILE NAME=.\Test.udl, vergessen Sie also

den Punkt vor dem Backslash nicht (.\), der das aktuelle Verzeichnis meint!

1

Wenigstens haben die Autoren auf Anhieb keines entdecken können.

23.4 Access-Tabellen aus Paradox erzeugen

1385

Setzen Sie die TableName-Eigenschaft auf Personen und Active auf True und binden Sie die übrigen Komponenten auf die gewohnte Weise an: ■ DataSource1.DataSet = ADOTable1 ■ DBGrid1.DataSource = DataSource1

Test Wenn Sie den Standort von PERSONAL.MDB verändern, genügt eine Korrektur von Test.udl, die Projekt-EXE-Datei braucht nicht neu erzeugt zu werden! HINWEIS: Ehe Sie das Beispiel von der Buch-CD laden, sollten Sie die UDL-Datei anpassen!

23.4 Access-Tabellen aus Paradox erzeugen Wollen Sie eine vorhandene Paradox-Datenbank nach Access übernehmen, so gibt es zumindest drei Möglichkeiten: ■ Wenn Sie über Microsoft Access verfügen, so benutzen Sie dessen Importfunktion (Datei| Externe Daten|Importieren...). ■ Unter Verwendung von SELECT ... INTO... ist das Exportieren einer kompletten Tabelle in nur einem Arbeitsgang möglich, siehe Ä 23.5 Paradox-Tabellen nach Access kopieren ■ Erzeugen der Tabelle mit CREATE TABLE und schrittweises Zusammenbauen Die letzte Variante ist Grundlage des vorliegenden Rezepts. Das Erzeugen mit der SQL-Anweisung CREATE TABLE ist zwar etwas umständlich, wir wollen Ihnen diese Variante trotzdem nicht vorenthalten, vor allem wegen des zu erwartenden hohen Lerneffekts. Es wird gewissermaßen eine Brücke zwischen den Paradox- und den Access-Datentypen geschlagen, wobei Sie jeden einzelnen Schritt detailliert nachvollziehen können (siehe Kapitel 3, SQL). Durch den parallelen Einsatz von BDE- und ADO-Komponenten haben Sie eine gute Vergleichsbasis zwischen den beiden Technologien, und der Umstieg zum zukunftsträchtigen ADO dürfte Ihnen wesentlich leichter fallen.

Oberfläche An Datenzugriffskomponenten brauchen Sie eine Table von der "BDE"-Seite sowie von der "ADO"-Seite je eine ADOConnection, eine ADOTable und eine ADO-Command-Komponente. Die anderen einfachen Oberflächenelemente können Sie leicht der folgenden Abbildung entnehmen. Binden Sie im Objektinspektor die Connection-Eigenschaft von ADOTable und ADOCommand an die ADOConnection, alles Weitere wird zur Laufzeit erledigt.

1386

Kapitel 23

How-to: ADO/SQL

Quelltext Beim Öffnen des Formulars muss die Verbindung zu beiden FIRMA-Beispieldatenbanken hergestellt werden. Aus Gründen der Einfachheit befinden sich diese in den Unterverzeichnissen \ParadoxDB und \AccessDB. HINWEIS: Die leere Ziel-Datenbank Firma.mdb muss vorher angelegt werden (Tabellen sind

nicht erforderlich!). procedure TForm1.FormCreate(Sender: TObject); begin Table1.DatabaseName := '.\ParadoxDB'; Session.GetTableNames(Table1.DatabaseName,'*.db',False, False, ComboBox1.Items); ADOConnection1.ConnectionString := 'Provider=Microsoft.Jet.OLEDB.4.0;Data Source=' + ExtractFilePath(ParamStr(0)) + '\AccessDB\Firma.mdb;Persist Security Info=False' end;

Bereits jetzt sollten Sie einen ersten Test durchführen. Nach Programmstart müssen alle in der Paradox-Datenbank enthaltenen Tabellen in der ComboBox aufgelistet werden. Um einen brauchbaren CREATE TABLE-Befehl zusammenzusetzen, bedarf es einiges an Knowhow über die DDL-Syntax sowie die benötigten Datentypen: procedure TForm1.Button1Click(Sender: TObject); var i:Integer; s:string;

Die folgende Hilfsfunktion ermittelt den kompatiblen Access-Datentyp auf Grundlage des übergebenen TFieldDef-Objekts: function getAccessType(fd: TFieldDef): string; var ft: TFieldType; begin ft := fd.DataType; case ft of

23.4 Access-Tabellen aus Paradox erzeugen

1387

ftAutoInc: Result := 'COUNTER'; // evtl. INTEGER zuweisen (siehe Bem.) ftString: Result:='TEXT('+IntToStr(fd.Size)+')'; ftSmallint: Result:='SMALLINT'; ftInteger: Result:='INTEGER'; ftWord: Result:='WORD'; ftBoolean: Result:='YESNO'; ftFloat : Result:='FLOAT'; ftCurrency: Result := 'CURRENCY'; ftDate, ftTime, ftDateTime: Result := 'DATETIME'; ftBlob, ftGraphic: Result := 'LONGBINARY'; ftMemo, ftFmtMemo: Result := 'MEMO' else Result:='MEMO' end end;

Im Hauptteil der Prozedur wird die CREATE TABLE-Anweisung mühselig zusammengestückelt und im Memo-Feld abgelegt: begin Table1.TableName:=ComboBox1.Text; Table1.FieldDefs.Update; s:='CREATE TABLE ' + Table1.TableName + ' ('; with Table1.FieldDefs do begin for i:=0 to Count-1 do begin s:=s + ' ' + Items[i].Name; s:=s + ' ' + getAccessType(Items[i]); s:=s + ',' end; s[Length(s)]:=')' end; Memo1.Clear; Memo1.Lines.Add (s) end;

Auch hier lohnt sich ein Zwischentest. Überprüfen Sie, ob im Memofeld eine sinnvolle, d.h. der DDL-Syntax entsprechende, SQL-Anweisung angezeigt wird (Zeilenumbrüche haben keine Bedeutung). Nachdem die SQL-Anweisung fertig ist, kann endlich die (noch leere) Access-Tabelle erzeugt werden: procedure TForm1.Button2Click(Sender: TObject); begin

Eine eventuell vorhandene gleichnamige Tabelle ist zu löschen: try ADOCommand1.CommandText:='DROP TABLE ' + ComboBox1.Text; ADOCommand1.Execute except end;

1388

Kapitel 23

How-to: ADO/SQL

Jetzt geht's zur Sache: ADOCommand1.CommandText:=Memo1.Text; ADOCommand1.Execute end;

Schließlich das Kopieren der Daten in die leere Tabelle: procedure TForm1.Button3Click(Sender: TObject); // Daten kopieren var i: Integer; begin Table1.Open; ADOTable1.TableName:=ComboBox1.Text; ADOTable1.Open; try while not Table1.EOF do begin ADOTable1.Insert; // Einfügemodus for i:=0 to Table1.Fields.Count-1 do

Leider klappt das Überschreiben des Feldinhalts nicht bei einem Zählerfeld, deshalb muss dieser Fall ausgeschlossen werden: if not (Table1.FieldDefs.Items[i].DataType = ftAutoInc) then ADOTable1.FieldByName(Table1.FieldDefs[i].Name).Value := Table1.Fields[i].Value ADOTable1.Post; // ab in die Datenbank Table1.Next end; finally Table1.Close; ADOTable1.Close end end;

Test Kopieren Sie nacheinander alle Tabellen. Wichtig ist, dass Sie dabei die logische Reihenfolge einhalten (also z.B. nicht schon Daten kopieren wollen, bevor die leere Access-Tabelle erzeugt ist).

23.4 Access-Tabellen aus Paradox erzeugen

1389

Vom Erfolg der Kopieroperationen können Sie sich am leichtesten überzeugen, wenn Sie Firma.mdb mit Microsoft Access öffnen:

HINWEIS: Nutzen Sie auch weitere Experimentiermöglichkeiten, indem Sie im Memo-Feld zu-

sätzliche Änderungen an der SQL-Anweisung vornehmen.

Bemerkungen ■ Es ist nahe liegend, dass auf ähnliche Art und Weise auch Indizes kopiert werden können (CREATE INDEX ..., siehe unser Buch "Borland Delphi – Datenbankprogrammierung", welches sich mit auf der Buch-CD befindet). ■ Vielleicht haben Sie den Hauptnachteil des Verfahrens bereits bemerkt: Die Werte der Primärschlüsselfelder können leider nicht kopiert werden. Wenn Sie es dennoch versuchen, erscheint eine Fehlermeldung. Alle Autowerte werden demnach von Access selbst vergeben, was zur Folge hat, dass die Verknüpfungen zwischen den Tabellen fehlerhaft sind. Ein Ausweg wäre es, wenn Sie innerhalb von CREATE TABLE den COUNTER-Datentyp durch INTEGER ersetzen, wobei allerdings noch weitere "Nacharbeiten" erforderlich sind. ■ Eine weitere Variante zeigt das folgende Rezept.

1390

Kapitel 23

How-to: ADO/SQL

23.5 Paradox-Tabellen nach Access kopieren Dank ADO bietet Delphi hervorragende Zugriffsmöglichkeiten auf Access-Datenbanken. In diesem Rezept wollen wir zeigen, wie Sie Ihre vorhandenen Paradox-Datenbestände komplett nach Access übertragen können, ohne dass Sie über das Programm Microsoft Access verfügen1. Gleichzeitig dürfte dies eine eindrucksvolle Demonstration für die Leistungsfähigkeit von SQL-Befehlen sein (SELECT ... INTO ...). BEISPIEL: Die Paradox 7-Tabelle Kunden wird von einer Access-Datenbank importiert (achten Sie auf das

Semikolon am Ende des sql-String!). sql := 'SELECT * INTO Kunden FROM Kunden IN "C:\Beispiele" "Paradox 7.x;" '; ADOCommand1.CommandText := sql; ADOCommand1.Execute;

Oberfläche Platzieren Sie links und rechts zwei einfache ListBox-Komponenten. Weiterhin benötigen wir von der "ADO"-Seite der Palette eine ADOConnection- und eine ADOCommand-Komponente. Ein OpenDialog ("Dialoge"-Seite) und ein paar Buttons vervollständigen die Oberfläche.

Verbinden Sie die Connection-Eigenschaft von ADOCommand1 mit ADOConnection1.

Quellcode Der implementation-Abschnitt von Unit1 beginnt mit der Deklaration mehrerer Hilfsvariablen: var verzPrx, // Verzeichnis der Paradox-Tabellen pfadAcc, // Pfad der Access-Datenbank tblName: string; // Name der Tabelle

Paradox-DB öffnen:

1

Access verfügt bekanntlich über eine Vielzahl von Importmöglichkeiten.

23.5 Paradox-Tabellen nach Access kopieren

1391

procedure TForm1.Button1Click(Sender: TObject); begin with OpenDialog1 do begin Title := 'Wählen Sie die Paradox-Datenbank aus !'; Filter := 'Paradox (*.db)|*.db'; if Execute then

Der Standort einer Paradox-Datenbank wird durch einen Verzeichnisnamen definiert, die FileName-Eigenschaft des OpenDialog liefert aber eine komplette Pfadangabe. Um die FileNameEigenschaft auf den Verzeichnisnamen zu kürzen, muss der Dateinamen abgeschnitten werden: verzPrx := ExtractFilePath(FileName);

Die Auflistung aller vorhandenen Paradox-Tabellen in der linken Listbox wird mittels GetTablesNames-Methode des standardmäßig vorhandenen Session-Objekts realisiert (man hätte stattdessen auch eine Session-Komponente von der "BDE"-Seite nehmen können): Session.GetTableNames(verzPrx,'*.db',False, False, ListBox1.Items) end end;

Das Öffnen der Access-Datenbank geschieht (fast) auf analoge Weise. Da aber hier eine Datei (*.mdb) und kein Verzeichnis vorliegt, kann auf ExtractFilePath verzichtet werden: procedure TForm1.Button2Click(Sender: TObject); begin with OpenDialog1 do begin Title := 'Wählen Sie die Access-Datenbank aus!'; Filter := 'Access-Datenbank (*.mdb)|*.mdb'; if Execute then begin pfadAcc := FileName; ADOConnection1.ConnectionString := 'Provider=Microsoft.Jet.OLEDB.4.0;Data Source=' + pfadAcc + ';Persist Security Info=False' end end;

Die GetTablesNames-Methode der ADOConnection liefert die vorhandenen Access-Tabellen zwecks Anzeige: ADOConnection1.GetTableNames(ListBox2.Items) end;

Eine bestimmte Paradox-Tabelle wird aus ListBox1 ausgewählt: procedure TForm1.ListBox1Click(Sender: TObject); begin tblName := ListBox1.Items[ListBox1.ItemIndex] end;

Nun kann mit Hilfe von SELECT ... INTO ein Importversuch starten. Vorher muss allerdings der SQL-String "zusammengestückelt" werden: procedure TForm1.Button3Click(Sender: TObject); var sql : string;

1392

Kapitel 23

How-to: ADO/SQL

begin sql := 'SELECT * INTO ' + tblName + ' FROM ' + tblName + ' IN ' + '"' + verzPrx + '" "Paradox 7.x;"'; // evtl. anpassen! try ADOCommand1.CommandText := sql; ADOCommand1.Execute // neue Tabelle importieren

Falls bereits eine gleichnamige Tabelle in der Access-Datenbank vorhanden ist, wird ein Fehler ausgelöst und die alte Tabelle gelöscht: except ADOCommand1.CommandText :=' DROP TABLE ' + tblName; ADOCommand1.Execute; // Tabelle löschen ADOCommand1.CommandText := sql; ADOCommand1.Execute // neue Tabelle importieren end end;

Test Bevor es losgehen kann, muss zunächst eine Access-Zieldatenbank vorhanden sein (kann auch leer sein!). Gehen Sie nun in logischer Reihenfolge vor: ■ Öffnen Sie die Paradox-Datenbank mit einer beliebigen Datei. Die linke Listbox wird Ihnen nun alle Tabellen anzeigen. ■ Öffnen Sie nun die Access-Datenbank. In der rechten Listbox werden Ihnen die bereits vorhandenen Tabellen angezeigt. ■ Selektieren Sie in der linken Listbox die zu kopierende Paradox-Tabelle und klicken Sie den Button "3. Tabelle kopieren =>".

23.6 Mit Shape-Befehlen arbeiten

1393

Bemerkungen ■ Unser Beispiel bezieht sich auf das aktuelle Paradox 7. Bei älteren Paradox-Formaten kann es zu folgender Fehlermeldung kommen:

Hier sollten Sie die Datenbank in ein näher an der Root liegendes Verzeichnis verschieben. ■ Auch Meldungen wie "Tabelle ist nicht vorhanden" oder "Unerwarteter Fehler vom externen Datenbanktreiber (12036)" können nerven. Sie sollten in einem solchen Fall den SELECT… INTO-Befehl auf das ältere Paradox-Format anpassen, z.B. auf "Paradox .x;". ■ Um das Beispiel überschaubar zu halten, wurde auf das Kopieren der Indizes verzichtet. ■ Ein weitere, allerdings umständlichere Möglichkeit (CREATE TABLE...) zeigt das Rezept Ä 23.1 Access-Tabellen aus Paradox erzeugen

23.6 Mit Shape-Befehlen arbeiten Eine Möglichkeit zum Verarbeiten hierarchischer Recordset-Strukturen bietet sich unter ADO mit den SHAPE-Befehlen, die man gewissermaßen als spezifische SQL-Erweiterung verstehen kann. In unserem Beispiel wollen wir eine Master-Detail-Beziehung zwischen den Tabellen "Raeume" und "Personen" der Access-Datenbank PERSONAL.MDB herstellen. Ziel ist es, beim Bewegen durch die Tabelle "Raeume" jeweils die im entsprechenden Raum sitzenden Personen aus der Tabelle "Personal" anzuzeigen.

Oberfläche Platzieren Sie auf dem Startformular die Komponenten entsprechend der nachfolgenden Abbildung. Unser Augenmerk gilt der ADOConnection (links) und den beiden ADODataSet-Komponenten mit jeweils "nachgeschalteter" DataSource. Die DBText-, die DBEdit- und die DBNavigatorKomponente verbinden Sie mit DataSource1, das DBGrid mit DataSource2.

1394

Kapitel 23

How-to: ADO/SQL

Eigenschaften zuweisen Wir beginnen mit dem Einstellen der ConnectionString-Eigenschaft von ADOConnection1. Dazu ist im Objektinspektor der folgende "Bandwurm" einzugeben (passen Sie den Pfad der Datenquelle entsprechend an): Provider=MSDataShape.1;Persist Security Info=True;Data Source=C:\Beispiele\Personal.mdb; Data Provider= Microsoft. Jet.OLEDB.4.0

HINWEIS: Wie Sie sehen, ist hier zwischen Provider und DataProvider zu unterscheiden!

Da sich die Datenbank im Anwendungsverzeichnis befindet, können Sie den sehr langen Pfadnamen einfach aus dem ConnectionString herauslöschen, so dass DataSource nur noch auf den Dateinamen Personal.mdb verweist (siehe Abbildung). Das erspart Ihnen dann auch Ärger, wenn das Programm auf einem anderen Rechner laufen soll.

Stellen Sie noch die Eigenschaften LoginPrompt auf False und Provider auf MSDataShape. Nun wenden wir uns dem ADODataSet1 zu. Dreh- und Angelpunkt ist die CommandText-Eigenschaft, die wir als SHAPE-SQL-Befehl im Anweisungseditor schreiben:

23.6 Mit Shape-Befehlen arbeiten

1395

SHAPE {SELECT * FROM Raeume} APPEND ({SELECT * FROM Personen} AS Personen RELATE Nr TO RaumNr)

HINWEIS: Achten Sie auf die unterschiedlichen runden und geschweiften Klammern im

SHAPE-Befehl! Jetzt erst sollten Sie für ADODataSet1 die Connection-Eigenschaft (nicht ConnectionString!) auf ADOConnection1 setzen. Klicken Sie nun doppelt auf ADODataSet1, und es öffnet sich der Feldeditor. Im Kontextmenü (rechte Maustaste) wählen Sie "Alle Felder hinzufügen ...". Wiederholen Sie das Gleiche mit ADODataSet2. Voher haben Sie dessen CommandText-Eigenschaft auf SELECT * FROM Personen

gesetzt und die Connection-Eigenschaft zugewiesen. Die Abbildung zeigt die hinzugefügten so genannten persistenten Feldobjekte und die zugrunde liegende Verknüpfung zwischen Master- und Detailtabelle:

!

Bemerkenswert an ADODataSet1, das die Tabelle "Raeume" umfasst, ist das Auftauchen des Feldobjekts Personen als Folge der APPEND-Klausel des SHAPE-Befehls. Der von Delphi automatisch vergebene Bezeichner für dieses Objekt heißt ADODataSet1Personen (siehe Typdeklaration von TForm1). Setzen Sie nun die DataSetField-Eigenschaft von ADODataSet2 auf diesen Wert, um die Detailtabelle mit der Mastertabelle zu verbinden:

1396

Kapitel 23

How-to: ADO/SQL

Sind alle Einstellungen richtig und Sie haben die Active-Eigenschaft der beiden ADODataSetKomponenten auf True gesetzt, so sehen Sie bereits zur Entwurfszeit Datensätze (siehe Entwurfsansicht zu Beginn).

Quellcode Ja, wir haben tatsächlich nichts vergessen, Sie brauchen keine einzige Zeile zu schreiben!

Test Nach dem Programmstart können Sie sich durch die Mastertabelle bewegen. Im Datengitter werden entsprechend mehr oder weniger Personen angezeigt. HINWEIS: Sie können sogar neue Personen hinzufügen, müssen dann allerdings links einen

gültigen Raum eintragen.

HINWEIS: Falls nur leere Felder angezeigt werden, überprüfen Sie, ob die Active-Eigenschaft

beider ADODataSet-Komponenten noch True ist, denn beim Herumdoktern an den Eigenschaften wird Active immer wieder automatisch auf False gesetzt.

23.7 Das TabControl unter ADO einsetzen

1397

23.7 Das TabControl unter ADO einsetzen Das TabControl (Seite "Win32" der Komponentenpalette) besteht aus einer Vielzahl sich überlappender und im Aufbau identischer Seiten in der Art eines "Karteikastens". Was liegt also näher als die Idee, diesen Karteikasten einmal in Verbindung mit einer Datenbank zu testen? Wir wollen dazu unsere Personal.mdb ein weiteres Mal strapazieren. Da es sich hier um eine Access-Datenbank handelt, bietet sich der Zugriff über die ADO-Technologie geradezu an.

Oberfläche Den Grundaufbau der Oberfläche entnehmen Sie bitte folgender Abbildung:

Da sich die Datenbank im Anwendungsverzeichnis befindet, können Sie den sehr langen Pfadnamen einfach aus dem ConnectionString herauslöschen, so dass DataSource nur noch auf den Dateinamen Personal.mdb verweist (siehe Abbildung). Das erspart Ihnen dann auch Ärger, wenn das Programm auf einem anderen Rechner laufen soll.

1398

Kapitel 23

How-to: ADO/SQL

Weisen Sie der SQl-Eigenschaft der Query-Komponente den folgenden Wert zu: SELECT * FROM Personen ORDER BY Nachname

Verbinden Sie die DataSet-Eigenschaft von DataSource1 mit ADOQuery1. Da auch der Einsatz eines berechneten Feldes (hier werden die beiden Felder Vorname und Nachname zu VollerName addiert) demonstriert werden soll, müssen Sie noch persistente Felder hinzufügen (Doppelklick auf ADOQuery1 und in das Fensterchen des kleinen Feldeditors gehen, dort Kontextmenü rechte Maustaste "Alle Felder hinzufügen" und "Neues Feld"):

Schließlich sieht das Fensterchen, das die persistenten Feldobjekte anzeigt, so aus:

HINWEIS: Vergessen Sie nicht, die DataSource- und DataField-Eigenschaften der DBEdit- und

DBText-Komponenten entsprechend zu setzen und schließlich die Active-Property von ADOuery1 auf True zu ändern.

1399

23.7 Das TabControl unter ADO einsetzen

Quellcode Auch diesmal wollen wir nur den Quelltext des implementation-Abschnitts von Unit1 zeigen, obwohl ein Blick in den interface-Abschnitt (persistente Datenbank-Feldobjekte!) durchaus weitere Einblicke verschafft (siehe Buch-CD). Beim Laden des Formulars wird unser Karteikasten zusammengebastelt: procedure TForm1.FormCreate(Sender: TObject); begin TabControl1.Align := alClient; TabControl1.TabHeight := 30; with ADOQuery1 do begin Open; while not EOF do begin

Ein Karteiblatt für jede Person: TabControl1.Tabs.Add(FieldByName('Nachname').AsString); Next end; First // zurück zur ersten Karte end end;

// Verbindung zur Query!

Beim Durchblättern der Karteikarten sollte eine Sicherheitskontrolle durchgeführt werden: procedure TForm1.TabControl1Change(Sender: TObject); begin with TabControl1 do begin if TabIndex <> -1 then if not ADOQuery1.Locate('Nachname', Tabs[TabIndex], []) then ShowMessage(Tabs[TabIndex -1] + ' nicht gefunden.') end end;

Das Feld VollerName wird im CalcField-Event von Query1 auf Basis des übergebenen DataSetParameters berechnet: procedure TForm1.ADOQuery1CalcFields(DataSet: TDataSet); begin DataSet['VollerName'] := DataSet['Nachname'] + ', ' + DataSet['Vorname'] end; end.

1400

Kapitel 23

How-to: ADO/SQL

Test Jede Sekretärin wird angesichts des ordentlich aufgeräumten Karteikastens laute Rufe der Begeisterung ausstoßen1:

Bemerkung Um die Anzeige des Gehalts ordentlich zu formatieren, sollten Sie sich die Bemerkung zum folgenden Rezept anschauen.

23.8 Das PageControl unter ADO einsetzen Das PageControl (Seite "Win32" der Komponentenpalette) wird in der Delphi-Hilfe als Nachfolger des in die Jahre gekommenen TabbedNotebook gepriesen. Es umfasst eine Anzahl sich überlappender und im Aufbau unterschiedlicher Seiten (TabSheet-Objekte). Es eignet sich deshalb besonders für mehrblättrige Dialoge (Register), wie wir sie in vielgestaltiger Form auch in der Delphi-IDE antreffen (z.B. Projekt|Optionen...).

Oberfläche Klicken Sie mit der rechten Maustaste auf das PageControl, wählen Sie "Neue Seite" und ändern Sie die Caption-Eigenschaft in "Personen". Bestücken Sie die Seite entsprechend nachfolgender Abbildung mit datengebundenen Steuerelementen. Beim DBNavigator lassen Sie nur die vier Bewegungsschaltflächen übrig (Eigenschaft VisibleButtons). Das Anbinden der ADOQuery1 (Zuweisen der ConnectionString-Eigenschaft etc.) an die

1

... oder aber in tiefe Depressionen verfallen.

23.8 Das PageControl unter ADO einsetzen

1401

Datenbank Personal.mdb wird hier als bekannt vorausgesetzt, da es bereits vielfach beschrieben ist, siehe z.B. das vorhergehende Rezept. Das Gleiche gilt für das Zuweisen der Eigenschaften von DataSource1 sowie das Anbinden der übrigen DataControls.

Setzen Sie die SQL-Eigenschaft von ADOQuery1 auf den Startwert SELECT * FROM Personen

Fügen Sie mittels rechter Maustaste eine zweite Seite hinzu (TabSheet2) und schaffen Sie die Voraussetzungen für einen einfachen Suchdialog:

Die auf der zweiten Seite oben rechts sichtbaren DataControls stammen von der ersten Seite (sie "scheinen" gewissermaßen durch).

1402

Kapitel 23

How-to: ADO/SQL

Quellcode Beim Start muss die Abfrage mittels Open-Methode geöffnet werden: procedure TForm1.FormCreate(Sender: TObject); begin ADOQuery1.Open end;

HINWEIS: Falls Sie den Aufruf der Open-Methode vergessen, werden Sie zwar zur Entwurfszeit

den ersten Datensatz sehen, zur Laufzeit bleibt die Anzeige aber leer (unabhängig von der Active-Eigenschaft von ADOQuery1). Im folgenden Event-Handler wird die Suche nach einem bestimmten Nachnamen gestartet, dazu wird die SQL-Eigenschaft in Abhängigkeit von den in Edit1 eingegebenen Anfangsbuchstaben erneut zugewiesen: procedure TForm1.Button1Click(Sender: TObject); // Suche starten begin with ADOQuery1 do begin SQL.Clear; // alte Abfrage löschen SQL.Add('SELECT * FROM Personen '); SQL.Add('WHERE Nachname LIKE '); SQL.Add('"' + Edit1.Text + '%"') // beachten Sie den Platzhalter "%" ! Open; Label5.Caption := IntToStr(RecordCount) + ' Personen gefunden!' end end;

Test Beim Start wird der gesamte Personalbestand selektiert (was man sich allerdings nur bei kleineren Datenbanken leisten kann). Gehen Sie jetzt zur Seite "Suchen", geben Sie die ersten Buchstaben einer Person ein und starten Sie die Suche:

Wechseln Sie anschließend wieder zur ersten Seite, so können Sie die gefundenen Personen näher unter die Lupe nehmen.

1403

23.9 Diagramme mit DBChart und ADO anzeigen

Bemerkung Damit das Gehalt ordentlich formatiert in Euro erscheint, müssen persistente Feldobjekte zur ADOQuery hinzugefügt (Doppelklick auf Komponente) und im Objektinspektor dem Feld ADOQuery1Gehalt die Eigenschaft DisplayFormat = #,##0.00 € zugewiesen werden.

23.9 Diagramme mit DBChart und ADO anzeigen Das vorliegende Rezept soll demonstrieren, wie man Ergebnisse von SQL-Abfragen mit der DBChart-Komponente grafisch auswerten kann, wobei der Zugriff mittels moderner ADO-Technologie erfolgt. Dabei wird auch auf einen ernsthaften Fehler (Bug) von DBChart hingewiesen und eine Möglichkeit gezeigt, wie man den Bug austricksen kann. Datenbasis ist die Access-Datenbank Firma.mdb.

Oberfläche Auf einem Formular platzieren Sie die in der folgenden Tabelle aufgelisteten Komponenten und stellen im Objektinspektor die entsprechenden Eigenschaften ein. Name

ADOQuery1

Icon

Komponenten- Eigenpalette schaft

ADO

Im Objektinspektor einzustellender Wert

Connection- Provider= String Microsoft.Jet.OLEDB.4.0; Data Source=Firma.mdb; Persist Security Info=False SQL

siehe Text!

DataSource1

Datenzugriff

DataSet

ADOQuery1

DBGrid1

Datensteuerung

DataSource

DataSource1

DBChart1

Datensteuerung

Die Einstellung der Eigenschaften erfolgt über Diagramm bearbeiten... im Kontextmenü der rechten Maustaste (siehe Text).

Wie Sie im Objektinspektor die ConnectionString-Eigenschaft der ADOQuery1 mit der Datenbank Firma.mdb verbinden, wird z.B. beschrieben in: Ä 23.1 Mit ADO auf Access-Datenbanken zugreifen HINWEIS: Da sich Firma.mdb im Anwendungsverzeichnis befindet, kann man im Connection-

string die Pfadangabe weglassen!

1404

Kapitel 23

How-to: ADO/SQL

SQL-Abfrage definieren Stellen Sie über den Objektinspektor die SQL-Eigenschaft für ADOQuery1 wie folgt ein: SELECT TOP 4 Kunden.Name, SUM(Rechnungen.GesamtNetto) AS TotalNetto, COUNT(Rechnungen.Nr) AS ReAnzahl FROM Kunden, Rechnungen WHERE Kunden.Nr = Rechnungen.KundenNr GROUP BY Kunden.Name ORDER BY SUM(Rechnungen.GesamtNetto) DESC

Nur dem SQL-Kundigen wird beim Anblick obigen "SQL-Ungetüms" Erleuchtung widerfahren: Die Abfrage basiert auf einer Master-Detail-Verknüpfung zwischen den Tabellen Kunden und Rechnungen und liefert ein Recordset mit vier Datensätzen, in denen die Kunden enthalten sind, die bisher für das meiste Geld eingekauft haben. Jeder Datensatz besteht aus drei Feldern: der Name des Kunden (Name), seine totale Rechnungssumme (TotalNetto) und die Anzahl seiner Rechnungen (ReAnzahl). Die Reihenfolge der Datensätze ist nach Kunden gruppiert, der Kunde mit der höchsten Summe steht am Anfang.

Persistente Felder hinzufügen Durch Doppelklick auf ADOQuery1 öffnet sich der Feldlisteneditor. Wählen Sie über das Kontextmenü der rechten Maustaste Alle Felder hinzufügen ...:

Im Ergebnis sind alle drei Felder jetzt als persistente Feldobjekte verfügbar, was verschiedene Vorteile mit sich bringt, auf die wir allerdings erst später zu sprechen kommen.

Erster Zwischentest Wenn Sie jetzt die Active-Eigenschaft von ADOQuery1 auf True setzen, müssten im DBGrid bereits zur Entwurfszeit die vier Datensätze angezeigt werden.

23.9 Diagramme mit DBChart und ADO anzeigen

1405

Da wir uns um das DBChart bis jetzt noch nicht gekümmert haben, zeigt es natürlich noch keinerlei Reaktionen, das aber wird sich im folgenden Abschnitt ändern.

DBChart programmieren Klicken Sie mit der rechten Maustaste auf die Komponente und wählen Sie Diagramm bearbeiten. Auf der "Diagramm"-Seite wählen Sie die Seite "Reihen" und klicken dann den Button "Hinzufügen" am rechten Rand. Es öffnet sich die attraktive Galerie, wo Sie sich z.B. für ein 3-D-Balkendiagramm entscheiden:

1406

Kapitel 23

How-to: ADO/SQL

Fügen Sie auf die gleiche Weise eine weitere Reihe hinzu:

Nun klicken Sie am oberen Rand auf ein weiteres Registerblatt "Reihen":

!

Die meisten Eigenschaften sind selbsterklärend, meist genügt die Übernahme der Standardeinstellungen, um zu einem brauchbaren Diagramm zu kommen. Keinesfalls ignorieren dürfen wir aber das Registerblatt "Datenquelle", wo wir die Datenmenge natürlich auf ADOQuery1 einstellen müssen. Danach ist festzulegen, welche Werte für die Balken und welche für die x-Achse denn nun angezeigt werden sollen.

1407

23.9 Diagramme mit DBChart und ADO anzeigen

Hilfe, ein Bug! In unserem Fall sollen in der ersten Reihe (Series1) das Feld TotalNetto, in der zweiten Reihe (Series2) das Feld ReAnzahl in Abhängigkeit vom Namen des Kunden angezeigt werden.

Wo bleibt Name???

Genau an dieser Stelle beginnen aber die Schwierigkeiten, wir wollen auf der x-Achse die Namen der Kunden anzeigen, wo aber ist das Feld Name? In den Rollboxen werden lediglich die Felder TotalNetto und ReAnzahl angeboten. HINWEIS: Wir haben es hier mit einem gemeinen Herstellerfehler (Bug) zu tun, denn Felder

vom Typ WideString werden im DBChart-Editor aus unerfindlichen Gründen nicht aufgelistet!

Korrektur des Fehlers zur Laufzeit Eine Fehlerkorrektur, d.h. ein Zuweisen der korrekten Eigenschaften des DBChart, ist laut Herstellerangaben erst zur Laufzeit möglich. Fügen Sie folgenden Code in das OnCreate-Event des Formulars ein. procedure TForm1.FormCreate(Sender: TObject); begin ADOQuery1.Close; DBChart1.Legend.Visible:=False;

Für die erste Reihe: with DBChart1.SeriesList.Series[0] do begin DataSource := ADOQuery1; XLabelsSource := ADOQuery1Name.FieldName; // Name-Feldobjekt YValues.ValueSource := ADOQuery1TotalNetto.FieldName; // TotalNetto-Feldobjekt CheckDataSource end;

1408

Kapitel 23

How-to: ADO/SQL

Für die zweite Reihe: with DBChart1.SeriesList.Series[1] do begin DataSource := ADOQuery1; YValues.ValueSource := ADOQuery1ReAnzahl.FieldName; CheckDataSource end; ADOQuery1.Open end;

// ReAnzahl-Feldobjekt

In ADOQuery1Name, ADOQuery1TotalNetto und ADOQuery1ReAnzahl erkennen Sie die persistenten Feldobjekte wieder, wie wir sie zu Beginn mit dem Feldlisteneditor hinzugefügt hatten.

Test Nach Programmstart dürfen Sie sich endlich an einem wunderschönen Balkendiagramm erfreuen:

Bemerkungen ■ Die optischen Möglichkeiten des DBChart sind so vielfältig1, dass man hier um eigenes Experimentieren kaum herumkommt. ■ Es bleibt zu hoffen, dass bald eine bugfreie Version des DBChart-Editors zur Verfügung steht, denn die jetzige Version ist trotz ihres beeindruckenden Funktionsumfangs für den ahnungslosen Entwickler wohl eher eine Zumutung. 1

... und die Online-Hilfe so besch...

23.10 Ein einfaches SQL-Abfrageprogramm schreiben

1409

23.10 Ein einfaches SQL-Abfrageprogramm schreiben SQL lernt man – wie jede andere Sprache auch – am besten durch das unermüdliche Ausprobieren von Beispielen. Wer schnell in die Geheimnisse von SQL eindringen will und sich dafür sein Werkzeug selbst "basteln" möchte, der ist mit diesem an Einfachheit kaum zu unterbietenden Progrämmchen bestens bedient. Der Einsteiger lernt darüber hinaus ■ wie man ein Menü anlegt, ■ einen Verzeichnisdialog aufruft und ■ die Query-Komponente programmiert.

Oberfläche Neben einem DBGrid (Seite "Datensteuerung") brauchen wir ein Memo (Seite "Standard"), eine Query (Seite "BDE") eine DataSource (Seite "Datenzugriff") und zwei Buttons.

Da wir der Einfachheit halber unsere Test-Datenbank direkt im Unterverzeichnis \FirmaDB abgespeichert haben, genügt es, wenn wir der DatabaseName-Eigenschaft von Query1 den Wert .\FirmaDB zuweisen: Verbinden Sie die Komponente DataSource1 über ihre DataSet-Eigenschaft mit Query1. Schließlich setzen Sie die DataSource-Eigenschaft der Komponente DBGrid1 auf DataSource1.

Quellcode Um die SQL-Abfrage zur Laufzeit durchzuführen, müssen die SQL- und die Active-Eigenschaft der Query-Komponente neu zugewiesen werden:

1410

Kapitel 23

How-to: ADO/SQL

procedure TForm1.Button1Click(Sender: TObject); // SQL ausführen begin Query1.SQL := Memo1.Lines; Query1.Active := True end;

Über den Menüeintrag Datenbank|Beenden verlassen Sie das Programm: procedure TForm1.Beenden1Click(Sender: TObject); begin Close end;

Test Tragen Sie in das Memo-Feld einen gültigen SQL-Befehl ein und lassen Sie sich vom Ergebnis überraschen:

Ihr kleiner "SQL-Lehrer" verhält sich nicht nur "gutmütig" gegenüber fehlerhaften SQL-Strings (kein böser Absturz!), sondern unterstützt Sie auch mit konkreten Fehlerhinweisen, z.B.:

Bemerkungen ■ Um sinnvoll mit dem Programm arbeiten zu können, sollten Sie natürlich die Datenbankstruktur kennen.

23.11 Datumsangaben in SQL-Strings einbauen

1411

■ Falls Sie mit anderen Datenbanken experimentieren wollen, dürfte es für Sie ein Leichtes sein, diese entweder in das Anwendungsverzeichnis kopieren oder aber eine OpenDialog-Komponente zum Programm hinzuzufügen. ■ Eine ausführliche Einführung in SQL sowie zahlreiche weitere Beispiele finden Sie in unserem Buch "Datenbankprogrammierung mit Borland Delphi".

23.11 Datumsangaben in SQL-Strings einbauen Wer sich gut in SQL auskennt, der kann es ja einmal mit der DATEVALUE-Anweisung versuchen. Für unsere Demo nehmen wir die Access-Beispieldatenbank Personal.mdb, die sich im Anwendungsverzeichnis befindet (siehe Buch-CD).

Oberfläche Wir brauchen ein ADODataSet (von der "ADO"-Seite der Komponentenpalette), eine DataSource (Seite "Datenzugriff"), ein DBGrid (Seite "Datensteuerung"), zwei normale Edit-Felder und zwei Buttons. Zur Anzeige des SQL-Strings dient Label3 (WordWrap=True), welches aus rein optischen Gründen links oben in ein Panel gesetzt wird.

Weisen Sie als Erstes die ConnectionString-Eigenschaft für das ADODataSet zu. Da sich die Access-Datenbank Personal.mdb im Anwendungsverzeichnis befindet, löschen wir die Pfadangabe aus dem Connection-String, so dass dieser schließlich so aussieht: Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Personal.mdb;Persist Security Info=False

Die CommandText-Eigenschaft erhält die (Default-)String-Eigenschaft: SELECT * FROM Personen ORDER BY Geburtstag

1412

Kapitel 23

How-to: ADO/SQL

Es dürfte nun für Sie ein Leichtes sein, das DBGrid über die DataSource mit der ADOConnection zu verbinden.

Quellcode procedure TForm1.Button1Click(Sender: TObject); // SQL ausführen var sql: string; begin with ADODataSet1 do begin Active := False; CommandText := 'SELECT * FROM Personen WHERE Geburtstag BETWEEN DATEVALUE("' + Edit1.Text + '") AND DATEVALUE("' + Edit2.Text + '") ORDER BY Geburtstag'; Active := True; Label3.Caption := CommandText // SQL-String anzeigen end end;

Test Die Datenbank bietet genügend Datensätze, um keine Langeweile beim Experimentieren aufkommen zu lassen.

Bemerkung Das Anzeigen des SQL-Strings ist für die Fehlersuche sehr hilfreich, insbesondere wenn, wie im vorliegenden Fall, Inhalte von Editierfeldern "eingebaut" werden müssen.

23.12 SQL-Abfrageergebnisse in einer Tabelle sichern

1413

23.12 SQL-Abfrageergebnisse in einer Tabelle sichern Haben Sie mit Hilfe einer Query, d.h. einer SQL-Abfrage, endlich die gewünschten Daten auf den Bildschirm gezaubert, ist es in vielen Fällen sinnvoll, diese in einer lokalen Tabelle abzuspeichern. Eine kleine Funktion soll Ihnen die Arbeit erleichtern.

Oberfläche Für unser kleines Testprogramm genügen eine Query, eine DataSource- und eine SaveDialogKomponente sowie einige Komponenten für die Oberflächengestaltung (Memo, DBGrid, zwei Buttons). Verbinden Sie die Query über die DatabaseName-Eigenschaft mit dem Alias "DBDemos", die SQL-Eigenschaft weisen Sie zur Laufzeit zu. Selbstverständlich muss noch die DataSourceKomponente mit der Query und mit dem DBGrid verbunden werden.

Quelltext Die Exportfunktion Query2Table erwartet als Übergabeparameter die Query (diese kann auch ungeöffnet sein) sowie den Tabellennamen und den Datenbanknamen. Über den Tabellennamen haben Sie die Möglichkeit, das Tabellenformat ("*.db" = Paradox oder "*.dbf" = dBase) zu bestimmen, der Datenbankname legt das Verzeichnis oder den Datenbank-Alias fest. Function Query2Table(Query: TQuery; sTableName, sDatabaseName: String): Boolean; var t : TTable; begin Result := False; Query.Active := True;

Dynamisches Erzeugen einer Table-Komponente: with TTable.Create(nil) do try

Zuweisen der Eigenschaften: Active TableName

:= False; := sTableName;

1414

Kapitel 23

How-to: ADO/SQL

DatabaseName := sDatabaseName; ReadOnly := False;

Export der Daten: BatchMove(Query, batCopy); Close; Result := True; finally Free end end;

HINWEIS: Alternativ können Sie mit BatchMove auch Daten an eine bestehende Tabelle anhän-

gen (batAppend), aktualisieren (batUpdate) oder auch Datensätze löschen (batDelete). Im Beispielprogramm weisen wir zunächst den im Memofeld eingegebenen String der SQL-Eigenschaft zu und öffnen dann die Query: procedure TForm1.Button2Click(Sender: TObject); begin Query1.Active := False; Query1.SQL := Memo1.Lines; Query1.Open end;

Für die Bestimmung von Name und Datenbank verwenden wir die SaveDialog-Komponente. Wir müssen den zurückgegebenen Dateinamen lediglich in Pfad- und Dateinamen zerlegen: procedure TForm1.Button1Click(Sender: TObject); begin if SaveDialog1.Execute then begin Query2Table(Query1,ExtractFilename(SaveDialog1.FileName), ExtractFilepath(SaveDialog1.FileName)) end end;

Test Nach dem Programmstart passen Sie die SQL-Abfrage an und klicken auf den "Abfrage"-Button. Das erhaltene SQL-Abfrageergebnis kann mit dem "Speichern"-Button in einer Tabelle gesichert werden.

23.13 Parameter in Abfragen verwenden

1415

23.13 Parameter in Abfragen verwenden Dass das "Zusammenbasteln" von SQL-Abfragen mit String-Operationen nicht die eleganteste Lösung ist, dürfte jeder schon festgestellt haben. Viel einfacher und vor allem schneller geht es mit Hilfe von Parametern. Diese werden von Ihnen innerhalb der SQL-Abfrage definiert, über die Params-Auflistung können Sie die Werte zuweisen. Delphi sorgt dafür, dass die Werte vor dem Verarbeiten der SQL-Anweisung entsprechend eingebettet werden. Keine Probleme mehr mit falsch gesetzten Anführungszeichen oder falschen Datentypen!

Oberfläche Erstellen Sie ein Formular entsprechend folgender Abbildung.

Die Query binden Sie über ihre DatabaseName-Eigenschaft an den Datenbank-Alias DBDEMOS.

1416

Kapitel 23

How-to: ADO/SQL

Quelltext Mit den folgenden Anweisungen erstellen wir eine Abfrage, in der die Bedingung der WHEREKlausel als Parameter (Typ Float) übergeben wird: procedure TForm1.Button1Click(Sender: TObject); begin Query1.Close; Query1.SQL.Text := 'SELECT * FROM Employee WHERE salary >= :Wert'; Query1.ParamByName('Wert').AsFloat := 30000; Query1.Open end;

Wie Sie dem folgenden Beispiel entnehmen können, ist bei der Verwendung der LIKE-Klausel die Verwendung von Anführungszeichen nicht nötig: procedure TForm1.Button2Click(Sender: TObject); begin Query1.Close; Query1.SQL.Text := 'SELECT * FROM Employee WHERE Lastname LIKE :Nachname'; Query1.ParamByName('Nachname').AsString := 'Y%'; Query1.Open end;

Alternativ können Sie auf Parameter auch per Index zugreifen, wir raten jedoch davon ab, da dies bei späteren Änderungen des Programms schnell zur Fehlerquelle werden kann: procedure TForm1.Button3Click(Sender: TObject); begin Query1.Close; Query1.SQL.Text := 'SELECT * FROM Employee WHERE Lastname LIKE :Nachname'; Query1.Params[0].AsString := 'P%'; Query1.Open end;

Test Starten Sie das Programm und testen Sie die verschiedenen Möglichkeiten aus.

23.14 Eine CheckListBox für SQL-Abfragen nutzen

1417

23.14 Eine CheckListBox für SQL-Abfragen nutzen Vielfach besteht die Notwendigkeit, Filterbedingungen der WHERE-Klausel zur Laufzeit aus verschiedenen Komponenten zusammenzustellen. Insbesondere für das Generieren von IN-Klauseln bietet sich die CheckListBox-Komponente (Palettenseite "Zusätzlich") an. BEISPIEL: Die Werte für die folgende IN-Klausel sollen aus einer CheckListBox entnommen werden: SELECT * FROM Employee WHERE EXTRACT(YEAR FROM hiredate) IN (1989,1993,1994)

Oberfläche Sie erstellen ein Formular mit folgender Oberfläche:

Das DBGrid wird mit der DataSource verbunden und diese mit der Query-Komponente, welche Sie an die Datenbank DBDEMOS anbinden. Die CheckListBox füllen Sie mittels ihrer ItemsEigenschaft wie oben dargestellt.

Quelltext Der Quellcode beschränkt sich auf den Button-Klick: procedure TForm1.CheckListBox1Click(Sender: TObject); var sqlstr, werte : string; i : Integer; begin werte := '';

Alle aktivierten Werte in der CheckListBox werden zu einem String zusammengefasst: for i := 0 to CheckListBox1.Items.Count - 1 do if CheckListBox1.Checked[i] then werte := werte + CheckListBox1.Items[i] + ',';

1418

Kapitel 23

How-to: ADO/SQL

Delete(werte, Length(werte), 1);

Die Query wird geschlossen: Query1.Close;

Der SQL-String wird neu zusammengesetzt: sqlstr := 'SELECT * FROM employee WHERE EXTRACT(YEAR FROM hiredate) IN (' + werte + ')'; Query1.SQL.Text := sqlstr;

Die Query wird geöffnet: Query1.Open end;

Test Nach dem Programmstart können Sie verschiedene Kombinationen in der CheckListBox auswählen, das DBGrid zeigt jeweils die gewünschten Datensätze an:

23.15 Access-Datenbanken über DAO abfragen In diesem Beispiel wollen wir zum einen den Zugriff auf eine Access-Tabelle, zum anderen die Verwendung von Abfragen (SQL) demonstrieren. Eigentlich kein Problem, könnte man denken, wird doch ein entsprechender Access-Treiber mitgeliefert. Allerdings werden Sie doch nicht extra die BDE installieren wollen, nur um auf eine Access-Datenbank zuzugreifen, denn mit den DAO (den Vorgängern von ADO) haben Sie bereits eine vollwertige Datenbank-Engine zur Verfügung.

Oberfläche Entwerfen Sie eine Oberfläche mit folgendem grundsätzlichen Aufbau:

23.15 Access-Datenbanken über DAO abfragen

1419

Beim Datengitter handelt es sich lediglich um ein StringGrid, das wir zur Laufzeit füllen werden. Der SQL-Text (Memo) kann zur Laufzeit verändert werden.

Quelltext Die folgende Unit ist aus Platzgründen nur auszugsweise abgedruckt, das vollständige Listing finden Sie auf der CD: unit DAO; interface Type DAOWorkspace = Variant; DAORecordset = Variant; DAODatabase = Variant; DAODBEngine = Variant; Var DBEngine : Variant; const { RecordsetTypeEnum } dbOpenTable = 1; dbOpenDynaset = 2; dbOpenSnapshot = 4; dbOpenForwardOnly = 8; dbOpenDynamic = 16;

1420

Kapitel 23

How-to: ADO/SQL

... implementation uses Activex,ComObj; initialization end.

Wie Sie sehen, erzeugt die Unit automatisch ein dBEngine-Objekt, die Basis für alle weiteren Aktionen mit den DAOs. Unser eigentliches Beispiel implementiert die obige Unit, um darauf aufbauend ein WorkspaceObjekt (entspricht in etwa einer Delphi-Session), ein Database-Objekt und zwei Recordset-Objekte (entspricht Delphi Table- bzw. Query-Komponenten) zu erstellen. var ws : DAOWorkspace; db : DAODatabase; rs, rs1: DAORecordset;

Das eigentliche Erstellen der Objekte1: procedure TForm1.FormCreate(Sender: TObject); begin DBEngine := CreateOleObject('DAO.DBEngine.35'); ws := DBEngine.Workspaces[0]; db := ws.OpenDatabase('BIBLIO.MDB'); RS := DB.OpenRecordSet('Authors',dbOpenTable); RS.MoveFirst; anzeige end;

Die Anweisung OpenRecordSet('Authors',dbOpenTable) öffnet die Tabelle wie ein Table-Objekt in Delphi. Wie Sie noch sehen werden, kann mit einem ähnlichen Aufruf auch ein "Query"-Objekt erzeugt werden. An dieser Stelle sind die DAO jedoch wesentlich flexibler, ein Recordset-Objekt kann beide Typen verwalten. Wie schon erwähnt, müssen wir uns um die Anzeige selbst kümmern. procedure anzeige; begin with Form1 do begin edit1.text := rs.Fields['Au_ID'].Value; edit2.text := rs.Fields['Author'].Value; if VarIsNull(rs.Fields['Year Born'].Value) then edit3.Text := '' else edit3.Text := rs.Fields['Year Born'].Value end end;

1

Der Unterschied zu einem Access- oder VB-Programm ist minimal.

23.15 Access-Datenbanken über DAO abfragen

1421

Auch bei diesen Datenbank-Objekten besteht das Problem mit NULL-Values, vergessen Sie nicht eine entsprechende Reaktion darauf (if VarIsNull...). Den Satzzeiger bewegen: procedure TForm1.Button1Click(Sender: TObject); begin rs.MoveFirst; anzeige end; procedure TForm1.Button4Click(Sender: TObject); begin rs.MoveLast; anzeige end; procedure TForm1.Button2Click(Sender: TObject); begin rs.MovePrevious; if rs.BOF then rs.MoveFirst; anzeige end; procedure TForm1.Button3Click(Sender: TObject); begin rs.MoveNext; if rs.EOF then rs.MoveLast; anzeige end;

Einen Datensatz löschen: procedure TForm1.Button5Click(Sender: TObject); begin if not rs.Updatable then begin ShowMessage('Tabelle kann nicht editiert werden!'); Exit end; rs.Delete; rs.MoveNext; if rs.EOF then rs.MoveLast; anzeige end;

Beim Füllen der Tabelle verwenden wir eine SQL-Abfrage. HINWEIS: Hierbei handelt es sich um Access-SQL, wo statt "%" ein "*" und statt "_" ein "?" für

die Platzhalter verwendet werden. procedure TForm1.Button6Click(Sender: TObject); var i : Integer; begin rs1 := db.OpenRecordSet(memo1.text,dbOpenDynaset); rs1.movelast; // RecordCount einlesen!!!! StringGrid1.RowCount := rs1.RecordCount; progressbar1.Max :=rs1.RecordCount;

1422

Kapitel 23

How-to: ADO/SQL

i := 0; rs1.Movefirst; while not rs1.eof do with StringGrid1 do begin inc(i); progressbar1.position := i; cells[0,i] := rs1.Fields['Au_ID'].Value; cells[1,i] := rs1.Fields['Author'].Value; if VarIsNull(rs.Fields['Year Born'].Value) then cells[2,i] := '' else cells[2,i] := rs1.Fields['Year Born'].Value; rs1.MoveNext end end;

Test Nach dem Start dürften die ersten Datensätze bereits angezeigt werden. Die Abfrage können Sie beliebig verändern und neu starten.

Bemerkung ■ Wie Sie sehen, ist es gar nicht so schwer, eine Access-Datenbank aus Delphi heraus zu öffnen. Voraussetzung ist allerdings eine korrekt installierte DAO-Version. Gegebenenfalls müssen Sie in der Unit DAO beim Erstellen des Objekts DBEngine den Objekttyp anpassen. ■ Unterschätzen Sie nicht die Möglichkeiten dieser Schnittstelle. Die Delphi-Datenbankobjekte werden Sie nur vermissen, wenn es darum geht, Daten in Komponenten anzuzeigen (darum müssen Sie sich hier selbst kümmern). Ansonsten werden neben den einfachen Zugriffsmethoden auf die Tabellen (Satzzeiger bewegen, schreiben, lesen etc.) auch Abfragen (Achtung: andere SQL-Syntax), Relationen, Security-Einstellungen etc. unterstützt. (Kurz: Fast alles, was MS Access kann.) ■ Mit einer kleinen Schnittstellen-Unit ist auch die Verwendung der DAO relativ simpel, vom Einsatz einer Typbibliothek möchten wir abraten, da viele Methodenaufrufe in den DAO mit variablen Parametern realisiert sind. Weiterhin kommt es zu Überschneidungen mit den Delphi-Bezeichnern etc.

24

How-to: Drucker/Berichte

Kapitel

24

How-to: Drucker/Berichte 24.1 Einen Drucker auswählen Geht es darum, Ausgaben auf dem Drucker vorzunehmen, können Sie entweder den Standarddrucker des Systems nutzen (Default für das Printer-Objekt), oder Sie stellen dem Anwender eine Möglichkeit zur Druckerauswahl zur Verfügung. Zwei Varianten bieten sich an: ■ Standard-Dialog (PrinterSetupDialog) ■ ComboBox Das Beispiel zeigt beide Varianten.

Oberfläche Neben zwei Buttons und einer ComboBox brauchen Sie lediglich eine PrinterSetupDialog-Komponente (Seite "Dialoge" der Palette).

Quelltext Mit dem Erstellen des Formulars wird auch die ComboBox gefüllt. Vorher müssen Sie jedoch auf alle Fälle die Unit Printers einbinden, sonst haben Sie keinen Zugriff auf das Printer-Objekt. uses Printers; procedure TForm1.FormCreate(Sender: TObject);

1424

Kapitel 24

How-to: Drucker/Berichte

begin ComboBox1.Items := Printer.Printers; ComboBox1.ItemIndex := Printer.PrinterIndex end;

Da es sich bei der Eigenschaft Printers um ein TStrings-Objekt handelt, können Sie die Eigenschaft Items (ebenfalls TStrings) direkt zuweisen. Der aktuelle Drucker wird über PrinterIndex abgefragt. Umgekehrt können Sie auch PrinterIndex zuweisen und damit den aktuellen Drucker wechseln. HINWEIS: Der Druckerwechsel an dieser Stelle hat keinen Einfluss auf den Standarddrucker

des Systems. Die Auswahl eines Druckers in der ComboBox: procedure TForm1.ComboBox1Click(Sender: TObject); begin Printer.PrinterIndex:= ComboBox1.ItemIndex end;

Der Klick auf den Button "Druckersetupdialog" zaubert mit procedure TForm1.Button1Click(Sender: TObject); // Drucker-Setup-Dialog begin PrinterSetupDialog1.Execute; ComboBox1.Items.Clear; ComboBox1.Items := Printer.Printers; ComboBox1.ItemIndex := Printer.PrinterIndex end;

die bekannte Dialogbox auf den Bildschirm. Gleichzeitig wird die Anzeige in der ComboBox aktualisiert.

24.2 In Millimetern drucken

1425

Einen winzigen Probeausdruck (der Name des aktuellen Druckers) erzeugen Sie z.B. mit: procedure TForm1.Button2Click(Sender: TObject); // Testdruck begin Printer.BeginDoc; Printer.Canvas.TextOut(100,100, Printer.Printers[Printer.PrinterIndex]); Printer.EndDoc end;

Test Richten Sie Ihren Drucker ein und starten Sie einen Probeausdruck!

24.2 In Millimetern drucken Wenn Sie mehr vorhaben, als nur ein paar Pixel oder Linien auszugeben, werden Sie sich sicher schon gewundert haben, was die Maßeinheit "Pixel" auf dem Drucker verloren hat. Je nach Druckerauflösung (600 dpi, 300 dpi, 150 dpi) ist die ausgegebene Grafik riesengroß oder mikroskopisch klein. Vermutlich haben sich die Borland-Programmierer quälenden Überlegungen dieser Art nicht hingegeben. Dabei ist dem Problem mit einer Zeile Quellcode beizukommen.

Oberfläche Lediglich ein Formular und ein Button.

Quelltext Fügen Sie den folgenden Quellcode in das OnClick-Ereignis des Buttons ein. Die wesentliche Zeile ist unterstrichen. var i,l, breite,hoehe : Integer; s : string; begin

Druckauftrag beginnen Printer.BeginDoc;

1426

Kapitel 24

How-to: Drucker/Berichte

... sonst stimmt das Handle nicht! Umstellen der Druckausgabe auf 1/10 mm. Beachten Sie, dass sich der Mittelpunkt des neuen Koordinatensystems in der linken oberen Ecke befindet. Positive y-Werte sind nach oben abzutragen1! SetMapMode(Printer.Canvas.handle,MM_LOMETRIC); with Printer.Canvas do begin

Schrifthöhe in 1/10 mm festlegen (Sie können ruhig nachmessen!): font.Height:=50; font.Name := 'Arial';

Textausrichtung auf Mitte/oben festlegen: SetTextAlign(handle,TA_CENTER+TA_TOP);

Danach ist die Blattgröße in 1/10 mm zu ermitteln. Vergessen Sie in diesem Zusammenhang die Eigenschaften PageWidth und PageHeight gleich wieder, die "rechnen" immer noch in Pixeln. breite := getDevicecaps(handle,horzsize) * 10; hoehe := getDevicecaps(handle,vertsize) * 10;

Eine erste Linie auf dem Drucker ausgeben: MoveTo(0,-1); LineTo(breite,-1); i := 1;

Eine Millimeterskala ausgeben: while i <= breite do begin MoveTo(i,-1); if (i-1) mod 100 = 0 then begin LineTo(i,-50); TextOut(i,-50,IntToStr(i div 100)); end else LineTo(i,-30); inc(i,10); end;

Text in verschiedenen Größen erzeugen: s := 'Programmieren macht Spaß ...'; SetTextAlign(handle,TA_LEFT+TA_TOP); i := 2; l := 2; while i < 20 do begin font.height:= i * 10;

1

Dass Sie sich ja nicht wundern, wenn keine Grafik auf dem Papier erscheint!

24.3 Pixel- und Vektorgrafiken drucken

1427

TextOut(200,-100-l * 10, s); inc(i); inc(l,i) end end;

Nicht vergessen: Printer.EndDoc end;

Das Beispiel hätte auch kürzer ausfallen können, auf diese Weise haben Sie jedoch gleich noch ein paar Techniken für die Druckausgabe dazugelernt. HINWEIS: Soll die Ausgabe bezüglich der Blattränder positioniert werden, müssen Sie den seit-

lichen und oberen Offset in die Berechnung einbeziehen. Das vorhergehende Rezept zeigt, wie Sie mit der Funktion GetDevCaps die nötigen Informationen ermitteln.

Test Wie das Blatt schließlich aus dem Drucker herauskommt, zeigt die folgende Abbildung:

24.3 Pixel- und Vektorgrafiken drucken Möchten Sie neben Text und Linien auch fertige Grafiken drucken? Wenn ja, dann dürfte dies genau der richtige Artikel für Sie sein.

Oberfläche Platzieren Sie eine Vektor- und eine Bitmap-Grafik in Image-Komponenten auf das Formular sowie zwei Buttons.

1428

Kapitel 24

How-to: Drucker/Berichte

Quelltext Die Ausgabe der Vektorgrafik ist mit relativ wenig Aufwand erledigt, Sie brauchen lediglich die Grafik mit StretchDraw auf den Canvas des Druckers zu kopieren: procedure TForm1.Button1Click(Sender: TObject); var rect : TRect; s : string; begin Printer.BeginDoc; Screen.Cursor:=crHourglass; with Printer.Canvas do begin rect:=Bounds(0,0,Printer.PageWidth,Printer.PageHeight); StretchDraw(Rect, Image1.Picture.Metafile) end; Printer.EndDoc; Screen.cursor:=crDefault end;

Leider gestaltet sich die Druckausgabe der Bitmap etwas aufwändiger, da nicht alle Drucker die StretchDraw-Funktion korrekt unterstützen. Aus diesem Grund findet sich in den Delphi-FAQs auch ein entsprechendes Codefragment, mit dem der Druckertreiber zur Zusammenarbeit überredet werden kann. Übergabewerte sind der Ausgabe-Canvas (Drucker), das Zielrechteck und natürlich auch die Bitmap, die gedruckt werden soll: procedure printBitmap(Canvas: TCanvas; DestRect: TRect; Bitmap: TBitmap); var BitmapHeader: pBitmapInfo; BitmapImage : POINTER; HeaderSize : DWORD; ImageSize : DWORD; HBMP : THandle; begin GetDIBSizes(Bitmap.Handle, HeaderSize, ImageSize); GetMem(BitmapHeader, HeaderSize);

24.3 Pixel- und Vektorgrafiken drucken

1429

HBMP := GlobalAlloc(GHND, Imagesize); BitmapImage:=GlobalLock(hBMP); try if not GetDIB(Bitmap.Handle, Bitmap.Palette, BitmapHeader^, BitmapImage^) then begin StretchDIBits(Canvas.Handle, DestRect.Left, DestRect.Top, DestRect.Right - DestRect.Left, DestRect.Bottom - DestRect.Top, 0, 0, Bitmap.Width, Bitmap.Height, BitmapImage, TBitmapInfo(BitmapHeader^), DIB_RGB_COLORS, SRCCOPY); end finally FreeMem(BitmapHeader); GlobalUnlock(hbmp); Globalfree(hbmp) end end;

Bitmap drucken: procedure TForm1.Button2Click(Sender: TObject); var rect : TRect; s : String; begin Printer.BeginDoc; Screen.cursor:=crHourglass; s := 'Testdruck'; Printer.Canvas.textout(10,10,s); rect:=Bounds(0,0,Printer.pagewidth div 2,Printer.pageheight div 2); PrintBitmap(Printer.Canvas, rect, Image2.Picture.Bitmap); Printer.EndDoc; Screen.cursor:=crDefault end;

Test Wenn Sie bereit sind, zwei Seiten Druckerpapier zu opfern, steht einem Versuch nichts im Wege.

Bemerkung Wer große Bitmaps auf den meisten Druckern fehlerfrei zu Papier bringen will, sollte die Ausgabe einiger Euros nicht scheuen und sich mit der TExcellentImagePrinter-Komponente von Joe Hecht anfreunden. Alle anderen Versuche werden früher oder später an einem Druckertreiber oder mangelndem Arbeitsspeicher scheitern. Ä http://www.code4sale.com/joehecht/prndib.htm

1430

Kapitel 24

How-to: Drucker/Berichte

24.4 Den Inhalt eines StringGrid ausdrucken Um den Inhalt eines StringGrid schnell und unkompliziert zu Papier zu bringen, sollte man sich der Funktion AssignPrn() erinnern, mit der es möglich ist, mit WriteLn Druckerausgaben vorzunehmen (also vom Prinzip genauso wie das Schreiben in eine Textdatei). In diesem Rezept werden wir außerdem die Delphi-Funktionen Format, Rewrite und CloseFile benutzen.

Oberfläche Ein StringGrid und ein Button "Drucken" genügen.

Quellcode uses Printers;

Für unseren Test bereiten wir ein individuelles StringGrid vor, das beim Laden des Formulars angepasst wird: procedure TForm1.FormCreate(Sender: TObject); begin with StringGrid1 do begin

Spalten: ColCount := 8; ColWidths[0] := 80; // erste Spalte 80 Pixel breit Cells[0,0] := 'Zeitraum'; Cells[1,0] := 'Montag'; Cells[2,0] := 'Dienstag'; Cells[3,0] := 'Mittwoch'; Cells[4,0] := 'Donnerstag'; Cells[5,0] := 'Freitag';

Zeilen: RowCount := 4; Cells[0,1] := ' 6:00-14:00'; Cells[0,2] := '14:00-22:00'; Cells[0,3] := '22:00- 6:00'; DefaultRowHeight := 20; Options := Options + [goEditing] + [goTabs] end end;

Die maßgebliche Routine: procedure TForm1.Button1Click(Sender: TObject); var f : TextFile; s, oldFnt : string; i : Word;

// Drucken

begin Printer.PrinterIndex := -1; // Standarddrucker einstellen oldFnt := Printer.Canvas.Font.Name; // Druckerfont merken

24.4 Den Inhalt eines StringGrid ausdrucken

1431

Die Druckerschriftart sollte eine feste Breite haben, damit die Spalten exakt untereinander gedruckt werden können: Printer.Canvas.Font.Name := 'Courier New'; AssignPrn(f); // Textfile mit Drucker verbinden

Das Kapseln des kritischen Codeabschnitts in einem try-finally-Block beugt einem Systemabsturz bei fehlerhaftem Druckerzugriff vor: try Rewrite(f);

// Textfile initialisieren

Kopfzeile formatieren und drucken: with StringGrid1 do begin s := Format('%-16s %-12s %-12s %-12s %-12s %-12s', [Cells[0,0], Cells[1,0], Cells[2,0], Cells[3,0], Cells[4,0], Cells[5,0]]); Writeln(f, s);

Um die ziemlich komplexe Format-Anweisung zu verstehen, ist ein tiefer Blick in die Delphi-Hilfe unumgänglich (oder aber in unser Delphi 6-Grundlagenbuch). Zunächst genügt es zu wissen, dass ihre Argumentliste aus zwei Teilen besteht: ■ ein Formatierungsstring (dessen durch Leerzeichen separierte Bestandteile durch ein %Zeichen eingeleitet werden, danach folgt die Anzahl Zeichen, das vorgestellte Minuszeichen steht für linksbündig, das nachgestellte s für String) und ■ die Liste der zu formatierenden Werte (in eckigen Klammern). Einfacher zu verstehen ist die folgende Format-Anweisung (Trennlinie formatieren und drucken): s := Format('%-80s', ['---------------------------------------------------------']); Writeln(f, s);

Jetzt der entscheidende Vorgang, Zeilen formatieren und drucken: for i := 1 to RowCount - 1 do begin s := Format('%-16s %-12s %-12s %-12s %-12s %-12s', [Cells[0,i], Cells[1,i], Cells[2,i], Cells[3,i], Cells[4,i], Cells[5,i]]); Writeln(f, s) end end finally CloseFile(f); // Textdatei schließen Printer.Canvas.Font.Name := oldFnt // Druckerfont zurücksetzen end end;

1432

Kapitel 24

How-to: Drucker/Berichte

Test Sie kommen nicht umhin, vor dem Start des Druckers einige Einträge in das StringGrid vorzunehmen.

Auf dem Papier dürfte sich dann etwa folgender Anblick bieten: Zeitraum Montag Dienstag Mittwoch Donnerstag Freitag -----------------------------------------------------------------------------------------6:00-14:00

Müller

Meyer

Krause

Kunze

Lehmann

14:00-22:00

Meyer

Krause

Lehmann

Müller

Meyer

22:00- 6:00

Krause

Lehmann

Müller

Meyer

Krause

Bemerkungen ■ Für jede andere Zeilen-/Spaltenanzahl als in unserem Beispiel müssen Sie die Format-Anweisung für die auszudruckenden Strings entsprechend anpassen. ■ Eine andere und etwas aufwändigere Möglichkeit ergibt sich aus den Methoden (Textout...) des Canvas des Printer-Objekts (siehe unser [BD6-Grundlagenbuch]).

24.5 Eine eigene Druckvorschau programmieren Drucken ist schön und gut, aber man möchte doch bitte schön schon vorher das Ergebnis sehen (WYSIWYG) und dann entscheiden, ob gedruckt werden soll oder nicht. Wie realisieren wir eine Druckvorschau? ■ Erste Aufgabe ist die Bestimmung des Druckers sowie seiner Parameter. Die Abfrage des Printer-Objekts ist die eine Möglichkeit, zusätzlich sollte jedoch auch ein anderer Drucker ausgewählt werden können. ■ Die Druckerparameter müssen in Millimetern ermittelt werden.

24.5 Eine eigene Druckvorschau programmieren

1433

■ Entsprechend dem Ausgabeformat des Druckers wird eine TWinControl-Komponente auf dem Formular platziert und (wenn nötig) skaliert. ■ Aus dem Verhältnis physikalische Druckbreite zur dargestellten Bildfeldbreite wird eine Skalierung der Druckausgabe vorbereitet. ■ Über einen Canvas werden die Ausgaben vorgenommen.

Oberfläche Außer einer TWinControl-Komponente brauchen Sie eigentlich nichts. Diese werden Sie in der Palette allerdings vergeblich suchen, die Komponente wird erst zur Laufzeit erstellt. Warum wir uns nicht für eine Image- oder Paintbox-Komponente entschieden haben? Der Grund ist ein recht lästiges Verhalten beider Komponenten, wenn man versucht, eine Größenänderung mit nachfolgender Anzeige zu realisieren. Entweder es wird viel zu zeitig ein OnPaint ausgelöst, oder die Komponente wird nicht richtig skaliert. Nach etlichen Minuten nervtötender Programmierung haben wir uns dann für einen noch relativ einfachen und damit idealen Vorgänger der oben genannten Komponenten entschieden. In diesem Zusammenhang sehen Sie auch gleich, wie Sie einen zugehörigen DC verwalten und über ein Canvas-Objekt kapseln. Um das Programm jedoch etwas komfortabler zu gestalten, sollten Sie noch eine Werkzeugleiste (Panel), zwei BitButtons und eine PrinterSetupDialog-Komponente spendieren. Weiterhin verwenden wir eine Shape-Komponente, um die physikalischen Blattabmessungen darzustellen (den Druckbereich repräsentiert die TWinControl-Komponente).

Der Ablauf im Detail Bevor es losgehen kann, müssen wir erst einmal die Komponente erzeugen: var blatt : TCanvas; dc : HDC;

1434

Kapitel 24

How-to: Drucker/Berichte

druckbreite,druckhoehe: Integer; panelx : TWinControl; procedure TForm1.FormCreate(Sender: TObject); begin panelx := TWincontrol.Create(self); panelx.parent := Form1;

An dieser Stelle können wir auch gleich noch einen DC für die Komponente anlegen und mit einem Canvas-Objekt kapseln: blatt := TCanvas.Create; blatt.handle := GetDC(panelx.handle); SetMapMode(blatt.handle,mm_anisotropic) end;

HINWEIS: Die Handle-Eigenschaft eines Canvas-Objekts kann nicht nur gelesen, sondern auch

geschrieben werden! Um die Druckvorschau an unterschiedliche Fenstergrößen anzupassen, wird die Anzeigefunktion im OnResize-Event untergebracht: procedure TForm1.FormResize(Sender: TObject); begin blattAnpassen; ausgabe(blatt) end;

Die Verwendung einer Komponente (statt des Fensters) für die Ausgabe hat seinen guten Grund. Das Bildfeld ist auf die Größe des druckbaren Blattbereichs skaliert, schneidet also genau wie der Drucker alle Ausgaben ab, die darüber hinausgehen. Das Hauptproblem unseres Programms ist die korrekte Skalierung der WinControl-Komponente: procedure blattAnpassen; var prnxy, formxy : Single; dx,dy,x,y : Integer; blattbreite, blatthoehe : Integer; scale : Single; xofs,yofs : Single;

Bestimmen der Blattabmessungen (in Millimetern): MMproPixelX MMproPixelY blattbreite blatthoehe

:= 25.4 / GetdeviceCaps(Printer.handle,LOGPIXELSX); := 25.4 / GetdeviceCaps(Printer.handle,LOGPIXELSY); := Round(GetdeviceCaps(Printer.handle,PHYSICALWIDTH) * MMproPixelX); := Round(GetdeviceCaps(Printer.handle,PHYSICALHEIGHT) * MMproPixelY);

24.5 Eine eigene Druckvorschau programmieren

1435

Bestimmen des Offsets für den bedruckbaren Bereich: xofs := Round(GetdeviceCaps(Printer.handle,PHYSICALOFFSETX) * MMproPixelX); yofs := Round(GetdeviceCaps(Printer.handle,PHYSICALOFFSETY) * MMproPixelY);

Bestimmung der Seitenabmessungen in Millimetern: druckbreite := GetDeviceCaps(Printer.handle, horzsize); druckhoehe := GetDeviceCaps(Printer.handle, vertsize); y := 35; x := 10;

Das Höhen-/Seitenverhältnis des Formulars ermitteln: formxy := (Form1.clientWidth - x) / (Form1.clientheight - y);

Das Gleiche für den Drucker: prnxy := blattbreite / blatthoehe;

Je nach Verhältnis bestimmen Blattbreite oder Blatthöhe die maximale Anzeigegröße auf dem Bildschirm: If formxy < prnxy then begin {Breite dominiert } dx := Form1.clientWidth - 20; dy := round(dx / prnxy); y := round((Form1.ClientHeight / 2 + 8) - (dy / 2)) end else begin {Höhe dominiert } dy := Form1.clientHeight - y-10; dx := round(dy * prnxy); x := round((Form1.clientWidth / 2) - (dx / 2)) end;

Das "Blatt" skalieren: Form1.shape1.setbounds(x,y,dx,dy); scale := dy /blatthoehe; panelx.setbounds(x + Round(xofs*scale),y + Round(yofs*scale), Round(druckbreite * scale), Round(druckhoehe * scale));

Damit wir nicht umständlich Skalierfaktoren einführen müssen, überlassen wir diese Aufgabe den folgenden API-Funktionen. Die Grafik im Anschluss an das Listing zeigt das Prinzip. SetMapMode(blatt.handle,mm_anisotropic); SetViewportExtEX(blatt.handle,dx,dy,nil); // Skalierung SetWindowExtEX(blatt.handle,druckbreite * 10,-druckhoehe * 10, nil); SetBKmode(blatt.handle,TRANSPARENT); blatt.Brush.Style := bsSolid; blatt.Brush.Color := clWhite; blatt.Pen.Color := clBlack;

Das "Blatt" wird weiß "gestrichen": blatt.fillRect(bounds(0, 0, druckbreite * 10,-druckhoehe * 10));

1436

Kapitel 24

+Y

-Y +X

Das virtuelle Druckerabbild

How-to: Drucker/Berichte

+Y +X

Komponente

+X

endgültige Darstellung in der Komponente

Wie Sie der Grafik entnehmen können, gibt es drei Darstellungsformen, von denen nur eine auf dem Bildschirm sichtbar ist (rechts). Mit den GDI-Anweisungen SetViewportExtEX(Form1.image1.Canvas.handle,dx,dy,nil); SetWindowExtEX(Form1.image1.Canvas.handle,druckbreite * 10,-druckhoehe * 10, nil);

bilden Sie die Druckerkoordinaten (1/10mm) im richtigen Verhältnis auf dem DC der Komponente ab. Die Multiplikation des y-Parameters mit -1 korrigiert die Darstellung, die y-Koordinate wird gekippt. Übrig bleibt ein kartesisches Koordinatensystem, das im Gegensatz zu den Bildschirmkoordinaten positive Werte nach oben abträgt. Der Nullpunkt befindet sich bei allen Darstellungsformen in der linken oberen Ecke. Nach diesen Vorbereitungen werden alle Ausgaben im Image so interpretiert, als wenn es sich um Druckerkoordinaten handeln würde (maßstäbliche Abbildung). Für eine Druckausgabe muss das Printer-Objekt lediglich in den MM_LOMETRIC-Mode gebracht werden. Die eigentliche Anzeigeprozedur fällt recht kurz aus. Damit wir die Funktion auch für den Drucker nutzen können, übergeben wir den Canvas des Ausgabeobjektes. Sie schreiben also nur eine Prozedur für beide Ausgabegeräte: procedure ausgabe(ziel : TCanvas); var i,l,n, x,y, breite,hoehe : Integer; s : String; begin with ziel do begin

24.5 Eine eigene Druckvorschau programmieren

1437

Schrifthöhe in 1/10mm: font.Height:=50; font.Name := 'Arial'; SetTextAlign(handle,TA_CENTER+TA_TOP); breite := druckbreite * 10; hoehe := druckhoehe * 10; moveto(0,1);LineTo(breite, 1); i := 1; while i <= breite do begin MoveTo(i,-1); if (i-1) mod 100 = 0 then begin LineTo(i,-50); TextOut(i,-50,IntToStr(i div 100)); end else LineTo(i,-30) Inc(i,10) end; SetTextAlign(handle,TA_LEFT+TA_TOP); n := 200; i := 0; x := druckbreite * 5; y := druckhoehe * 5; while i < 500 do begin Dec(n,5); DC_textout(ziel,x, -y, i, n, ' rotierender Text'); Inc(i,15) end; for i := 1 to 300 do rectangle(x-i, y-i, x+i, y+i) end end;

HINWEIS: Nähere Informationen zu den einzelnen Druckfunktionen finden Sie im Grundlagen-

teil dieses Buchs. Bis jetzt wurde die Grafik nur auf dem Bildschirm wiedergegeben. Für die Druckausgabe ist eine der beiden Tasten verantwortlich: procedure TForm1.SpeedButton1Click(Sender: TObject); begin Printer.BeginDoc;

Skalieren auf 1/10 mm: SetMapMode(Printer.Canvas.handle,MM_LOMETRIC); ausgabe(Printer.Canvas); Printer.EndDoc end;

1438

Kapitel 24

How-to: Drucker/Berichte

HINWEIS: Wollen Sie ein Koordinatensystem realisieren, das positive Werte nach unten abträgt,

können Sie nicht den Abbildungsmodus MM_LOMETRIC verwenden, sondern MM_ANISOTROPIC. In diesem Fall müssen Sie sich allerdings selbst um die Skalierung auf 1/10 mm kümmern. Wie Sie sehen, ist der Aufwand für die Druckausgabe recht gering. Die Einbindung eines Drucker-Setup-Dialogs ist mit wenigen Zeilen erledigt: procedure TForm1.SpeedButton2Click(Sender: TObject); begin PrinterSetupDialog1.Execute; blattAnpassen; ausgabe(Form1.image1.Canvas) end;

Test Als Lohn der Mühe winkt eine standesgemäße Druckvorschau, von welcher aus Sie natürlich sofort auch den Drucker einrichten bzw. den Druckvorgang starten können:

1439

24.6 Eine eigene Druckausgabe realisieren

24.6 Eine eigene Druckausgabe realisieren Befreien Sie sich aus der sklavischen Abhängigkeit von den (alten) QuickReport- bzw. (neueren) RaveReports-Komponenten! Vor allem dann, wenn Sie eine typisierte Datei statt einer "echten" Datenbank auswählen, bieten sich Ihnen durch den Direktzugriff auf das Printer-Objekt weitaus umfassendere Gestaltungsmöglichkeiten.

Oberfläche Die Oberfläche entspricht der kleinen Datenbankapplikation, wie sie in Ä 21.26 Ein FileStream-Objekt als BDE-Ersatz verwenden beschrieben wurde. Nur haben wir noch die beiden Menüpunkte Druckereinrichtung und Drucken sowie einen PrinterSetupDialog hinzugefügt.

Quelltext Aus Übersichtlichkeitsgründen verpacken wir den Code in eine extra Unit: unit Unit2; interface procedure printPersonen;

// Interface-Routine

implementation uses Printers, Dialogs, SysUtils, Graphics, Windows, Unit1; var breite, hoehe: Word; y: Integer=0;

// // // //

wegen Drucker, Messageboxen, Stringfunktionen wegen fsBold etc. wegen Druckausgabe in mm (SetMapMode etc.) Datenherkunft

// Breite und Höhe in mm // aktuelle vert. Druckposition in mm

1440

Kapitel 24

const oRand=20; uRand=10; lRand=20; dz = 5;

// // // //

How-to: Drucker/Berichte

oberer Rand = 20 mm unterer ... linker Rand ... Zeilenabstand = 5 mm

procedure printTitle; var m: Word; txt: string; begin

Da die Druckausgabe auf 1/10 mm eingestellt ist, müssen alle mm-Angaben mit 10 multipliziert werden: with Printer.Canvas do begin // Überschrift: Font.Height:= 8 * 10; // Schrifthöhe = 8 mm Font.Style := [fsBold]; txt := 'Personaldatei'; m := (breite * 10 - TextWidth(txt)) div 2; // Überschrift zentrieren TextOut(m,y * 10,txt) // Überschrift drucken end; Dec(y, 20) // Abstand zur nächsten Druckausgabe = 20 mm end; procedure pL(x: Word; s: string); // linksbündige Druckausgabe x(mm), -y(mm) begin SetTextAlign(Printer.Handle,TA_LEFT+TA_TOP); // Ausrichten auf linke obere Ecke Printer.Canvas.TextOut(lRand*10 + x*10,y*10,s) end; procedure pR(x: Word; s: string); // rechtsbündige Druckausgabe x(mm), -y(mm) begin SetTextAlign(Printer.Handle,TA_RIGHT+TA_TOP); // Ausrichten auf rechte obere Ecke Printer.Canvas.TextOut(lRand*10 + x*10,y*10,s) end;

Nach dem Titel kann der Tabellenkopf gedruckt werden: procedure printHeader; // Tabellenkopf in Höhe y drucken begin with Printer.Canvas do begin Font.Height := 40; Font.Style := []; pR(30,'Name'); pR(80,'Geburtsdatum'); pR(120,'Geschlecht');pR(150,'Telefon'); Dec(y,8); // nächste Zeile 4 mm tiefer Pen.Width := 3; MoveTo(lRand*10, y*10); LineTo(breite*10,y*10); // ... eine Trennlinie ziehen

Die eben erzeugte Trennlinie dient nach einem Probeausdruck gleichzeitig zum Anlegen eines Lineals, mit dem man für die printLine-Prozedur exakt die x-Abstände (in mm) ablesen kann. Dec(y, dz); Pen.Width := 1 end end;

// Zeilenvorschub

24.6 Eine eigene Druckausgabe realisieren

1441

procedure printLine(i:Word); // druckt i-te Fahrt in Höhe y begin with Printer.Canvas do with personen[i-1] do begin pR(30, name); pR(80,FormatDateTime('dd/mm/yyyy', geburt)); if personen[i].geschlecht then pR(120,'männlich') else pR(120, 'weiblich'); pR(150, IntToStr(nr)); end; Dec(y,dz) // Zeilenvorschub (y hat negative Achse!) end;

Die folgende (durchaus verzichtbare) Routine druckt für den Aktenlocher Markierungen am linken Rand. Letztlich ging es den Autoren nur darum, den Einsatz weiterer Grafikmethoden (MoveTo, Ellipse) zu demonstrieren: procedure printLoch; var ym: Integer; begin ym:= hoehe * -10 div 2; // vertikale Seitenmitte with Printer.Canvas do begin MoveTo(0,ym); LineTo(50,ym); Ellipse(30, ym-420,70, ym-380); Ellipse(30, ym+380, 70, ym+420) end end;

Jetzt folgt die Schnittstellen-Routine, wie sie von außerhalb aufgerufen werden kann: procedure printPersonen; // Interface-Routine für Drucken var i:Word; procedure seitenNr; begin y:= -(hoehe-5); pR(breite-5,'Seite ' + IntToStr(Printer.PageNumber)); end; begin with Printer do begin Orientation := poPortrait; // Hochformat (poLandscape = Querformat) BeginDoc; // muss wegen Handle bereits hier stehen! SetMapMode(Handle,MM_LOMETRIC); // Umstellen Druckausgabe auf 0.1 mm (y nach oben!) breite := GetDeviceCaps(Handle, HorzSize); // Seitenbreite (druckbarer Bereich) in mm hoehe := GetDeviceCaps(Handle, VertSize); // Seitenhöhe (druckbarer Bereich) in mm y := -oRand; // oberer Rand = 20mm printLoch; printTitle; printHeader; for i:= 1 to pmax do begin // alle Personen zeilenweise drucken printLine(i); if y < -(hoehe-uRand) then begin // neue Seite Break; seitenNr; NewPage; y:= -oRand; SetMapMode(Handle,MM_LOMETRIC); // sonst ist neue Seite leer!!!

1442

Kapitel 24

How-to: Drucker/Berichte

printLoch; printHeader end end; seitenNr; // für letzte Seite EndDoc end end;

Die in Unit1 vorzunehmenden Ergänzungen sind minimal: Binden Sie die Unit2 in den lokalen uses-Abschnitt von Unit1 ein. Schließlich sind für die neu hinzugekommenen Menüpunkte folgende Event-Handler zu schreiben: procedure TForm1.Drucken1Click(Sender: TObject); begin printPersonen end;

// Drucken

procedure TForm1.Druckereinrichtung1Click(Sender: TObject); // Druckereinrichtung begin PrinterSetUpDialog1.Execute end;

Test Öffnen Sie die Datei PERSONAL.DAT (siehe Buch-CD). Falls Sie nur den Standarddrucker verwenden wollen, brauchen Sie das Menü Druckereinrichtung nicht zu bemühen. Hier ein Probeausdruck:

24.7 Access-Reports drucken

1443

24.7 Access-Reports drucken Wenn Sie über Microsoft Access (unter Benutzung der OLE-Schnittstelle) ausdrucken lassen, können Sie gleich von mehreren Vorteilen profitieren: Zum einen können Sie die Daten in der Access-Datenbank speichern, gleichzeitig sind in dieser Datenbank auch die dazugehörigen Berichte enthalten. Weiterhin können Sie den recht intuitiven Report-Generator von Access zum Berichtsentwurf einsetzen.

Oberfläche Wieder einmal genügen ein Formular und ein Button.

Quelltext Unser Beispiel haben wir auf die wesentlichsten Zeilen reduziert, um zu zeigen, wie einfach es ist, einen Report über Access ausdrucken zu lassen. Binden Sie zunächst die Unit ComObj ein: uses ComObj; ...

Nachfolgend finden Sie einige Konstanten, mit denen Sie zum einen das Ausgabeziel und zum anderen das Beenden von Access steuern können: const acViewNormal = $00000000; acViewDesign = $00000001; acViewPreview = $00000002; acQuitPrompt = $00000000; acQuitSaveAll = $00000001; acQuitSaveNone = $00000002; ...

Die eigentliche Druckausgabe: procedure TForm1.Button1Click(Sender: TObject); var Access: Variant; begin

Wir versuchen zunächst eine eventuell vorhandene Instanz von Access zu nutzen: try Access := GetActiveOleObject('Access.Application') except

Schlägt dies fehl, erzeugen wir eine neue: Access := CreateOleObject('Access.Application') end;

1444

Kapitel 24

How-to: Drucker/Berichte

Access anzeigen (setzen Sie die Visible-Eigenschaft nicht auf True, bleibt Access unsichtbar): Access.Visible := True;

Die gewünschte Datenbank öffnen: Access.OpenCurrentDatabase(ExtractFilePath(Paramstr(0)) + 'db1.mdb', True);

Die Druckausgabe oder (wie im Beispiel) die Anzeige der Druckvorschau: Access.DoCmd.OpenReport('vorwahl', acViewPreview, EmptyParam, EmptyParam);

Nutzen Sie die direkte Druckausgabe, können Sie Access auch gleich wieder schließen lassen: // Access.CloseCurrentDatabase; // Access.Quit(acQuitSaveAll) end;

Zur Funktionsweise: Nach dem erfolgreichen Erstellen einer Access-Instanz über die GetObjectFunktion können Sie bereits auf das DoCmd-Objekt von Access zugreifen. SYNTAX:

DoCmd.OpenReport "Berichtsname" [, Ansicht] [, Filtername] [, Bedingung]

Auch das Übergeben von Filtern oder Bedingungen (entspricht einer WHERE-Klausel bei SQL) ist, wie Sie sehen, kein Problem.

Test Starten Sie das Programm und klicken Sie auf den Button. Es sollte (so vorhanden) die Druckvorschau angezeigt werden:

24.8 Einen einfachen Rave Report erstellen

1445

Bemerkung Falls beim Aufruf von Access eine Fehlermeldung erscheint, sollten Sie vorher im Menü Tools| Debugger-Optionen... auf der Seite "Sprach-Exceptions" das Häkchen bei "Bei Delphi-Exceptions stoppen" entfernen. Wenn Sie die EXE-Datei direkt aufrufen, hat dies allerdings keine Bedeutung.

24.8 Einen einfachen Rave Report erstellen Mit einer kleinen Serie von Rezepten wollen wir Ihnen die Funktionsweise des in Delphi 7 neu eingeführten Rave Reports näher bringen. Leider entspricht das Produkt einem typischen Klischee von US-Software: Guter Ansatz, aber eine total sinnfreie Bedienung und Umsetzung, und das Ganze vor allem bunt1. Doch zurück zum Beispiel. Grundlage ist die Datenbank Personal.mdb mit der Tabelle Personen. Alle Mitarbeiter sollen in einer einfachen Liste dargestellt werden.

Oberfläche (Formular) Entwerfen Sie zunächst ein Formular entsprechend folgender Abbildung.

Setzen Sie zunächst die ConnectionString-Eigenschaft der ADOConnection-Komponente: Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Personal.mdb;

Verbinden Sie die ADOTable-Komponente über ihre Connection- und TableName-Eigenschaft mit der Tabelle Personen und setzen Sie Active auf True. Die DataSource- sowie die DBGrid-Komponente nutzen wir lediglich für die Kontrolle. In einem zweiten Schritt platzieren Sie eine RvProject- und eine RvDatasetConnection-Komponente auf dem Formular. RvDatasetConnection binden Sie über die Eigenschaft Table direkt an die bereits geöffnete ADOTable-Komponente. Weiterhin sollten Sie der RvDatasetConnection-Komponente einen sinnvollen Namen (z.B. RvDS_Personal) geben, um später in Designer die Datasets besser auseinander halten zu können.

1

Sie werden sicher auch über diverse Fallstricke stolpern und sich hinterher fragen, wie ein paar Programmierer ein Produkt so sinnlos verhunzen können.

1446

Kapitel 24

How-to: Drucker/Berichte

Oberfläche (Report) Wechseln Sie nun zur RvProject-Komponente. Über das PopUp-Menü (Rave Visual Designer) können Sie den eigentlichen Berichts-Designer starten. Über die Oberfläche des Designers brauchen wir Ihnen sicher nicht allzu viel zu erzählen, lehnt sich die Oberfläche doch weitgehend an das Konzept der Delphi-IDE an. Das weitere Vorgehen möchten wir Ihnen deshalb nur stichpunktartig erläutern: ■ Der erste Schritt ist das Erzeugen eines neuen Reports (Datei|Neu). ■ Fügen Sie nun über den Menüpunkt Datei|Neues Datenobjekt eine Direct Data View in den Report ein:

■ Hierbei handelt es sich bereits um die RvDatasetConnection-Komponente aus Ihrem DelphiProjekt. Nach dem Einfügen zeigt die Projekt-Übersicht bereits die Details unserer Datenverbindung an:

■ Im Folgenden ist es wichtig zu wissen, dass der Rave-Reportgenerator grundsätzlich erst einmal seitenorientiert arbeitet. Um eine Unterstützung für bandorientierte Ausgaben zu realisieren, müssen Sie zunächst eine Region-Komponente in das noch leere Formular einfügen. Inner-

24.8 Einen einfachen Rave Report erstellen

1447

halb dieser Region-Komponente können Sie nun Band- und DataBand-Komponenten platzieren. ■ Für unseren Bericht benötigen wir zwei Band-Komponenten (Kopfzeile und Tabellenkopf) sowie ein DataBand, in dem die eigentlichen Tabellendaten später angezeigt werden. ■ Fügen Sie in die einzelnen Bänder entsprechend folgender Abbildung Text- bzw. DataTextKomponenten ein. Die Verknüpfung mit den zugrunde liegenden Daten erfolgt wie in Delphi. Verwenden Sie die Eigenschaft DataView, um die Datenquelle zuzuordnen, und die Eigenschaft DataField, um die gewünschte Spalte zu selektieren.

■ Das DataBand selbst binden Sie über die Eigenschaft DataView an die erzeugte Connection. ■ Für den Reportgenerator müssen Sie nun noch den Zusammenhang zwischen den einzelnen Bändern festlegen. Dazu dient die Eigenschaft BandStyle, die Sie für die drei Bänder entsprechend den folgenden Abbildungen festlegen:

■ Das war es auch schon, mit F9 können Sie einen ersten Test starten:

1448

Kapitel 24

How-to: Drucker/Berichte

■ Speichern Sie den Report im Projektverzeichnis Ihrer Delphi-Anwendung und beenden Sie den Report-Designer. ■ In Ihrem Delphi-Projekt muss nun der neue Report eingebunden werden. Nutzen Sie dazu die ProjectFile-Eigenschaft der RvProject-Komponente.

Quelltext In das OnClick-Ereignis des Buttons tragen Sie ein: procedure TForm1.Button1Click(Sender: TObject); begin RvProject1.Open; RvProject1.Execute end;

Test Nach dem Programmstart und dem Klick auf den Button werden Sie aufgefordert, sich zwischen Drucken, Druckvorschau und dem Speichern in einer Datei zu entscheiden. Wählen Sie "Preview", um wenigstens einige Bäume vor dem Ende in der Papiermühle zu bewahren.

Bemerkungen ■ Wie bereits erwähnt, können Sie den Report jederzeit während der Entwurfsphase im RaveDesigner testen (F9). ■ Das Papierformat können Sie über die Orientation-Eigenschaft des Reports (Baumansicht: Report|MainPage) anpassen.

24.9 Berechnungen in Rave-Reports ausführen

1449

24.9 Berechnungen in Rave-Reports ausführen Hier finden Sie ein echtes Beispiel für die These: "Warum einfach, wenn es auch kompliziert geht?" Was hat bloss die Nevrona-Programmierer geritten, die CalcOp-Komponenten zu erfinden? Ein einfach implementierter Formelparser (siehe Crystal Report) ist tausend Mal sicherer und einfacher in der Bedienung. Doch wir wollen uns davon nicht entmutigen lassen. Aufbauend auf dem Vorgängerbeispiel möchten wir uns im Folgenden mit Berechnungen innerhalb des Reports beschäftigen. Zum einen wollen wir Berechnungen innerhalb einer Datenzeile, zum anderen über alle Datensätze anstellen. Als Datengrundlage dient uns, wie nicht anders zu erwarten, die Mitarbeiter-Datenbank.

Oberfläche (Formular) Keine Änderungen zum vorhergehenden Beispiel.

Oberfläche (Report) Kopieren Sie sich zunächst den Report des Vorgängerbeispiels, um diesen zu erweitern. Wählen Sie in der Projektansicht den Report aus und wechseln Sie zur Eigenschaftenliste, um einen neuen Parameter (quasi eine Variable) zu erzeugen. Öffnen Sie dazu den Eigenschaftseditor von Parameters und geben Sie einfach einen Namen ein (in unserem Fall Krankenkasse). Fügen Sie nachfolgend in das DataviewBand eine DataText-Komponente sowie eine CalcOpKomponente ein. Mit dieser Komponente können Sie einfache Berechnungen mit zwei Eingabewerten (z.B. Feldwerten, Parametern, Konstanten etc.) vornehmen. Das Ergebnis dieser Berechnung kann wiederum mit einer weiteren Operation bearbeitet werden. HINWEIS: Die CalcOp-Komponente ist nur in der Baumansicht auf der rechten Seite sichtbar:

Legen Sie die Eigenschaften der CalcOp-Komponente entsprechend der folgenden Abbildung fest:

1450

Kapitel 24

How-to: Drucker/Berichte

Der Hintergrund: die Multiplikation (Operator) aus Gehalt (Src1DataField) und einer Konstanten (Src2Value) wird im Parameter Krankenkasse (DestParam) gespeichert. Die Darstellung erfolgt als Gleitkommazahl (DisplayType) mit zwei Nachkommastellen (DisplayFormat). Das Grundprinzip der CalcOp-Komponente zeigt die folgende Abbildung: Src1Value Src1DataField

Src1Function

Src1CalcVar

DestParam Operator

DestPIVar

Src2Value Src2DataField

ResultFunction

Src2Function

Src2CalcVar

HINWEIS: Beachten Sie, dass Sie nur jeweils einen Eingabewert festlegen können.

Dass ein Formelparser an dieser Stelle sinnvoller gewesen wäre, wird wohl kaum jemand bestreiten wollen. Mit der CalcOp-Komponente haben wir bisher lediglich eine Berechnung ausgeführt und das Ergebnis im Parameter Krankenkasse gespeichert. Um diesen Wert auch zur Anzeige zu bringen, verwenden wir die bereits eingefügte DataText-Komponente. Legen Sie deren Anzeigewert mit Hilfe der Eigenschaft DataField bzw. dem zugeordneten Eigenschaftseditor auf den Parameter Krankenkasse fest.

24.9 Berechnungen in Rave-Reports ausführen

1451

Damit ist die zeilenweise Berechnung angeschlossen1. Wir wenden uns der Gesamtsumme am Berichtsende zu:

Fügen Sie dazu zunächst eine Band-Komponente, und legen Sie deren Style-Eigenschaft wie folgt fest. 1

Wer es gern einfacher hat, verwendet an dieser Stelle natürlich eine entsprechende SQL-Anweisung und übergibt an den Reportgenerator eine fertig berechnete Spalte. Dies ist zum einen einfacher, zum anderen wesentlich schneller, da der Rave-Report in dieser Beziehung als "lahme Ente" bezeichnet werden kann.

1452

Kapitel 24

How-to: Drucker/Berichte

Fügen Sie nun für die Gesamtsumme der Gehälter eine CalcText-Komponente ein und legen Sie deren Controller-Eigenschaft mit "DataView1DataBand" fest. Über die Eigenschaft Datafield können Sie den Inhalt (Gehalt) der Komponente festlegen. Welche Berechnungsfunktion zur Anwendung kommt, bestimmt CalcType. Bei der Gesamtsumme der Spalte Krankenkassenbeiträge verfahren Sie genauso, dass Sie in diesem Fall als Datafield den Parameter Krankenkasse verwenden.

Test Damit steht einem Test des Reports über F9 nichts mehr im Wege:

24.10 Parameter an Rave-Reports übergeben

1453

24.10 Parameter an Rave-Reports übergeben Jeder Report lebt auch von der Kommunikation zwischen Anwendung und Berichtsgenerator. Im Gegensatz zum Quickreport, wo es sich um ein und dasselbe Programm handelt, ist beim RaveReport ein anderer Mechanismus nötig. Verwendung finden die schon aus dem Vorgängerbeispiel bekannten Berichtsparameter.

Oberfläche (Formular) Ergänzen Sie die Oberfläche von Rezept 24.8 um eine Textbox und ein Memofeld für die Eingabe zur Laufzeit:

Oberfläche (Report) Im Report selbst erzeugen Sie zwei neue Parameter, indem Sie auf der rechten Seite (Baumansicht) das Report-Objekt auswählen und nachfolgend auf der linken Seite (Eigenschaften) die Eigenschaft Parameters editieren:

HINWEIS: Bei Parametern handelt es sich zunächst immer um Stringwerte.

1454

Kapitel 24

How-to: Drucker/Berichte

Im Title-Band des Reports können Sie jetzt eine DataText- und eine DataMemo-Komponente platzieren. Über die Eigenschaft DataField legen Sie die Verknüpfung zwischen Komponente und Parameter fest.

HINWEIS: Ein Test im Berichts-Designer dürfte nicht zum Erfolg führen, da die Parameterwerte

erst vom Delphi-Programm bereitgestellt werden.

Quelltext Im Delphi-Projekt ergänzen Sie den Aufruf des Berichts um die folgenden zwei Zeilen: procedure TForm1.Button1Click(Sender: TObject); begin RvProject1.Open; RvProject1.SetParam('Bearbeiter',Edit1.Text); RvProject1.SetParam('Anmerkung',Memo1.Lines.Text); RvProject1.Execute; end;

Test Nach dem Programmstart können Sie die beiden Eingabefelder editieren. Nachfolgend rufen Sie den Report auf:

24.12 Mit dem alten QuickReport arbeiten

1455

24.11 Berichte verketten Das Verketten mehrerer Berichte zu einem Dokument ist mit dem Rave-Report recht elegant gelöst. Eine Reportdatei kann mehrere Reportseiten (diese können wiederum aus mehreren Einzelseiten bestehen) enthalten. Diese können mit Hilfe der GotoPage-Eigenschaften zu einer Kette verbunden werden.

Oberfläche (Formular) Übernehmen Sie einfach das Rezept 24.8.

Oberfläche (Report) Fügen Sie über den Menüpunkt Datei|Neue Reportseite eine neue Seite in den Report ein. Markieren Sie nachfolgend in der Baumansicht auf der rechten Seite das Report-Objekt und legen Sie dessen FirstPage-Eigenschaft auf den Namen der neuen Seite (Page2) fest. Nachfolgend öffnen Sie diese Seite und platzieren einige Komponenten darauf:

Um die Folgeseite dieses Berichts festzulegen, verwenden Sie die Eigenschaft GotoPage. Wählen Sie hier Page1 aus.

Test Nach dem Speichern des Reports können Sie diesen auch gleich im Designer testen. Nach dem Deckblatt folgt, wie nicht anders zu erwarten, der eigentliche Bericht.

24.12 Mit dem alten QuickReport arbeiten Mit Delphi 7 wurden die bewährten QuickReport-Komponenten rigoros aufs Altenteil gesetzt, ihren Platz haben die RaveReports-Komponenten eingenommen. Wer dennoch weiter mit QuickReport arbeiten will, muss zunächst das Package dcltqr70.bpl installieren.

Installation Wählen Sie das Menü Komponente|Packages installieren. Im folgenden Dialogfenster klicken Sie auf den Button "Hinzufügen..." und suchen im Dateidialog das Verzeichnis C:\Programme\Borland\Delphi7\Bin, wo Sie die Datei dclqrt70.bpl öffnen und anschließend mit "OK" bestätigen.

1456

Kapitel 24

How-to: Drucker/Berichte

Als letztes Register der Komponentenpalette müsste jetzt QReport hinzugekommen sein, und schon ist es wieder wie in alten Zeiten:

Um die Verwendung der Komponenten an einem ganz einfachen Beispiel zu demonstrieren, soll der Inhalt der Tabelle Kunden.db aus unserer FIRMA-Datenbank ausgedruckt werden (die Datenbank befindet sich im Projektverzeichnis der Buch-CD).

Oberfläche Eröffnen Sie ein neues Projekt und platzieren Sie eine Table- und eine QuickRep-Komponente (ganz links auf der Palette) auf dem Startformular (Form1). Verbinden Sie die Table-Komponente über ihre DatabaseName- und TableName-Eigenschaft mit der Tabelle Kunden.DB und setzen Sie Active auf True. Zoomen Sie QuickRep1 auf die gewünschte Größe und setzen Sie seine DataSet-Eigenschaft auf Table1. Klappen Sie die Bands-Eigenschaft von QuickRep1 auf und setzen Sie HasPageHeader, HasTitle, HasColumnHeader, HasDetail und HasPageFooter auf True.

1457

24.12 Mit dem alten QuickReport arbeiten

Zum Report werden jetzt automatisch und in der richtigen Reihenfolge Kopfzeile, Titel, Spaltentitel, Detailbereich und Fußbereich hinzugefügt. Nun bestücken Sie die einzelnen Abschnitte mit weiteren QuickReport-Komponenten. Die Schriftart stellen Sie wie gewohnt über das Font-Objekt ein (Abbildung):

QuickRep1

Table1

QRSysData1 QRLabel1

PageHeader Title

QRLabel2

ColumnHeader Detail PageFooter

QRDBText1

QRDBText2 QRSysData2

Setzen Sie die DataSet-Eigenschaft der QRDBText-Komponenten auf Table1 und deren DataFieldEigenschaft entsprechend dem anzuzeigenden Feldnamen. In die Caption-Eigenschaften der QRLabel-Komponenten tragen Sie die entsprechenden Beschriftungen ein. Der Data-Eigenschaft der beiden QRSysData-Komponenten weisen Sie die Werte qrsDate bzw. qrsPageNumber zu.

1458

Kapitel 24

How-to: Drucker/Berichte

Quellcode In das OnCreate-Event von Form1 tragen Sie ein: procedure TForm1.FormCreate(Sender: TObject); begin QuickRep1.Preview end;

Test Nach Programmstart (F9) erscheint die Bericht-Vorschau, die Sie nach Klick auf das Drucksymbol auch zu Papier bringen können.

Falls der Report nicht oder fehlerhaft angezeigt wird, überprüfen Sie nochmals, ob die ActiveEigenschaft von Table1 tatsächlich True ist und ob die DataSet-Eigenschaft von QuickRep1 auf Table1 zeigt.

Bemerkungen ■ Sie können den Report bereits während der Entwurfsphase testen (mit rechter Maustaste auf QuickRep1 klicken, "Druckbild"). ■ Das Papierformat können Sie über die Page-Eigenschaft von QuickRep1 den unterschiedlichsten Bedürfnissen anpassen (A4, Randabstände etc.). ■ Zahlreiche weitere Anwendungsbeispiele für die verschiedenen QuickReport-Komponenten finden Sie in unserem Buch "Datenbankprogrammierung mit Borland Delphi", welches sich mit auf dieser Buch-CD befindet.

25

How-to: Komponenten/OOP

Kapitel

25

How-to: Komponenten/OOP 25.1 Eine einfache Klasse benutzen Ein Delphi-Programm setzt sich bekannterweise bausteinartig aus verschiedenen Units zusammen, die teils "vorgefertigt" und teils vom Benutzer erstellt werden. Im Rezept Ä 17.9 Eine Unit erstellen und anwenden wurde die klassische Vorgehensweise demonstriert, wie sie noch aus der alten Pascal-Zeit stammt. Für den OOP-Einsteiger empfiehlt sich deshalb ein Studium des o.g. Rezepts, denn nur so wird er die Vorzüge der folgenden objektorientierten Lösung so richtig zu würdigen wissen. Diese zeigt am gleichen Problem, wie man die Nachteile der klassischen Lösung vermeidet. Ziel ist es, möglichst viel "Intelligenz" in die Unit zu verlagern, so dass sich der Anwender nicht mehr um solch lästigen Dinge wie Typüberprüfung, Formatierung etc. zu kümmern braucht und so zu einem leicht nachvollziehbaren, transparenten Code kommt.

Oberfläche Diese besteht im Wesentlichen aus einem Formular (Form1) mit zwei Edit-Feldern und einer RadioGroup zur Auswahl zwischen zwei Mehrwertsteuersätzen (siehe Laufzeitabbildung am Schluss des Rezepts).

Quelltext der Unit Fügen Sie zum Projekt eine Unit hinzu (Datei|Neu|Unit). Unsere Unit soll keine einzelnen Funktionen, Prozeduren, Variablen ... exportieren, sondern eine Klasse TArtikel: unit Berechnungen; interface uses SysUtils; // wegen Format-Funktion type TArtikel = class(TObject) private

1460

Kapitel 25

How-to: Komponenten/OOP

Die Zustände (Felder) der Klasse: nett: Double; mws: Single;

Die Zugriffsmethoden: function getNetto: string; procedure setNetto(nt: string); function getBrutto: string; procedure setBrutto(br: string); public

Die öffentliche Schnittstelle der Klasse sind drei Eigenschaften: property netto: string read getNetto write setNetto; property brutto: string read getBrutto write setBrutto; property mwst: Single read mws write mws; end;

Im Implementation-Abschnitt kümmern wir uns um die Implementierung der Zugriffsmethoden: implementation var wert: Double; code: Integer;

// Hilfsvariablen

function TArtikel.getNetto; begin Result := Format('%m',[nett]) end; procedure TArtikel.setNetto; begin Val(nt, wert, code); if code = 0 then nett := wert end; function TArtikel.getBrutto; begin Result := Format('%m',[nett * (1 + mws)]) end; procedure TArtikel.setBrutto; begin Val(br, wert, code); if code = 0 then nett := wert / (1 + mws) end; end.

1461

25.1 Eine einfache Klasse benutzen

Quelltext zum Testen Hier der Implementation-Abschnitt von Unit1: uses Berechnungen;

// stellt Klasse TArtikel bereit

var art: TArtikel;

// Objektvariable referenzieren

Die Startaktivitäten: procedure TForm1.FormCreate(Sender: begin art := TArtikel.Create; // // Werte initialisieren: RadioGroup1.ItemIndex := 1; // RadioGroup1Click(Self) // end;

TObject); Objektvariable instanziieren MWSt = 16% Anfangsanzeige von Netto und Brutto

Mehrwertsteuer geändert: procedure TForm1.RadioGroup1Click(Sender: TObject); begin case RadioGroup1.ItemIndex of 0: art.mwst := 0.07; 1: art.mwst := 0.16 end; // Brutto und Netto neu anzeigen: Edit1.Text := art.netto; Edit2.Text := art.brutto end;

Netto geändert: procedure TForm1.Edit1KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState); begin art.netto := Edit1.Text; // Netto übernehmen Edit2.Text := art.brutto // Brutto neu anzeigen end;

Brutto geändert: procedure TForm1.Edit2KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState); begin art.brutto := Edit2.Text; // Brutto übernehmen Edit1.Text := art.netto // Netto neu anzeigen end; procedure TForm1.Button1Click(Sender: TObject); begin Close end;

// Beenden

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin art.Free end;

1462

Kapitel 25

How-to: Komponenten/OOP

Test Äußerlich ist keinerlei Unterschied zum Beispiel Ä 17.9 Eine Unit erstellen und anwenden festzustellen. Vergleichen Sie aber den Quelltext, so werden Sie feststellen, dass es intern bei unserer objektorientierten Lösung wesentlich übersichtlicher zugeht.

25.2 Eigenschaften und Felder verstehen "Was ist denn nun der Unterschied zwischen Eigenschaften und Feldern eines Objekts? Beide fallen doch unter den gemeinsamen Begriff Attribut ...". Wir wollen diese Frage anhand eines selbst definierten Objekts für einen simplen Kreis entschärfen. Unser Objekt (TCircle) soll nur ein einziges Feld (F_Radius) haben, dafür aber drei Eigenschaften: ■ Radius (radius) ■ Umfang (periphery = 2 * Pi * radius) ■ Flächeninhalt (area =Pi * radius * radius) Die zugrunde liegenden mathematischen Formeln werden als bekannt vorausgesetzt und tun im Übrigen nichts zur Sache, da es im Wesentlichen nur um die Erläuterung eines Prinzips geht.

Oberfläche Unser Startformular (Form1) bestücken wir mit drei Editierfeldern (Edit1, Edit2, Edit3), einer Schaltfläche (Button1) und diversen Labels (siehe Laufzeitabbildung am Schluss des Rezepts).

Quelltext für Unit2 Man sollte es sich zur Gewohnheit werden lassen, selbst definierte Klassen in eine separate Unit auszulagern. Fügen Sie deshalb eine neue Unit (Unit2) zum Projekt hinzu. unit Unit2; interface

1463

25.2 Eigenschaften und Felder verstehen

Die Klasse TCircle wird deklariert. Felder und Zugriffsmethoden gehören in den privateAbschnitt, die Eigenschaftsprozeduren hingegen in den public-Abschnitt (siehe Kommentare): type TCircle = class(TObject) private // Felder und Zugriffsmethoden: F_Radius: Double; // das ist ein Feld, das den Zustand speichert! function getPeriph: Double; // das ist eine Methode für den Lesezugriff procedure setPeriph(periph: Double); // dto. für Schreibzugriff function getArea: Double; // das ist eine Methode für den Lesezugriff procedure setArea(area: Double); // dto. für Schreibzugriff public // die öffentliche Schnittstelle der Klasse: property radius: Double read F_Radius write F_Radius; // das ist eine Eigenschaft! property periphery: Double read getPeriph write setPeriph; // dto. property area: Double read getArea write setArea; // dto. end;

Die vier Zugriffsmethoden müssen noch implementiert werden. Dabei verwenden wir wieder freizügig die Kurzform der Methodenköpfe: implementation function TCircle.getPeriph; begin getPeriph:= 2*Pi*F_Radius end; procedure TCircle.setPeriph; begin F_Radius:= periph/2/Pi end; function TCircle.getArea; begin getArea:= Pi*F_Radius*F_Radius end; procedure TCircle.setArea; begin F_Radius:= Sqrt(area/Pi) end; end.

Quelltext für Unit1 Der implementation-Abschnitt von Unit1, wo wir unsere selbst definierte Klasse benutzen werden: ... uses Unit2; var aCircle: TCircle;

// Objektvariable deklarieren

Jetzt müssen wir uns, wie immer, um die Ereignismethoden unseres Formulars kümmern: procedure TForm1.FormCreate; // Laden des Formulars begin Edit1.Text:= ''; Edit2.Text:=''; Edit3.Text:= ''; aCircle:= TCircle.Create // Wichtig: Objektinstanz entsteht! end;

1464

Kapitel 25

procedure TForm1.EditKeyPress; begin if Key=',' then key:= '.' end;

How-to: Komponenten/OOP

// Eingabekorrektur // Dezimalkomma => Dezimalpunkt

procedure TForm1.EditKeyUp; // Werte-Eingabe für alle drei Edit-Felder var wert: Double; code: Integer; s: string; begin if Sender = Edit1 then // Radius geändert begin Val(Edit1.Text, wert, code); aCircle.radius:= wert; wert:= aCircle.periphery; Str(wert:8:3, s); Edit2.Text:= s; wert:= aCircle.area; Str(wert:8:3, s); Edit3.Text:= s end; if Sender = Edit2 then begin // Umfang geändert Val(Edit2.Text, wert, code); aCircle.periphery:= wert; wert:= aCircle.radius; Str(wert:8:3, s); Edit1.Text:= s; wert:= aCircle.area; Str(wert:8:3, s); Edit3.Text:= s end; if Sender = Edit3 then // Fläche geändert begin Val(Edit3.Text, wert, code); aCircle.area:= wert; wert:= aCircle.radius; Str(wert:8:3, s); Edit1.Text:= s; wert:= aCircle.periphery; Str(wert:8:3, s); Edit2.Text:= s end; end; procedure TForm1.Button1Click; begin Close end;

// Beenden

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin aCircle.Free end; // Objekt freigeben

Test Nach dem Programmstart können Sie in ein beliebiges der drei Editierfelder einen Wert eingeben. Die Anzeige in den übrigen zwei Feldern wird sofort aktualisiert! Damit ist unser Programm zugleich auch ein eindrucksvolles Beispiel für die unter Windows möglichen so genannten "interaktiven" Berechnungen, die auf eine Ergebnistaste verzichten können.

25.3 Private/öffentliche Formularmethoden aufrufen

1465

Bemerkungen ■ Obwohl unser Objekt drei Eigenschaften hat, wird nur der Radius im (privaten) Feld F_Radius gespeichert, man kann dieses Feld deshalb auch als "Zustandsvariable" bezeichnen. Die Eigenschaften radius, periphery und area lesen bzw. speichern diese Variable mittels Read- bzw. Write-Klausel, wobei über die Zugriffsmethoden "Online"-Umrechnungen auszuführen sind. ■ Die Read-Zugriffsmethoden sind immer parameterlose Funktionen, die Write-Zugriffsmethoden immer Prozeduren mit einem Übergabeparameter! ■ Natürlich wäre es auch möglich, statt einer Eigenschaftsprozedur (property... read/write) die direkten Zuweisungen über die Zustandsvariablen oder die Zugriffsmethoden zu verwenden. Dies hätte allerdings nichts mehr mit sauberer objektorientierter Programmierung zu tun.

25.3 Private/öffentliche Formularmethoden aufrufen Normalerweise braucht man sich um den interface-Abschnitt einer Formular-Unit nicht zu kümmern, da der Delphi-Editor die Datenfelder (das sind Komponenten) und Methodendeklarationen (das sind die Kopfzeilen der Event-Handler) automatisch hinzufügt. Was verbirgt sich aber hinter den mit private und public gekennzeichneten Abschnitten der Klassendeklaration TForm? Ein simples Testbeispiel wird für Erleuchtung sorgen. Eine Public-Methode kann auch von einem anderen Formular aus aufgerufen werden, während die Private-Methoden außerhalb der Form-Unit tabu sind.

Oberfläche Wir brauchen zwei Formulare mit ein paar Buttons. Hier das Startformular (Form1):

1466

Kapitel 25

How-to: Komponenten/OOP

Über das Menü Datei|Neues Formular fügen wir Form2 hinzu:

Quelltext für Unit1 Fügen Sie im interface-Abschnitt von Unit1 zur Typdeklaration TForm1 die folgenden (unterstrichenen) Methodendeklarationen hinzu: type TForm1 = class(TForm) ... private procedure setLabelA(s: string); public procedure setLabelB(s: string); end;

// private Methode von TForm1 // öffentliche Methode von TForm1

Beide Methoden verändern den Inhalt von Label1 und sind bis auf den unterschiedlichen Gültigkeitsbereich (private bzw. public) identisch. Dem implementation-Abschnitt von Unit1 fügen Sie folgenden Code hinzu: uses Unit2;

// ermöglicht Zugriff auf Form2

procedure TForm1.SetLabelA; begin Label1.Caption:= s end;

// private Methode, Kurzform

procedure TForm1.SetLabelB; begin Label1.Caption:= s end;

// öffentliche Methode, Kurzform

procedure TForm1.Button2Click; begin Form2.Show end;

// Formular2 anzeigen!

procedure TForm1.Button3Click; // private Methode aufrufen begin setLabelB('Hallo, das ist ein Private-Methode von Form1!') end; procedure TForm1.Button1Click; begin Close end; end.

// Beenden

1467

25.4 Auf mehrere Formulare zugreifen

Quelltext für Unit2 Im implementation-Abschnitt von Unit2 können wir nur auf die öffentliche Methode setLabelB von Form1 zugreifen (die private Methode setLabelA bleibt nach außen unzugänglich): uses Unit1;

// ermöglicht Zugriff auf Form1

procedure TForm2.Button1Click; // öffentliche Methode in Form1 aufrufen begin Form1.setLabelB('Hallo, das ist eine Public-Methode von Form1!') end; end.

Im implementation-Abschnitt wurde von der Kurzform der Prozedurköpfe Gebrauch gemacht (Parameterleiste weggelassen).

Test Starten Sie das Programm, zeigen Sie Form2 an und vergewissern Sie sich, dass Sie tatsächlich von Form2 aus Zugriff auf die Public-Methode von Form1 haben:

25.4 Auf mehrere Formulare zugreifen Möchten Sie Eigenschaften in mehreren Formularen gleichzeitig ändern oder Methoden aufrufen, können Sie sich der Forms-Eigenschaft bedienen.

Oberfläche Für das Startformular (Form1) brauchen wir zwei Schaltflächen (Button1 und Button2). Über den Menüpunkt Datei|Neues Formular fügen wir ein zweites Formular (Form2) hinzu, auf dem wir ebenfalls zwei Schaltflächen (Button1 und Button2) platzieren (siehe Laufzeitansicht unten).

1468

Kapitel 25

How-to: Komponenten/OOP

Erster Test Wir starten die Applikation und stellen fest, dass nur ein Formular (Form1) erscheint, obwohl uns ein Blick in die Projektdatei (Ansicht|Projekt Quelltext) belehrt, dass beide Formulare vorhanden sind: program Project1; uses Forms, Unit1 in 'UNIT1.PAS' {Form1}, Unit2 in 'UNIT2.PAS' {Form2}; {$R *.RES} begin Application.CreateForm(TForm1, Form1); Application.CreateForm(TForm2, Form2); Application.Run; end.

// Hauptformular

Aber: Nur das Hauptformular (Form1) wird beim Start automatisch angezeigt, bei allen weiteren Formularen muss die Show-Methode nachhelfen.

Quelltext für Form1 In den implementation-Abschnitt von Form1 kopieren Sie folgenden Code: uses Unit2;

// sonst ist die Variable Form2 unbekannt!

procedure TForm1.Button1Click(Sender: TObject); // Form2 laden begin Form2.Show end; procedure TForm1.Button2Click(Sender: TObject); // Beenden begin Close end; end.

Zweiter Test Sie können jetzt durch Klick auf Button2 das zweite Formular anzeigen. Wenn Unit2 nicht eingefügt wurde, erfolgt eine Fehlermeldung des Compilers (Variable Form2 unbekannt)! Sie können die Unit2 auch weiter oben, also in der Uses-Klausel des Interface-Abschnitts, anführen, würden aber dadurch auch allen anderen eventuellen Nutzern der Unit1 Tür und Tor zur Unit2 öffnen, was in unserem Beispiel weder beabsichtigt noch notwendig ist.

Quelltext für Form2 Um weitere Möglichkeiten zu demonstrieren, wollen wir mit dem Screen-Objekt arbeiten. Dessen FormCount-Eigenschaft erfasst die Gesamtanzahl von Formularen, die sich auf dem Bildschirm befinden. Als Beispiel, wie man auf alle geöffneten Formulare der Applikation zugreifen kann (also

1469

25.4 Auf mehrere Formulare zugreifen

auch, falls vorhanden, Form3, Form4 ...), werden diese nach Klick auf Form2.Button2 gelb gefärbt. Mit Hilfe der Eigenschaft Forms (nur zum Lesen und nur zur Laufzeit verfügbar) kann auf dem Bildschirm auf ein bestimmtes Formular zugegriffen werden, indem man dessen Position als Index angibt. Das erste Formular hat den Indexwert 0, das zweite den Indexwert 1 usw. procedure TForm2.Button2Click(Sender: TObject); // alles gelb var i: Integer; begin for i := 0 to Screen.FormCount-1 do Screen.Forms[i].Color := clYellow; end; procedure TForm2.Button1Click(Sender: TObject); begin Close end;

// Beenden

Test Nachdem Sie Form2 von Form1 aus geladen haben, können Sie von Form2 aus beide Formulare gelb einfärben:

Bemerkung Beim Ausprobieren werden Sie mit folgender Frage konfrontiert: Wieso bewirkt die gleiche Anweisung (Close) bei Form1 das Schließen der gesamten Applikation und bei Form2 nur das Schließen des einzelnen Formulars? Antwort: Form1 ist standardmäßig das so genannte Hauptformular. Sie können das aber jederzeit ändern, indem Sie den Menüpunkt Projekt|Optionen... wählen und in dem sich öffnenden Fenster auf der Seite "Formulare" ein beliebiges anderes Formular zum Hauptformular küren.

1470

Kapitel 25

How-to: Komponenten/OOP

25.5 Nach Komponenten suchen Delphi lässt mit der FindComponent-Funktion einen "Spürhund" von der Leine, der beliebige Komponenten im Programm aufstöbern kann. Einzige Bedingung: Die Name-Eigenschaft muss bekannt sein. Wohlgemerkt, nur der Name. Ob es sich dabei um ein Editierfeld, ein Label usw. handelt, brauchen Sie nicht zu wissen. Im folgenden Testprogramm geben Sie den Namen der zu suchenden Komponente in ein Editierfeld ein. Falls die Aktion vom Erfolg gekrönt ist, erscheint die Beschriftung (Caption) der aufgespürten Komponente in roter Farbe.

Oberfläche Das erste Editierfeld (Edit1) dient zur Eingabe des Namens. Die auf dem Panel befindlichen Komponenten fungieren als Beispiele für zu suchende Objekte.

Quelltext Es werden nur die beiden wesentlichen Ereignisprozeduren der Unit1 angegeben. procedure TForm1.Button1Click(Sender: TObject); // Starte Suche var compo: TComponent; i : Integer; txt : String; begin txt := Edit1.Text; compo := TComponent(FindComponent(txt)); if compo <> nil then begin i := compo.ComponentIndex; if Components[i] is TLabel then TLabel(Components[i]).Font.Color := clRed; if Components[i] is TEdit then TEdit(Components[i]).Font.Color := clRed; if Components[i] is TCheckbox then TCheckbox(Components[i]).Font.Color := clRed; if Components[i] is TRadioButton then TRadioButton(Components[i]).Font.Color := clRed end else MessageBeep(0) end;

25.6 Den Besitzer einer Komponente ermitteln

1471

Test Starten Sie das Programm. Haben Sie einen gültigen Komponentennamen eingegeben (Groß-/ Kleinschreibung spielt keine Rolle), so wird die Farbe der Beschriftung der gefundenen Komponente geändert, bei Misserfolg hören Sie einen Piepton.

Bemerkungen ■ An Objektvariablen führt auch hier kein Weg vorbei, schließlich muss ja das Ergebnis der Suche irgendwie zugewiesen werden. Der Objekttyp TComponent ist der zugrunde liegende abstrakte Ausgangstyp für alle Komponenten. Jedes Element, das der Benutzer im FormularDesigner manipulieren kann, ist ein Nachkomme von TComponent. Alle Komponenten erben einen Teil ihrer Grundfunktionen von TComponent, so auch die Instanzen von TEdit, TLabel ... ■ Immer wenn beim Programmstart etwas neu zu zeichnen bzw. auszudrucken ist, sollte man dazu das FormPaint-Ereignis besetzen. FormCreate oder FormActivate sind dafür nicht zu gebrauchen. ■ Liefert die FindComponent-Funktion den Wert nil, so ist die gesuchte Komponente nicht im Formular vorhanden. In diesem Fall ergäbe das Zuweisen der ComponentIndex-Eigenschaft einen Laufzeitfehler.

25.6 Den Besitzer einer Komponente ermitteln Das folgende Beispiel ermittelt den Eigentümer eines Editierfeldes (Edit1) und alle seine Vorgänger innerhalb der Objekthierarchie. Gewissermaßen als "Zugabe" erfahren Sie auch noch die Größe des vom Eigentümer belegten Speicherplatzes.

Oberfläche Auf dem Startformular (Form1) platzieren Sie ein Editierfeld (Edit1), ein Listenfeld (ListBox1) und mehrere Labels, von denen nur eines (Label2) zur Informationsausgabe verwendet wird (die übrigen dienen lediglich zur Beschriftung):

1472

Kapitel 25

How-to: Komponenten/OOP

Quelltext Der gesamte für unser Beispiel wesentliche Code wird in das OnCreate-Ereignis von Form1 gepackt: procedure TForm1.FormCreate(Sender: TObject); var TComp: TComponent; Size: Word; SizeStr: string; curClass: TClass; begin TComp := Edit1.Owner; // Eigentümer zuweisen Edit1.Text := TComp.ClassName; // Namen ermitteln Size := TComp.InstanceSize; // Speicherplatz feststellen Str(Size, SizeStr); Label2.Caption := SizeStr+' Bytes'; // Anzeige des Speicherplatzbedarfs Listbox1.Clear; curClass:= Edit1.ClassType; // Objektklasse feststellen while curClass <> nil do begin ListBox1.Items.Add(curClass.ClassName); // Namen eintragen curClass:= curClass.ClassParent // Vorfahren ermitteln end end;

Test Sie brauchen das Programm nur zu starten und werden sofort mit folgendem Ergebnis konfrontiert:

25.7 Eine Ereignisprozedur zur Laufzeit zuweisen

1473

Der Besitzer von Edit1 ist der Objekttyp TForm1. Eine Instanz dieser aus TForm abgeleiteten Objektklasse belegt in unserem Fall 784 Bytes.

25.7 Eine Ereignisprozedur zur Laufzeit zuweisen Erzeugen Sie Komponenten erst zur Laufzeit oder wollen Sie auf bestimmte Ereignisse nicht sichtbarer Objekte (Application, Bitmap etc.) zurückgreifen, müssen Sie die Ereignisprozedur per Quellcode zuweisen. In diesem Rezept wollen wir zeigen, wie einem dynamisch erzeugten Button eine neue OnClickEreignisprozedur zugewiesen werden kann.

Oberfläche Ein nacktes Formular genügt! Wo aber bleibt der obligatorische "Beenden"-Button? Lassen Sie sich überraschen!

Quelltext Ergänzen Sie die private-Sektion der Typdeklaration TForm1 um die beiden unterstrichenen Anweisungen: type TForm1 = class(TForm) procedure FormCreate(Sender: TObject); private { Private-Deklarationen } newButton: TButton; procedure newButtonClick(Sender: TObject); public end;

Im implementation-Abschnitt tragen Sie folgenden Code in das FormCreate-Ereignis ein: procedure TForm1.FormCreate(Sender: TObject); begin newButton := TButton.Create(Application); with newButton do begin Parent := Form1; Caption := 'Beenden';

Die Ereignisprozedur wird zugewiesen: OnClick := newButtonClick;

Der neue Button soll exakt in der Mitte von Form1 erscheinen: Left Top end end;

:= (Parent.ClientWidth - Width) div 2; := (Parent.ClientHeight - Height) div 2;

1474

Kapitel 25

How-to: Komponenten/OOP

Die neue Ereignisprozedur müssen Sie komplett selbst eintippen (der Rahmencode wird nicht, wie gewohnt, von der IDE erzeugt): procedure TForm1.newButtonClick(Sender: TObject); begin Close end;

Test Nach Programmstart präsentiert sich der "von Geisterhand" erzeugte Button exakt in der Mitte des Formulars, und er funktioniert tatsächlich!

25.8 Zur Laufzeit alle Objekteigenschaften ermitteln Möchten Sie zur Laufzeit mehr über ein bestimmtes Objekt wissen, zum Beispiel über welche Eigenschaften das Objekt verfügt (siehe Objektinspektor), dann ist guter Rat teuer. Das folgende kleine Beispielprogramm zeigt Ihnen, wie Sie nicht nur die Eigenschaften selbst, sondern auch den jeweiligen Datentyp anzeigen können.

Oberfläche Erzeugen Sie ein Formular und fügen Sie eine ListBox und einen Button hinzu (die Listbox-Einträge werden zur Laufzeit erstellt).

25.9 Neue Komponenten-Packages installieren

1475

Quelltext Nehmen Sie die Unit TypeInfo in Ihr Projekt auf und erweitern Sie die Ereignisprozedur des Buttons wie folgt: uses TypInfo; ... procedure TForm1.Button1Click(Sender: TObject); var i : Integer; PropList : TPropList; begin GetPropList(Form1.ClassInfo, tkProperties, @PropList); i := 0; while( (Nil <> PropList[i]) and (i < High(PropList)) ) do begin ListBox1.Items.Add(PropList[i].Name + ': ' + PropList[i].PropType^.Name); Inc(i) end end;

Test Nach Klick auf den Button werden die Namen und Datentypen aller Eigenschaften von Form1 aufgelistet.

25.9 Neue Komponenten-Packages installieren Auf verschiedenen Internet-Sites werden Delphi-Komponenten zum freien Download angeboten. Für den Programmierer sind sie oft eine Quelle der Inspiration, da meist der komplette Sourcecode mitgeliefert wird. Vorteilhaft sind so genannte "native" Komponenten (also kein OCX bzw. ActiveX), da sie später keinen extra Installationsaufwand erfordern und unkompliziert mit der Project.exe weitergegeben werden können. Beim Versuch, die Neulinge auf die Komponentenpalette zu bringen, kommt es aber oft zu Fehlschlägen oder gar Wutausbrüchen, da die notwendige Installationsprozedur für den Einsteiger zu kompliziert ist und dieser meist nicht die notwendige Geduld zum intensiven Studium der verkorksten Formulierungen der Readme-Datei aufbringt.

Ein Beispiel muss her! Wir wollen die Vorgehensweise am Beispiel der sehr ergiebigen RX Library 2.75 demonstrieren, wie sie bis vor gar nicht allzu langer Zeit noch auf der Website http://www.rxlib.com zu finden war. HINWEIS: Leider wird eine für Delphi 7 aktualisierte Version der RX Library nicht mehr ange-

boten, die gezeigte Vorgehensweise dürfte aber für alle anderen Komponentenbibliotheken analog sein.

1476

Kapitel 25

How-to: Komponenten/OOP

Nach dem erfolgreichen Download muss zunächst die ZIP-Datei RXLIB275.ZIP entpackt werden. Im Ergebnis erscheinen neben diversen Readme-Dateien auch eine RSINST.EXE. Nach deren Aufruf scheint alles wie geschmiert zu laufen, denn die Installationsroutine (InstallShield) kopiert nun in ein von Ihnen zu bestimmendes Unterverzeichnis von Delphi (...\Borland\Delphi7\...) eine große Anzahl von Units (.PAS) und einige wenige .DPK-Dateien. InstallShield verabschiedet sich mit einer pompösen Erfolgsmeldung – wozu also die ganze Aufregung? Die Ernüchterung: Auf der Komponentenpalette werden Sie vergeblich nach den Neuankömmlingen Ausschau halten, denn der Hauptteil der Installation ist noch zu erledigen. Brennend vor Ungeduld beginnt zunächst ein zielloses Herumstochern in den verwirrenden Möglichkeiten, die das Komponenten-Menü bietet:

? Wissen muss man, dass dieses Menü im Moment nicht weiterhilft, sondern das Chaos weiter vergrößert.

Ohne Grundlagen geht nichts Basis für ein überlegtes Vorgehen ist das Verständnis der verschiedenen Dateitypen, die uns im Zusammenhang mit Packages begegnen: ■ .DPK (Quelldatei mit Liste der zum Package gehörenden Units) ■ .BPL (Compiliertes Package, quasi eine Windows-DLL) ■ .DCP (zugehörige binäre Info-Datei) ■ .PAS (Quelltextdatei für Unit) ■ .DCU (compilierte Unit) Nur die fettgedruckten Dateitypen (mindestens eine .DPK und eine oder mehrere .PAS) haben wir im Beispiel vom Internet heruntergeladen, die anderen müssen noch durch die IDE (Compiler) erzeugt werden. Die .DPK-Datei ist vergleichbar mit einer .DPR-Delphi-Projektdatei, da sie lediglich ein "Verzeichnis" enthält. Wichtig für das folgende Verständnis ist die Unterscheidung zwischen ■ Laufzeit (Runtime)-Package (Beispiel: RXCTL5.DPK) und ■ Entwufszeit (Designtime)-Package (Beispiel: DCLRX5.DPK)

25.9 Neue Komponenten-Packages installieren

1477

Während das Laufzeit-Package lediglich die Funktion der Programm-EXE sicherstellt, ermöglicht das Entwurfszeit-Package das Benutzen der Komponente auch in der Delphi-Entwicklungsumgebung. HINWEIS: Für beide Packages ist deshalb jeweils eine eigene .DPK-Datei erforderlich!

Laufzeit-Package installieren Über den Menüpunkt Datei\Öffnen... der Delphi-IDE öffnen Sie das Laufzeit-Package RXCTL5.DPK. In unserem Beispiel wurde die Datei von InstallShield in das Verzeichnis \Borland\Delphi5\RX\Units\ kopiert.

Klicken Sie den "Compilieren"-Button (oben links im Package-Fenster). Im Ergebnis entstehen die Dateien RXCTL5.BPL und RXCTL5.DCP.

Widerstehen Sie der Verlockung, jetzt schon auf den "Install"-Button zu klicken, denn das dürfen Sie nur für ein Entwurfszeit-Package (siehe nächster Abschnitt).

1478

Kapitel 25

How-to: Komponenten/OOP

Verschieben Sie die compilierte Datei RXCTL5.BPL in das Windows\System-Verzeichnis (oder ein anderes Suchverzeichnis entsprechend der in der Delphi-IDE eingestellten "PATH"-Umgebungsvariablen).

Entwurfszeit-Package installieren Um das Entwurfszeit-Package in die Delphi-IDE zu bringen und zu registrieren, gehen wir im ersten Schritt ähnlich wie beim Laufzeit-Package vor: Über Datei|Öffnen... wird die Designtime-Datei DCLRX5.DPK geladen und compiliert (Schaltfläche "Compilieren" im Package-Fenster). Klicken Sie nun auf die Schaltfläche "Install" im Package-Fenster und warten Sie auf den Moment, in dem sich Ihnen ein ähnlicher Anblick wie der folgende bietet.

Die Flut von Neuankömmlingen können Sie jetzt endlich in der Komponentenpalette bewundern.

Bemerkungen ■ Den Quelltext der Packages (.PAS-Dateien) sollten Sie nicht in der Delphi-IDE speichern. ■ Ältere Versionen der .BPL-Dateien sollten Sie vorher aufspüren und löschen. ■ In der zum Download meist mitgelieferten Readme-Datei finden Sie weitere Hinweise.

25.10 Aus einer Unit eine Komponente machen Um eigene Delphi-Komponenten zu entwickeln, braucht man kein Profi zu sein. Auch der Einsteiger ist bereits dazu in der Lage, wenn er sich im Unit-Konzept auskennt und sich etwas in die objektorientierte Programmierung eingelesen hat. Wir wollen die Vorgehensweise am Beispiel einer durchaus nützlichen Komponente newStringGrid demonstrieren, die hauptsächlich die Idee des Rezepts

1479

25.10 Aus einer Unit eine Komponente machen

Ä 18.55 Den Inhalt eines StringGrid in einer Datei sichern beinhaltet. In diesem Rezept wurde die neue Funktionalität des StringGrid in eine separate Unit ausgelagert, was das Umschreiben in Komponenten-Code sehr vereinfacht. Beachten Sie die Unterschiede durch Vergleichen! Zur weiteren Aufwertung wurde außerdem die Funktionalität von Ä 18.57 Die blaue Zelle im StringGrid verschwinden lassen hinzugenommen.

Unit testGrid Neue Komponenten werden als reiner Quelltext entwickelt, der in einer oder mehreren Units verpackt ist. Wir brauchen also keine Formulare (*.frm) und keine Projektdatei (*.dpr). Öffnen Sie eine neue Unit und benennen Sie diese um in testGrid und speichern Sie sie später auch unter exakt demselben Namen (testGrid.pas) ab. unit testGrid; interface uses Grids, Classes, SysUtils, Controls;

Unser neues Gitter wird als Nachkomme von TStringGrid deklariert, erbt also alle Eigenschaften, Methoden und Ereignisse. Zusätzlich erhält es vier Methoden und eine Write-Only-Eigenschaft (Dateipfad): type TtestGrid = class(TStringGrid) private path: string; public procedure saveGrdToFile; procedure loadGrdFromFile; procedure clearGrid; procedure cleanBlueCell; property filePath: string write path; end; procedure Register;

// nur Schreibzugriff

// achten Sie hier auf die Groß-/Kleinschreibung!!!

Im implementation-Abschnitt sind weitaus weniger Unterschiede zur klassischen Realisierung festzustellen. Lediglich der Klassenbezeichner TnewStringGrid ist den Namen der Methoden vorangestellt. implementation var buff: string; fStream: TFileStream;

// Puffervariable für eine Zelle des Gitters // Filestream (unser Dateityp)

1480

Kapitel 25

How-to: Komponenten/OOP

procedure TtestGrid.cleanBlueCell; var grdRec: TGridRect; begin with grdRec do begin Top := -1; Left := -1; Right := -1; Bottom := -1 end; Selection := grdRec end; procedure TtestGrid.saveGrdToFile; var i, j, m, row, col, len: Word; begin fStream := TFileStream.Create(path, fmCreate); // erzeugt neue (leere) Datei fStream.Free; fStream := TFileStream.Create(path, fmOpenWrite); // öffnet Datei für Schreibzugriff col := ColCount - 1; row := RowCount - 1; fStream.WriteBuffer(row, SizeOf(Word)); fStream.WriteBuffer(col, SizeOf(Word)); if FixedCols = 1 then m := 1 else m := 0; for i := 1 to row do for j := m to col do begin buff:= Cells[j,i]; len := Length(buff); fStream.WriteBuffer(len, SizeOf(Word)); fStream.WriteBuffer(buff[1], len) // Buffer => Datei end; fStream.Free end; procedure TtestGrid.loadGrdFromFile; var i, j, m, row, col, len: Word; begin fStream := TFileStream.Create(path, fmOpenRead); // öffnet Datei für Lesezugriff fStream.ReadBuffer(row, SizeOf(Word)); fStream.ReadBuffer(col, SizeOf(Word)); if FixedCols = 1 then m := 1 else m := 0; for i := 1 to row do for j := m to col do begin fStream.ReadBuffer(len, SizeOf(Word)); SetLength(buff, len); fStream.ReadBuffer(buff[1], len); Cells[j,i] := buff // Datei => Buffer

25.10 Aus einer Unit eine Komponente machen

1481

end; fStream.Free end; procedure TtestGrid.clearGrid; var i, j, m: Word; begin if FixedCols = 1 then m := 1 else m := 0; for j := m to ColCount-1 do for i:=1 to RowCount-1 do Cells[j,i] := '' end;

Diese Prozedur sorgt dafür, dass die neue Komponente auf der Seite "Beispiele" der Komponentenpalette ihren Platz findet. procedure Register; begin RegisterComponents('Beispiele', [TtestGrid]) end; end.

Installation Über das Menü Komponente|Komponente installieren .... gelangen Sie zu einem zweiseitigen Dialogfeld, das Ihnen die Auswahl bietet, die neue Komponente in ein bereits vorhandenes Package oder in ein neues Package zu compilieren. Es empfiehlt sich letztere Alternative, da wir durch unsere waghalsigen Experimente den bereits vorhandenen Bestand nicht gefährden wollen:

Nun folgen noch zwei Dialoge, die Sie mit "Ja" bzw. "OK" abschließen:

1482

Kapitel 25

How-to: Komponenten/OOP

Schauen Sie nun auf die "Beispiele"-Seite der Komponentenpalette, ob der Neuankömmling testGrid auch tatsächlich seinen Platz dort eingenommen hat:

Oberfläche Nehmen Sie ein testGrid von der "Beispiele"-Seite und platzieren Sie noch drei Buttons auf das Startformular:

Implementation-Abschnitt von Unit1 Beim Vergleich mit der klassischen Unit-Realisierung wird deutlich: Aus den Prozeduren sind Methoden geworden!

25.10 Aus einer Unit eine Komponente machen

1483

Wie die folgende Abbildung erklärt, erhalten Sie beim Quelltext schreiben die Unterstützung der Intellisense, wobei natürlich auch die neuen Methoden angeboten werden:

var pmax: Word = 10; procedure TForm1.FormCreate(Sender: TObject); var i: Word; begin with testGrid1 do begin ColCount := 4; DefaultColWidth:= 100; // alle Spalten zunächst 100 Pixel breit ColWidths[0] := 30; // erste Spalte nur 30 Pixel breit

Spaltenüberschriften zuweisen: Cells[0,0] := 'Nr'; Cells[1,0] := 'Name'; Cells[2,0] := 'Vorname'; Cells[3,0] := 'Geburtsdatum'; RowCount := pmax + 1; Options := Options + [goEditing, goTabs, goColSizing]; for i := 1 to pmax do Cells[0,i] := IntToStr(i); // Zeilen durchnummerieren filePath := 'Test1.dat'; // !!! cleanBlueCell // !!! end; end;

Schreiben in Datei: procedure TForm1.Button1Click(Sender: TObject); begin testGrid1.saveGrdToFile end;

Lesen von Datei: procedure TForm1.Button3Click(Sender: TObject); begin testGrid1.loadGrdFromFile end;

1484

Kapitel 25

How-to: Komponenten/OOP

Der Inhalt der Anzeige wird gelöscht: procedure TForm1.Button2Click(Sender: TObject); begin testGrid1.clearGrid end;

Die lästige blaue Zelle wird im OnExit-Event beseitigt: procedure TForm1.testGrid1Exit(Sender: TObject); begin testGrid1.cleanBlueCell end;

Test Falls beim Compilieren ein Fehler in der Komponenten-Unit auftaucht, können Sie diese sofort vor Ort editieren (In Place Editing).

Bemerkungen ■ Fügen Sie weitere Verbesserungen (Eigenschaften und Methoden) aus den übrigen StringGridRezepten hinzu, denn dies ist ein ideales Übungsfeld für die Komponentenentwicklung! ■ Falls Sie beim Laden des Projekts von der CD auf folgende Fehlermeldung stoßen

befindet sich die neue Komponente offensichtlich noch nicht auf der "Beispiele"-Seite der Komponentenpalette, und Sie müssen die Installation wiederholen.

25.11 Eine Farbauswahl-Komponente programmieren

1485

25.11 Eine Farbauswahl-Komponente programmieren Nachdem Sie im Rezept Ä 19.4 Grafiken in einem Listenfeld anzeigen die Vorgehensweise bei Grafikausgaben in Listboxen bzw. Comboboxen kennen gelernt haben, wollen wir jetzt eine Combobox so modifizieren, dass später ohne zusätzlichen Programmieraufwand die 16 Grundfarben angezeigt und über eine Color-Eigenschaft zugewiesen werden können (Farbauswahl). Sie werden feststellen, dass bereits mit wenigen Quelltextzeilen eine "selbst gestrickte" Komponente programmiert ist.

Quelltext Erster Schritt zur fertigen Komponente ist das Ableiten von einer bereits vorhandenen. Starten Sie dazu den "Komponenten-Experten" (Komponente|Neue Komponente...). Vergeben Sie einen eindeutigen Bezeichner für die neue Klasse (TFarbBox) und wählen Sie den gewünschten Typ des Vorfahren (TComboBox) aus.

Der "Experte" erzeugt danach folgendes Programmgerüst: unit FarbBox; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, StdCtrls; type TFarbBox = class(TComboBox) private { Private-Deklarationen } protected

1486

Kapitel 25

How-to: Komponenten/OOP

{ Protected-Deklarationen } public { Public-Deklarationen } published { Published-Deklarationen } end; procedure Register; implementation procedure Register; begin RegisterComponents('Beispiele', [TFarbBox]); end; end.

Würden Sie jetzt diese Komponente in Delphi einbinden, stünde die gesamte Funktionalität der Vorfahren-Klasse TComboBox zur Verfügung, ohne dass Sie auch nur eine Zeile Quellcode geschrieben haben. Wir wollen diese Komponente so verändern, dass die Combobox die 16 Grundfarben anzeigt. Erster Schritt ist das Überschreiben der Initialisierungsmethode Create. Diese wird in Delphi ausnahmsweise nicht als Procedure, sondern als Constructor bezeichnet, was auch in der Deklaration zum Ausdruck kommt (es handelt sich jedoch quasi um eine Prozedur). Erweitern Sie den Public-Abschnitt der Klassendefinition wie folgt: ... public constructor Create(AOwner: TComponent);override;

Die Umsetzung im Implementations-Abschnitt der Unit: constructor TFarbBox.Create(AOwner: TComponent); begin inherited Create(AOwner); // Aufruf der Vorfahr-Methode Style := csOwnerDrawFixed; // Festlegen der Style-Eigenschaft end;

Bei jeder Initialisierung der Komponente wird jetzt automatisch der Style csOwnerDrawFixed festgelegt. Da zu diesem Zeitpunkt die Komponente noch nicht komplett initialisiert ist, können wir auch noch nicht die benötigten 16 Einträge hinzufügen. Dazu müssen wir eine weitere Methode überschreiben bzw. erweitern: CreateWnd. Die Deklaration: protected procedure CreateWnd; override;

25.11 Eine Farbauswahl-Komponente programmieren

1487

Die Umsetzung: procedure TFarbBox.CreateWnd; var i: Integer; begin inherited CreateWnd; // Aufruf der Vorfahr-Methode Items.Clear; for i := 0 to 15 do Items.Add(''); ItemIndex := 0 end;

Für die Abfrage der gewählten Farbe erzeugen wir eine neue Eigenschaft, über die ein TColor-Wert abgefragt werden kann. Der Wert wird jedoch nicht direkt gespeichert, sondern über ein Array abgefragt. Verantwortlich dafür ist die Funktion getColor: ... private function getColor: TColor;

Das Array mit den Farbwerten (Index = Farbwert): const qbColor : array [0..15] of TColor = (0, 8388608, 32768, 8421376, 128, 8388736, 32896, 12632256, 8421504, 16711680, 65280, 16776960, 255, 16711935, 65535, 16777215);

Die Umsetzung von getColor: function TFarbBox.getColor:TColor; begin Result:= qbColor[ItemIndex] end;

ItemIndex ist die Nummer des ausgewählten ComboBox-Eintrags. Die Deklaration der neuen ReadOnly-Eigenschaft: published property color : TColor read getColor;

Alles, was jetzt noch bleibt, ist das Erweitern der DrawItem-Methode: protected procedure DrawItem(Index: Integer; Rect: TRect; State: TOwnerDrawState); override;

Die Umsetzung erfolgt wie im Rezept: Ä 19.4 Grafiken in einem Listenfeld anzeigen procedure TFarbBox.DrawItem(Index: Integer; Rect: TRect; State: TOwnerDrawState); begin Canvas.Brush.Color := qbColor[Index]; Canvas.FillRect(rect) end;

1488

Kapitel 25

How-to: Komponenten/OOP

Damit ist sie auch schon fertig, unsere neue Komponente. Sie müssen jetzt lediglich die Komponente in ein Delphi-Package aufnehmen (Komponente|Komponente installieren...), damit sie in der Toolbar angezeigt wird (Seite "Beispiele"). Wie Sie dem Neuling ein originelleres Erscheinungsbild als das von seinem Vorfahren TComboBox ererbte Paletten-Outfit geben können, siehe Ä 19.7 Eine Bitmap-Ressourcendatei erstellen

Test Unsere neue Komponente ist uns noch den Beweis ihrer Funktionsfähigkeit schuldig geblieben. Öffnen Sie eine neue Anwendung und platzieren Sie auf dem Startformular eine TFarbBoxKomponente. Beim Blick in den Objektinspektor sind Sie jetzt vielleicht etwas enttäuscht, fehlt doch die neue Eigenschaft Color. Der Grund ist schnell gefunden: Da es sich um eine ReadOnlyEigenschaft handelt, hat es wenig Sinn, wenn sie im Objektinspektor angezeigt wird. Zur Laufzeit steht die Eigenschaft natürlich zur Verfügung. Besetzen Sie das OnClick-Event der FarbBox wie folgt: procedure TForm1.FarbBox1Click(Sender: TObject); begin Color := FarbBox1.Color end;

Nachdem Sie das Programm gestartet haben, können Sie durch Klick auf einen Eintrag für den Formularhintergrund eine von 16 Farben auswählen:

Bemerkungen ■ Wenn Sie das Beispiel von der Buch-CD ausprobieren, sollten Sie zunächst nur die Unit FarbBox.pas in die IDE laden und über Komponente|Komponente installieren... die FarbBox in ein neues oder ein bereits vorhandenes Package compilieren. ■ Nachdem Sie sich vergewissert haben, dass die neue Komponente auf der "Beispiele"-Seite der Komponentenpalette gelandet ist, laden Sie das komplette Projekt. ■ Unter Windows XP mussten wir die Unit XPMan in das Projekt aufnehmen, um ein fehlerfreies Funktionieren der Komponente zu gewährleisten.

25.12 Eine unsichtbare Komponente programmieren

1489

25.12 Eine unsichtbare Komponente programmieren Ausgangspunkt für derartige Komponenten, die zur Laufzeit im Hintergrund agieren, ist die Klasse TComponent. An dieser Stelle wollen wir uns auf eine Komponente beschränken, die ein Dialogformular verwaltet (ähnlich TOpenDialog). Dabei wollen wir uns nicht auf das einfache Anzeigen des Dialogs beschränken, sondern auch eine Interaktion ermöglichen. Dazu ist es nötig, Ereignisse des Formulars über das Komponenten-Interface zur Verfügung zu stellen. HINWEIS: Zum Installieren der Komponente siehe z.B. Rezept 25.10.

Klassendefinition Ausgangspunkt ist, wie nicht anders zu erwarten, eine Ableitung der Klasse TComponent: type TNonVis = class(TComponent) private FOnYesClick: TNotifyEvent; FOnNoClick: TNotifyEvent; FOnHelpClick: TNotifyEvent; FBoundedEdit: TEdit; protected procedure Notification(AComponent: TComponent; Operation: TOperation); override; public procedure ShowDialog; published property BoundedEdit: TEdit read FBoundedEdit write FBoundedEdit; property OnYesClick: TNotifyEvent read FOnYesClick write FOnYesClick; property OnNoClick: TNotifyEvent read FOnNoClick write FOnNoClick; property OnHelpClick: TNotifyEvent read FOnHelpClick write FOnHelpClick; end;

Neben drei Ereignissen (wir kommen später darauf zurück) wird eine Eigenschaft (ein gebundenes Editfeld) sowie eine Methode (die Anzeige des Dialogs) über die Komponente bereitgestellt.

Implementierung des Formulars Erzeugen Sie einen einfachen Dialog mit folgendem grundsätzlichen Aufbau:

Erweitern Sie nachfolgend die Klassendefinition des Formulars:

1490

Kapitel 25

How-to: Komponenten/OOP

type TMyForm1 = class(TForm) BitBtn1: TBitBtn; BitBtn2: TBitBtn; BitBtn3: TBitBtn; Edit1: TEdit; procedure BitBtn1Click(Sender: TObject); procedure BitBtn2Click(Sender: TObject); procedure BitBtn3Click(Sender: TObject); private public FKompo : TNonvis end;

Über diese recht einfach implementierte Eigenschaft FKomp (Sie könnten auch zwei InterfaceMethoden schreiben) werden wir eine Referenz auf die Komponenten-Instanz übergeben. Auf diese Weise wird es uns möglich, aus dem Dialog heraus auf Ereignisse und Eigenschaften der Komponente Einfluss zu nehmen. In unserem speziellen Beispiel geht es darum, dass jeder Tastendruck ein Ereignis in der Komponente auslösen soll: procedure TMyForm1.BitBtn1Click(Sender: TObject); begin if Assigned(FKompo.OnYesClick) then FKompo.OnYesClick(Self); if Assigned(FKompo.BoundedEdit) then FKompo.BoundedEdit.Text:= Edit1.Text; Close end; procedure TMyForm1.BitBtn2Click(Sender: TObject); begin if Assigned(FKompo.OnNoClick) then FKompo.OnNoClick(Self); Close end; procedure TMyForm1.BitBtn3Click(Sender: TObject); begin if Assigned(FKompo.OnHelpClick) then FKompo.OnHelpClick(Self) end;

Nach dem Test, ob die jeweilige Methode bzw. Eigenschaft auch zugewiesen wurde (if Assigned), können wir die Ereignisse auslösen bzw. die Eigenschaften setzen.

Komponenten-Interface Bleibt lediglich die Implementierung der Komponente: uses mForm1;

Vor der Anzeige der Dialogbox müssen wir die aktuelle Instanz (Self) der Komponente an den Dialog übergeben.

25.12 Eine unsichtbare Komponente programmieren

1491

procedure TNonVis.ShowDialog; begin myForm1.FKompo := Self; myForm1.ShowModal end;

Werden gebundene Komponenten geändert (BoundedEdit), müssen wir darauf reagieren: procedure TNonVis.Notification(aComponent: TComponent; Operation: TOperation); begin inherited Notification(aComponent, Operation); if (Operation = opRemove) and (FBoundedEdit <> nil) and (aComponent = BoundedEdit) then BoundedEdit := nil end;

Damit ist unsere Komponente auch schon fertig. In einem Programm kann nach dem Einbinden der Komponente und dem Aufruf der Methode ShowDialog über die Ereignisse der aktuelle Status der Dialogbox abgefragt werden. BEISPIEL: Reaktion auf die "Nein"-Taste procedure TForm1.NonVis1NoClick(Sender: TObject); begin ShowMessage('No wurde gewählt'); Abort end;

Oberfläche (Testprogramm) Installieren Sie die Komponente wie gewohnt und erstellen Sie nachfolgend ein neues Projekt. In das Hauptformular fügen Sie die Komponente, einen Button und ein Editfeld ein:

Die Komponente können Sie mit dem Textfeld über den Objektinspektor verbinden:

1492

Kapitel 25

How-to: Komponenten/OOP

Quelltext (Testprogramm) Fügen Sie hinter dem Button den folgenden Code ein: procedure TForm1.Button1Click(Sender: TObject); begin nonvis1.ShowDialog; end;

Die drei Ereignisse der Komponente werden wie folgt belegt: procedure TForm1.NonVis1YesClick(Sender: TObject); begin showmessage('Yes wurde gewählt'); end; procedure TForm1.NonVis1NoClick(Sender: TObject); begin showmessage('No wurde gewählt'); abort end; procedure TForm1.NonVis1HelpClick(Sender: TObject); begin showmessage('Help wurde gewählt'); end;

Test Starten Sie das Programm und klicken Sie auf den Button. Nachfolgend können Sie im Dialogfenster die Komponentenereignisse auslösen:

Bemerkung Soll die Komponente Windows-Botschaften empfangen, bekommen Sie Schwierigkeiten. Unsichtbare Komponenten können keine Botschaften empfangen, da es sich nicht um Fenster handelt. Wie es dennoch geht, zeigt Ihnen z.B. das Rezept: Ä 20.3 Einen Joystick abfragen

25.13 Eine grafische Komponente programmieren

1493

25.13 Eine grafische Komponente programmieren Eine dritte Gruppe von Komponenten ist für die grafische Ausgabe im weitesten Sinne zuständig. Dabei kann es sich um einfache Grafiken (Vektor/Bitmap) oder auch um komplexere Darstellungen (Tabellen etc.) handeln. In die Wahl des Vorfahrtyps sollten Sie folgende Überlegungen einbeziehen: ■ Braucht die Komponente ein Fenster-Handle? ■ Soll die Komponente zur Laufzeit den Fokus erhalten? ■ Sollen andere Komponenten im Clientbereich der Komponente abgelegt werden? Ist keine der obigen Forderungen zu erfüllen, können Sie die Komponente von TGraphicControl ableiten. Andernfalls wäre TWinControl oder einer der Nachfahren von TWinControl die richtige Wahl. HINWEIS: Komponenten, die von TGraphicControl abgeleitet werden, verbrauchen weniger

Systemressourcen, da keine Fenster-Handles zu verwalten sind! Als Beispiel wollen wir eine einfache Komponente realisieren, die in der Lage ist, Grafiken aus einer ImageList anzuzeigen. Zwei Eigenschaften bilden dabei die Schnittstelle: ■ ImageList ■ ImageIndex Erzeugen Sie also eine neue Komponente (z.B. ImageView), die von der Klasse TGraphicControl abgeleitet wird. HINWEIS: Zum Installieren der Komponente siehe Vorgängerrezepte oder Liesmich.txt auf der

Buch-CD.

Komponenten-Interface Erweitern Sie die Klassendefinition wie folgt: type TImageView = class(TGraphicControl) private FImageList : TImageList; FImageIndex : Integer; procedure SetImageList(value: TImageList); function GetImageList:TImageList; procedure SetImageIndex(value:Integer); function GetImageIndex:Integer; protected procedure paint; override; procedure Notification(AComponent: TComponent; Operation: TOperation); override;

1494

Kapitel 25

How-to: Komponenten/OOP

public constructor Create(AOwner:Tcomponent); override; published property Imagelist: TImageList read getImageList write setImageList; property ImageIndex: integer read getImageIndex write setImageindex; end;

Neben einer privaten Variablen zum Speichern der Referenz auf das ImageList-Objekt (FImageList) benötigen wir noch einige Interface-Methoden (Get..., Set...). Wesentlichster Teil unserer Erweiterung ist das Überschreiben der Paint-Methode. Diese wird vom Parent der Komponente immer dann aufgerufen, wenn der Inhalt erneut dargestellt werden muss. Da die Eigenschaft ImageList an eine weitere Komponente gebunden ist, müssen wir auch die Notification-Methode erweitern.

Der Konstruktor Beim Initialisieren der Komponente sollten Sie eine Mindestgröße festlegen, da andernfalls nichts mehr zu sehen ist. constructor TImageView.Create(aOwner:TComponent); begin inherited Create(aOwner); Width := 30; Height := 30 end;

Die Paint-Methode Unsere Ausgabeprozedur ist die Paint-Methode. An dieser Stelle ist es besonders wichtig zu prüfen, ob überhaupt eine ImageList zugewiesen wurde. Nachfolgende Zugriffe auf dieses Objekt würden andernfalls zu Schutzverletzungen führen. procedure TImageView.paint; begin inherited paint; if FImagelist <> NIL then begin if Width <> FImagelist.Width then width := FImagelist.Width; if Height <> FImagelist.Height then Height := FImageList.Height; FImageList.Draw(Canvas,0,0,FImageIndex) end; //----------------------------------------if csDesigning in ComponentState then Canvas.DrawFocusRect(Bounds(0,0, Width, Height)) end;

Die eigentliche Darstellung des ImageList-Icons ist relativ simpel. Beachten Sie jedoch die Anweisungen im zweiten Teil der Paint-Methode. Hier wird mit der Methode DrawFocusRect ein Fokus-Rahmen gezeichnet, wenn die Komponente in der Entwurfsumgebung angezeigt wird (ComponentState). Lassen Sie diese Anweisungen weg, ist die Komponente auch zur Entwurfszeit nicht auf dem Formular zu sehen.

25.13 Eine grafische Komponente programmieren

1495

Die Notification-Methode Auf das Löschen der ImageList reagieren wir mit: procedure TImageView.Notification(AComponent: TComponent; Operation: TOperation); begin inherited Notification(AComponent, Operation); if (Operation = opRemove) and (FImagelist <> nil) and (AComponent = Imagelist) then begin ImageList := nil; ImageIndex :=0 end end;

Interface-Implementierung Unsere Interface-Methoden haben neben der reinen Wertübergabe auch noch weitere Aufgaben: procedure TImageView.SetImageList(value: TImageList); begin FImageList := Value; FImageIndex := 0; if FImageList <> nil then begin Width := FImageList.Width; Height := FImagelist.Height; Paint end end; Function TImageView.GetImageList:TImageList; begin Result := FImageList end; procedure TImageView.SetImageIndex(value:Integer); begin if FImageList <> nil then if value > fImageList.Count-1 then value := fImageList.Count-1; FImageIndex := value; Paint end; function TImageView.GetImageIndex:Integer; begin result := FImageIndex end;

So wird neben der Skalierung auch gleich eine Fehlerprüfung (zu große Werte) integriert.

1496

Kapitel 25

How-to: Komponenten/OOP

Test Nach Installation der Komponente platzieren Sie diese zusammen mit einer ImageList auf ein Formular und weisen die Eigenschaften ImageList und ImageIndex zu. Bereits zur Entwurfszeit wird das Bildchen angezeigt.

HINWEIS: Hinweise zum Ausprobieren/Installieren des Beispiels auf der Buch-CD finden Sie in

den Vorgängerrezepten bzw. in der beigefügten Liesmich.txt.

25.14 Eine Systemkomponente schreiben Wem es zu viel Arbeit ist, diverse Systeminformationen mühsam über API-Aufrufe zu ermitteln, kann sich mit der im Folgenden vorgestellten Komponente helfen. Neben diversen Informationen wie ■ Betriebssystem ■ Farbauflösung ■ Speicher ■ Windows-Directory ■ System-Directory ■ User-Name ■ Computer-Name ■ Prozessortyp bietet die Komponente auch die Möglichkeit, Drag & Drop-Operationen des Explorers über ein Event auszuwerten. Last but not least kann die Anwendung über eine Eigenschaft vor dem TaskManager versteckt werden. HINWEIS: Zum Installieren der Komponente siehe Rezept 25.10.

Quelltext unit syscomp; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;

25.14 Eine Systemkomponente schreiben

1497

Als Erstes definieren wir einen neuen Event-Typ, alle mittels Drag & Drop an die Anwendung übergebenen Dateinamen sollen über den Parameter Files ausgelesen werden können: type TDragDropEvent = procedure(Files : TStringList) of object;

Die verschiedenen Betriebssysteme lassen sich über folgenden Typ auseinander halten: TBetriebsSystem = (bsWin95, bsWinNT, bsWin32);

Damit kommen wir zur eigentlichen Komponentendefinition. Ausgangspunkt ist die Basisklasse TComponent, da wir eine nicht sichtbare Komponente programmieren wollen. TSystem = class(TComponent) private

Interne Variablen und Schnittstellenfunktionen: FOnDragDrop : TDragDropEvent; FFiles : TStringList; FHide : Boolean; procedure SetHide(status: Boolean); function GetColorCount:Integer; function getTotalPhysMemory:Longint; function getAvailPhysMemory:Longint; function getTotalPageFile:Longint; function getAvailPageFile:Longint; function getWindowsDirectory:String; function getSystemDirectory:String; function getUserName:String; function getComputerName:String; function getProcessorType:String; function getProcessorCount:Integer; function getSystem: TBetriebsSystem; procedure AppMessage(var Msg: Tmsg; var Handled: Boolean); public constructor Create(AOwner: TComponent); override; published

Die Ereignisse: property OnDragDrop: TDragDropEvent read FOnDragDrop write FOnDragDrop;

Eigenschaften: property property property property property property property property

ColorCount: Integer read GetColorCount; Hide: Boolean read FHide write SetHide; TotalPhysMemory: Longint read getTotalPhysMemory; AvailPhysMemory: Longint read getAvailPhysMemory; TotalPageFile: Longint read getTotalPageFile; AvailPageFile: Longint read getAvailPageFile; WindowsDirectory: String read getWindowsDirectory; SystemDirectory: String read getSystemDirectory;

1498

Kapitel 25

How-to: Komponenten/OOP

property UserName: String read getUserName; property ComputerName: String read getComputerName; property ProcessorType: String read getProcessorType; property ProcessorCount: Integer read getProcessorCount; property System: TBetriebsSystem read GetSystem; end; procedure Register; implementation

Die Unit brauchen wir für die Drag & Drop-Unterstützung: uses shellapi;

Registrieren der Komponente und Platzieren auf der "Beispiele"-Seite der Komponentenpalette: procedure Register; begin RegisterComponents('Beispiele', [TSystem]); end;

Mit dem Erstellen der Komponente registrieren wir auch das Formular als Drag & Drop-Ziel: constructor TSystem.Create(AOwner: TComponent); begin inherited; FFiles:= TStringList.Create; DragAcceptFiles((AOwner As TForm).handle , True); DragAcceptFiles(Application.Handle, True); Application.OnMessage := AppMessage end;

Weitere Informationen zum Thema Drag & Drop finden Sie in: Ä 28.20 Drag & Drop mit dem Explorer realisieren Farbtiefe bestimmen: function TSystem.GetColorCount:Integer; begin GetColorCount := 1 SHL GetDeviceCaps(GetDC(0), BITSPIXEL) end;

Anwendung vor dem Task-Manager verstecken, wenn Hide auf True gesetzt wird: procedure TSystem.SetHide(status:Boolean); begin FHide := Status; If Status then showWindow(application.handle,sw_hide) else showWindow(application.handle,sw_show) end;

25.14 Eine Systemkomponente schreiben

Die folgende Routine reagiert auf Messages, unter anderem auch auf WM_DROPFILES: procedure TSystem.AppMessage(var Msg: Tmsg; var Handled: Boolean); var i : integer; anzahl : word; PFilename : PChar; begin if Msg.Message = WM_DROPFILES then begin PFilename:=StrAlloc(255); FFiles.Clear; // bestimmt die Anzahl der Dateinamen ... anzahl := DragQueryFile(Msg.WParam,$FFFFFFFF,PFilename, 255); for i := 0 to (anzahl - 1) do begin DragQueryFile(Msg.WParam, i, PFilename, 255); FFiles.add(StrPas(PFilename)); end; DragFinish(Msg.WParam); Handled := True;

Sollte eine Ereignisprozedur zugewiesen worden sein, wird diese jetzt und hier aufgerufen: if assigned(FOnDragDrop) then FOnDragDrop(FFiles); StrDispose(PFilename) end; end;

Speicherinformationen ermitteln: function TSystem.getTotalPhysMemory:Longint; var memory : TMEMORYSTATUS; begin GlobalMemoryStatus(memory); getTotalPhysMemory:= memory.dwTotalPhys; end; function TSystem.getAvailPhysMemory:Longint; var memory : TMEMORYSTATUS; begin GlobalMemoryStatus(memory); getAvailPhysMemory:= memory.dwAvailPhys; end; function TSystem.getTotalPageFile:Longint; var memory : TMEMORYSTATUS; begin GlobalMemoryStatus(memory); getTotalPageFile:= memory.dwTotalPageFile; end;

1499

1500

Kapitel 25

How-to: Komponenten/OOP

function TSystem.getAvailPageFile:Longint; var memory : TMEMORYSTATUS; begin GlobalMemoryStatus(memory); getAvailPageFile:= memory.dwAvailPageFile; end;

Das Windows-Verzeichnis bestimmen: function TSystem.getWindowsDirectory:String; var P: PChar; begin P:=StrAlloc(MAX_PATH+1); windows.GetWindowsDirectory(P,MAX_PATH+1); getWindowsDirectory:= P; StrDispose(P); end;

Systemverzeichnis: function TSystem.getSystemDirectory:String; var P: PChar; begin P:=StrAlloc(MAX_PATH+1); windows.GetSystemDirectory(P,MAX_PATH+1); getSystemDirectory:= P; StrDispose(P); end;

Den User-Namen (im Netzwerk wichtig) bestimmen: function TSystem.getUserName:String; var P : PChar; size: DWord; begin size :=1024; P:=StrAlloc(size); windows.GetUserName(P,size); getUserName:= P; StrDispose(P); end;

Computer-Name: function TSystem.getComputerName:String; var P : PChar; size: DWord; begin size :=MAX_COMPUTERNAME_LENGTH+1; P:=StrAlloc(size); windows.GetComputerName(P,size); getComputerName:= P; StrDispose(P); end;

1501

25.14 Eine Systemkomponente schreiben

Der Prozessortyp wird als String zurückgegeben: function TSystem.getProcessorType:String; var systeminfo:TSystemInfo; zw : string; begin GetSystemInfo(systeminfo); case systeminfo.dwProcessorType 386 : zw := 'Intel 486 : zw := 'Intel 586 : zw := 'Intel 860 : zw := 'Intel 21064 : zw := 'ALPHA end; result := zw; end;

of 386'; 486'; Pentium'; 860'; 21064';

Unter NT/2000/XP sind auch mehrere Prozessoren möglich: function TSystem.getProcessorCount:Integer; var systeminfo:TSystemInfo; begin GetSystemInfo(systeminfo); result := systeminfo.dwNumberOfProcessors; end;

Das Betriebssystem: function TSystem.getSystem:TBetriebsSystem; var os : TOSVERSIONINFO; begin os.dwOSVersionInfoSize := sizeof(os); GetVersionEx(os); case os.dwPlatformId of VER_PLATFORM_WIN32s : result := bsWin32; VER_PLATFORM_WIN32_WINDOWS : result := bsWin95; VER_PLATFORM_WIN32_NT : result := bsWinNT; end end;

Zur weiteren Unterscheidung der Betriebssysteme siehe Ä 27.12 Das aktuelle Betriebssystem ermitteln

Testoberfläche Neben der neu entwickelten Komponente brauchen wir noch eine ListBox und einen Button.

1502

Kapitel 25

How-to: Komponenten/OOP

Quellcode zum Testen procedure TForm1.Button1Click(Sender: TObject); begin with ListBox1.Items do begin add('Prozessortyp: ' + system1.ProcessorType); add(Format('Vefügbarer Speicher: %d',[system1.TotalPhysMemory])); add(Format('Belegter Speicher: %d',[system1.AvailPhysMemory])); add('Windows-Verzeichnis: ' + system1.WindowsDirectory); add('Systemverzeichnis: ' + system1.SystemDirectory); add('Benutzername: ' + system1.UserName); add('Computername: ' + system1.ComputerName); end; end;

Einlesen der Drag & Drop-Dateinamen in ein Listenfeld procedure TForm1.System1DragDrop(Files: TStringList); begin Listbox1.Items := files end;

Test

HINWEIS: Hinweise zum Ausprobieren/Installieren des Beispiels auf der Buch-CD finden Sie in

den Vorgängerrezepten bzw. in der beigefügten Liesmich.txt.

25.15 Word-Formulare über OLE drucken

1503

25.15 Word-Formulare über OLE drucken Arbeiten Sie auch mit dem Microsoft Office-Paket, dann können Sie Word zum idealen ReportGenerator umbauen. Der Vorteil liegt auf der Hand: Der Report kann einfach durch jeden editiert werden, die Daten laden wir erst zur Laufzeit in das vorhandene Formular.

Oberfläche Der Aufbau der Oberfläche dürfte selbst erklärend sein:

Auch unser "Report" ist nicht zu anspruchsvoll, für einen kleinen Test dürfte es aber reichen. Starten Sie Word und gestalten Sie den Report nach Ihren Wünschen. Fügen Sie als Platzhalter Formularfelder (Symbolleiste Formular) ein. Auf diese Weise kann der Report entweder "von Hand" oder per Programm ausgefüllt werden.

Speichern Sie das Dokument im Verzeichnis des Delphi-Beispielprogramms ab.

1504

Kapitel 25

How-to: Komponenten/OOP

Quelltext Der Zugriff auf das Word-Dokument wird, wie nicht anders zu erwarten, über OLE realisiert: uses comobj; {$R *.DFM} var word: variant; procedure TForm1.Button1Click(Sender: TObject); begin word := CreateOleObject('Word.Application'); word.visible := True;

Nach dem Erzeugen einer Objektinstanz laden wir den gewünschten Report: word.Documents.Open(FileName:= ExtractFilePath(Paramstr(0)) + 'gehalt.doc');

Nachfolgend können wir die Formularfelder füllen: word.ActiveDocument.FormFields.Item('Text1').Result := edit1.text; word.ActiveDocument.FormFields.Item('Text2').Result := edit2.text; word.ActiveDocument.FormFields.Item('Text3').Result := edit3.text end;

Für den Ausdruck könnten wir auch aus Delphi sorgen, günstiger ist es allerdings, wenn dies der Endbenutzer vornimmt (so kann auch der Drucker gewechselt werden).

Test Starten Sie das Programm, füllen Sie die Editfelder aus und drücken Sie auf den Button.

1505

25.16 Eine .NET-Assembly einbinden

25.16 Eine .NET-Assembly einbinden Das wohl wichtigste neue Feature von Delphi 7 ist die Möglichkeit des Einbindens von .NETKomponenten. Wir wollen hier den Zugriff auf die ArrayList-Komponente demonstrieren, die Bestandteil der mscorlib.dll-Assembly ist. HINWEIS: Als Voraussetzung für dieses Beispiel muss das .NET-Framework installiert sein!

Assembly registrieren Wechseln Sie an der Kommandozeile in das Verzeichnis des Microsoft .NET-Frameworks, in welchem sich die mscorlib.dll befindet, und führen Sie dort den Befehl regasm mscorlib.dll

aus:

Oberfläche Neben einer ListBox werden noch einige Buttons benötigt.

Quellcode uses ComObj; var dotNetArrList:Variant;

// Objektvariable

1506

Kapitel 25

How-to: Komponenten/OOP

Start: procedure TForm1.Button1Click(Sender: TObject); var cap: Integer; item: Variant; i: Integer; begin

Das Objekt erzeugen: dotNetArrList := CreateOleObject('System.Collections.ArrayList');

Die Kapazität der ArrayList lesen: cap := dotNetArrList.Capacity; ListBox1.Items.Add('Kapazität der ArrayList: ' + IntToStr(cap));

Drei Einträge hinzufügen: dotNetArrList.Add('Das ist der erste Eintrag in die ArrayList!'); dotNetArrList.Add('Das ist der zweite Eintrag in die ArrayList!'); dotNetArrList.Add('Das ist der dritte Eintrag in die ArrayList!');

Alle Einträge lesen: for i := 0 to dotNetArrList.Count-1 do begin item := dotNetArrList.Item(i); ListBox1.Items.Add(item) end end;

Test

Bemerkung Falls wir, wie im Beispiel, die ArryaList mit einem parameterlosen Konstruktor aufrufen, kann sie standardmäßig 16 Einträge aufnehmen (Capacity=16). Die Count-Eigenschaft hingegen entspricht der Anzahl der tatsächlich belegten Einträge.

26

How-to: Internet/Intranet

Kapitel

26

How-to: Internet/Intranet 26.1 Feststellen, ob TCP/IP auf dem PC installiert ist Ohne TCP/IP-Protokoll geht heute kaum noch etwas. Es kann deshalb einigen Ärger sparen, wenn unsere Internet-Applikationen gleich beim Start feststellen könnten, ob TCP/IP auf dem Anwendungsrechner installiert ist.

Oberfläche

Quellcode Binden Sie zunächst im interface-Abschnitt die Winsock-Unit ein: uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, Winsock;

... und ergänzen Sie die Typdeklaration von TForm1 um eine neue Methode: type TForm1 = class(TForm) Button1: TButton; procedure Button1Click(Sender: TObject); private public function IsTCPIP: boolean; { Public declarations } end;

1508

Kapitel 26

How-to: Internet/Intranet

Der implementation-Abschnitt: function TForm1.IsTCPIP: boolean; var wsaData: TWSAData; begin result := true; case Winsock.WSAStartup($0101, wsaData) of WSAEINVAL, WSASYSNOTREADY, WSAVERNOTSUPPORTED: result := false; else Winsock.WSACleanup end end;

Der Aufruf der Funktion: procedure TForm1.Button1Click(Sender: TObject); begin if IsTCPIP then MessageDlg('TCP/IP ist installiert!', mtInformation, [mbOk],0) else MessageDlg('TCP/IP ist nicht installiert!', mtWarning, [mbOk],0) end;

Als Alternative zu ShowMessage kommt hier die vielgestaltige MessageDlg-Funktion (Unit Dialogs) zum Einsatz.

Test Nach dem Klick auf den Button informiert Sie eine MessageBox über den Stand der Dinge:

26.2 Die IP-Adresse des aktiven Computers ermitteln Die im Folgenden vorgestellte Funktion ermöglicht Ihnen, die IP-Adresse des aktuellen Computers abzufragen. Binden Sie zunächst die Unit WinSock ein. In der eigentlichen Prozedur müssen Sie vor der Abfrage der Informationen die Winsock-Funktionen initialisieren. Dazu wird neben der erforderlichen Winsock-Version (in unserem Fall 1.1) auch eine WSDATA-Struktur übergeben, die für uns jedoch bedeutungslos ist. Schlägt die Initialisierung fehl, beenden wir die Funktion an dieser Stelle und geben einen Leerstring zurück.

26.3 Ermitteln, ob eine Internet-Verbindung besteht

1509

Im Erfolgsfall ermitteln wir zunächst den Computernamen (z.B. "PPro200"). Mit diesem können wir nachfolgend über die Funktion GetHostByName die gewünschten Informationen abfragen. Allerdings sind hier Einflüsse von C-Programmierern unübersehbar: Die Autoren haben selten eine so verschachtelte Arbeit mit Pointern realisieren müssen. Der Aufruf der Funktion inet_ntoa wird zum Hürdenlauf aus Dereferenzierung und Typisierung von Zeigern. uses WinSock; ... function GetIPAddress: string; var phoste : PHostEnt; Buffer : array [0..100] of char; WSAData : TWSADATA; begin result := ''; if WSAStartup($0101, WSAData) <> 0 then exit; GetHostName(Buffer, SizeOf(Buffer)); phoste :=GetHostByName(buffer); if phoste = nil then result := '127.0.0.1' else result := StrPas(inet_ntoa(PInAddr(phoste^.h_addr_list^)^)); WSACleanup end;

Verwendung der Funktion: procedure TForm1.Button1Click(Sender: TObject); begin Label1.Caption := getIPAddress end;

Test

26.3 Ermitteln, ob eine Internet-Verbindung besteht Möchten Sie überprüfen, ob der Computer über eine Internet-Anbindung verfügt, können Sie sich der API-Funktion InternetGetConnectedState bedienen. Das folgende Beispiel zeigt die Verwendungsmöglichkeiten.

1510

Kapitel 26

How-to: Internet/Intranet

Oberfläche Den Grundaufbau der Oberfläche entnehmen Sie bitte der folgenden Abbildung:

Quelltext Binden Sie zunächst die Unit WinInet ein: uses WinInet;

Die Funktion InternetGetConnectedState erwartet einen DWord-Pointer, um Informationen über die Art der Internet-Verbindung zurückzugeben. Die Funktion selbst gibt True oder False zurück. procedure TForm1.Button1Click(Sender: TObject); var dwFlags : DWord; begin if InternetGetConnectedState(@dwFlags, 0) then begin checkbox1.Checked := (dwFlags and INTERNET_CONNECTION_MODEM) <> 0; checkbox2.Checked := (dwFlags and INTERNET_CONNECTION_LAN) <> 0; checkbox3.Checked := (dwFlags and INTERNET_CONNECTION_PROXY) <> 0; ShowMessage('Internet-Connection vorhanden!') end end;

Test Starten Sie das Programm und klicken Sie auf den Test-Button.

26.4 Dateien automatisch aus dem Internet laden

1511

26.4 Dateien automatisch aus dem Internet laden Soll Ihr Programm eine einfache Update-Möglichkeit mit Internet-Anbindung bieten, müssen Sie nicht gleich mit Kanonen auf Spatzen schießen. Bevor Sie extra ein neues FTP-Programm schreiben, sollten Sie sich in der API bzw. bei den Delphi-Units umsehen. Die Unit URLMon bietet Ihnen mit der Funktion UrlDownloadToFile alles, was Sie für den Download einer einzelnen Datei aus dem Internet benötigen. Der Vorteil dieser Variante: Die RAS- bzw. Proxy-Einstellungen des Internet Explorers werden automatisch für den Download genutzt, Ihr Programm kommt ohne jede Konfiguration ans Ziel1.

Oberfläche Ein Formular, ein einsamer Button und ein Memofeld genügen.

Quelltext Binden Sie zunächst die beiden folgenden Units ein: uses URLmon, ShellApi;

Um den Aufruf zu vereinfachen (die Funktion UrlDownloadToFile erwartet PChar-Parameter), programmieren wir eine kleine Hilfsfunktion: function GetURLFile(was, wohin: string): Boolean; begin Result := UrlDownloadToFile(nil, PChar(was), PChar(wohin), 0, nil) = 0 end;

Der eigentliche Aufruf ist denkbar einfach. Wie das folgende Beispiel zeigt, laden wir zunächst eine HTML-Datei aus dem Internet, anschließend eine GIF-Grafik, die mit dem Standard-Viewer (das dürfte der Internet Explorer sein) angezeigt wird. procedure TForm1.Button1Click(Sender: TObject); begin screen.Cursor := crHourglass; if GetURLFile('http://www.chip.de/index.html', ExtractFilePath(Paramstr(0)) + 'test.txt') then begin memo1.lines.LoadFromFile(ExtractFilePath(Paramstr(0)) + 'test.txt'); end else showmessage('Probleme beim Download !'); if GetURLFile('http://www.chip.de/images/coi_logo_de_frei_03.gif', ExtractFilePath(Paramstr(0)) + 'test.gif') then begin ShellExecute(0,'open',PChar(ExtractFilePath(Paramstr(0)) + 'test.gif'),nil,nil,SW_NORMAL) end else showmessage('Probleme beim Download!'); screen.Cursor := crDefault; end; 1

... einen funktionierenden Internet-Zugang vorausgesetzt.

1512

Kapitel 26

How-to: Internet/Intranet

Test Nach dem Klick auf den Start-Button dürfte es je nach Internet-Anbindung einige Sekunden dauern, bevor das Ergebnis auf dem Bildschirm zu sehen ist:

26.5 Daten ins HTML-Format exportieren Was auf den ersten Blick recht kompliziert scheint, ist mit Delphi-Mitteln recht einfach zu realisieren. Wer einige Grundkenntnisse über den Aufbau von HTML-Dateien besitzt, hat in wenigen Minuten eigene "Export-Filter" programmiert. In diesem Rezept wollen wir drei Varianten betrachten: ■ Ausgabe von "Hello World" ■ Export einer Tabelle ■ Export einer Tabelle mit eingelagerter Grafik Die beiden letzten Filter beziehen sich auf die DBDEMOS-Beispieldatenbank.

Oberfläche Da wir mittlerweile voraussetzen, dass Sie locker mit Bound Controls umgehen können, wollen wir mit "Trivialitäten" nicht gar zu viel Zeilen verschwenden: Die beiden Table-Komponenten sind mit DBDEMOS (DataBaseName-Eigenschaft) und den Tabellen employee.db und biolife.db verbunden (TableName-Eigenschaft). Das DBImage ist über die DataSource-Komponente mit Table2 verbunden (DataField = Graphic). Bereits zur Entwurfszeit müsste Sie ein stattlicher Fisch erfreuen (Active-Eigenschaft der Table-Komponenten auf True setzen!).

26.5 Daten ins HTML-Format exportieren

1513

Quellcode "Hello World" Unser "Hello World"-Beispiel zum Eingewöhnen: procedure TForm1.Button1Click(Sender: TObject); var f : TStringList; begin f := TStringlist.Create; f.Add('

hello world

'); f.SaveToFile('test.htm') end;

HINWEIS: Die Arbeit mit einer StringList hat sich als recht sinnvoll erwiesen, zum einen be-

schränkt sich die Ausgabe auf wenige Quellcodezeilen, zum anderen wird die Datei im Speicher aufgebaut und erst am Schluss auf die Platte geschrieben.

Test "Hello World" Nach dem Start entdecken Sie im Projektverzeichnis die Datei test.htm, welche Sie sich im IE betrachten können.

Quellcode "Export Tabelle" Hinter die Geheimnisse der HTML-Programmierung kommen Sie am schnellsten, wenn Sie einige fertige HTML-Dokumente im Quelltext betrachten. Schnell wird klar, dass mit ein, zwei Schleifen eine Tabelle mit diversen Formatierungen realisierbar ist. Der folgende Code gibt die Tabelle employee.db im HTML-Format aus: procedure TForm1.Button2Click(Sender: TObject); var f : TStringList; begin f := TStringList.Create;

Erzeugen der Überschrift und des Tabellenkopfes: f.Add('

Mitarbeiterliste

'); f.Add('');

1514

Kapitel 26

How-to: Internet/Intranet

f.Add(' '); f.Add(' '); f.Add(' '); f.Add(' ');

Damit können wir uns auch schon der Schleife zuwenden (jede Zeile wird mit einem -Tag eingeleitet): while not Table1.eof do begin f.Add(' '); f.Add(' '); f.Add(' '); f.Add(' '); Table1.Next end;

Zum Schluss die Tabelle beenden und speichern: f.Add('

' + 'Vorname	' + 'Nachname
' + Table1.fieldbyname('firstname').AsString + '	' + Table1.fieldbyname('lastname').AsString + '

'); f.SaveToFile('table.htm');

Wie Sie sehen, lässt sich mit wenig Aufwand ein beachtliches Resultat erreichen. Das HTMLDokument kann einfach weitergegeben bzw. veröffentlicht oder auch mit Hilfe des Web-Browsers ausgedruckt werden.

Test "Export Tabelle" Nach dem Start erscheint im Anwendungsverzeichnis die Datei table.htm. Das Ergebnis im IE:

26.5 Daten ins HTML-Format exportieren

1515

Quellcode "Export Tabelle + Grafik" Auch Grafiken stellen offensichtlich kein Problem dar, denn JPEG-Dateien können nach der Einbindung der Unit JPEG verarbeitet werden, und GIF-Dateien lassen sich zum Beispiel mit den Freeware-Komponenten der RXTOOLS verarbeiten. Die Ausgabe der Grafiken und Texte aus der Tabelle Biolife.db: uses JPEG; ... var f : TStringlist; i : Integer; begin i := 0; f := TStringlist.Create; f.Add('

Fische

'); f.Add(''); f.Add(' '); f.Add(' '); f.Add(' '); f.Add(' '); while not Table2.eof do begin f.Add(' '); f.Add(' ');

Hier wird der Link auf die Grafik erzeugt (wir verwenden für die Dateinamen eine laufende Nummer): f.Add(' '); f.Add(' ');

Für den Export der Bitmap-Daten erzeugen wir zunächst ein TJPEGImage-Objekt, dem wir die Grafik mit Assign zuweisen. Danach brauchen wir die neue Grafik nur noch zu speichern: with tJPEGImage.Create do begin Assign(dbimage1.Picture.Graphic); SaveToFile(IntToStr(i) + '.JPG'); Free end; Table2.Next; inc(i) end; f.Add('

' + 'Name	' + 'Grafik
' + Table2.fieldbyname('Species Name').AsString + '

'); f.SaveToFile('pics.htm'); f.Free end;

1516

Kapitel 26

How-to: Internet/Intranet

Test "Tabelle + Grafik" Die frisch erzeugte Datei pics.htm im Internet Explorer:

Bemerkungen ■ Wenn Sie die Datei pics.htm weitergeben wollen, müssen Sie dazu auch alle .jpg-Dateien mitliefern. Sie finden diese, ebenfalls frisch angelegt, im Projektverzeichnis. ■ Die Qualität der Grafik und damit auch ihre Größe können Sie mit der CompressionQualityEigenschaft des TJPEGImage-Objektes beeinflussen.

26.6 Einen WebBrowser programmieren Zu einer Internet-Einbindung gehört neben diversen Export- und Import-Optionen auch eine Möglichkeit, Internet-Inhalte, d.h. HTML-Seiten, in einer ansprechenden Form auf den Bildschirm zu bringen. Die Rede ist von einem Internet-Browser, der direkt in Ihr Delphi-Projekt integriert ist. Wie nicht anders zu erwarten, finden Sie das WebBrowser-Control auf der "Internet"-Seite der Komponentenpalette.

1517

26.6 Einen WebBrowser programmieren

Übersicht Haben Sie den MS Internet Explorer ab Version 3.0 auf Ihrem Rechner installiert, so stellt dieser über die ActiveX-Schnittstelle ein WebBrowser-Control und ein InternetExplorer-Objekt zur Verfügung. Während es sich beim InternetExplorer-Objekt um eine ActiveX-Schnittstelle für den Internet Explorer handelt, ist das WebBrowser-Control ein vollwertiges ActiveX-Control, das in einem Delphi-Formular dargestellt werden kann. Allerdings werden Sie auf Ihrer Festplatte vergeblich nach einer entsprechenden OCX-Datei Ausschau halten, es handelt sich um einen In-Process COM-Server, der über die SHDOCVW.DLL importiert wird. Was kann nun dieses Control? Die Anwort ist eigentlich schon gegeben, basiert doch der MS Internet Explorer auf diesem Control. Unterstützt werden alle Features des HTML-Standards, d.h. Frames, Tabellen, Style Sheets, ActiveX-Objekte, Plug-ins und Scripts (JavaScript und VBScript). Was kann dieses Control nicht? Im Unterschied zum MS Internet Explorer stellt das Control lediglich einen Browser dar. Tasten und Eingabefelder sowie die dazugehörigen Funktionen müssen (bzw. können) Sie selbst programmieren. Stellen Sie sich diese Aufgabe aber nicht zu schwierig vor, mit wenigen Methoden und Eigenschaften haben Sie das Control voll im Griff. Gleichzeitig lässt sich damit der Browser ohne Probleme an das "Look and Feel" Ihrer Anwendung anpassen. Eigenschaften

Methoden

Ereignisse

Application Busy Container Document Height Left LocationName LocationURL Parent Path Top TopLevelContainer Type Visible Width

GoBack GoForward GoHome GoSearch Navigate Refresh Stop

BeforeNavigate CommandStateChange DownloadBegin DownloadComplete FrameBeforeNavigate FrameNavigateComplete FrameNewWindow NavigateComplete NewWindow ProgressChange PropertyChange Quit StatusTextChange TitleChange WindowActivate WindowMove WindowResize

Bevor Sie vor diesen umfangreichen Möglichkeiten zurückschrecken, seien Sie beruhigt: Bis auf die Methoden, die Namen dürften eigentlich aussagekräftig genug sein, brauchen Sie kaum Eigenschaften oder Ereignisse. Wer es etwas komfortabler mag, kann über NavigateComplete ermitteln, wann die HTML-Seite komplett geladen ist bzw. mit ProgressChange einen Fortschrittsbalken aktualisieren.

1518

Kapitel 26

How-to: Internet/Intranet

Folgende kleine Beispielanwendung zeigt den Einsatz der WebBrowser-Komponente.

Oberfläche Erzeugen Sie dazu ein neues Formular und binden Sie die Komponente ein. Platzieren Sie einige Buttons sowie eine ComboBox im Formularkopf (siehe folgende Abbildung). Verwenden Sie dazu am besten eine ToolBar-Komponente. Über eine ImageList können Sie bei Bedarf eigene Abbildungen für die Buttons bereitstellen.

In den Formularfuß fügen Sie eine StatusBar-Komponente ein.

Quelltext Wichtigste Ereignisprozedur ist das KeyDown-Event der ComboBox: procedure TForm1.ComboBox1KeyDown(Sender: TObject; var Key: Word; Shift: TShiftState); begin if key = VK_RETURN then begin WebBrowser1.Navigate(ComboBox1.Text); WebBrowser1.SetFocus end end;

An die Methode Navigate wird der Inhalt der ComboBox (ein URL) übergeben. Danach wird der Browser versuchen, die gewünschte HTML-Seite zu öffnen. Über procedure TForm1.WebBrowser1StatusTextChange(Sender: TObject; const text: WideString); begin StatusBar1.SimpleText := text end;

werden dem Anwender Informationen in der Statuszeile angezeigt.

1519

26.6 Einen WebBrowser programmieren

BEISPIEL: Auszug aus einem Protokoll Verbinden mit Site: 192.0.0.1 Web Site gefunden. Warten auf Antwort ... Übertragung beginnen von Site: http://i586/AdvWorks/default.asp Seite öffnen: http://i586/AdvWorks/default.asp Bild öffnen: http://i586/AdvWorks/multimedia/images/back_sub.gif

Gleichzeitig können Sie noch etwas für die Optik tun, eine Fortschrittsanzeige gibt Auskunft über den Stand der Dinge: procedure TForm1.WebBrowser1ProgressChange(Sender: TObject; Progress, ProgressMax: Integer); begin if (Progress = -1) Or (ProgressMax = 0) then StatusBar1.SimpleText := '' else StatusBar1.SimpleText := Format('%f',[(Progress * 100 / ProgressMax)]) end;

Ist die Übertragung beendet, blenden wir den kompletten URL in die Eingabezeile ein: procedure TForm1.WebBrowser1NavigateComplete(Sender: TObject; const URL: WideString); begin if not inList(url,ComboBox1.Items) then ComboBox1.Items.Add(url); ComboBox1.Text := url end;

Gleichzeitig wird der URL in die ComboBox eingefügt. Eine kleine Hilfsprozedur: Function InList(s:string;sl:TStrings): Boolean; var i : Integer; begin Result:=True; for i := 0 to sl.Count-1 do if UpperCase(sl[i]) = UpperCase(s) then Exit; Result:=False end;

Die Tastenbelegung: procedure TForm1.BackBtnClick(Sender: TObject); begin WebBrowser1.GoBack end;

// Zurück

procedure TForm1.ForwardBtnClick(Sender: TObject); begin WebBrowser1.GoForward end;

// Vorwärts

procedure TForm1.StopBtnClick(Sender: TObject); begin WebBrowser1.Stop end;

// Stopp

1520

Kapitel 26

procedure TForm1.RefreshBtnClick(Sender: TObject); begin WebBrowser1.Refresh end;

How-to: Internet/Intranet

// Aktualisieren

Das war auch schon alles, um das Grundgerüst eines Web-Browsers in eine Delphi-Anwendung zu integrieren. An der Oberfläche kann natürlich noch "gefeilt" werden, beispielsweise wäre das Speichern von Adressen in einer Datenbank-Tabelle denkbar.

Test Starten Sie den Browser und geben Sie einen URL Ihrer Wahl ein (über einen Internet-Zugang sollten Sie natürlich verfügen, den kann der Browser allein nicht ersetzen):

26.7 Auf MS-Mail-Funktionen zugreifen Da mittlerweile fast jeder glaubt, ohne Mail geht nichts mehr, machen sich zunehmend Mail-Funktionen in den Menü- und Werkzeugleisten von diversen Programmen breit. Natürlich wollen auch wir nicht zurückstehen, wenn es gilt, neue Technologien einzusetzen. Auf die gesamte Funktionalität der Mail-Schnittstelle können wir an dieser Stelle leider nicht eingehen, wir werden uns auf das Senden einer Message beschränken. Der schnellste Weg zu einer Mail ist die Verwendung der Funktion MapiSendMail, die über die Unit mapi importiert wird.

Oberfläche Erstellen Sie ein Formular, das über eine Memo- und eine Edit-Komponente verfügt. Ergänzen Sie ein Menü, über das die Mail-Funktion gestartet werden kann.

1521

26.7 Auf MS-Mail-Funktionen zugreifen

HINWEIS: Sie können statt der Memo-Komponente auch eine RTF-Komponente verwenden,

MS-Mail unterstützt auch Schriftattribute wie fett, kursiv etc.

Quelltext Für den Aufruf der Funktion MapiSendMail brauchen Sie eine Variable vom Typ TMapiMessage. Das folgende Listing kommentiert die wichtigsten Elemente des Typs: TMapiMessage = packed record ulReserved: Cardinal; lpszSubject: LPSTR; lpszNoteText: LPSTR; lpszMessageType: LPSTR; lpszDateReceived: LPSTR; lpszConversationID: LPSTR; flFlags: FLAGS; lpOriginator: PMapiRecipDesc; nRecipCount: Cardinal; lpRecips: PMapiRecipDesc; nFileCount: Cardinal; lpFiles: PMapiFileDesc end;

// // // // // // // // // // // //

reserviert Beschreibung Message der eigentliche Message-Text Message-Typ Datum (beim Senden nil) nil MAPI_RECEIPT_REQUESTED (optional) nil, sonst Pointer auf zusätzliche Infos nur Empfang } nur Empfang Anzahl der verknüpften Dateien Zeiger auf Array mit Dateiinfos

Die eigentliche Prozedur: procedure TForm1.Sendenan1Click(Sender: TObject); var MMessage : TMapiMessage; Fehler : Integer; begin

Initialisieren der Struktur: FillChar(MMessage, SizeOf(MMessage), 0); with MMessage do begin ulReserved := 0; lpszSubject := PChar(Edit1.text); lpszNoteText := PChar(Memo1.Lines.Text); lpszMessageType := nil; lpszDateReceived := nil;

1522

Kapitel 26

How-to: Internet/Intranet

lpszConversationID := nil; flFlags := 0; lpOriginator := nil; nRecipCount := 0; lpRecips := nil; nFileCount := 0; lpFiles := nil; end; Fehler := MapiSendMail(0, Application.Handle, MMessage,MAPI_DIALOG or MAPI_LOGON_UI, 0); case fehler of 0 : ; MAPI_E_USER_ABORT : ShowMessage('Nutzerabbruch') else ShowMessage('Fehler') end end;

Wenn ein Fehler auftritt, können Sie diesen über den Rückgabewert der Funktion auswerten, wir beschränken uns auf die Unterscheidung zwischen Nutzerabbruch (die Mail wurde nicht versendet) und Fehlermeldung.

Test Starten Sie das Programm, geben Sie eine Beschreibung und einen Text für die Message ein. Nach dem Start der oben genannten Funktion und der Auswahl des Profils (Messagebox wird eingeblendet) erhalten Sie folgende Dialogbox.

26.8 Mailversand über OLE-Automation realisieren

1523

Die Eintragungen aus dem Delphi-Programm wurden übernommen, Sie müssen lediglich noch ein "Opfer" für Ihre Mail finden. Dazu können Sie das Adressbuch verwenden, das Ihnen ebenfalls zur Verfügung steht. Sollten Sie mit der folgenden Fehlermeldung konfrontiert werden, versuchen Sie es einmal mit dem nächsten Rezept, das die OLE-Schnittstelle verwendet.

26.8 Mailversand über OLE-Automation realisieren Wie schon im vorhergehenden Rezept geht es darum, aus einer Applikation heraus auf die MailFunktionalitäten des Systems zuzugreifen.

Oberfläche Den Grundaufbau der Oberfläche entnehmen Sie bitte der folgenden Abbildung (unterhalb der beiden Edit-Komponenten ist eine ListBox!). Mit Hilfe der OpenDialog-Komponente werden wir auch Dateianhänge realisieren.

Quelltext Auf die Verwendung von API-Funktionen können wir dank der komfortablen OLE-Schnittstelle gänzlich verzichten. Lediglich eine Konstante müssen wir in Erfahrung bringen.

1524

Kapitel 26

How-to: Internet/Intranet

const olMailItem = 0;

Nach dem Klick auf den Button erstellen wir zuerst eine Instanz des MS Outlook-Objektes und ein neues Mail-Objekt. procedure TForm1.Button2Click(Sender: TObject); var myOutlook, mailitem : Variant; i : Integer; begin myOutlook := CreateOLEObject('Outlook.Application'); mailitem := myOutlook.CreateItem(olMailItem);

Nachfolgend weisen wir einfach die entsprechenden Eigenschaften zu: mailitem.Subject := Edit1.Text; mailitem.To := Edit2.Text; mailitem.Body := memo1.Text;

Etwas aufwändiger wird es bei Dateianhängen: for i := 0 to ListBox1.Items.Count - 1 do mailitem.Attachments.Add(ListBox1.Items[i])

Nicht vergessen, die Mail auch in den Postkasten zu werfen, andernfalls war die Arbeit umsonst: mailitem.Send end;

Mit dem zweiten Button bieten wir einen Weg, Dateien an die Mail anzuhängen: procedure TForm1.Button1Click(Sender: TObject); begin if OpenDialog1.Execute then ListBox1.Items := OpenDialog1.Files end;

Test Starten Sie das Programm, füllen Sie die entsprechenden Textboxen aus, bevor Sie die Mail versenden. HINWEIS: MS Outlook (nicht Express!) muss selbstverständlich auf Ihrem Computer installiert

sein, um auf die OLE-Schnittstelle zugreifen zu können!

26.9 Eine E-Mail automatisch generieren

1525

26.9 Eine E-Mail automatisch generieren Mit Hilfe der Anweisung "mailto:" ist es problemlos möglich, eine E-Mail mit Adressangabe, Betreffzeile und E-Mail-Text zu generieren, lediglich auf Dateianhänge müssen Sie verzichten. Folgende Varianten bieten sich an: BEISPIEL: Eine einfache E-Mail ohne Betreffzeile oder Body-Text mailto:[email protected]

BEISPIEL: Eine E-Mail mit einer Betreffzeile ("Preisanfrage") mailto:[email protected]?subject=Preisanfrage

BEISPIEL: Eine E-Mail mit Adresse, Betreffzeile und zusätzlicher Kopie an die Adresse "[email protected]" mailto:[email protected][email protected]

BEISPIEL: Eine E-Mail mit Adresse, Betreffzeile sowie einem E-Mail-Text mailto:[email protected]?subject=Freude über Delphi 7 Kochbuch&Body=Gratuliere,%0A endlich mal ein Rezept was funktioniert!!!

Wie Sie sehen, ist die Verwendung recht einfach. Es sind lediglich einige Grundregeln zu beachten: ■ Die Betreffzeile (subject) ist mit einem Fragezeichen von der Adressangabe zu trennen. ■ Alle weiteren Optionen sind mit einem "&" voneinander zu trennen. ■ Zeilenumbrüche in der Textangabe können Sie mit der Kombination "%0A" realisieren. ■ Leerzeichen in der Adressangabe können Sie mit "%20" einfügen.

Oberfläche Für ein kleines Testprogramm brauchen Sie lediglich ein Editierfeld und einen Button.

Quelltext Binden Sie zunächst die Unit ShellAPI ein: uses ShellAPI;

Mit der Funktion ShellExecute rufen wir die mit "mailto:" verknüpfte Mail-Anwendung auf (dies sollte im Normalfall Outlook-Express bzw. Outlook sein): procedure TForm1.Button1Click(Sender: TObject); begin shellExecute(handle,'open', PChar(Edit1.Text), nil, nil, SW_SHOW) end;

1526

Kapitel 26

How-to: Internet/Intranet

Test Tragen Sie in das Editfeld einen sinnvollen String ein und testen Sie die Reaktion des Mail-Programms:

26.10 Einen Web-Link in mein Programm einbauen Bei einem Hyperlink handelt es sich entweder um einen ■ URL, d.h. eine Ressource im Internet oder Intranet, oder um ■ eine Datei oder Anwendung auf der lokalen Festplatte oder im LAN. Ein Hyperlink zu Microsoft Office-Dokumenten könnte auch zu einer bestimmten Position oder einem bestimmten Objekt innerhalb des gesuchten Dokuments springen.

Hyperlinks in ActiveX-Komponenten Navigiert wird mit Hilfe dreier Funktionen, die Sie über die Unit urlmon importieren: ■ HlinkGoBack (vorherige HTML-Seite) ■ HlinkGoForward (nächste HTML-Seite) ■ HlinkNavigateString (Sprung zur angegebenen HTML-Seite bzw. Adresse) Handelt es sich um ein ActiveX-Control und befindet sich dieses nicht in einer HTML-Seite, wird ein entsprechender Browser gestartet. Bei ActiveX-Dokumenten dürfte der Fall klar sein, diese befinden sich in einer HTML-Seite, der Browser braucht also nur zum neuen Ziel zu wechseln.

26.11 Eine Web-Adresse aufrufen

1527

BEISPIEL: HlinkNavigateString procedure TMyAXForm1.Button3Click(Sender: TObject); begin HlinkNavigateString(self.ComObject, StringToOleStr(Edit1.Text)) end;

Wie Sie sehen, muss der Funktion als Parameter die Schnittstellenreferenz des Controls (IUnknown) übergeben werden (deshalb auch die Beschränkung auf ActiveX-Komponenten). Beachten Sie, dass die Zieladresse als Pointer auf einen WideString erwartet wird. Die nötige Umwandlung realisiert die Funktion StringToOleStr.

Hyperlinks in Formularen Soll der Link auf dem Formular zu sehen sein, verwenden Sie einfach ein Label. Wählen Sie als Beschriftung den gewünschten URL und setzen Sie die Cursor-Eigenschaft auf crHandPoint.

Der Aufruf ist selten einfach: uses ShellAPI; ... procedure TForm1.Label1Click(Sender: TObject); begin ShellExecute(Handle,'open',PChar(TLabel(sender).Caption),nil,nil,SW_SHOW) end;

Test Nach Klick auf den Hyperlink sollte die gewünschte Website erscheinen (mitunter ist es erforderlich, vorher eine Internet-Verbindung manuell zu öffnen).

26.11 Eine Web-Adresse aufrufen Sicher ist Ihnen schon aufgefallen, dass man aus einigen Programmen direkt ins Internet verzweigen oder eine E-Mail absenden kann. Die Realisierung mittels Delphi-Programm ist relativ einfach.

Variante 1 (Standard-EXE) Aus einer "normalen" EXE können Sie mit Hilfe der ShellExecute-Funktion auch eine WebAdresse öffnen (Unit shellAPI einbinden):

1528

Kapitel 26

How-to: Internet/Intranet

ShellExecute(Application.MainForm.Handle, // Handle der // übergeordneten Anwendung nil, // Welche Operation (open, print) PChar('http://www.online.de'), // Dateiname nil, // Parameter nil, // Startverzeichnis SW_SHOWMAXIMIZED); // Anzeigemodus

Oberfläche Zwei Editierfelder und zwei Buttons – mehr brauchen Sie nicht für erste Versuche.

Quelltext uses shellAPI; {$R *.DFM}

Für den Besuch einer Webseite: procedure TForm1.Button1Click(Sender: TObject); // Website begin ShellExecute(Application.MainForm.Handle, nil, PChar('http://' + Edit1.Text), nil,nil, SW_SHOWMAXIMIZED) end;

Auf die gleiche Weise können Sie auch den Mail-Client dazu veranlassen, eine neue Mail zu erzeugen: procedure TForm1.Button2Click(Sender: TObject); // EMail begin ShellExecute(Application.MainForm.Handle, nil, PChar('MAILTO:' + Edit2.Text), nil, nil, SW_SHOWMAXIMIZED) end;

Test Da anzunehmen ist, dass auf Ihrem PC ein Web-Browser installiert ist, dürfte es keine Schwierigkeiten bereiten, z.B. die Homepage der Autoren zu besuchen bzw. ihnen eine Mail zu schicken:

26.12 Den Internet Information Server installieren

1529

Variante 2 (OLE-Server oder ActiveX) Über die Unit urlmon wird eine weitere Möglichkeit bereitgestellt, Hyperlinks zu realisieren. Bei einem Hyperlink handelt es sich entweder um eine ■ URL, d.h. eine Ressource im Internet oder Intranet, oder um ■ eine Datei oder Anwendung auf der lokalen Festplatte oder im LAN. Ein Hyperlink zu Microsoft Office-Dokumenten könnte auch zu einer bestimmten Position oder einem bestimmten Objekt innerhalb des gesuchten Dokuments springen. Navigiert wird mit Hilfe dreier Funktionen, die Sie über die Unit urlmon importieren: ■ HlinkGoBack (vorherige HTML-Seite) ■ HlinkGoForward (nächste HTML-Seite) ■ HlinkNavigateString (Sprung zur angegebenen HTML-Seite bzw. Adresse) Handelt es sich um ein ActiveX-Control und befindet sich dieses nicht auf einer HTML-Seite, wird ein entsprechender Browser gestartet. Bei ActiveX-Dokumenten dürfte der Fall klar sein, diese befinden sich in einer HTML-Seite, der Browser braucht also nur zum neuen Ziel zu wechseln. BEISPIEL: HlinkNavigateString procedure TMyAXForm1.Button3Click(Sender: TObject); begin HlinkNavigateString(Self.ComObject, StringToOleStr(Edit1.Text)) end;

Wie Sie sehen, muss der Funktion als Parameter die Schnittstellenreferenz des Controls (IUnknown) übergeben werden (deshalb auch die Beschränkung auf ActiveX-Komponenten). HINWEIS: Beachten Sie, dass die Zieladresse als Pointer auf einen WideString erwartet wird.

Die nötige Umwandlung realisiert die Funktion StringToOleStr.

26.12 Den Internet Information Server installieren Wer Web-Anwendungen entwickeln will, sollte sich als Erstes um seinen Web-Server kümmern. Das vorliegende Rezept zeigt, wie wir den IIS (Internet Information Server von Microsoft bzw. Personal Web Server) für eine ISAPI-Anwendung vorbereiten. Ziel ist das vorschriftsmäßige Einrichten des IIS unter Windows 2000/XP1. HINWEIS: Voraussetzung ist, dass Sie auf dem Computer über die kompletten Administratoren-

rechte verfügen! 1

Unter W2000 Server können komplett neue Websites angelegt werden, unter W2000 zunächst nur virtuelle Unterverzeichnisse zur Standardwebsite.

1530

Kapitel 26

How-to: Internet/Intranet

HINWEIS: Internetinformationsdienste ist unter Windows 2000 Professional nicht als Standard

installiert. Zur Installation gehen Sie wie folgt vor: ■ Wählen Sie im Windows-Startmenü Einstellungen|Systemsteuerung und doppelklicken Sie dann auf Software. ■ Wählen Sie Windows-Komponenten hinzufügen/entfernen und folgen Sie anschließend den auf dem Bildschirm angezeigten Anweisungen zum Installieren, Entfernen oder Hinzufügen von Komponenten zu IIS. HINWEIS: Haben Sie Windows 2000 aktualisiert, so wird der IIS nur dann installiert, wenn in

Ihrer vorherigen Windows-Version der Personal Web-Server (PWS) installiert war.

Virtuelles Verzeichnis anlegen Sie können auch aus Verzeichnissen heraus veröffentlichen, die nicht in Ihrem Basisverzeichnis enthalten sind, indem Sie ein virtuelles Verzeichnis erstellen. Das ist ein Verzeichnis, das physisch nicht im Basisverzeichnis enthalten ist, jedoch Client-Browsern so angezeigt wird, als ob dies der Fall wäre. Ein virtuelles Verzeichnis verfügt über einen Alias, also einen Namen, den Client-Browser für den Zugriff auf dieses Verzeichnis verwenden. Da der Alias normalerweise kürzer als der Pfadname des Verzeichnisses ist, ist dies für Benutzer einfacher einzugeben. Ein Alias erhöht zudem die Sicherheit, da Benutzer den physischen Standort der Dateien auf dem Server nicht kennen und Ihre Dateien so nicht manipulieren können. Mit Hilfe von Alias-Namen ist das Verschieben von Verzeichnissen in der Site einfacher. Anstatt den URL für die Seite zu ändern, genügt es, die Zuordnung vom Alias zum physischen Standort der Seite zu ändern. BEISPIEL: Sie richten eine Website namens "Wurstwaren" mit Informationen zu den Erzeugnissen Ihrer Firma

im firmeninternen Intranet ein. Die folgende Tabelle zeigt die Zuordnungen vom physischen Standort der Dateien zum auf die Dateien zugreifenden URL: Physischer Standort

Alias

URL

C:\Inetpub\wwwroot

(Basisverzeichnis)

http://Erzeugnisse/

C:\Inetpub\wwwroot\Skripts

Skripts

http://Erzeugnisse/Skripts/

D:\Fleischerkatalog

Wurstwaren

http://Erzeugnisse/Wurstwaren/

Rufen Sie den Internetdienste-Manager über Start|Einstellungen|Systemsteuerung|Verwaltung|Internetdienste-Manager auf und starten Sie ihn.

26.12 Den Internet Information Server installieren

1531

Klicken Sie mit der rechten Maustaste auf Standardwebsite und wählen Sie im Kontextmenü Neu| Virtuelles Verzeichnis. Der Begrüßungsbildschirm des Assistenten erscheint. Klicken Sie "Weiter" und geben Sie einen schlüssigen Namen (Alias) für das Verzeichnis ein. Falls Sie es nicht schon vor dem Start des Internetdienste-Managers getan haben, sollten Sie jetzt schleunigst ein "richtiges" Verzeichnis (z.B. \WebSite) auf der Festplatte anlegen, welches für den späteren Inhalt Ihrer Website zuständig ist:

Im folgenden Dialog stellen Sie die Zugriffsberechtigungen ein. Die hier zu treffenden Entscheidungen können später korrigiert werden (siehe folgende Abbildung). Klicken Sie die Schaltflächen "Weiter" und "Fertig stellen". Der Assistent hat nun seine Arbeit erledigt, und in der Strukturansicht des IIS dürfte nun ein neues Unterverzeichnis \TestDelphi zur Standardwebsite hinzugekommen sein.

1532

Kapitel 26

How-to: Internet/Intranet

Vorläufigen Inhalt hinzufügen Für Testzwecke stellen Sie irgendeinen Inhalt in das virtuelle Verzeichnis \TestDelphi, der vom IIS übermittelt werden kann. Erzeugen Sie dazu eine vorläufige HTML-Seite mit einem mehr oder weniger sinnvollen Inhalt und kopieren Sie diese als Default.htm in das auf der Festplatte angelegte Unterverzeichnis (\WebSite). Am einfachsten können Sie eine HTML-Seite mit Word generieren, indem Sie ein beliebiges Dokument einfach als Dateityp "Webseite (*.htm)" abspeichern. Schließlich sollte der Internetdienste-Manager Ihnen folgenden Anblick bieten:

26.12 Den Internet Information Server installieren

1533

Die Dummy-Datei Default.htm kann dann später durch eine richtige Web-Anwendung ersetzt werden.

Verzeichnisfreigabe Für die meisten Rezepte muss das Festplatten-Verzeichnis C:/Inetpub/Scripts freigegeben sein, damit es – wie in obiger Abbildung – auch im IIS erscheint. Falls es im IIS nicht zu sehen ist, so müssen Sie über das Kontextmenü der rechten Maustaste den Eigenschaftendialog des /ScriptsUnterverzeichnis aufrufen und im Register "Webfreigabe" die entsprechende Option setzen.

Weitere Einstellungen ■ Über das Kontextmenü Eigenschaften des virtuellen Verzeichnisses \TestDelphi sollten Sie noch folgende Einstellungen gemäß nachfolgender Abbildung vornehmen bzw. überprüfen: ■ Ausführungsberechtigungen: Skripts und ausführbare Dateien bedeutet, dass die ISAPIAnwendung bei Bedarf vom Webserver gestartet werden kann. ■ Anwendungsschutz: Hoch(isoliert) bedeutet, dass die ISAPI-Anwendung in einem separaten Speicherbereich ausgeführt wird. Diese Einstellung ist unter Testbedingungen besonders wichtig, da ansonsten der Web-Server leicht zum Absturz gebracht werden kann. ■ Wie Sie sehen, können Sie auch (fast) alle Einstellungen korrigieren, die Sie oben bei der Erzeugung der virtuellen Webseite mit Hilfe des Assistenten vorgenommen haben.

1534

Kapitel 26

How-to: Internet/Intranet

Test Nun sollte der IIS bereit sein, um als Testplattform für Ihre Internet-Anwendung zu dienen. Um das zu überprüfen, starten Sie den Internet Explorer und geben als Adresse http://localhost/TestDelphi ein:

26.13 Eine einfache Web-Server-Anwendung verstehen

1535

HINWEIS: Wenn Sie über das Netzwerk auf den IIS zugreifen wollen, müssen Sie anstatt local-

host den Namen oder die IP-Adresse des Servers angeben, also z.B. http://Pentium866/TestDelphi oder http://192.168.2.1/TestDelphi.

Bemerkungen ■ Den IIS öffnen Sie über Start|Einstellungen|Systemsteuerung|Verwaltung|Internet-Informationsdienste. ■ Es erleichtert die Orientierung, wenn Sie auch eine Verknüpfung zum IIS auf dem Desktop einrichten. ■ Wie Sie eine Web-Anwendung unter Benutzung der WebBroker-Komponenten schreiben können, wird gezeigt in Ä 26.13 Eine einfache Web-Server-Anwendung verstehen

26.13 Eine einfache Web-Server-Anwendung verstehen Jeder Einsteiger braucht ein Weilchen, bis er ein Gefühl für Web-Server-Anwendungen entwickelt hat. Das folgende Beispiel macht Sie mit dem Grundprinzip vertraut und gibt einen kurzen Text im IE (Internet Explorer) aus. Voraussetzung ist die ordnungsgemäße Intallation des IIS (Internet Information Server). Ausnahmsweise schießen wir hier wegen des Lerneffekts bewusst mit Kanonen auf Spatzen, da man statischen Text natürlich viel einfacher mit einer simplen HTML-Seite erzeugen könnte.

ISAPI-DLL unter Delphi erzeugen ■ Öffnen Sie über Datei|Neu|Weitere... die Objektgalerie und wählen Sie auf der Registerseite "Neu" das Symbol für "Web-Server-Anwendung". ■ Im nachfolgenden Dialogfenster belassen Sie es bei der Option "ISAPI/NSAPI-DLL". Nach dem "OK" erstellt Delphi ein neues Projekt für die Web-Server-Anwendung mit einem Web-Modul. ■ Klicken Sie mit der rechten Maustaste in das Web-Modul und wählen Sie im Kontextmenü Aktions-Editor... . Es erscheint der Aktions-Editor. Hier können Sie die einzelnen Aktionsobjekte, die eine Web-Anwendung zur Verfügung stellt, verwalten. ■ Im Kontextmenü der rechten Maustaste wählen Sie "Hinzufügen" (oder klicken Sie auf das erste Icon der Symbolleiste). Im Web-Modul erscheint ein neues Aktionsobjekt WebActionItem1 (siehe Abbildung unten). ■ Da die einzelnen WebActionItem-Objekte anhand ihres Pfades (PathInfo-Eigenschaft) voneinander unterschieden werden, ist es einer einzigen Web-Anwendung möglich, dem Client mehrere Aktionsobjekte zur Verfügung zu stellen, auf die dieser mittels verschiedener URLs

1536

Kapitel 26

How-to: Internet/Intranet

zugreifen kann, z.B. mit http://localhost/Scripts/WebApp.dll/Pfad1 auf das WebActionItemObjekt mit der PathInfo-Eigenschaft 'Pfad1'. HINWEIS: Wenn Sie die Default-Eigenschaft eines WebActionItem-Objekts auf True setzen, ist

dieser Pfad der Standardpfad und kann in dem URL beim Aufruf der Webseite weggelassen werden. ■ Öffnen Sie den Objektinspektor für das Objekt WebActionItem1 und weisen Sie diesem als PathInfo-Eigenschaft /Info zu.

■ Wechseln Sie zur "Ereignis"-Seite des Objektinspektors und doppelklicken Sie auf das OnAction-Ereignis. Es erscheint der Code-Editor mit dem vorbereiteten Event-Handler, in welchen Sie zwischen begin und end den gewünschten HTML-Text eintragen: procedure TWebModule1.WebModule1WebActionItem1Action(Sender: TObject; Request: TWebRequest; Response: TWebResponse; var Handled: Boolean); begin Response.Content := ' Hallo, das ist ein einfaches Web-Modul! ' end;

■ Sie erkennen, dass in diesem OnAction-Event-Handler ein Response-Objekt überreicht wird, dem wir einfach einen gültigen HTML-String zugewiesen haben (das kann auch eine ganze Seite sein!). ■ Speichern Sie das Projekt unter DelphiWeb_1.dpr ab, ändern Sie vorher den Namen der Unit1 in Main und speichern Sie diese auch als Main.pas ab.

26.14 ADO-Recordsets an eine ASP-Seite senden

1537

■ Nun können Sie das Objekt compilieren (nicht mit F9, sondern über Prjekt|DelphiWeb_1 compilieren oder Strg+F9). ■ Im Projektverzeichnis werden Sie jetzt eine ISAPI-DLL mit dem Namen DelphiWeb_1.dll entdecken. Kopieren Sie diese DLL in das Skriptverzeichnis des IIS (\Inetpub\Scripts).

ISAPI-DLL mit IIS und IE testen Geben Sie die exakte URL in Ihren Webbrowser ein (http://localhost/scripts/DelphiWeb.dll/Info). Falls der IIS richtig gestartet ist, können Sie sich an Ihrer ersten Web-Anwendung erfreuen:

Durch Eingabe der URL wird der IIS veranlasst, die ISAPI-DLL in den Speicher zu laden und auszuführen. Sie stellen beim Experimentieren fest, dass bei nachfolgenden Aufrufen die Seite schneller dargestellt wird als beim ersten Mal, da sie sich ja bereits im Speicher befindet.

Bemerkungen ■ Falls die Webseite nicht angezeigt wird, ist wahrscheinlich das /Scripts-Verzeichnis noch nicht freigegeben, siehe Ä 26.12 Den Internet Information Server installieren ■ Das Beispiel ist vom Prinzip her auch für die anderen Web-Anwendungstypen (NSAPI, CGI, Apache) geeignet. ■ Wie man eine Web-Anwendung sinnvoll zum Anzeigen dynamischer Inhalte einsetzt, wird in unserem Buch "Borland Delphi – Datenbankprogrammierung" gezeigt, welches sich mit auf der Buch-CD befindet.

26.14 ADO-Recordsets an eine ASP-Seite senden Man kann bekanntlich mittels CreateObject auf einer ASP-Seite ein ASP-Objekt instanziieren, um dessen Methoden aufzurufen. Das vorliegende Rezept arbeitet ähnlich, denn es benutzt dazu ebenfalls ein ASP-Objekt innerhalb einer (vom IIS verwalteten) COM-DLL, um auf eine Access-Datenbank über ADO zuzugreifen und das Ergebnis in der ASP-Seite abzulegen.

1538

Kapitel 26

How-to: Internet/Intranet

Unser ASP-Objekt erzeugt allerdings keine fertige HTML-Tabelle, sondern nur ein ADO-Recordset innerhalb der ASP-Seite. Die komplette Tabellendarstellung muss deshalb im ASP-Script erledigt werden, wodurch auf dieser Seite ein relativ hoher Aufwand entsteht (dementsprechend gering ist der Aufwand beim ASP-Objekt). Grundlage ist die Access-Datenbank Firma.mdb, die sich im Verzeichnis \Inetpub\ wwwroot\ FirmaDB befinden sollte.

Gerüst für COM-DLL Starten Sie Delphi und wählen Sie Datei|Neu|Weitere... und klicken Sie das Symbol "ActiveXBibliothek" von der "ActiveX"-Seite der Objektgalerie. Fügen Sie über Datei|Neu|Weitere... ein "Active-Server-Objekt" hinzu (links neben dem Symbol für "ActiveX-Bibliothek"). Tragen Sie als Name der CoClass "Recordset" ein und wählen Sie "Objektkontext" als Active-Server-Typ (ab IE 5.0):

Nach dem OK erscheint der Typbibliothek-Editor, mit dem Sie die Schnittstelle des Active-ServerObjekts wie folgt editieren: ■ Klicken Sie mit der rechten Maustaste auf das IRecordset-Interface und wählen Sie im Kontextmenü Neu|Methode (das Gleiche erreichen Sie auch durch Klick auf die entsprechende Schaltfläche in der oberen Symbolleiste). ■ Benennen Sie die Methode um in returnADO. ■ Schalten Sie rechts auf die "Parameter"-Registerseite um und vervollständigen Sie die Einträge so, wie in der folgenden Abbildung gezeigt. ■ Klicken Sie auf die Schaltfläche "Implementierung aktualisieren".

26.14 ADO-Recordsets an eine ASP-Seite senden

1539

Speichern Sie das Projekt wie folgt ab: ■ Unit1.pas als uRecordset.pas (vorher im Quellcode den Unit-Namen ebenfalls in uRecordset ändern!), ■ Recordset.asp bleibt Recordset.asp und ■ Project2.dpr als DelphiADO_1.dpr (das wird später der Name unserer COM-DLL).

Quellcode für ASP-Objekt Öffnen Sie die Unit uRecordset, fügen Sie die Unit ADOdb hinzu und tragen Sie die Implementierung der Methode returnADO ein: unit uRecordset; {$WARN SYMBOL_PLATFORM OFF} interface uses ComObj, ActiveX, AspTlb, DelphiADO_1_TLB, StdVcl, ADOdb; type TRecordset = class(TASPMTSObject, IRecordset) protected function returnADO: OleVariant; safecall; end; implementation uses ComServ; function TRecordset.returnADO: OleVariant;

1540

Kapitel 26

How-to: Internet/Intranet

Ab hier müssen Sie den Quelltext selbst eintragen. Wie Sie sehen, benutzen wir kein Datenmodul, sondern erzeugen die ADODataSet-Komponente per Code (deshalb brauchen wir auch die Unit ADOdb!): var ADODataSet1 : TADODataSet; RecordSet : _Recordset; begin ADODataSet1 := TADODataSet.Create(nil); // ADODataSet wird erzeugt try ADODataSet1.ConnectionString := 'Provider=Microsoft.Jet.OLEDB.4.0; Data Source=C:\Inetpub\wwwroot\FirmaDB\Firma.mdb;Persist Security Info=False'; ADODataSet1.CommandText := 'SELECT * FROM Kunden'; ADODataSet1.Open; RecordSet := ADODataSet1.Recordset._xClone; RecordSet.Set_ActiveConnection(nil); Result := RecordSet; ADODataSet1.Close finally ADODataSet1.Free // ADODataSet wird freigegeben end

HINWEIS: Achten Sie auf die unterstrichenen Passagen im Quelltext, die Sie gegebenenfalls an-

passen müssen. Ab hier brauchen Sie nicht mehr zu vervollständigen, denn dieser Code ist bereits vorhanden: end; initialization TAutoObjectFactory.Create(ComServer, TRecordset, Class_Recordset, ciMultiInstance, tmApartment); end.

Stellen Sie unter Projekt|Optionen... das Ausgabeverzeichnis der COM-DLL auf C:\Inetpub\ Scripts ein (oder auf ein anderes Verzeichnis mit gleichen Ausführungsrechten) und compilieren Sie mit Strg+F9. Registrieren Sie die COM-DLL mit Start|ActiveX-Server eintragen.

ASP-Seite Durch die ganz zu Beginn im Assistenten gewählte Option "Für dieses Objekt ein Vorlagen-TestScript generieren" wurde bereits automatisch eine einfache ASP-Datei Recordset.asp erzeugt, welche wir jetzt einfach durch folgenden Code ersetzen: ASP-Anwendung

26.14 ADO-Recordsets an eine ASP-Seite senden

1541

<% Dim ASPObj %> <% Dim rs %> <% set ASPObj = Server.CreateObject("DelphiADO_1.Recordset") %> <% set rs = ASPObj.returnADO %> <% For j = 0 to rs.fields.count - 1 %> <% Next %> <%Do Until rs.Eof %> <% For j = 0 to rs.fields.count - 1 %> <% Next %> <% rs.movenext %> <%Loop%>

<% Response.Write(rs.fields(j).name) %>

<% Response.Write(rs.fields(j)) %>

<% set ASPObj = nothing %> <% set rs = nothing %>

Dem versierten Delphi-Programmierer dürfte es nicht allzu schwer fallen, vorübergehend in die "Niederungen" von VB Script hinabzusteigen, um obigen Code zu verstehen. Was passiert? Nach dem Instanziieren des ASP-Objekts mittels CreateObject wird die returnRecordset-Methode aufgerufen, die das komplette Recordset der Variant-Variablen rs zuweist. Was folgt, ist ein relativ mühseliges Zusammenstückeln der Tabelle und das Füllen der einzelnen Zellen. Kopieren Sie die Datei Recordset.asp in das Verzeichnis C:\Inetpub\wwwroot.

Test Starten Sie den IIS und rufen Sie mit dem Internet Explorer die Datei Recordset.asp auf. Haben Sie alles richtig gemacht, so werden Sie nicht enttäuscht. HINWEIS: Weitere Informationen und Beispiele sowie Hinweise zur Fehlersuche und Installa-

tion auf Fremdrechnern finden Sie in unserem Buch "Borland Delphi Datenbankprogrammierung", welches sich mit auf der Buch-CD befindet.

1542

Kapitel 26

How-to: Internet/Intranet

26.15 Eine einfache Multi-Tier-Anwendung testen HINWEIS: Für dieses Rezept ist die Enterprise-Edition von Borland Delphi 7 erforderlich!

Man könnte den Titel auch anders formulieren: Wie schaffe ich möglichst schnell einen Einstieg in die Entwicklung verteilter Anwendungen, ohne von der Komplexität der Komponenten und ihrer Features erschlagen zu werden? In früheren Delphi-Versionen wurde die Multi-Tier-Technologie unter dem Begriff MIDAS (Multitier Distributed Applications Services) zusammengefasst1. Das vorliegende Rezept bietet dazu eine schrittweise Anleitung anhand eines simplen Beispiels. Es besteht aus zwei separaten Projekten: ■ MIDAS-Server (ActiveX-DLL) ■ MIDAS-Client (Standard-EXE) Ziel der Demo ist die Realisierung eines Nur-Lese-Zugriffs auf die Tabelle Orders der zu Delphi mitgelieferten Beispieldatenbank DBDEMOS. Die Verbindung zwischen Client und Server soll 1

Mittlerweile ist diese Bezeichnung aus unerfindlichen Gründen bei Borland in Ungnade gefallen, obwohl die früheren MIDAS-Komponenten nach wie vor vorhanden sind und nur auf andere Seiten der Komponentenpalette umgelagert wurden.

1543

26.15 Eine einfache Multi-Tier-Anwendung testen

dabei über DCOM erfolgen. Der Einfachheit halber befinden sich Client und Server auf dem gleichen Rechner. Für unser Beispiel kommen wir ohne eine einzige Zeile Quellcode aus, alles kann im Objektinspektor erledigt werden! Entnehmen Sie bitte die Zusammenschaltung der Komponenten der folgenden Abbildung: MIDAS-Server (Project2.dll)

Table1 TableName DBDEMOS

DataSetProvider1 (Exported=True) DataSet

DatabaseName

DCOM

MIDAS-Client (Project1.exe)

DCOMConnection1 ServerName

ClientDataSet1

RemoteServer

(Project2.testKlasse) ProviderName

ServerGUID

DataSet

testKlasse DataSource DBGrid1

DataSource1

Wir haben diesmal ganz bewusst die Namen der Komponenten bei ihren Standardbezeichnern belassen. Für den Profi dürfte obige Abbildung bereits genügend Informationen liefern, der Einsteiger aber wird sich über die folgende detaillierte Beschreibung freuen:

MIDAS-Server Öffnen Sie ein neues Projekt. Da der MIDAS-Server als DLL implementiert werden soll, wählen Sie über Datei|Neu|Weitere... die "ActiveX"-Seite der Objektgalerie. Doppelklicken Sie auf das "ActiveX-Bibliothek"-Symbol. Wählen Sie wieder Datei|Neu|Weitere..., gehen Sie diesmal aber zur "Multi-Tier"-Seite und fügen Sie ein "Externes Datenmodul" zum Projekt hinzu. Im Dialogfenster geben Sie als Namen der CoClass testKlasse ein und klicken OK.

Nach dem OK steht eine vorgefertigte Unit bereit, deren Namen Sie aber zweckmäßigerweise ändern in MServerD. Das ist zunächst das Einzige, was Sie tun müssen, denn den restlichen Code sollen Sie sich nur anschauen und staunen, was Delphi alles für Sie erledigt hat:

1544

Kapitel 26

unit MServerD;

How-to: Internet/Intranet

// geändert!

interface uses Windows, Messages, SysUtils, Classes, ComServ, ComObj, VCLCom, DataBkr, DBClient, MServer_TLB, StdVcl;

Hier die Definition der Klasse, die vom Server exportiert wird: type TtestKlasse = class(TRemoteDataModule, ItestKlasse) private { Private declarations } protected class procedure UpdateRegistry(Register: Boolean; const ClassID, ProgID: string); override; public { Public declarations } end; implementation {$R *.DFM} class procedure TtestKlasse.UpdateRegistry(Register: Boolean; const ClassID,ProgID: string); begin if Register then begin inherited UpdateRegistry(Register, ClassID, ProgID); EnableSocketTransport(ClassID); EnableWebTransport(ClassID); end else begin DisableSocketTransport(ClassID); DisableWebTransport(ClassID); inherited UpdateRegistry(Register, ClassID, ProgID) end end; initialization TComponentFactory.Create(ComServer, TtestKlasse, Class_MServerDll, ciMultiInstance, tmApartment); end.

In das (leere) Fenster des Datenmoduls ziehen Sie eine Table-Komponente (Seite "BDE") und eine DataSetProvider-Komponente (Seite "Datenzugriff") hinein. Verbinden Sie nun Table1 mit der Beispieldatenbank (DatabaseName = DBDEMOS, TableName = Orders.db). Schließlich setzen Sie noch die DataSet-Eigenschaft von DataSetProvider1 auf Table1.

26.15 Eine einfache Multi-Tier-Anwendung testen

1545

Speichern Sie das Projekt in einem separaten Unterverzeichnis (\ServerDll) ab. HINWEIS: Achten Sie darauf, dass die Unit unter ihrem Namen, also als MServerD.pas abge-

speichert wird! Wählen Sie jetzt den Menüpunkt Start|ActiveX-Server eintragen (nicht F9, denn wir haben es mit keiner Anwendung zu tun!). Ihre ActiveX-Bibliothek wird jetzt compiliert und registriert. Im Projektverzeichnis müssten Sie jetzt den Midas-Server als neue Datei Project2.dll entdecken.

MIDAS-Client Öffnen Sie ein völlig neues Projekt (am besten Sie schließen vorher Delphi und starten erneut) und platzieren Sie eine DCOMConnection ("DataSnap"-Seite), eine DataSource und ein ClientDataSet (beide "Datenzugriff"-Seite) sowie ein DBGrid ("Datensteuerung"-Seite) auf das Startformular. Weisen Sie nun die ServerName-Eigenschaft für DCOMConnection1 zu. Die Klappbox verschafft Ihnen einen genauen Überblick über alle momentan registrierten Klassen, so dass Sie nur Project2.testKlasse aus dem Angebot auszuwählen brauchen:

HINWEIS: Die Schreibweise für den Servernamen ist immer Bibliotheksname.Klassenname, da

eine Bibliothek natürlich auch mehr als nur eine Klasse exportieren kann.

1546

Kapitel 26

How-to: Internet/Intranet

Automatisch wurde bereits die ServerGUID angezeigt. Testweise dürfen Sie auch schon einmal Connected auf True setzen. Falls alles ruhig bleibt, können Sie sich erst einmal zurück lehnen. Später brauchen Sie sich um die Connected-Eigenschaft nicht mehr zu kümmern, sie wird automatisch auf True gesetzt, sobald ein ClientDataSet "angeklemmt" wird. Nun ist ClientDataSet1 an der Reihe, wo drei Eigenschaften einzustellen sind: ■ Die RemoteServer-Eigenschaft setzen Sie auf DCOMConnection1. ■ Beim Eintragen des ProviderName werden Sie wieder durch eine Klappbox unterstützt, denn diese listet Ihnen alle im MIDAS-Server enthaltenen DataSetProvider auf (in unserem Fall nur DataSetProvider1). ■ Setzen Sie schließlich Active auf True. HINWEIS: Falls kein DataSetProvider auf der Angebotsliste erscheint, müssten Sie im MIDAS-

Server nachschauen, ob die Exported-Eigenschaft von DataSetProvider1 tatsächlich noch auf True steht (Standardwert). Der Rest ist ein Kinderspiel: Setzen Sie die DataSet-Eigenschaft von DataSource1 auf ClientDataSet1 und verbinden Sie das DBGrid mit seiner Datenquelle (DataSource = DataSource1). Bereits jetzt zur Entwurfszeit müssten im Datengitter Datensätze angezeigt werden:

Falls nichts angezeigt wird, sollten Sie nachschauen, ob die Active-Eigenschaft des ClientDataSet1 auch wirklich True ist (ansonsten überprüfen Sie Active auch noch einmal im Server-Projekt für Table1). Speichern Sie nun das Projekt in einem extra Verzeichnis ab (\ClientExe). Anschließend können Sie es wie gewohnt compilieren und starten (F9).

Test Falls die Datensätze bereits zur Entwurfszeit sichtbar sind, dann ist auch deren Anzeige zur Laufzeit so ziemlich sicher. In unserem Fall ist das Editieren noch nicht möglich. Zwar können Sie

26.16 Ein ClientDataSet editieren

1547

Änderungen im Datengitter vornehmen, diese werden aber nicht an den Server übertragen (Abhilfe siehe Nachfolgerezept).

Bemerkungen Wir haben den MIDAS-Server ganz bewusst als DLL und nicht als EXE implementiert, da er auf derselben Maschine wie der Client läuft und keine eigene Bedienoberfläche braucht. Bei einer Implementierung als EXE würde sein Symbol zumindest auf der Taskleiste erscheinen und möglicherweise Konfusion auslösen. HINWEIS: Ein In-Process-Server (DLL) ist immer um einiges schneller als ein Out of Process-

Server (EXE)! Zukünftige ActiveX-Bibliotheken sollten Sie nicht beim Standardbezeichner (Project2.dll) belassen, sondern sich zu einer individuellen Namensgebung aufraffen. Ansonsten wird die alte (gleich lautende) Bibliothek überschrieben, und Ihre alten Clients erleben böse Abstürze. HINWEIS: Erledigen Sie die Namensgebung der ActiveX-DLL möglichst vor dem erstmaligen

Registrieren, eine spätere Umbenennung kann Konfusion verursachen, da die TLBDatei (Schnittstellenbeschreibung) ihren alten Namen zunächst beibehält.

26.16 Ein ClientDataSet editieren HINWEIS: Dieses Rezept ist die Fortsetzung des Vorgängerrezepts.

Sicherlich möchten Sie in Ihrem MIDAS-Client nicht nur Datensätze betrachten, sondern auch welche editieren, hinzufügen oder löschen. Wenn Sie aber glauben, dass sei mit dem Hinzufügen einer einfachen DBNavigator-Komponente erledigt, so haben Sie sich geirrt.

Erste Oberfläche Diese entspricht dem Vorgängerrezept, fügen Sie lediglich eine DBNavigator-Komponente hinzu und verbinden Sie diese mit der DataSource-Komponente.

Erster Test Zwar können Sie sich jetzt auch mit dem Navigator durch das Datengitter bewegen. Der Versuch, Datensätze zu ändern (z.B. SaleDate oder ShipDate), endet nach dem Klick auf den RefreshButton aber in einem bösen "vielsagenden" Meldungsfenster:

1548

Kapitel 26

How-to: Internet/Intranet

Offensichtlich ist der DBNavigator mit einem ClientDataSet überfordert.

Korrigierte Oberfläche Verordnen Sie dem DBNavigator eine kleine Abmagerungskur, so dass nur noch die vier Bewegungstasten und die Tasten zum Hinzufügen, Löschen und Rückgängigmachen übrig bleiben (VisibleButtons-Eigenschaft entsprechend ändern). Hinzu kommt eine separate Schaltfläche "Änderungen übernehmen".

Quellcode Ganz ohne Code geht es diesmal nicht mehr: procedure TForm1.Button1Click(Sender: TObject); // Änderungen übernehmen begin if ClientDataSet1.ApplyUpdates(-1) > 0 then begin ShowMessage('Fehler beim Aktualisieren!'); ClientDataSet1.CancelUpdates // ursprüngliche Datenmenge anzeigen end end;

26.17 Mit einer SocketConnection arbeiten

1549

Test Starten Sie das Programm und testen Sie es auf Herz und Nieren. Das ClientDataSet lässt so ziemlich alles widerspruchslos mit sich machen. Die Stunde der Wahrheit schlägt erst bei der Übernahme der Änderungen, insbesondere wenn Sie Datensätze gelöscht haben. Das dürfte nur bei den Datensätzen funktionieren, die Sie selbst neu hinzugefügt haben, andernfalls wird meist die referenzielle Integrität verletzt (eine entsprechende Fehlermeldung der Datenbank-Engine weist Sie auf vorhandene Detaildatensätze in verknüpften Tabellen hin). In einer verteilten Umgebung sind solche Fehlermeldungen allerdings nur auf dem Datenbankserver sichtbar und für den Client nutzlos. Compilieren Sie deshalb das Programm, verlassen Sie Delphi, starten Sie die EXE-Datei und wiederholen Sie sicherheitshalber alle Tests.

Bemerkungen ■ Die ApplyUpdates-Methode des ClientDataSet schreibt alle aktualisierten, eingefügten und gelöschten Datensätze zurück in den Provider des Anwendungsservers. Rückgabewert ist die Anzahl der aufgetretenen Fehler. Der Parameter MaxErrors entspricht der maximalen Fehlerzahl, die der Provider zulässt, bevor er die Aktualisierung vorzeitig abbricht (der Wert -1 erlaubt eine unbegrenzte Fehlerzahl). ■ Leider kann der Provider nicht feststellen, ob eine Aktualisierung in einem Memo-Feld mit den Änderungen eines anderen Benutzers in Konflikt steht, und kann sie deshalb auch nicht als Fehler zurückgeben.

26.17 Mit einer SocketConnection arbeiten HINWEIS: Für dieses Rezept ist die Enterprise-Edition von Borland Delphi 7 erforderlich!

Sie haben das "Trockenschwimmen" auf dem lokalen PC satt und möchten endlich einmal eine echte verteilte Anwendung testen! Voraussetzung ist allerdings der Zugang zu einem TCP/IP-Netzwerk. Um die langwierige Installation zu umgehen, setzen wir für unser kleines Experiment allerdings voraus, dass Delphi sowohl auf dem Client-PC als auf dem Server-PC installiert ist.

MIDAS-Server Wir verwenden dieselbe einfache Server-Komponente Project2.dll wie bereits in den Vorgängerrezepten. Es dürfte für Sie kein Problem sein, diese Komponente auf dem Server-PC noch einmal neu zu erstellen (bzw. Projektdatei kopieren) und zu registrieren. Und noch etwas dürfen Sie nicht vergessen: HINWEIS: Um mit einer SocketConnection arbeiten zu können, ist auf dem Server-PC der

Borland Socket Server (Datei ScktSrvr.exe im \Bin-Unterverzeichnis) zu starten.

1550

Kapitel 26

How-to: Internet/Intranet

MIDAS-Client Auch der Client entspricht dem aus dem Vorgängerrezept, bis auf eine kleine Änderung: Da DCOM-Verbindungen nicht gerade pflegeleicht sind1, haben wir uns diesmal für eine TCP/IP-Verbindung entschieden. Tauschen Sie also die DCOMConnection durch eine SocketConnection aus und korrigieren Sie die RemoteServer-Eigenschaft des ClientDataSet entsprechend. HINWEIS: Socket-Verbindungen haben den Vorteil, dass sie für fast alle Rechner möglich sind,

sie stellen jedoch keinerlei Sicherheitsprotokolle bereit! Nun zu den Eigenschaften der SocketConnection. Sie können im Objektinspektor entweder die IPAdresse des Anwendungsservers (Address-Eigenschaft) oder den Namen des Server-PCs (HostEigenschaft) eingeben. Letzteres scheint bequemer, da Sie hier durch einen Suchdialog unterstützt werden und dabei auch mitbekommen, ob die TCP/IP-Verbindung zum Server-PC funktioniert.

Für die Port-Eigenschaft ist standardmäßig der Wert 211 eingetragen, Änderungen sind aber im Eigenschaftendialog des Borland Socket Servers möglich (folgende Abbildung).

1

Die Autoren haben leider schlechte Erfahrungen bezüglich Registrierung und Zuverlässigkeit gesammelt.

26.17 Mit einer SocketConnection arbeiten

1551

Entscheidend ist der Moment, in dem Sie die ServerName-Eigenschaft zuweisen wollen. Damit ist nicht etwa der Server-PC (siehe Host-Eigenschaft), sondern der Name des dort bereitgestellten COM-Servers (ActiveX-DLL) gemeint! Kommt hier per Klappbox kein Angebot (Project2.testKlasse), sondern eine Fehlermeldung:

so sollten Sie überprüfen, ob der Borland Socket Server auf dem Server-PC ordnungsgemäß gestartet wurde. Auf der "Benutzer"-Seite des BSS sehen Sie, ob die Verbindung zum Client-PC "steht":

1552

Kapitel 26

How-to: Internet/Intranet

Test Wenn Sie bereits zur Entwurfszeit Datensätze im DBGrid gesehen haben, besteht gute Hoffnung, dass das auch nach Programmstart so bleibt. Allerdings dauert es meist ein paar Sekunden, bis die Verbindung zum Server hergestellt ist und die Eingabemaske erscheint, aber danach können Sie mit einer "echten" verteilten Anwendung arbeiten!

Weitere Hinweise zur Fehlersuche Falls der COM-Server auf dem Server-PC nicht ordnungsgemäß registriert ist, erscheint meist die folgende Fehlermeldung:

26.18 Mit einer WebConnection arbeiten

1553

Wenn Sie probeweise auf dem Server-PC den Anwendungsserver entfernen (Menüpunkt Start| ActiveX-Server austragen), so darf auf dem Client-PC auch zur Entwurfszeit der Anwendungsserver nicht mehr aufgelistet werden (ServerName der SocketConnection hat keine Einträge). Löschen Sie im Objektinspektor der SocketConnection die ServerGUID-Eigenschaft!

26.18 Mit einer WebConnection arbeiten HINWEIS: Für dieses Rezept ist die Enterprise-Edition von Borland Delphi 7 erforderlich!

Anstelle von DCOM oder TCP/IP können Sie auch mittels HTTP auf einen Remote-Anwendungsserver zugreifen. Dazu steht clientseitig die Komponente WebConnection zur Verfügung. Wie bei einer SocketConnection ist das Vorhandensein einer eigenen TCP/IP-Adresse Voraussetzung. HINWEIS: Aufgrund der durch die Wininet.dll (im IE enthalten) bereitgestellten SSL-Sicher-

heitsfunktionen bietet eine WebConnection aber den Vorteil, dass auch auf Server zugegriffen werden kann, die durch eine Firewall geschützt sind. In der vorliegenden Demo werden wir das gleiche Problem wie im vorhergehenden Rezept lösen, allerdings werden wir anstatt einer SocketConnection eine WebConnection einsetzen. Ausgehend davon soll im Folgenden nur noch auf die sich ergebenden Änderungen zum Vorgängerrezept Bezug genommen werden.

Server-PC Serverseitig sind zwei Installationen wichtig: ■ Internet Information Server (IIS, ab Version 4) oder Netscape Enterprise (ab Version 3.6). Der IIS ist Bestandteil von Windows 2000, muss aber extra installiert werden. ■ Die Systembibliothek httpsrvr.dll. Diese ist "Ansprechpartner" für den Client und managt die Kommunikation mit dem Anwendungsserver, indem sie die HTTP-Aufrufe des Clients in COM-Aufrufe für den Anwendungsserver umwandelt. Die Bibliothek befindet sich im \BinUnterverzeichnis von Delphi. Den IIS installieren Sie über Systemsteuerung|Software|Windows Komponenten hinzufügen| Internet-Informationsdienste:

1554

Kapitel 26

How-to: Internet/Intranet

Verschieben Sie die Bibliothek httpsrvr.dll aus dem \Delphi7\Bin-Verzeichnis in das Verzeichnis \Inetpub\Scripts. Starten Sie den IIS über Systemsteuerung|Verwaltung|Internetdienste-Manager.

Client-PC Setzen Sie die RemoteServer-Eigenschaft des ClientDataSet auf WebConnection1. Knackpunkt der Verbindung zum Server-PC ist das richtige Zuweisen der URL-Eigenschaft für die WebConnection-Komponente, denn hier wird der clientseitige "Anlaufpunkt" festgelegt, die URL der httpsrvr.dll auf dem Server-PC. Bei den Autoren heißt der Server-PC Pentium300. Die URL-Eigenschaft wäre demzufolge: http://Pentium300/scripts/httpsrvr.dll

26.18 Mit einer WebConnection arbeiten

1555

Das Zuweisen der ServerName-Eigenschaft (project2.testKlasse) unterscheidet sich nicht vom Vorgängerrezept bzw. von der Verwendung einer anderen Connection-Komponente.

Test Um die Funktion des IIS (im Intranet) zu testen, sollten Sie erst einmal versuchen, vom Internet Explorer des Servers aus auf den IIS zuzugreifen. Starten Sie also den Internet Explorer und geben Sie die Adresse einer beliebigen HTML-Seite an, die sich im /Inetpub/wwwroot-Verzeichnis des IIS befindet, z.B. http://localhost/Test.htm

Die aufgerufene Seite muss nun im IE angezeigt werden. Auf analoge Weise testen Sie die Verbindung vom Client, indem Sie den dortigen IE starten und z.B. eingeben: http://Pentium300/Test.htm

Falls diese Versuche zufrieden stellend verlaufen, dürfte einem erfolgreichen Test des ClientProjekts nichts mehr entgegenstehen.

Bemerkung Falls Sie die Anwendung trotz aller Bemühungen in einer verteilten Umgebung nicht zum Laufen bringen, sollten Sie die komplette Applikation zunächst in einer lokalen Umgebung testen. Geben Sie dann folgende URL-Eigenschaft für die WebConnection ein: http://localhost/scripts/httpsrvr.dll

1556

Kapitel 26

How-to: Internet/Intranet

26.19 Eine 3-Tier-Applikation programmieren HINWEIS: Für dieses Rezept ist die Enterprise-Edition von Borland Delphi 7 erforderlich!

Dieses Rezept begleitet Sie Schritt für Schritt durch eine etwas anspruchsvollere verteilte Applikation. Wir wollen uns diesmal nicht auf die Anzeige nur einer einzigen Tabelle beschränken, sondern zwei Tabellen (Customer und Orders) so miteinander verknüpfen, dass in den Clients alle zu einem bestimmten Kunden gehörenden Bestellungen (hierarchische Recordsets) angezeigt und editiert werden können. HINWEIS: Zur Vorbereitung empfiehlt sich das Durcharbeiten der vorhergehenden Rezepte.

Auch diesmal ist unser MIDAS-Server ein In-Process-Automationsserver (ActiveX-DLL). Der MIDAS-Client ist wie üblich eine normale EXE, die Kommunikation mit dem MIDAS-Client wird per SocketConnection ( TCP/IP) realisiert. Die Applikation läuft zunächst komplett auf dem lokalen PC, was uns aber nicht hindern soll, sie später auf zwei oder mehr PCs zu verteilen.

Projekt MIDAS-Server Öffnen Sie ein neues Projekt. Da dieser MIDAS-Server als DLL implementiert wird, wählen Sie über Datei|Neu|Weitere... die "ActiveX"-Seite der Objektgalerie und doppelklicken auf das "ActiveX-Bibliothek"-Symbol. Ändern Sie den Namen der Library in MidasServer und speichern das Projekt vorsichtshalber bereits jetzt in ein separates Unterverzeichnis \ServerDll ab. Wählen Sie wieder Datei|Neu|Weitere..., gehen zur "Multi-Tier"-Seite und fügen ein "Externes Datenmodul" zum Projekt hinzu. Als Namen der Co-Klasse geben Sie KuBest ein (die Klasse soll ja den Zugriff auf die verknüpften Tabellen der Kunden und Bestellungen ermöglichen):

Nach dem OK steht die vorgefertigte Unit1 des Datenmoduls bereit, deren Namen Sie aber in KuBestDM ändern. Speichern Sie bereits jetzt sicherheitshalber die Datei als KuBestDM.pas ab.

26.19 Eine 3-Tier-Applikation programmieren

1557

HINWEIS: Einen Unit-Bezeichner sollten Sie nicht länger als acht Zeichen wählen. unit KuBestDM;

// geändert!

interface ...

Den restlichen, ziemlich umfangreichen Unit-Code hat Delphi für uns erledigt! Nun widmen wir uns der Ausgestaltung des Remote-Datenmoduls. Von der "BDE"-Seite der Komponentenpalette ziehen Sie eine Table- und eine Query-Komponente in das Fenster, von der "Datenzugriff"-Seite eine DataSource- und zwei DataSetProvider-Komponenten und ändern jeweils deren Name-Eigenschaft entsprechend folgender Abbildung:

HINWEIS: In der Kopfleiste des Remote-Datenmoduls steht der Name der exportierten Klasse!

Das "Zusammenschalten" der Komponenten erfolgt ausschließlich über den Objektinspektor, erfordert also keinerlei Quelltext. Zunächst binden Sie die Table- und die Query-Komponente über ihre DatabaseName-Eigenschaft an die zu Delphi mitgelieferte Beispieldatenbank DBDEMOS. Die TableName-Eigenschaft von TabKunden setzen Sie auf Customer.db. Nun verbinden Sie sowohl ProvKunden als auch SrcKunden mit TabKunden, indem Sie die DataSet-Eigenschaft entsprechend setzen. QryBest stellt die für den aktuellen Kunden aufgegebenen Bestellungen zur Verfügung. Die SQLEigenschaft ist deshalb: SELECT * FROM Orders WHERE (CustNo = :CustNo)

HINWEIS: Achten Sie bei Parametereinträgen auf die exakte Schreibweise (Leerzeichen vor

dem Doppelpunkt, nicht danach!).

1558

Kapitel 26

How-to: Internet/Intranet

Die DataSource setzen Sie auf SrcKunden, damit :CustNo in obiger SQL-Abfrage auf den entsprechenden Primärschlüssel aus TabKunden verweisen kann (Einbetten Tabelle Orders in Customer). Fügen Sie sowohl zu TabKunden als auch zu QryBest persistente Feldobjekte hinzu (das lässt sich leider nicht vermeiden, da Sie andernfalls die Verknüpfung beider Tabellen nicht in den Griff kriegen). Doppelklicken Sie hierzu auf die jeweilige Komponente, und es öffnet sich der (zunächst leere) Feldeditor. Klicken Sie mit der rechten Maustaste auf eine beliebige Stelle und wählen Sie im Kontextmenü Alle Felder hinzufügen..., so dass sich schließlich folgender Anblick bietet:

Setzen Sie probeweise die Active-Eigenschaft von Table- und Query-Komponente auf True, um festzustellen, ob Datenbankanbindung und Tabellenverknüpfung fehlerfrei sind. Compilieren und Registrieren erfolgen über den Menüpunkt Start|ActiveX-Server eintragen. Falls alles klappt, werden Sie durch ein Meldungsfenster belohnt:

Im Projektverzeichnis finden Sie jetzt die Datei MidasServer.dll vor. HINWEIS: In späteren Projekt-Testphasen ist es immer wieder möglich, Änderungen am

MIDAS-Server vorzunehmen und ihn erneut zu compilieren, ohne dass sich dadurch seine Registrierung ändert.

26.19 Eine 3-Tier-Applikation programmieren

1559

Projekt MidasClient Wieder öffnen Sie ein neues Projekt (diesmal eine ganz normale EXE) und gestalten die im Folgenden abgebildete Bedienoberfläche mit einer SocketConnection-, zwei ClientDataset-, zwei DataSource-, zwei DBGrid-, zwei DBNavigator-Komponenten und einem Button.

Aus Übersichtlichkeitsgründen ändern Sie auch hier die Name-Eigenschaft der MIDAS-Komponenten in SockConn, CdsKunden, SrcKunden, CdsBest und SrcBest. Beide Navigatorkomponenten befreien Sie mittels VisibleButtons-Eigenschaft von einigen für unsere Zwecke nutzlosen Schaltflächen (siehe Abbildung). Das "Zusammenschalten" der Client-Komponenten bedarf ihrerseits keiner einzigen Zeile Quellcode, denn es wird von Delphi großzügig unterstützt (Eigenschaften werden im Objektinspektor aufgelistet). Sie beginnen mit der Host-Eigenschaft der SocketConnection und setzen diese mit Hilfe des Auswahldialogs zunächst auf den Namen des eigenen Computers. Für unsere Entwicklungsarbeiten ist das ganz zweckmäßig, später sollte man das natürlich ändern. Sie starten den Borland Socket Server (Aufruf der Datei scktsrvr.exe aus dem \Delphi\BinVerzeichnis). Das Symbol wird in der Taskleiste angezeigt.

1560

Kapitel 26

How-to: Internet/Intranet

Jetzt versuchen Sie, die ServerName-Eigenschaft auf MidasServer.KuBest zu setzen (muss in der Klappbox aufgelistet werden, da wir unseren Server auf dem Entwicklungsrechner registriert haben). Setzen Sie auch probeweise Connected auf True. Nun stellen Sie die RemoteServer-Property von CdsKunden auf SockConn (wird als einzige aufgelistet) ein und ProviderName auf ProvKunden (der Bezeichner stammt aus dem MidServer1Projekt!). Analog verfahren Sie mit dem zweiten ClientDataset (CdsBest), das auf den Provider ProvBest verweisen muss. Sie verbinden die DataSet-Eigenschaft von SrcKunden bzw. SrcBest mit dem entsprechenden ClientDataSet und setzen die DataSource-Eigenschaft der beiden DBGrids und der beiden DBNavigatoren entsprechend.

Quellcode Ganz ohne geht es diesmal nicht. Um die vorgenommenen Änderungen in die Datenbank übernehmen zu können, ist folgender Event-Handler erforderlich: procedure TForm1.ButtonClick(Sender: TObject); begin if CdsKunden.ApplyUpdates(-1) > 0 then begin ShowMessage('Fehler beim Aktualisieren der Datenbasis!'); cdsKunden.CancelUpdates end end;

Außerdem empfiehlt sich folgende Ergänzung: procedure TForm1.FormCreate(Sender: TObject); begin cdsKunden.First end;

Test Starten Sie zuerst den Borland Socket Server. Testen Sie die Verbindung zum MIDAS-Server, indem Sie die Connected-Eigenschaft von SockConn und die Active-Eigenschaft beider ClientDataSets auf True setzen. Bereits jetzt zur Entwurfszeit müsste der erste Kunde im oberen Gitter erscheinen und die ihm zugeordneten Bestellungen im unteren. Dann starten Sie unser Client-Projekt (F9), doch die Enttäuschung ist groß: Zwar können Sie sich im oberen Datengitter durch die Kundentabelle bewegen, im unteren Datengitter hingegen rührt sich nichts. Was haben wir falsch gemacht bzw. vergessen?

Notwendige Ergänzungen Beide Tabellen sind zwar serverseitig, aber nicht clientseitig miteinander verknüpft! Das holen wir jetzt schnellstens nach und versuchen, die DataSetField-Eigenschaft des ClientDataSet CdsBest auf das entsprechende Schlüsselfeld von CdsKunden zu setzen. Aber im Objektinspektor von CdsBest wird unter DataSetField kein Eintrag aufgelistet, weil CdsKunden standardmäßig keine persistenten (sondern nur dynamische) Felder bereitstellt.

26.19 Eine 3-Tier-Applikation programmieren

1561

Fügen Sie deshalb zu CdsKunden persistente Feldobjekte hinzu (Doppelklick auf die Komponente, mit rechter Maustaste Kontextmenü des Felder-Editors aufrufen, "Alle Felder hinzufügen..."), und siehe da, endlich wird als DataSetField-Eigenschaft von CdsBest der Eintrag CdsKundenQryBest zur Auswahl angeboten.

Ein erneuter Start des Projekts wird nun endlich vom Erfolg gekrönt sein. Bei Auswahl eines anderen Kunden kommt Bewegung in das untere Datengitter, alle dem aktuellen Kunden zugeordneten Bestellungen werden angezeigt.

1562

Kapitel 26

How-to: Internet/Intranet

Bemerkungen ■ Nachdem auf dem lokalen PC alles ordnungsgemäß funktioniert, können Sie die Anwendung auf verschiedene PCs verteilen. Im Client-Projekt wäre dazu lediglich eine flexible Zuweisung der Host-Eigenschaft der SocketConnection erforderlich. ■ Um die Netzbelastung gering zu halten, empfiehlt es sich, die Anzahl der angezeigten Kunden zu begrenzen, z.B. durch Ersatz der Table- durch eine Query-Komponente mit folgender SQLEigenschaft: SELECT * FROM Customers WHERE CustNo = -1

■ Durch diese Client/Server-typische Abfrage ist ein quasi verzögerungsfreies Öffnen des ClientDataSet möglich, da zu Beginn kein Kunde angezeigt wird. Die Einschränkung der anzuzeigenden Datensätze ist durch Änderung der CommandText-Eigenschaft des ClientDataSet möglich, z.B.: SELECT * FROM Customers WHERE Company LIKE ... usw.

■ Um solch nachträgliche Änderungen einer SQL-Abfrage zu ermöglichen, ist innerhalb der Options-Eigenschaft von ProvKunden (im Server-Projekt) der Eintrag poAllowCommandText auf True zu setzen. ■ Durch Austausch der SocketConnection- mit einer WebConnection- oder einer DCOMConnection-Komponente können Sie verschiedene Client-Anwendungen mit unterschiedlichen Verbindungstypen erstellen. Am Server-Projekt sind keinerlei Veränderungen erforderlich! ■ Während der Entwicklungsphase ist es wärmstens zu empfehlen, auf Client- und Server-PC Delphi zu installieren. Für die endgültige Anwendung ist natürlich das Erstellen von Setup-Projekten unumgänglich.

27

How-to: System

Kapitel

27

How-to: System 27.1 Systemzeit freigeben Läuft ein rechenzeitintensiver Programmteil, werden alle anderen Programmfunktionen blockiert. Dieses Verhalten hat sich auch bei einem 32-Bit-Programm nicht geändert. Lediglich die Auswirkungen auf andere Prozesse sind reduziert worden, jeder Prozess erhält seine Rechenzeit vom System zugewiesen. Was Sie in diesem Zusammenhang mit der ProcessMessages-Methode anfangen können, zeigt Ihnen das folgende Beispiel.

Oberfläche Sie brauchen ein Formular, drei Labels, ein Panel, ein Timer-Objekt sowie vier Buttons. Die in der Abbildung dargestellte "Digitaluhr" (Panel) wird durch das Programm gestartet und soll den Einfluss von ProcessMessages auf das Verhalten der eigenen Anwendungen verdeutlichen.

1564

Kapitel 27

How-to: System

Quelltext Mit dem Klick auf jeden der drei Buttons wird 2.000.000 Mal der Sinus einer Zahl berechnet. Das folgende Beispiel ermittelt die Werte ohne Rücksicht zu nehmen (die Uhr steht). Mit diesem "egoistischen" Verhalten wird die schnellste Ausführungszeit erkauft. procedure TForm1.Button1Click(Sender: TObject); var a : Single; von,bis,x : LongInt; begin MessageBeep(0); Screen.Cursor := crHourGlass; von := getTickCount; for x := 1 to 2000000 do a := Sin(x) + a; bis := getTickCount; MessageBeep(0); Label1.Caption := IntToStr((bis - von)) + ' ms'; Screen.Cursor := crDefault end;

Was passiert im Einzelnen? Nach der Ausgabe eines Pieptones wird über das Screen-Objekt der Mauszeiger in eine Sanduhr umgewandelt. Die API-Funktion GetTickCount liefert uns die Anzahl von Millisekunden seit dem Systemstart. Nach der Schleife brauchen wir diesen Wert für die Berechnung der Bearbeitungsdauer. Im folgenden Beispiel wird bei jedem Schleifendurchlauf die Rechenzeit für andere Anwendungen freigegeben. Die Programmlaufzeit steigt drastisch an! procedure TForm1.Button2Click(Sender: TObject); var a : Single; von,bis, x : LongInt; begin MessageBeep(0); Screen.Cursor := crHourGlass; von := getTickCount; for x := 1 to 2000000 do begin Application.processMessages; a := Sin(x) + a end; bis := getTickCount; MessageBeep(0); Label2.Caption := IntToStr((bis - von)) + ' ms'; Screen.Cursor := crDefault end;

Der doppelte Zeitbedarf dürfte für eine professionelle Anwendung unzumutbar sein. Da könnte man auch gleich eine Interpretersprache, wie zum Beispiel Visual Basic, verwenden. Es gilt also, einen "goldenen Mittelweg" zu finden. Dass man durch geschickte Zuteilung auch eine akzeptable Programmlaufzeit erreichen kann, zeigt das folgende Beispiel. Bei for-Schleifen bietet sich die mod-Anweisung an, da keine zusätzliche Laufvariable benötigt wird.

27.1 Systemzeit freigeben

1565

procedure TForm1.Button3Click(Sender: TObject); var a : Single; von, bis, x: LongInt; begin MessageBeep(0); Screen.Cursor := crHourGlass; von := getTickCount; for x := 1 To 2000000 do begin if (x Mod 50000) = 0 then Application.ProcessMessages; a := Sin(x) + a end; bis := getTickCount; MessageBeep(0); Label3.Caption := IntToStr((bis - von)) + ' ms'; Screen.Cursor := crDefault end;

Die Ressourcen werden mit jedem 50.000-ten Durchlauf freigegeben. Die Uhr erhält genügend Rechenzeit, um ihre eigene Aufgabe auszuführen.

Test Starten Sie das Programm und vergleichen Sie die drei Varianten!

Bemerkung Verwenden Sie die ProcessMessages-Methode, können lange Programmteile durch erneute Benutzereingaben (Tastatur, Maus) unterbrochen werden. Dies kann zu unerwünschten Seiteneffekten führen (Variableninhalte verändern sich undefiniert, Prozeduren werden mehrfach ausgeführt etc.). Um dies zu vermeiden, sollten Sie gegebenenfalls globale Statusvariablen einführen:

1566

Kapitel 27

How-to: System

var inBearbeitung: Boolean; Procedure Berechne; begin if inBearbeitung then Exit; inBearbeitung := True; ... inBearbeitung := False end;

Sollte das Modul bereits ausgeführt werden, bricht die Ausführung nach der ersten Zeile sofort ab, eine erneute Bearbeitung der Prozedur/Funktion wird vermieden.

27.2 Threads verstehen Obwohl Sie in diesem Buch mehrere Beispiele finden, in denen Threads zur Lösung von Programmieraufgaben eingesetzt wurden, möchten wir noch einmal in einem separaten Beispiel auf diese Problematik eingehen.

Oberfläche Neben drei PaintBoxen, in denen wir über drei einzelne Threads Ausgaben vornehmen werden, brauchen wir noch drei Trackbars zum Einstellen der jeweiligen Prozessprioritäten.

Soll ein Prozess vorübergehend angehalten werden, können Sie dazu die CheckBoxen verwenden.

27.2 Threads verstehen

1567

Quelltext-Threads Nach dem Start des Hauptformulars werden die drei Threads erzeugt. Jeder Thread versucht nun, mit maximaler Geschwindigkeit so viele Zeichenoperationen wie möglich in einer der drei Paintboxen auszuführen. uses thread2; var Th1: TLineThread; Th2: TRectThread; Th3: TCircThread; procedure TForm1.Button1Click(Sender: TObject); begin Th1:= TLineThread.Create(PaintBox1,tpLower); end; procedure TForm1.Button2Click(Sender: TObject); begin Th2:= TRectThread.Create(PaintBox2,tpLower); end; procedure TForm1.Button3Click(Sender: TObject); begin Th3:= TCircThread.Create(Paintbox3,tpLower); end;

Sie haben die Möglichkeit, über die Trackbars in das Geschehen einzugreifen und die Priorität einzelner Threads zu verändern: procedure TForm1.TrackBar1Change(Sender: TObject); var Th: TThread; begin if Sender is TTrackBar then with TTrackBar(Sender) do begin case Tag of 1: Th:= Th1; 2: Th:= Th2; 3: Th:= Th3; end; Case Position of 1: Th.Priority:= tpIdle; 2: Th.Priority:= tpLowest; 3: Th.Priority:= tpLower; 4: Th.Priority:= tpNormal; 5: Th.Priority:= tpHigher; 6: Th.Priority:= tpHighest; 7: Th.Priority:= tpTimeCritical end end end;

1568

Kapitel 27

How-to: System

HINWEIS: Falls es nicht schon zu spät ist: Die Prozesspriorität tpTimeCritical sollten Sie in

Ihrem Programm nicht einsetzen, spätestens ein Test wird Sie von der Richtigkeit dieser Warnung überzeugen. Zum Anhalten (nicht Beenden) von Threads können Sie die Methode Suspend einsetzen. Den normalen Ablauf erreichen Sie nach einem Aufruf von Resume. procedure TForm1.CheckBox1Click(Sender: TObject); var Th: TThread; begin if Sender is TCheckBox then with TCheckBox(Sender) do begin case Tag of 1: Th:= Th1; 2: Th:= Th2; 3: Th:= Th3; end; if Th.Suspended then Th.Resume else Th.Suspend end end;

Was passiert in der Unit thread2? Die Anwort gibt das folgende Listing. unit thread2; interface uses Classes, ExtCtrls, Windows; type TPaintThread = class(TThread) private FX1, FX2, FY1, FY2, FColor: Integer; FBox: TPaintBox; { Private-Deklarationen } protected procedure Execute; override; procedure Paint(x1, y1, x2, y2, Color: Integer); procedure DoPaint; virtual; abstract; public constructor Create(Box: TPaintBox; ThreadPriority: TThreadPriority); end; type TLineThread =class(TPaintThread) protected procedure DoPaint; override; end; type

27.2 Threads verstehen

1569

TRectThread = class (TPaintThread) protected procedure DoPaint; override; end; type TCircThread = class (TPaintThread) protected procedure DoPaint; override; end; implementation

Initialisieren des neuen Threads: constructor TPaintThread.Create(Box: TPaintBox; ThreadPriority: TThreadPriority); begin inherited Create(False); Priority := ThreadPriority; FColor:= 0; FBox:= Box; FX1 := 0; FX2:= 0; FY1:= 0; FY2:= 0 end;

Jede Thread-Instanz führt die folgende Methode aus (eine echte Arbeitsbeschaffungsmaßnahme!): procedure TPaintThread.Execute; var x1, y1, x2, y2, i : Integer; begin // Platzieren Sie den Threadcode hier: Randomize; while True do Paint(Random(200), Random(200), Random(200), Random(200), Random($FFFF)) end;

procedure TPaintThread.Paint(x1, y1, x2, y2, Color: Integer); begin FX1:= x1; FX2:= x2; FY1:= y1; FY2:= y2; FColor:= Color; Synchronize(DoPaint) end;

Was in der synchronisierten Methode DoPaint angezeigt wird, hängt davon ab, wie die Methode von den einzeln abgeleiteten Thread-Klassen (TLineThread, TRectThread ...) überschrieben wurde: {TLineThread} Procedure TLineThread.DoPaint; begin with FBox.Canvas do begin Pen.Color:= FColor;

1570

Kapitel 27

How-to: System

MoveTo(FX1, FY1); LineTo(FX2, FY2) end end; {TRectThread} Procedure TRectThread.DoPaint; begin with FBox.Canvas do begin Brush.Style := bsClear; Pen.Color:= FColor; Rectangle(FX1, FY1, FX2, FY2) end end; {TCircThread} procedure TCircThread.DoPaint; begin with FBox.Canvas do begin Brush.Style := bsClear; Pen.Color:= FColor; Ellipse(FX1, FY1, FX2, FY2) end end; end.

Test Starten Sie das Programm und starten Sie nacheinander die Threads. Verringern Sie die jeweiligen Prozessprioritäten und beobachten Sie das Verhalten.

27.3 Windows-Botschaften verarbeiten

1571

HINWEIS: Je nach Betriebssystem (Windows ME, Windows XP) ändert sich auch das Verhalten

der Anwendung, da die Threadverarbeitung sich unterscheidet. Weitere Einsatzmöglichkeiten von Threads finden Sie in Ä 19.15 Einen Bildausschnitt scrollen Ä 21.10 Änderungen in einem Verzeichnis überwachen Ä 27.6 Daten zwischen Prozessen austauschen

27.3 Windows-Botschaften verarbeiten Reichen Ihnen die von Delphi zur Verfügung gestellten Ereignisse nicht, müssen Sie sich selbst um die Verarbeitung von Messages kümmern. Dazu bieten sich mehrere Varianten an: ■ Schreiben einer neuen Ereignisprozedur (Event) ■ Überschreiben der Fenster-Methode WndProc ■ Verwenden der Ereignisprozedur Application.OnMessage

Neue Ereignisprozedur (Event) Grundsätzlich können Sie für jede Message (Nachricht), die an das Fenster gerichtet ist, eine neue Ereignisprozedur schreiben. Alles, was Sie machen müssen, ist eine Erweiterung der Fensterklasse. In unserem Beispiel wollen wir auf das Verschieben des Fensters reagieren. Das System stellt zu diesem Zweck die Botschaft WM_MOVE bereit. Die Deklaration: type TForm1 = class(TForm) protected procedure WMMove(var message: TMessage); message WM_MOVE; end; ...

Die eigentliche Ereignisprozedur: procedure TForm1.WMMove(var message: TMessage); begin beep; end;

Über die Struktur TMessage TMessage = record Msg: Word; case Integer of 0: ( WParam: Word; LParam: Longint; Result: Longint);

1572

Kapitel 27

1: ( WParamLo: WParamHi: LParamLo: LParamHi: ResultLo: ResultHi:

How-to: System

Byte; Byte; Word; Word; Word; Word);

end;

können Sie die einzelnen Message-Parameter auswerten. Beispielsweise ist bei obiger Botschaft im Parameter lParam die Fensterposition enthalten. Die Abfrage könnte also wie folgt aussehen: xPos := message.lParamLo; yPos := message.lParamHi;

Ein derartiger Message-Handler ist jedoch auf eine einzige Message beschränkt, wollen Sie auf mehrere Botschaften mit ein und demselben Ereignis reagieren, ist der Programmieraufwand beträchtlich. In diesem Fall ist die folgende Variante effektiver.

Überschreiben von WndProc Ansatzpunkt für einen Message-Handler, der alle Fensterbotschaften erhält, ist die Methode WndProc. Diese Methode existiert bereits und muss aus diesem Grund überschrieben werden. Die dazu nötige Deklaration finden Sie im folgenden Listing: type TForm1 = class(TForm) protected procedure WndProc(var Message: TMessage); override; end; ...

Die eigentliche Umsetzung ist relativ einfach, in einer Case-Anweisung können Sie, in Abhängigkeit von den übergebenen Botschaften, Funktionen bzw. Prozeduren ausführen. Die ursprüngliche Prozedur sollten Sie jedoch in jedem Fall weiterhin aufrufen (inherited WndProc(Message)), andernfalls könnte es schnell zu Problemen kommen. procedure TForm1.WndProc(var Message: TMessage); begin case Message.Msg of WM_KEYDOWN, WM_MOVE : beep; end; inherited WndProc(Message); end;

Application.OnMessage Sollen nicht nur die fensterspezifischen Botschaften empfangen werden, sondern auch die an die Applikation gerichteten, müssen Sie sich etwas zeitiger in die Ereigniskette einklinken. Sinnvoller Ansatzpunkt ist das OnMessage-Ereignis von TApplication.

27.3 Windows-Botschaften verarbeiten

1573

So einfach wie bei der Zuweisung anderer Ereignisprozeduren ist es in diesem Fall allerdings nicht, Sie müssen die Zuordnung zur Laufzeit erzeugen. Dazu erweitern Sie die Typdeklaration des Fensters um folgenden Eintrag: type TForm1 = class(TForm) procedure FormCreate(Sender: TObject); protected procedure MyMessage(var Msg: TMsg; var Handled: Boolean); end; ...

Im FormCreate-Ereignis verknüpfen Sie dann das OnMessage-Ereignis mit Ihrer Ereignisprozedur: procedure TForm1.FormCreate(Sender: TObject); begin Application.OnMessage := MyMessage end;

Die eigentliche Botschaftsbehandlung: procedure TForm1.MyMessage(var Msg: TMsg; var Handled: Boolean); begin case Msg.Message of wm_KeyDown : beep; end; end;

Der Datentyp TMsg: TMsg = record hwnd: HWnd; // Fenster-Handle message: Word; wParam: Word; lParam: LongInt; time: Longint; // Zeitpunkt der Botschaft pt: TPoint; // Position des Cursors end;

Test Im Beispiel auf der Buch-CD erfolgt immer dann die Ausgabe in einer ListBox, wenn Sie das Fenster verschieben:

1574

Kapitel 27

How-to: System

27.4 Den Computer herunterfahren und neu starten Geht es um die Installation von Anwendungen, Treibern etc. oder müssen Sie programmgesteuert die Bildschirmauflösung ändern, wird ein erneuter Systemstart fällig. Das Windows-API stellt zu diesem Zweck die Funktion ExitWindowsEx bereit. SYNTAX:

ExitWindowsEx(uFlags: UINT; dwReserved: DWORD): BOOL;

Die möglichen Werte für uFlags: Konstante

Beschreibung

EWX_FORCE

Dieser Wert wird mit den restlichen Konstanten kombiniert, um die entsprechende Aktion ohne "Nachfragen" (Dialoge) auszuführen.

EWX_LOGOFF

Ausloggen des Users.

EWX_POWEROFF

Ausschalten des Systems (nur wenn die Hardware dies unterstützt).

EWX_REBOOT

Herunterfahren des Systems und Neustart.

EWX_SHUTDOWN

Herunterfahren des Systems.

Leider werden Sie an dieser Stelle wieder einmal mit den kleinen, aber feinen Unterschieden zwischen Windows 95/98 und Windows 2000/XP konfrontiert. Während Windows 95/98 ohne große Vorbereitungen die Funktion ausführen kann, müssen Sie unter NT erst die nötigen Sicherheitsattribute (SeShutdownPrivilege) setzen.

Oberfläche Den Grundaufbau der Oberfläche entnehmen Sie bitte der folgenden Abbildung.

Über die Checkbox werden wir das Flag EWX_FORCE zuschalten.

Quelltexte Die eigentliche Funktion zum Beenden von Windows unterscheidet automatisch die Betriebssysteme, Sie brauchen also nicht extra das System abzufragen. Übergeben Sie der Funktion einen String, wird dieser in einer Dialogbox eingeblendet. Der zweite Parameter ist eine der Konstanten aus der obigen Tabelle.

27.4 Den Computer herunterfahren und neu starten

1575

uses windows,dialogs; Function ExitWindows(Frage:string;flag:word): Boolean; var vi : TOSVersionInfo; hToken : THandle; tp : TTokenPrivileges; h : DWord; begin result := False; if frage <> '' then if MessageDlg(frage, mtConfirmation, [mbYes,mbNo],0) = IDNo then exit; vi.dwOSVersionInfoSize:=SizeOf(vi); GetVersionEx(vi); if vi.dwPlatformId = VER_PLATFORM_WIN32_NT then begin // Windows NT OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES,hToken); LookupPrivilegeValue(nil,'SeShutdownPrivilege',tp.Privileges[0].Luid); tp.PrivilegeCount := 1; tp.Privileges[0].Attributes := SE_PRIVILEGE_ENABLED; h := 0; AdjustTokenPrivileges(hToken,False,tp,0,PTokenPrivileges(nil)^,h); CloseHandle(hToken); result := ExitWindowsEx(flag,0); end else Result := ExitWindowsEx(flag,0) end;

Wie Sie sehen, ist bei Windows NT schon etwas Arbeit nötig, um das nötige Sicherheitsattribut einzuschalten. Unser eigentliches Beispielprogramm fällt, wie nicht anders zu erwarten, recht kurz aus: var flag:word; procedure TForm1.CheckBox1Click(Sender: TObject); begin if checkbox1.Checked then flag := EWX_FORCE else flag := 0 end; procedure TForm1.Button2Click(Sender: TObject); begin if ExitWindows('Beenden',ewx_logoff+flag) then Label1.Caption:='JA' end; ... if ExitWindows('Beenden',ewx_poweroff+flag) then Label1.Caption:='JA' ... if ExitWindows('Beenden',ewx_reboot+flag) then Label1.Caption:='JA' ... if ExitWindows('Beenden',ewx_shutdown+flag) then Label1.Caption:='JA'

1576

Kapitel 27

How-to: System

Test Probieren Sie die verschiedenen Optionen aus. Um den Einfluss von EWX_FORCE zu testen, öffnen Sie einmal ein paar Anwendungen und beenden dann Windows.

27.5 Ein anderes Programm starten Möchten Sie aus Ihrem Delphi-Programm heraus eine andere Anwendung starten, brauchen Sie eine Funktion, der Sie sowohl das zu startende Programm, den Pfad als auch die Parameter übergeben können. Ein möglicher Einsatzfall könnte z.B. die Oberfläche für eines der vielen Shareware-Packprogramme sein. Unter Windows wählen Sie die betreffenden Dateien aus, in einem versteckten Fenster lassen Sie den DOS-Packer ablaufen. Zwei eigentlich grundverschiedene Varianten bieten sich Ihnen an: ■ die Funktion ShellExecute ■ die Funktion CreateProcess Während Sie mit ShellExecute in der 32-Bit-Version andere Programme nur noch asynchron starten können, bietet sich Ihnen mit CreateProcess die Möglichkeit, so lange zu warten, bis die gestartete Anwendung beendet wurde (synchron).

ShellExecute Unser Beispielprogramm soll Ihnen die Möglichkeiten der API-Funktion ShellExecute verdeutlichen. Neben diversen Parametern werden auch die wichtigsten Fehler durch das Programm behandelt.

Oberfläche Die Oberfläche besteht neben drei Edit-Feldern aus einer RadioGroup für die Parameter sowie zwei Buttons.

27.5 Ein anderes Programm starten

1577

Quelltext Das nachfolgende Listing besteht zu 99 % aus Fehlerbehandlung und Aufbereitung der Parameter. procedure TForm1.Button2Click(Sender: TObject); var i,i1,typ : integer; msg : string; begin case radiogroup1.itemindex of 0 : typ:=SW_HIDE; 1 : typ:=SW_MINIMIZE; 2 : typ:=SW_RESTORE; 3 : typ:=SW_SHOW; 4 : typ:=SW_SHOWMAXIMIZED; 5 : typ:=SW_SHOWMINIMIZED; 6 : typ:=SW_SHOWMINNOACTIVE; 7 : typ:=SW_SHOWNA; 8 : typ:=SW_SHOWNOACTIVATE; 9 : typ:=SW_SHOWNORMAL; end; i := shellexecute(handle, // Handle des aufrufenden Fensters 'open', // open oder print PChar(edit1.text), // Name der Anwendung PChar(edit2.text), // Parameter PChar(edit3.text), // Verzeichnis typ); // Anzeigeoption if i <= 32 then begin case i of 0 : msg:='Zu wenig Speicher, ausführbare Datei war zerstört, Relokationswerte waren ungültig'; 2 : msg:='Datei wurde nicht gefunden.'; 3 : msg:='Verzeichnis wurde nicht gefunden.'; 5 : msg:='Fehler beim gemeinsamen Zugriff auf eine Datei im Netz oder Fehler'+ ' beim Zugriff auf eine gesperrte Datei im Netz.'; 6 : msg:='Bibliothek forderte separate Datensegmente für jede Task an.'; 8 : msg:='Zu wenig Speicher, um die Anwendung zu starten.'; 10: msg:='Falsche Windows-Version.'; 11: msg:='Ungültige ausführbare Datei. Entweder keine Windows -Anwendung oder Fehler in der EXE-Datei.'; 12: msg:='Anwendung für ein anderes Betriebssystem.'; 13: msg:='Anwendung für MS-DOS 4.0.'; 14: msg:='Typ der ausführbaren Datei unbekannt.'; 15: msg:='Versuch, eine Real-Mode-Anwendung zu laden.'; 19: msg:='Versuch, eine komprimierte ausführbare Datei zu laden. Die Datei muss dekomprimiert'+ ' werden, bevor sie geladen werden kann.'; 20: msg:='Ungültige dynamische Linkbibliothek (DLL). Eine

1578

Kapitel 27

How-to: System

der DLLs, die benötigt wurde, um '+ 'die Anwendung auszuführen, war beschädigt.'; end; showmessage(msg); end; end;

Aus der langen Fehlerliste können Sie schon ersehen, dass es nicht einfach ist, eine andere Anwendung fehlerfrei zu starten. Verzichten Sie in diesem Zusammenhang auch nicht auf eine Auswertung, die Anwender Ihrer Programme werden es Ihnen danken (besser eine Messagebox mit einer Fehlermeldung als ein schwarzer Bildschirm!).

Test Probieren Sie die verschiedenen Parameter aus. Übergeben Sie DOS-Kommandos mit dem Parameter "/C". BEISPIEL: Übergabe von DOS-Kommandos /Cdir *.* > c:\1.txt

Die entstandene Textdatei können Sie in Delphi einlesen.

CreateProcess Mit der CreateProcess-Funktion bietet sich unter Windows NT/XP bzw. Windows 95/98 ein sinnvoller Weg, eine Anwendung zu starten. Für uns ist im Wesentlichen nur das Beenden des Prozesses interessant. Mit der WaitForSingleObject-Funktion haben wir die Möglichkeit, so lange zu warten, bis der Prozess beendet wird. Auf die verschiedenen Optionen beim Programmstart wollen wir nicht weiter eingehen. Sollten Sie in dieser Richtung weitere Versuche anstellen, dürfte die TStartupInfo-Struktur der geeignete Ansatzpunkt sein.

Oberfläche Die Oberfläche des Programms ist recht spartanisch: Außer einem Button finden Sie nur ein Textfeld für die Eingabe der Kommandozeile (Programmname und Parameter).

27.5 Ein anderes Programm starten

1579

Quelltext procedure TForm1.Button1Click(Sender: TObject);

Einbinden der beiden Strukturen: var StartupInfo: TStartupInfo; ProcessInfo: TProcessInformation; begin

HINWEIS: Die Struktur StartupInfo muss unbedingt initialisiert werden (wenigstens alles auf

null setzen!): FillChar(StartupInfo, SizeOf(TStartupInfo), 0); StartupInfo.cb := Sizeof(TStartupInfo); if CreateProcess(nil, // Anwendungsname PChar(Edit1.Text), // Parameter nil, // Security nil, // Security False, NORMAL_PRIORITY_CLASS, // Priorität nil, // Environment PChar(edit2.text), // Verzeichnis StartupInfo, ProcessInfo) then begin

Sollte ein Prozess erzeugt worden sein, warten wir mit WaitForSingleObject so lange, bis dieser beendet wurde: WaitForSingleObject(ProcessInfo.hProcess, INFINITE); CloseHandle(ProcessInfo.hProcess); Showmessage('Prozess beendet!'); end else ShowMessage('Fehler!') end;

Der Funktion CreateProcess übergeben Sie neben der Kommandozeile und den beiden Strukturen zusätzliche Parameter, die unter anderem die Prozesspriorität bestimmen. Angefangen mit der Leerlaufaktivität (IDLE_PRIORITY_CLASS) über das "normale" Programm (NORMAL_PRIORITY_CLASS) kann die Priorität bis zur Echtzeitfähigkeit (REALTIME_PRIORITY_CLASS) erhöht werden. HINWEIS: Möchten Sie eine bestimmte Anzahl vom Millisekunden warten, müssen Sie der

Funktion WaitForSingleObject statt INFINITE einen Wert übergeben.

Ergänzung Soll eine DOS-Anwendung im Hintergrund gestartet werden (nicht sichtbar), müssen Sie folgenden Funktionsaufruf verwenden:

1580

Kapitel 27

How-to: System

procedure TForm1.Button2Click(Sender: TObject); var StartupInfo: TStartupInfo; ProcessInfo: TProcessInformation; begin FillChar(StartupInfo, SizeOf(TStartupInfo), 0); StartupInfo.cb := Sizeof(TStartupInfo); StartupInfo.dwFlags := STARTF_USESHOWWINDOW; StartupInfo.wShowWindow:=SW_HIDE; if CreateProcess(nil, // Anwendungsname 'command.com /CDIR *.* > c:\dir.dat', // Parameter nil, // Security nil, // Security False, NORMAL_PRIORITY_CLASS, // Priorität nil, // Environment 'c:\', // Verzeichnis StartupInfo, ProcessInfo) then begin WaitForSingleObject(ProcessInfo.hProcess, INFINITE); CloseHandle(ProcessInfo.hProcess); end else ShowMessage('Fehler!'); form2.memo1.Lines.LoadFromFile('c:\dir.dat'); form2.show end;

Das Beispiel erzeugt eine Textdatei, die nachfolgend in einem Memofeld angezeigt werden kann. Ein DOS-Fenster ist nicht zu sehen (auf PIF-Dateien können Sie verzichten).

Test

27.6 Daten zwischen Prozessen austauschen

1581

27.6 Daten zwischen Prozessen austauschen Geht es darum, Daten zwischen verschiedenen Prozessen auszutauschen (dies schließt auch Prozesse auf Computern ein, die über ein LAN miteinander verbunden sind), bietet sich eine sehr leistungsfähige Variante an: die so genannten Named Pipes. HINWEIS: Die im Folgenden vorgestellten Programme sind nur zum Teil unter Windows 95/98

ausführbar. Lediglich die Client-Anwendung läuft unter Windows 95/98, da alle wesentlichen Server-Funktionen nicht unterstützt werden. Unter Windows NT/2000/XP laufen sowohl Client als auch Server, beide Anwendungen können auch lokal miteinander kommunizieren (ohne Netzwerk). Das Grundprinzip einer Named Pipe können Sie sich ähnlich wie einen SQL-Server vorstellen (der MS SQL Server benutzt ebenfalls Named Pipes für den Datentransfer). Ein Server wartet auf die Clientanfrage, erfolgt diese, wird ein neuer Thread gestartet, der diese Anfrage bearbeitet und gegebenenfalls Daten zurücksendet.

Named Pipe-Server Um das Beispiel nicht noch mehr zu verkomplizieren, wollen wir uns darauf beschränken, einen Wert (Uhrzeit) über den Client vom Server anzufordern. Genauso gut könnten Sie auch ganze Dateien übertragen oder eine Datenbank auslesen.

Oberfläche Den Aufbau der Oberfläche entnehmen Sie bitte der folgenden Abbildung:

Quelltext Fast die gesamte Funktionalität der Server-Anwendung ist in der Unit server untergebracht. Im Wesentlichen handelt es sich um einen eigenen Thread, in dessen Execute-Methode sich die Routinen zum Bereitstellen der Pipe befinden. unit server; interface

1582

Kapitel 27

How-to: System

uses Classes, Windows, WinTypes, SysUtils, Messages; type TServerThread = class(TThread) private FCount: Integer; FPipe: THandle; protected procedure Execute; override; procedure ShowVCL; procedure ShutDown; public destructor Destroy; end; implementation uses unit1;

Im Destruktor wird die Pipe geschlossen: { TServerThread } destructor TServerThread.Destroy; begin if DisconnectNamedPipe(FPipe) then CloseHandle(FPipe); inherited Destroy; end;

Die Hauptroutine: procedure TServerThread.Execute; var fConnected, fSuccess: LongBool; chRequest: string[55]; chReply: string; lb: byte absolute chRequest; dwThreadID, cbBytesRead, cbReplyBytes, cbWritten: DWord;

HINWEIS: Wie der Name schon sagt, handelt es sich um Named Pipes, d.h., der Bezeichner

spielt eine wesentliche Rolle. Für unser Programm verwenden wir "TimePipe", die weiteren Angaben kennzeichnen eine Pipe (im Gegensatz zu einer Datei oder einer Schnittstelle). const PipeName :PChar = '\\.\pipe\TimePipe'+ #0 ; begin FCount:= 0;

Die Kommentare im folgenden Listing dürften für das Verständnis ausreichen:

1583

27.6 Daten zwischen Prozessen austauschen

while True do begin //Pipe-Erzeugung: FPipe := CreateNamedPipe(PipeName, PIPE_ACCESS_DUPLEX, PIPE_TYPE_Message or PIPE_READMODE_Byte or PIPE_WAIT, PIPE_UNLIMITED_INSTANCES, 225, 255, NMPWAIT_USE_DEFAULT_WAIT, nil); if (FPipe <> INVALID_HANDLE_VALUE) then //Warten auf Clientzugriff: fConnected := ConnectNamedPipe(FPipe, nil); if (fConnected) then begin inc(FCount); chRequest :='

';

//Empfang Clientanfrage fSuccess := ReadFile(FPipe, chRequest[1], sizeof(chRequest), cbBytesRead, Nil);

Auswerten der Clientanfrage (an dieser Stelle könnten Sie weitere Befehle einbauen): if (Copy(chRequest, 1, Length('GETTIME'))='GETTIME') then chReply:=TimeToStr(Time) else if (Copy(chRequest, 1, Length('EXIT'))='EXIT') then begin chReply:='Und Tschüß'; synchronize(ShutDown); end; //Antwort zum Client: fSuccess := WriteFile(FPipe, chReply[1], length(chReply), cbWritten, nil); //Verbindungsabbau: FlushFileBuffers(FPipe); DisconnectNamedPipe(FPipe); CloseHandle(FPipe); synchronize(ShowVCL) end end end;

Der Direktzugriff auf VCL-Komponenten aus einem Thread heraus ist nicht zulässig, dazu muss eine synchronisierte Methode verwendet werden: procedure TServerThread.ShowVcl; begin Form1.Panel2.Caption:= IntToStr(FCount) end;

Das Beenden des Threads hat ebenfalls das Schließen des Hauptfensters zur Folge, wir senden dazu einfach eine Windows-Botschaft:

1584

Kapitel 27

How-to: System

procedure TServerThread.ShutDown; begin PostMessage(Form1.Handle, WM_CLOSE, 0,0) end;

Wird der Server gestartet, erstellt das Programm eine Instanz des obigen Thread-Objekts: var TimeServer: TServerThread; begin TimeServer:= TServerThread.Create(False); Button2.Enabled:= False end;

Named Pipe-Client Im Vergleich zum Server ist der Verwaltungsaufwand des Clients relativ gering. Wichtig ist vor allem eine Möglichkeit, den Namen des Rechners anzugeben, auf dem die Server-Anwendung läuft. Nur so ist eine Kommunikation überhaupt möglich.

Oberfläche Neben einem Eingabefeld brauchen Sie lediglich zwei Buttons und mehrere Label-Komponenten. Der Timer dient dazu, die Uhrzeit des Client-Rechners anzuzeigen.

Quelltext Nach dem Buttonklick soll sich der Client mit dem Server verbinden. Dazu wird aus der Eingabezeile der Server-Name ausgelesen und mit dem Pipe-Namen, den wir als Konstante in der ServerAnwendung festgelegt haben, verknüpft. procedure TForm1.Button2Click(Sender: TObject); var send : string; recv : string[255]; d : Byte absolute recv; re : DWord; pipe : String; begin pipe := '\\'+ Edit1.text+'\pipe\TimePipe'; send := 'GETTIME';

27.6 Daten zwischen Prozessen austauschen

1585

Der eigentliche Aufruf ist eine Anfrage, d.h., es werden sowohl Daten gesendet als auch empfangen. Der letzte Parameter der Funktion gibt eine Timeout-Zeit in Millisekunden vor, nach der die synchrone Ausführung der Funktion abgebrochen wird: if CallNamedPipe(PChar(pipe), @send[1], // address of write buffer length(send), // size, in bytes, of write buffer @recv[1], // address of read buffer sizeof(recv), // size, in bytes, of read buffer re, // address of number of bytes read 3000 // time-out time, in milliseconds ) then begin

Das war es auch schon, was bleibt, ist die Anzeige der empfangenen Daten: d := re; panel2.caption := recv; end else showmessage('Kein Connect zum TimeServer') end;

Auf die gleiche Art und Weise können wir auch den Server beenden, wir senden einfach den (selbst definierten) Befehl "Exit", auf den der Server entsprechend reagiert: procedure TForm1.Button1Click(Sender: TObject); var send : string; recv : string[100]; re : Dword; pipe : String; begin pipe := '\\'+ Edit1.text+'\pipe\TimePipe'; send := 'EXIT'; if not CallNamedPipe(PChar(pipe), @send[1], // Adresse (write buffer) length(send), // Größe in Bytes (write buffer) @recv[1], // Adresse (read buffer) sizeof(recv), // Größe in Bytes (read buffer) re, // Adresse der Anzahl gelesener Bytes 3000 // time-out in Millisekunden )then showMessage('kein Connect zum Time-Server') else showMessage('Shutdown Time-Server') end;

Test Starten Sie den Server und vergessen Sie nicht die Taste "TimeServer Starten" zu drücken (erst hier wird der Thread gestartet, der auf den Client wartet). Starten Sie danach den Client und geben Sie den Computernamen des Servers an. Nach dem Druck auf die Taste "Hole Server Zeit" müsste die Uhrzeit des Server-Computers in der Label-Komponente angezeigt werden. Zum Vergleich sehen Sie gleichzeitig die Uhrzeit des Client-Rechners.

1586

Kapitel 27

How-to: System

Bemerkungen ■ Wer unter Windows NT/2000/XP arbeitet, findet in der Systemsteuerung unter "Server" auch die Möglichkeit, geöffnete Ressourcen anzuzeigen. Dazu gehören neben konventionellen Dateien auch die Pipes. ■ Bevor Sie vergeblich versuchen, die geöffnete Pipe des Beispiels in der Ressourcen-Anzeige sichtbar zu machen, müssen wir Sie darauf hinweisen, dass die Pipe sofort nach dem ClientAufruf wieder geschlossen wird. ■ Das im Beispiel vorgestellte Programmgerüst dürfte sich mit relativ wenig Aufwand auch für andere Einsatzzwecke verwenden lassen, Änderungen sind im Wesentlichen im Thread des Servers vorzunehmen.

27.7 Mit der Registrierdatenbank arbeiten Seit Windows 95 besteht die Möglichkeit, etwas mehr Ordnung in das Chaos der Systemdateien zu bringen. Statt Dutzender von INI-Dateien werden nunmehr alle Informationen zu Soft- und Hardware in einer Registrierdatenbank gespeichert. Zusätzlich lassen sich auch noch nutzerspezifische Daten unterbringen.

Oberfläche Der Aufbau der Oberfläche für unser Demo-Programm:

27.7 Mit der Registrierdatenbank arbeiten

1587

Die Oberfläche dient lediglich als Demonstrationsbeispiel für die einzelnen Routinen und hat keinerlei praktische Bedeutung.

Quelltext (Test-Programm) + Test In der Create-Ereignisprozedur des Programms initialisieren wir das TRegistry-Objekt und legen gleichzeitig die Root innerhalb der Systemdatenbank fest: uses registry; {$R *.DFM} var regist : TRegistry; procedure TForm1.FormCreate(Sender: TObject); begin regist := TRegistry.Create; regist.RootKey := HKEY_LOCAL_MACHINE; end;

Der Ausgangspunkt vor dem Start des Testprogramms könnte wie folgt aussehen:

Die folgende Ereignisroutine testet, ob unter "HKEY_LOCAL_MACHINE" der Schlüssel "SOFTWARE" vorhanden ist (das sollte der Fall sein):

1588

Kapitel 27

How-to: System

procedure TForm1.Button1Click(Sender: TObject); begin if regist.KeyExists('SOFTWARE') then Label1.Caption := 'vorhanden' else Label1.Caption := 'nicht vorhanden' end;

Testen, ob Schlüssel "Shareware" in "HKEY_LOCAL_MACHINE" vorhanden ist (wenn ja, löschen Sie diesen am besten, in dieser Baumebene haben solche Einträge nichts zu suchen): if regist.KeyExists('SHAREWARE') then Label1.Caption := 'vorhanden' else Label1.Caption := 'nicht vorhanden'

Nach dem Erzeugen eines neuen Schlüssels mit if regist.CreateKey('\SOFTWARE\Doberenz & Kowalski\Testanwendung\1.0') then Label5.Caption := 'erzeugt' else Label5.Caption := 'Fehler oder schon vorhanden'

dürfte der Baum wie folgt aussehen:

Speichern eines Stringwertes unter dem obigen Schlüssel: regist.OpenKey('\SOFTWARE\Doberenz & Kowalski\Testanwendung\1.0',True); regist.WriteString('Programm-ID','45-1246-31-1996');

Speichern eines Integer-Wertes: regist.OpenKey('\SOFTWARE\Doberenz & Kowalski\Testanwendung\1.0',True); regist.WriteInteger('TestLong',47110001);

Unter dem Schlüssel "SOFTWARE\Doberenz & Kowalski\Testanwendung\1.0" werden die folgenden Felder abgespeichert:

Auslesen eines Feldes (String): regist.OpenKey('\SOFTWARE\Doberenz & Kowalski\Testanwendung\1.0',True); label6.caption := regist.ReadString('Programm-ID');

27.8 Binäre Daten aus der Registry laden

1589

Löschen eines Feldes: regist.OpenKey('\SOFTWARE\Doberenz & Kowalski\Testanwendung\1.0',True); if regist.DeleteValue('Test-Integer') then Label3.Caption := 'gelöscht' else Label3.Caption := 'Problem'

Löschen eines Teilschlüssels: if regist.DeleteKey('\SOFTWARE\Doberenz & Kowalski\Testanwendung\1.0') then Label3.Caption := 'gelöscht' else Label3.Caption := 'Problem'

Nach der Löschaktion sollte der Baum wie folgt aussehen:

Zum Löschen des restlichen Baumes können Sie entweder das Programm ändern regist.DeleteKey('\SOFTWARE\Doberenz & Kowalski')

oder Sie verwenden den Registriereditor. Allerdings sollten Sie beim Löschen nicht allzu sorglos vorgehen, eine unbeabsichtigte Aktion kann eine Neuinstallation von Windows bzw. einer Anwendung nach sich ziehen.

27.8 Binäre Daten aus der Registry laden Suchen Sie eine Möglichkeit, etwas umfangreichere Daten (zum Beispiel eine lange Seriennummer etc.) in eine Registrierdatenbank zu speichern? Wenn ja, dann bietet das folgende Rezept eine Lösung. Am Beispiel eines Bildes zeigen wir Ihnen, wie Sie Binärdaten in der Registrierdatenbank speichern und auch wieder laden können. HINWEIS: Im Normalfall sollten Sie keine Bilder etc. in der Registrierdatenbank speichern, da

dies die System-Performance negativ beeinflusst.

1590

Kapitel 27

How-to: System

Oberfläche Den Grundaufbau der Oberfläche entnehmen Sie bitte der folgenden Abbildung:

Quelltext Einbinden der Unit Registry: uses Registry;

Zuerst das Speichern der Grafik: procedure TForm1.Button1Click(Sender: TObject); var reg : TRegistry; m : TMemoryStream; begin Reg := TRegistry.Create; with Reg do begin RootKey := HKEY_LOCAL_MACHINE; OpenKey('\Software\DOKO\Test', True); m := TMemoryStream.Create; image1.Picture.Bitmap.SaveToStream(m); WriteBinaryData('Image', m.Memory^ , m.Size);

HINWEIS: Achten Sie auf die Dereferenzierung des Pointers! Worauf der Pointer zeigt ist se-

kundär, Sie können beliebige Daten auf diese Weise speichern. m.Free; Free end end;

Die Grafik löschen: procedure TForm1.Button2Click(Sender: TObject); begin image1.Picture.Bitmap := nil end;

27.9 Registry-Zweige komplett auslesen

1591

Auslesen der Grafik aus der Registrierdatenbank: procedure TForm1.Button3Click(Sender: TObject); var m : TMemoryStream; i : Integer; begin with TRegistry.Create do begin RootKey := HKEY_LOCAL_MACHINE; OpenKey('\Software\DOKO\Test', False); m := TMemoryStream.Create; i := GetDataSize('Image'); m.SetSize(i); ReadBinaryData('Image', m.Memory^ , m.Size); m.Position := 0; image1.Picture.Bitmap.LoadfromStream(m); m.free; Free; end; end;

Mit der folgenden Routine löschen wir den Registry-Eintrag, um auch wieder für Ordnung zu sorgen: procedure TForm1.Button4Click(Sender: TObject); begin with TRegistry.Create do begin RootKey := HKEY_LOCAL_MACHINE; DeleteKey('\Software\DOKO') end end;

Test Starten Sie das Programm und klicken Sie die Buttons von oben nach unten an. Zunächst wird das Bild in der Registrierdatenbank gespeichert, nachfolgend wird das Image auf dem Formular gelöscht. Mit Button3 werden die Daten aus der Registrierdatenbank geladen und angezeigt, Button4 räumt die Registrierdatenbank wieder auf.

27.9 Registry-Zweige komplett auslesen Realisieren Sie ein Programm zum Auslesen von Daten aus der Registrierdatenbank oder möchten Sie Informationen strukturiert aus der Registry auslesen, müssen Sie einen Weg finden, wie Sie alle Untereinträge bzw. alle Werte eines Schlüssels bestimmen können. Ein kleines Beispielprogramm zeigt Ihnen die Vorgehensweise.

Oberfläche Lediglich ein Label, eine TreeView-Komponente (Palette "Win32") und ein Button sind erforderlich.

1592

Kapitel 27

How-to: System

Quelltext Möchten Sie alle Untereinträge bestimmen, kommen Sie um einen rekursiven Funktionsaufruf nicht herum. Binden Sie jedoch zunächst die Unit Registry ein: uses registry;

Die folgende Prozedur erwartet als ersten Parameter den RootKey (z.B. HKEY_LOCAL_MACHINE), den Startkey, ab dem gesucht werden soll (z.B. SOFTWARE), sowie den übergeordneten Baumzweig in der TreeView-Komponente: procedure GetAllKeys(root: HKey; Key:string; node : TTreeNode); var reg : TRegistry; list : TStringList; i : Integer; begin reg := TRegistry.Create; reg.RootKey := root;

Zunächst wird versucht, den gewünschten Baumzweig zu öffnen: if reg.OpenKeyReadOnly(key) then begin

Sollten Untereinträge vorhanden sein if reg.HasSubKeys then begin

wird eine Liste dieser Untereinträge erstellt: list := TStringList.Create; reg.GetKeyNames(list);

Damit der Nutzer nicht denkt, die Anwendung ist "eingeschlafen", aktualisieren wir kurz das Formular: Form1.Label1.Caption := Key; Application.ProcessMessages;

Für alle Untereinträge des Registry-Schlüssels wird die Prozedur rekursiv aufgerufen, mit dem Aufruf erzeugen wir gleichzeitig auch den Baumzweig im TreeView: for i := 0 to list.Count -1 do if list[i] <> '' then GetAllKeys(root, Key + '\' + list[i], Form1.TreeView1.Items.AddChild(node,list[i])) end end; reg.Free end;

Der Aufruf der Funktion: procedure TForm1.Button1Click(Sender: TObject); begin TreeView1.Items.BeginUpdate; GetAllKeys(HKEY_LOCAL_MACHINE,'Software\Microsoft',

27.10 Die installierten Anwendungen anzeigen

1593

TreeView1.Items.Add(nil,'HKEY_LOCAL_MACHINE')); TreeView1.Items.EndUpdate end;

HINWEIS: Um Zeit zu sparen, ist es sinnvoll, die Aktualisierung der TreeView-Komponente

während des Einlesens zu deaktivieren.

Test Starten Sie das Programm, klicken Sie auf den Button und üben Sie sich etwas in Geduld, da das Einlesen einige Minuten in Anspruch nehmen kann.

HINWEIS: Wie schon erwähnt, ist das Programm zwar gründlich, aber nicht gerade schnell. Wer

lediglich eine visuelle Darstellung benötigt, sollte die Baumzweige erst einlesen, wenn in der TreeView der Eintrag aktiviert wird.

27.10 Die installierten Anwendungen anzeigen Möchten Sie mit einem Programm die installierte Software verwalten, brauchen Sie die Liste der registrierten Anwendungen sowie deren Deinstallationsroutine. Die gewünschten Informationen finden sich, wie nicht anders zu erwarten, in der Registry unter: HKEY_LOCAL_MACHINE\ SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall

Die eigentlichen Schlüssel enthalten nur eine Kurzbezeichnung (teilweise auch eine GUID), der im Uninstaller angezeigte Name findet sich als String-Wert unter der Bezeichnung "DisplayName":

1594

Kapitel 27

How-to: System

Der zweite Eintrag "UninstallString" gibt, wie der Name schon sagt, das Deinstallationsprogramm sowie die nötigen Aufrufparameter an.

Oberfläche Unser Test-Programm soll neben der reinen Anzeige auch die Deinstallation von Anwendungen ermöglichen. Die Namen der Anwendungen werden in einer ListBox angezeigt, die UninstallStrings speichern wir in einer separaten StringList. Die ImageList stellt uns die Grafiken für die beiden Buttons zur Verfügung.

Quelltext Binden Sie zunächst die beiden folgenden Units ein: uses Registry, ShellAPI;

Die interne Verwaltung der Uninstall-Strings: var myList : TStringList;

Mit der folgenden Prozedur lesen wir die Einträge aus der Registry aus und füllen die Listbox sowie die interne Stringliste. HINWEIS: Einträge, die keinen Wert für DisplayName enthalten, sind nur für die interne Ver-

waltung einiger Programme da, wir zeigen Sie aus diesem Grund auch nicht an. procedure TForm1.leseEintraege; var reg : TRegistry; sl : TStringList; i : Integer; begin reg := TRegistry.Create;

27.10 Die installierten Anwendungen anzeigen

1595

reg.Rootkey := HKEY_LOCAL_MACHINE; myList.Clear; ListBox1.Clear; if reg.OpenKeyReadOnly('SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall') then begin sl := TStringList.Create; reg.GetKeyNames(sl); for i := 0 to sl.Count-1 do begin if reg.OpenKeyReadOnly('SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\' + sl[i]) then begin if (reg.ValueExists('DisplayName'))and (reg.ValueExists('UninstallString')) then begin listbox1.items.Add(reg.ReadString('DisplayName')); mylist.Add(reg.ReadString('UninstallString')); end end; reg.CloseKey end; sl.Free end; try ListBox1.ItemIndex := 0; StatusBar1.SimpleText := myList[0]; except end end;

HINWEIS: Die Registry-Schlüssel öffnen wir nur mit OpenKeyReadOnly, um Probleme mit den

Zugriffsrechten unter NT zu vermeiden. Mit dem Öffnen des Formulars initialisieren wir die Listbox sowie die interne Stringliste: procedure TForm1.FormCreate(Sender: TObject); begin myList := TStringlist.Create; leseEintraege end; procedure TForm1.ToolButton1Click(Sender: TObject); begin leseEintraege end;

Ein Klick auf einen Listbox-Eintrag zeigt uns den zugehörigen Uninstall-String an: procedure TForm1.ListBox1Click(Sender: TObject); begin StatusBar1.SimpleText := myList[ListBox1.ItemIndex] end;

1596

Kapitel 27

How-to: System

Die Deinstallation gestaltet sich etwas aufwändiger, da wir mit der Aktualisierung der Listbox so lange warten müssen, bis das Deinstallationsprogramm fertig ist. Wir verwenden dazu die Funktion CreateProcess, über die technischen Hintergründe informieren Sie sich bitte im Rezept Ä 27.5 Ein anderes Programm starten procedure TForm1.ToolButton3Click(Sender: TObject); var StartupInfo: TStartupInfo; ProcessInfo: TProcessInFormation; begin if ListBox1.ItemIndex < 0 then Exit; if Application.MessageBox('Anwendung wirklich deinstallieren?', 'Frage', MB_YESNO + MB_ICONWARNING) <>IDYES then Exit; FillChar(StartupInfo, SizeOf(TStartupInfo), 0); StartupInfo.cb := Sizeof(TStartupInfo); if CreateProcess(nil, // Anwendungsname Pchar(myList[ListBox1.ItemIndex]), // Parameter nil, // Security nil, // Security False, NORMAL_PRIORITY_CLASS, // Priorität nil, // Environment nil, // Verzeichnis StartupInfo, ProcessInfo) then begin WaitForSingleObject(ProcessInfo.hProcess, INFINITE); CloseHandle(ProcessInfo.hProcess); leseEintraege; end else ShowMessage('Uninstall nicht gefunden') end;

Test Nach dem Start des Programms erscheinen alle installierten Anwendungen in der Liste:

27.11 Die Systemkonfiguration ermitteln

1597

HINWEIS: Vorsicht mit dem Deinstallieren von Anwendungen, es geht manchmal schneller, als

man will.

27.11 Die Systemkonfiguration ermitteln Für viele Anwendungsprogramme ist es wichtig, etwas über die Rechnerkonfiguration zu erfahren. Mit reinen Pascal-Befehlen lassen sich tiefergehende Informationen nur zum Teil abrufen, wir müssen wieder einmal die API bemühen. Die wohl wichtigsten Angaben zum System: ■ Arbeitsspeicher, freier Arbeitsspeicher ■ Auslagerungsdatei ■ Systemressourcen (GDI, USER) ■ Windows-Verzeichnis ■ Systemverzeichnis ■ Prozessortyp, Prozessoranzahl ■ Bildschirmauflösung, Farbtiefe ■ Datum, Zeit ■ User-Name, Computer-Name ■ Betriebssystem, Version

Oberfläche Zur Oberfläche unserer Anwendung gibt es nicht viel zu sagen, neben einem StringGrid befinden sich lediglich ein Timer und ein Button im Formular Form1.

1598

Kapitel 27

How-to: System

Auf die Funktion des Timers kommen wir später zurück, wichtig ist nur, dass Sie die Kind-Eigenschaft des Buttons auf bkClose setzen, damit sich das Fenster schließen lässt.

Quelltext Die gesamte Funktionalität findet sich in der FormActivate-Ereignisprozedur wieder. Die meisten Befehle dürften selbst erklärend sein, andernfalls sind Kommentare in den Code eingefügt. Noch ein Hinweis zum Aufruf einiger API-Funktionen: Erwarten diese einen Zeiger auf einen Zeichenpuffer, müssen Sie diesen entsprechend vorbereiten. Die unseres Erachtens nach einfachste Möglichkeit besteht in folgenden fünf Schritten: 1. Puffer anlegen: var p:PChar;

2. Puffergröße festlegen: P:=StrAlloc(MAX_PATH+1);

3. Puffer übergeben: GetWindowsDirectory(p, MAX_PATH);

4. Puffer auslesen: Label1.Caption:= p;

5. Puffer löschen: StrDispose(p);

Zurück zum Beispiel: unit Unit1; ... procedure TForm1.FormActivate(Sender: TObject); var p : PChar; l :longint; zw :string; dc : hdc; memory : TMEMORYSTATUS; systeminfo : TSystemInfo; ...

Formatieren des Grids: with StringGrid1 do begin colwidths[0]:=clientwidth div 2; colwidths[1]:=clientwidth div 2;

HINWEIS: Initialisieren Sie den Parameter dwLength mit der Größe der Struktur. Der Grund für

dieses Vorgehen liegt in der späteren Erweiterbarkeit (zusätzliche Systeminformationen).

1599

27.11 Die Systemkonfiguration ermitteln

memory.dwLength := sizeof(memory); GlobalMemoryStatus(memory);

Speicherinformationen: cells[0,0]:='phys. Speicher'; cells[1,0]:=inttostr(memory.dwTotalPhys) + ' cells[0,1]:='phys. Speicher frei'; cells[1,1]:=inttostr(memory.dwAvailPhys) + ' cells[0,2]:='Auslagerungsspeicher'; cells[1,2]:=inttostr(memory.dwTotalPageFile) cells[0,3]:='Auslagerungsspeicher frei'; cells[1,3]:=inttostr(memory.dwAvailPageFile) P:=StrAlloc(MAX_PATH+1);

Bytes'; Bytes'; + ' Bytes'; + ' Bytes';

Verzeichnisinformationen: GetWindowsDirectory(P,MAX_PATH+1); cells[0,4]:='Windows-Verzeichnis'; cells[1,4]:= p; StrDispose(P); P:=StrAlloc(MAX_PATH+1); GetSystemDirectory(P,MAX_PATH+1); cells[0,5]:='Systemverzeichnis'; cells[1,5]:= p; StrDispose(P); GetSystemInfo(systeminfo);

Hardware: cells[0,6]:='Prozessor(en)'; cells[1,6]:= inttostr(systeminfo.dwNumberOfProcessors); case systeminfo.dwProcessorType of 386 : zw := 'Intel 386'; 486 : zw := 'Intel 486'; 586 : zw := 'Intel Pentium'; 860 : zw := 'Intel 860'; 2000 : zw := 'MIPS R2000'; 3000 : zw := 'MIPS R3000'; 4000 : zw := 'MIPS R4000'; 21064 : zw := 'ALPHA 21064'; 601 : zw := 'PPC 601'; 603 : zw := 'PPC 603'; 604 : zw := 'PPC 604'; 620 : zw := 'PPC 620'; end; cells[0,7]:='Prozessor'; cells[1,7]:= zw;

Datum, Zeit: cells[0,8]:='Zeit'; cells[1,8]:= timetostr(time); cells[0,9]:='Zeit seit Systemstart'; cells[1,9]:=timetostr(getcurrenttime /60000000 ); cells[0,10]:='Datum';cells[1,10]:=datetostr(date);

1600

Kapitel 27

How-to: System

Bildschirmauflösung, Palette: cells[0,11]:='Grafikauflösung'; cells[1,11]:=inttostr(screen.width)+'x'+inttostr(screen.height); bitpix := GetDeviceCaps(dc,BITSPIXEL); if bitpix > 24 then bitpix := 24; cells[1,12]:=inttostr(GetDeviceCaps(dc,14) shl bitpix); ReleaseDC(0,dc); dw := 1024; P:=StrAlloc(256);

User-Name, Computer-Name: GetUserName(p,dw); cells[0,13]:='Username';cells[1,13]:=p; StrDispose(P); P:=StrAlloc(256); GetComputerName(p,dw); cells[0,14]:='Computername';cells[1,14]:=p; StrDispose(P);

Betriebssystem, Version: os.dwOSVersionInfoSize := sizeof(os); GetVersionEx(os); case os.dwPlatformId of VER_PLATFORM_WIN32s : zw := 'Win32s unter Windows 3.x'; VER_PLATFORM_WIN32_WINDOWS : zw := 'Windows 95/98'; VER_PLATFORM_WIN32_NT : zw := 'Windows NT/2000'; end; cells[0,15]:='Betriebssystem'; cells[1,15]:=zw + ' ' + inttostr(os.dwMajorVersion) + '.' + inttostr(os.dwMinorVersion) end end;

Der Timer aktualisiert die Anzeige der Zeit bzw. Systemzeit: procedure TForm1.Timer1Timer(Sender: TObject); begin with stringGrid1 do begin cells[1,8]:= timetostr(time); cells[1,9]:=inttostr(getcurrenttime)+' ms'; end end;

Test Starten Sie das Programm und überprüfen Sie die ermittelten Angaben (vielleicht haben Sie mehr Speicher, als Sie dachten?).

27.12 Das aktuelle Betriebssystem ermitteln

1601

Weitere Informationen finden Sie in Ä 21.4 Den Laufwerkstyp bestimmen Ä 27.12 Das aktuelle Betriebssystem ermitteln Neben den bereits verwendeten API-Funktionen sollten Sie sich auch die folgenden näher ansehen: ■ GetSystemMetrics (Environment) ■ SystemParametersInfo (Environment) ■ GetKeyboardType (Tastatur)

27.12 Das aktuelle Betriebssystem ermitteln Auf den ersten Blick gleichen sich Windows 95/98/ME und Windows NT/2000/XP wie ein Ei dem anderen. Aber im Verborgenen schlummern die Unterschiede, wie viele Programmierer schon leidvoll erfahren mussten. Soll eine Anwendung unter beiden Betriebssystemen laufen, bleibt in vielen Fällen nichts anderes übrig als eine systemabhängige Programmierung. Die folgende Funktion hilft Ihnen bei der Unterscheidung.

Oberfläche Nicht der Rede wert ... nur ein Label und ein Button zum Testen.

Quelltext Die Funktion GetWindowsVersionString gibt den Namen des Betriebssystems zurück: function GetWindowsVersion : string; var winInfo : TOSVersionInfo; begin result := '';

1602

Kapitel 27

How-to: System

winInfo.dwOSVersionInfoSize := sizeof (OSVERSIONINFO); GetVersionEx(winInfo); if winInfo.dwPlatformId = VER_PLATFORM_WIN32_NT then begin if (winInfo.dwMajorVersion <= 4) then begin result := 'Windows NT ' + inttostr(winInfo.dwMajorVersion); end; if ((winInfo.dwMajorVersion = 5) and (winInfo.dwMinorVersion = 0)) then result := 'Windows 2000' else if ((winInfo.dwMajorVersion = 5 ) and (winInfo.dwMinorVersion >= 1)) then result := 'Windows XP'; end; if winInfo.dwPlatformId = VER_PLATFORM_WIN32_WINDOWS then begin if ((winInfo.dwMajorVersion > 4) or ((winInfo.dwMajorVersion = 4) and (winInfo.dwMinorVersion > 0))) then begin if (winInfo.dwMinorVersion = 90) then result := 'Windows ME' else result := 'Windows 98'; end else result := 'Windows 95'; end; if result = '' then result := 'Win32s'; end;

Mit unserem kleinen Testprogramm wird folgende Routine abgearbeitet: procedure TForm1.Button1Click(Sender: TObject); begin label1.Caption := GetWindowsVersion end;

Test Starten Sie das Programm und klicken Sie auf den Button:

oder

27.13 Alle geöffneten Windows-Fenster anzeigen

1603

27.13 Alle geöffneten Windows-Fenster anzeigen Das folgende Rezept ermöglicht Ihnen den Einblick in einige Windows-Interna. Gleichzeitig werden Sie mit den Möglichkeiten von Callback-Prozeduren vertraut gemacht. Ziel unseres Programms ist die Darstellung aller Fenster, die sich auf dem Windows-Desktop befinden. Sie werden feststellen, dass es einige Fenster mehr sind, als Sie auf den ersten Blick vermutet haben.

Oberfläche Fügen Sie in ein Formular eine ListView-Komponente (Seite "Win32") und einen Button ein. Die ViewStyle-Eigenschaft der ListView setzen Sie auf vsReport. Erweitern Sie die ListView um sechs Spalten (rechte Maustaste, Spalteneditor) entsprechend der Abbildung.

Quelltext Die eigentliche Prozedur für die Anzeige der einzelnen Fenster ist eine Callback-Funktion, die von Windows für jedes offene Fenster einmal aufgerufen wird. Der Vorteil dieser Funktion: Sie können immer davon ausgehen, dass das Fenster zu diesem Zeitpunkt noch existiert. Die Übergabewerte an die Funktion sind das Handle des Fensters sowie ein eindeutiger Integerwert, mit dem Sie zum Beispiel aus Ihrem Programm heraus einen Pointer etc. an die Routine übergeben können. function var PID title begin Result

EnumWindowsProc (Wnd: HWND; LParam: LPARAM): BOOL; stdcall; : LongWord; : array[0..255] of Char; := True;

Ermitteln der Prozess-Id: GetWindowThreadProcessID(Wnd, @PID);

1604

Kapitel 27

How-to: System

Bestimmen des Fenstertextes, so vorhanden: GetWindowText(Wnd, title, 256); with Form1.ListView1.Items.Add do begin Caption := IntToStr(wnd); SubItems.Add(title); SubItems.Add(IntToStr(PID));

Ist das Fenster sichtbar? if IsWindowVisible(wnd) then SubItems.Add('JA') else SubItems.Add('NEIN');

Welches Handle hat der Parent? SubItems.Add(IntToStr(GetWindowLong(Wnd, GWL_HWNDPARENT)));

Ist das Fenster minimiert? if IsIconic(wnd) then SubItems.Add('JA') else SubItems.Add('NEIN') end end;

Der Callback-Aufruf der Funktion EnumWindowsProc wird über die Funktion EnumWindows ausgelöst. Übergeben wird der Zeiger auf die Funktion sowie der schon oben beschriebene eindeutige Integer-Wert. procedure TForm1.Button1Click(Sender: TObject); begin ListView1.Items.Clear; EnumWindows(@EnumWindowsProc, 1) end;

Test Nach dem Start des Programms können Sie sich die Fensterliste anzeigen lassen:

27.14 Die Taskliste anzeigen

1605

27.14 Die Taskliste anzeigen Möchten Sie einen eigenen Task-Manager programmieren, brauchen Sie nicht nur eine Liste der Anwendungen, sondern auch deren Prozess-ID, um zum Beispiel die Anwendung zu beenden oder um weitere Informationen über den Prozess zu ermitteln. HINWEIS: Es ist günstig, wenn Sie das vorhergehende Rezept bereits ausprobiert haben, dieses

Rezept erweitert lediglich den Funktionsumfang.

Oberfläche Fügen Sie in ein Formular eine ListView-Komponente und zwei Buttons ein. Die ViewStyle-Eigenschaft der ListView setzen Sie auf vsReport. Erweitern Sie die ListView um zwei Spalten (rechte Maustaste, Spalteneditor) entsprechend der Abbildung.

Quelltext Zuerst einmal deklarieren Sie die Callback-Funktion EnumWindowsProc, die für alle geöffneten Fenster aufgerufen wird. Im Unterschied zum vorhergehenden Rezept filtern wir jetzt jedoch alle Fenster heraus, die nicht in die Definition eines Tasks passen: function EnumWindowsProc (Wnd: HWND; LParam: LPARAM): BOOL; stdcall; var PID : LongWord; Title : array[0..255] of Char; begin Result := True; if (IsWindowVisible(Wnd) or IsIconic(wnd)) and ((GetWindowLong(Wnd, GWL_HWNDPARENT) = 0) or (GetWindowLong(Wnd, GWL_HWNDPARENT) = GetDesktopWindow)) and (GetWindowLong(Wnd, GWL_EXSTYLE) and WS_EX_TOOLWINDOW = 0) then begin

Zusätzlich ermitteln wir die zugehörige Prozess-ID GetWindowThreadProcessID(Wnd, @PID);

1606

Kapitel 27

How-to: System

sowie den Fenstertitel: GetWindowText(Wnd, Title, 256); with Form1.ListView1.Items.Add do begin Caption := title; SubItems.Add(IntToStr(PID)) end end end;

Über Button1 wird die ListView gelöscht und die Callback-Funktion aufgerufen: procedure TForm1.Button1Click(Sender: TObject); begin ListView1.Items.Clear; EnumWindows(@EnumWindowsProc, 1) end;

Mit der folgenden Funktion ist es möglich, einen Prozess über dessen Prozess-ID zu löschen: procedure KillProcessByPID(PID : DWord); var myHandle : THandle; i: Integer; begin myhandle := OpenProcess(PROCESS_TERMINATE, False, PID); TerminateProcess(myHandle, 0) end;

Den Aufruf der Funktion, die Prozess-ID, hatten wir in den Substrings gespeichert: procedure TForm1.Button2Click(Sender: TObject); begin KillProcessByPID(Strtoint(ListView1.Selected.SubItems[0])) end;

Test Nach dem Start und dem Klick auf den Refresh-Button sollten Sie eine Liste aller geöffneten Anwendungen vorfinden:

27.15 Den EXE-Namen eines Prozesses ermitteln

1607

27.15 Den EXE-Namen eines Prozesses ermitteln Im vorhergehenden Rezept hatten wir die Liste aller Tasks bestimmt. Leider fehlt uns bei den Angaben über die einzelnen Tasks eine wichtige Information: Welches Programm versteckt sich eigentlich hinter der Kurzbeschreibung und in welchem Verzeichnis ist es zu finden? An dieser Stelle trennen sich allerdings die Wege, je nach Betriebssystem müssen Sie entweder die Toolhelp32-Funktionen (Windows 95, Windows 98, Windows ME) oder das Process Status Helper-API, kurz PSAPI (Windows NT, Windows 2000/XP), verwenden.

Oberfläche Wir erweitern das vorhergehende Rezept um eine ComboBox zur Auswahl des Betriebssystems (0 = Windows 95/98/ME, 1 = Windows NT/2000/XP):

Quelltext (Windows 95, 98, ME) Fügen Sie die folgenden Units ein: uses TlHelp32, ShellApi;

Der Funktion GetEXENameTH wird eine gültige Prozess-ID übergeben, Rückgabewert ist die zugeordnete EXE inklusive Pfadangabe: function GetEXENameTH(PID: DWord) : string; var h : THandle; PE : TProcessEntry32; begin result := '';

Über die Toolhelp-Funktionen wird ein Momentan-Snapshot aller laufenden Prozesse erzeugt: h := CreateToolhelp32Snapshot(TH32CS_SnapProcess, 0); PE.dwSize := Sizeof(PE);

1608

Kapitel 27

How-to: System

Die erzeugte Liste wird so lange durchlaufen, bis die Prozess-Id mit der gesuchten übereinstimmt. Ist dies der Fall, kann über eine Struktur vom Typ TProcessEntry32 der EXE-Name bestimmt werden: if Process32First(h, PE) then repeat if PE.th32ProcessID = PID then begin Result := PE.szExeFile; Break end; until not Process32Next(h, PE); CloseHandle(h) end;

Quelltext (Windows NT 3, NT 4, 2000, XP) Da die Toolhelp-Funktionen unter Windows NT nicht zur Verfügung stehen bzw. unter Windows 2000/XP nur unvollständige Pfadangaben liefern, bleibt uns nur der Weg über das PSAPI. Fügen Sie die PSAPI-Unit zur Uses-Klausel hinzu: uses ... PSAPI;

Wie auch bei der vorhergehenden Funktion wird eine Prozess-ID übergeben, Rückgabewert ist der EXE-Name inklusive Pfadangabe: function GetEXENamePS(PID: DWord): string; var h: THandle; begin result := ''; h := OpenProcess(PROCESS_QUERY_INFORMATION or PROCESS_VM_READ, False, PID); if h <> 0 then try SetLength(Result, MAX_PATH); GetModuleFileNameEx(h, 0, PChar(Result), MAX_PATH) finally CloseHandle(h); end end;

HINWEIS: Übergeben Sie Prozess-IDs aus einer Prozessliste, müssen Sie einige Sonderfälle

berücksichtigen: Unter Windows NT ist die Prozess-ID 0 immer der "System Idle Process", unter NT 4 ist PID 2, unter Windows 2000 PID 8 der "System-Process". In allen genannten Fällen müssen Sie den Prozessnamen selbst generieren. Die Anzeige des EXE-Namens realisieren wir im ListViewChange-Ereignis. Je nach Betriebssystem wird die eine oder die andere Funktion aufgerufen: procedure TForm1.ListView1Change(Sender: TObject; Item: TListItem; Change: TItemChange);

27.16 Die Prozess-Priorität der Anwendung ändern

1609

begin try if ComboBox1.ItemIndex = 0 then Label1.Caption := GetEXENameTH(Strtoint64(Item.SubItems[0])); if ComboBox1.ItemIndex = 1 then Label1.Caption := GetEXENamePS(Strtoint64(Item.SubItems[0])); except end end;

HINWEIS: Sie können das Betriebssystem natürlich auch automatisch ermitteln, wird wollten

das Beispiel an dieser Stelle nicht unnötig kompliziert gestalten.

Test Nach dem Start können Sie die EXE-Namen der verschiedenen Prozesse bestimmen:

27.16 Die Prozess-Priorität der Anwendung ändern Ist Ihr Programm mit zeitaufwändigen Berechnungen ausgelastet, ist es häufig sinnvoll, diese im Hintergrund vorzunehmen. Der Anwender bekommt damit die Gelegenheit, weiter an seinem PC zu arbeiten. Voraussetzung ist jedoch, dass Ihr Hintergrundprogramm nicht die gesamte Rechenzeit verbraucht. Die normalerweise vom System zugeteilte Rechenzeit lässt bei aufwändigen Operationen ein normales Arbeiten mit anderen Anwendungen kaum zu. Abhilfe schafft das Ändern der Prozesspriorität. Folgende Optionen bieten sich an: ■ HIGH_PRIORITY_CLASS ■ IDLE_PRIORITY_CLASS ■ NORMAL_PRIORITY_CLASS

1610

Kapitel 27

How-to: System

Wie sich die unterschiedlichen Prozessprioritäten auf das Leistungsverhalten der Anwendung selbst bzw. auf andere Anwendungen auswirken, zeigt ein kleines Testprogramm.

Oberfläche Fügen Sie einem Formular eine RadioGroup (wie abgebildet) sowie zwei Buttons und zwei Labels hinzu.

Quelltext Zuerst die Auswahl der Prozesspriorität über die RadioGroup: procedure TForm1.RadioGroup1Click(Sender: TObject); begin case RadioGroup1.ItemIndex of 0 : SetPriorityClass(GetCurrentProcess, HIGH_PRIORITY_CLASS); 1 : SetPriorityClass(GetCurrentProcess, IDLE_PRIORITY_CLASS); 2 : SetPriorityClass(GetCurrentProcess, NORMAL_PRIORITY_CLASS) end end;

Mit dem Klick auf den "Start"-Button wird eine Endlosschleife gestartet, in der zum einen ein Wert inkrementiert (i) , zum anderen ein Gleitkommawert berechnet wird. procedure TForm1.Button2Click(Sender: TObject); var i : Integer; t1 : dword; d : Double; begin ok := True; i := 0; t1 := GetTickCount; while ok do begin Inc(i); d := Sin(Sqrt(Sin(Random) * Cos(Random))); if i mod 1000 = 0 then begin

27.17 Die Netzwerkdialoge einbinden

1611

Anzeige der Zeit (Millisekunden) für 1000 Schleifendurchläufe: Label2.Caption := Format('%d ms/1000',[(GetTickCount - t1)]); t1 := GetTickCount; Application.ProcessMessages end;

Anzeige der berechneten Werte: Label1.Caption := IntToStr(i) + Format('%8.2f',[d]) end end;

Test Nach dem Start des Programms klicken Sie auf den "Start"-Button. Wählen Sie die verschiedenen Prozessprioritäten aus und versuchen Sie, mit anderen Anwendungen zu arbeiten. Beobachten Sie gleichzeitig die Zeit, die für 1000 Schleifendurchläufe gebraucht wird.

27.17 Die Netzwerkdialoge einbinden Wer in seinen Programmen die Netzwerkfunktionen von Windows nutzen möchte, kommt um die Einbindung von Netzwerk-Dialogen kaum herum. Wichtig sind vor allem die Dialoge zum ■ Einrichten einer Verbindung (Laufwerk) ■ Trennen einer Verbindung (Laufwerk) ■ Aufheben der Druckerzuordnung Der Anwender kann diese Einstellungen auch im Ordner "Netzwerkumgebung" vornehmen, aber wozu sollte extra ein anderes Fenster geöffnet werden, wenn wir die Dialoge in ein Delphi-Programm einbinden können?

1612

Kapitel 27

How-to: System

Oberfläche

Quelltext Der eigentliche Aufruf ist relativ einfach, Sie übergeben einfach das Handle des aktuellen Fensters sowie eine der folgenden Konstanten: Konstante

Bemerkung

RESOURCETYPE_DISK

Laufwerke einbinden/Verbindung aufheben

RESOURCETYPE_PRINT

Drucker einbinden/Verbindung aufheben

Der Dialog "Netzlaufwerk verbinden" procedure TForm1.Button1Click(Sender: TObject); begin WNetConnectionDialog(handle, RESOURCETYPE_DISK) end;

27.18 Den Windows-Lizenznehmer ermitteln

1613

Der Dialog "Netzlaufwerk trennen" procedure TForm1.Button2Click(Sender: TObject); begin WNetDisconnectDialog(handle, RESOURCETYPE_DISK) end;

Der Dialog "Netzwerkdrucker trennen": procedure TForm1.Button4Click(Sender: TObject); begin WNetDisconnectDialog(handle, RESOURCETYPE_PRINT) end;

HINWEIS: Dieser Dialog wird unter Windows XP nicht mehr angeboten.

27.18 Den Windows-Lizenznehmer ermitteln Möchten Sie den Lizenznehmer von Windows ermitteln? Kein Problem, Sie finden zwar keine API-Funktion dafür, aber die Information befindet sich in der Registrierdatenbank und ist damit schnell ausgelesen. Einen Unterschied gilt es jedoch zu berücksichtigen: Windows 95/98/ME und Windows NT/2000/XP legen die Werte in unterschiedlichen Verzeichnissen ab.

1614

Kapitel 27

How-to: System

Oberfläche Auf dem Startformular platzieren Sie zwei Labels und einen Button.

Quelltext Binden Sie zunächst die Unit Registry ein: uses Registry;

Die beiden folgenden Funktionen unterscheiden automatisch das aktuelle Betriebssystem und liefern als Funktionsergebnis den gesuchten Wert zurück: function GetRegisteredOwner:string; var VersionInfo : TOSVersionInfo; reg : TRegistry; begin VersionInfo.dwOSVersionInfoSize := SizeOf(VersionInfo); GetVersionEx(VersionInfo); reg := TRegistry.Create; reg.RootKey := HKEY_LOCAL_MACHINE; if (VersionInfo.dwPlatformId = VER_PLATFORM_WIN32_NT) then // NT reg.OpenKey('SOFTWARE\Microsoft\Windows NT\CurrentVersion',False) else reg.OpenKey('SOFTWARE\Microsoft\Windows\CurrentVersion',False); result := reg.ReadString('RegisteredOwner'); reg.Free end; function GetRegisteredOrganization:string; var VersionInfo : TOSVersionInfo; reg : TRegistry; begin VersionInfo.dwOSVersionInfoSize := SizeOf(VersionInfo); GetVersionEx(VersionInfo); reg := TRegistry.Create; reg.RootKey := HKEY_LOCAL_MACHINE; if (VersionInfo.dwPlatformId = VER_PLATFORM_WIN32_NT) then // NT reg.OpenKey('SOFTWARE\Microsoft\Windows NT\CurrentVersion',False) else reg.OpenKey('SOFTWARE\Microsoft\Windows\CurrentVersion',False); result := reg.ReadString('RegisteredOrganization'); reg.Free end;

Die Verwendung ist denkbar einfach: procedure TForm1.Button1Click(Sender: TObject); begin Label1.Caption := GetRegisteredOwner; Label2.Caption := GetRegisteredOrganization end;

27.19 Die Seriennummer der Festplatte ermitteln

1615

Test

27.19 Die Seriennummer der Festplatte ermitteln Einen einfachen Kopierschutz für Ihre Programme können Sie mit Hilfe der Festplattenseriennummer realisieren. Diese lesen Sie mit Hilfe der API-Funktion GetVolumeInformation aus. Etwas einfacher ist der Aufruf mit der folgenden kleinen Funktion: function HDSerialID(drive:Char): string; var ID, dwx, dwy : DWord; begin if GetVolumeInformation(pChar(drive + ':\'), nil, 0, @ID, dwx, dwy, nil, 0) then result := IntToStr(ID) else result := 'Error' end;

Oberfläche Zum Austesten genügt ein Formular mit einem Label und einem Button.

Quelltext Neben obiger Funktion genügt folgender Code zum Auslesen der Seriennummer von Laufwerk "C:": procedure TForm1.Button1Click(Sender: TObject); begin Caption := HDSerialID('c') end;

Test

1616

Kapitel 27

How-to: System

27.20 Unter Windows automatisch einloggen Wen hat es als Entwickler noch nicht genervt, bei jedem Systemstart von Windows NT zuerst mit dem "Affengriff" (Strg+Alt+Entf) Fingergymnastik betreiben zu müssen, um anschließend Name und Passwort einzugeben? Abhilfe schaffen zwei Einträge in der Registrierdatenbank. Unser kleines Programm zeigt die Vorgehensweise.

Oberfläche Erstellen Sie ein Formular mit folgendem Grundaufbau:

Über die beiden Textboxen können wir später den Anmeldenamen und das Passwort vorgeben. Achtung: Beide werden in die Registrierdatenbank eingetragen.

Quelltext Binden Sie die Unit Registry ein und erstellen Sie folgende Funktion: procedure SetLogonOn(Name, Passwort : string); var reg : TRegistry; begin reg := TRegistry.Create; reg.RootKey := HKEY_LOCAL_MACHINE; if reg.OpenKey('\Software\Microsoft\Windows NT\CurrentVersion\Winlogon',FALSE) then begin reg.WriteString('DefaultUserName',Name); reg.WriteString('DefaultPassword',Passwort); reg.WriteString('AutoAdminLogon','1') end; reg.Free end;

Auf das spätere Löschen der Einträge sollten Sie nicht verzichten, immerhin kann sich ja nun jeder ungehinderten Zugang zu Ihrem Computer verschaffen: procedure SetLogonOff; var reg : TRegistry; begin reg := TRegistry.Create; reg.RootKey := HKEY_LOCAL_MACHINE;

27.20 Unter Windows automatisch einloggen

1617

if reg.OpenKey('\Software\Microsoft\Windows NT\CurrentVersion\Winlogon',FALSE) then try reg.DeleteValue('DefaultUserName'); reg.DeleteValue('DefaultPassword'); reg.DeleteValue('AutoAdminLogon'); except end; reg.free end;

Die eigentlichen Funktionsaufrufe dürften selbst erklärend sein: procedure TForm1.Button1Click(Sender: TObject); begin SetLogonOn(Edit1.Text,Edit2.Text); end; procedure TForm1.Button2Click(Sender: TObject); begin SetLogonOff end;

Test Angesichts des heiklen Themas kann ein hektisches Ausprobieren dieses Rezepts unangenehme Folgen nach sich ziehen. HINWEIS: Vergewissern Sie sich zunächst noch einmal gründlich, welchen User-Namen und

welches Passwort Sie bisher eingegeben haben, sonst kann es passieren, dass Sie später selbst als Administrator in Ihren eigenen Computer nicht mehr reinkommen! Starten Sie nun das Programm und geben Sie exakt Ihren bisherigen User-Namen und das zugehörige Passwort ein. Dann holen Sie tief Luft und klicken den "ON"-Button. Die trügerische Ruhe täuscht. Schließen Sie das Programm und beenden Sie Windows NT. Die Stunde der Wahrheit schlägt beim Neustart, hier entscheidet es sich, ob das automatische LogOn funktioniert. Wenn ja, können Sie auch einen Restart des Systems ohne erneutes Einloggen ermöglichen. Schlägt das automatische Einloggen fehl, so müssen Sie versuchen, sich unter einem anderen gültigen Namen und Passwort einzuloggen, um dann unter Delphi an die Fehlerbeseitigung zu gehen. Wollen Sie das automatische LogOn wieder rückgängig machen, so starten Sie das Programm erneut, klicken aber dann (ohne irgendwelche Eingaben in die beiden Editierfelder) den "OFF"-Button. HINWEIS: Möchten Sie sich trotz automatischer Anmeldung unter einem anderen Nutzerkonto

anmelden, halten Sie während des Startvorgangs von Windows die Shift-Taste gedrückt.

1618

Kapitel 27

How-to: System

27.21 Den System-About-Dialog anzeigen Bevor Sie zu viel Zeit daran verschwenden, einen eigenen About-Dialog zu programmieren, sollten Sie es doch einfach einmal mit dem Standard-Dialog des Systems versuchen:

Oberfläche Da man die About-Box gewöhnlich über das Hilfe-Menü erreicht, fügen wir spaßeshalber eine MainMenu-Komponente in das Testformular ein. Weiterhin gibt es eine CheckBox, welche die Auswahl zwischen zwei Aufrufkonventionen zulässt.

Quelltext uses shellApi; procedure TForm1.About1Click(Sender: TObject); begin if CheckBox1.Checked then // Anwendungs-Icon einblenden ShellAbout(Self.Handle,'Projekt 1', 'Diese Anwendung darf frei kopiert werden!', Application.Icon.Handle) else // Windows-Icon

27.23 Uninstall-Routinen in ein Programm einbauen

1619

ShellAbout(Self.Handle,'Projekt 1','Diese Anwendung darf frei kopiert werden!',0) end;

Wählen Sie für den vierten Parameter der ShellAbout-Funktion einen anderen Wert (z.B. 4), werden andere Icons in der Dialogbox angezeigt.

27.22 Eine laufende EXE-Datei löschen Dieses Rezept kann nur in Verbindung mit einer anderen Problemstellung, wie z.B. Ä 27.23 Uninstall-Routinen in ein Programm einbauen sinnvoll praktisch angewendet werden.

27.23 Uninstall-Routinen in ein Programm einbauen Zu einer sauber programmierten Anwendung gehört mittlerweile auch eine Uninstall-Routine, die über die Systemsteuerung (Software) aufgerufen werden kann. Wie Sie diese Funktion in Ihren eigenen Programmen realisieren können, zeigt das folgende Rezept.

Oberfläche Diesmal ohne Worte:

Quelltext Dreh- und Angelpunkt ist auch hier die Registrierdatenbank von Windows, in die ein entsprechender Schlüssel einzutragen ist : procedure TForm1.Button1Click(Sender: TObject); var reg : TRegistry; begin reg := TRegistry.Create; reg.RootKey := HKEY_LOCAL_MACHINE; reg.OpenKey('SOFTWARE\Microsoft\Windows\CurrentVersion\uninstall\' + Application.Title,True); // Schlüssel auswählen reg.WriteString('DisplayName',Application.Title); reg.WriteString('UninstallString',paramstr(0)+ ' /u'); reg.Free end;

1620

Kapitel 27

How-to: System

Das Resultat in der Registrierdatenbank:

Nach dieser Vorarbeit können wir uns der eigentlichen Deinstallation zuwenden. Ausgelöst wird diese durch den Übergabeparameter "/U", den wir im initialization-Abschnitt der Unit auswerten: initialization Application.Title := 'Mein Delphi-Testprogramm'; if ParamCount > 0 then if UpperCase(ParamStr(1))= '/U' then deinstall; end.

Grundsätzlich geht es im Folgenden darum, alle Einträge in der Registrierdatenbank zu löschen sowie alle Dateien zu entfernen. Doch gerade an dieser Stelle werden Sie auf ein Problem stoßen: Eine laufende Anwendung kann sich nicht selbst löschen! D.h., selbst wenn Sie einen Kindprozess starten, der die entsprechende EXE-Datei löscht, bleibt immer noch das Problem, die EXE des Kindprozesses zu löschen. Der Ausweg ist entweder ein Eintrag in der Registrierdatenbank, dass beim nächsten Systemstart die gewünschte Datei gelöscht werden soll (leider verbleibt die Anwendung sowie das zugehörige Unterverzeichnis bis zum nächsten Systemstart auf der Platte) oder eine Batch-Datei. Die zweite Variante basiert auf der Möglichkeit, dass sich eine Batch-Datei selbst löschen kann. Für den Namen der Batch-Datei verwenden wir die schon aus Rezept R5.10 bekannte Funktion: function CreateTempFileName:String; var p : PChar; d : PChar; begin p := StrAlloc(MAX_PATH+1); d := StrAlloc(MAX_PATH+1); GetTempPath(MAX_PATH,d); GetTempFileName(d,'$',0,p); Result := String(p); StrDispose(p); StrDispose(d) end;

1621

27.23 Uninstall-Routinen in ein Programm einbauen

Unsere Deinstallationsroutine: procedure DeInstall; var reg : TRegistry; pfad : string; batchfile : TStringlist; batchname : string; begin

Sicherheitsabfrage: if MessageDlg('"' + application.Title + '" deinstallieren?', mtConfirmation, [mbYes, mbNo], 0) = mrYes then begin

Löschen der Uninstall-Informationen: reg := TRegistry.Create; reg.RootKey := HKEY_LOCAL_MACHINE; reg.DeleteKey('SOFTWARE\Microsoft\Windows\CurrentVersion\uninstall\'+ Application.Title); reg.Free;

Ab hier können Programmeinstellungen gelöscht werden, z.B. {

reg := TRegistry.Create; reg.RootKey := HKEY_LOCAL_MACHINE; reg.Free; }

reg.DeleteKey('SOFTWARE\XYZ');

Nun das eigentliche Löschen der EXE sowie aller Unterverzeichnisse: batchname := CreateTempFileName; batchname := Copy(batchname,1,Length(batchname)-3) + 'bat';

Zur Sicherheit entfernen wir noch mögliche Dateiattribute: FileSetAttr(paramstr(0),0);

Erzeugen der Batch-Datei: batchfile := TStringlist.Create; batchfile.add(':Label1'); batchfile.add('del "' + Paramstr(0)+ '"'); batchfile.add('if Exist "' + ParamStr(0) + '" goto Label1'); batchfile.add('rmdir "' + ExtractFilePath(ParamStr(0)) + '"'); batchfile.add('del ' + batchname); batchfile.SaveToFile(batchname);

Wichtig: Sie sollten das aktuelle Verzeichnis wechseln, da dieses sonst nicht gelöscht werden kann: ChDir('c:\');

Ausführen der Batch-Datei: WinExec(PChar(batchname),sw_hide);

Wir zeigen schon einmal die Vollzugsmeldung an, obwohl das Programm noch läuft (und damit auch die EXE noch nicht gelöscht ist):

1622

Kapitel 27

How-to: System

ShowMessage('Programm deinstalliert!'); Halt; end end;

Nachdem das Programm beendet ist, kann die Batch-Datei endlich zum Zuge kommen (bisher läuft diese nur in der Endlosschleife). Die EXE wird gelöscht, danach das Verzeichnis und zum Schluss die BAT-Datei selbst.

Test Kopieren Sie die EXE in ein eigenes Unterverzeichnis. Starten Sie das Programm und klicken Sie auf den Button, um die Uninstall-Informationen in die Registrierdatenbank einzutragen. Schließen Sie danach das Programm und wechseln Sie in die Systemsteuerung. Unter dem Menüpunkt Software finden Sie den folgenden Dialog mit der Eintragung unseres Programms:

Deinstallieren Sie das Programm. Danach müssten die EXE sowie das Unterverzeichnis verschwunden sein. Gleiches sollte auf die Batch-Datei zutreffen. Die Erfolgsmeldung:

Bemerkung Wenn Sie das zu Delphi beigefügte Programm InstallShield verwenden, um Installationsdisketten zwecks Weitergabe Ihrer Applikation anzufertigen, so werden damit auch automatisch alle notwendigen Deinstallationsinformationen für den Zielrechner erzeugt. In diesem Fall brauchen Sie sich nicht um eine eigene Deinstallationsroutine zu kümmern. Siehe Ä 22.32 Ein Setup für Datenbankanwendungen erstellen

27.24 Den Status der CapsLock-Taste ändern

1623

27.24 Den Status der CapsLock-Taste ändern Möchten Sie aus dem Programm heraus den Status der CapsLock-Taste ändern, können Sie dieses mit Hilfe zweier API-Funktionen tun. Mit dem Aufruf der Funktion GetKeyboardState ermitteln Sie zunächst den aktuellen Status der Tastatur. Über das Array KeyboardState beeinflussen Sie nachfolgend den Status einzelner Tasten. Mit SetKeyboardState geben Sie die Änderungen an das System weiter.

Oberfläche Um die Auswirkungen der Statusänderung bequem verfolgen zu können, benutzen wir ein Memofeld.

Quelltext procedure TForm1.Button1Click(Sender: TObject); var KeyboardState : TKeyboardState; begin GetKeyboardState(KeyboardState); if (KeyboardState[VK_CAPITAL] = 0) then KeyboardState[VK_CAPITAL] := 1 else KeyboardState[VK_CAPITAL] := 0; SetKeyboardState(KeyboardState) end;

Test Schreiben Sie etwas in das Memofeld und ändern Sie per Programm den Status der Feststelltaste für Großbuchstaben (CapsLock). HINWEIS: Da die obigen Funktionsaufrufe immer nur den aktuellen Thread/Prozess betreffen,

hat eine Änderung keine Auswirkung auf andere Anwendungen. Der Status der Tastatur-LEDs wird ebenfalls nicht beeinflusst.

1624

Kapitel 27

How-to: System

27.25 Die Anzeige kritischer Systemfehler vermeiden Obwohl Delphi mit Try-Except bzw. Try-Finally zwei entsprechende Konstrukte zur Fehlerbehandlung bereitstellt, kommt es bei einigen Fehlersituationen vor, dass trotzdem vom System eine Fehlermeldung angezeigt wird (z.B. beim Zugriff auf ein leeres Diskettenlaufwerk). Möchten Sie diese unschönen Fehlerdialoge vermeiden, sollten Sie mit der API-Funktion SetErrorMode die Wachsamkeit des Systems herabsetzen. Übergeben Sie der Funktion die Konstante SEM_FAILCRITICALERRORS, werden alle Fehler an das Programm weitergereicht, das System reagiert nicht darauf. BEISPIEL: Verwendung der Funktion var SaveErrorMode : Word; begin

Aktuellen Modus merken: SaveErrorMode := SetErrorMode(SEM_FAILCRITICALERRORS ); try // Hier könnte der kritische Code stehen, der überwacht werden soll ... finally

Modus zurücksetzen: SetErrorMode( SaveErrorMode ); end; end;

27.26 Eine Schriftart temporär installieren Möchten Sie mit Ihrer Anwendung eine spezielle Schriftart vertreiben bzw. diese benutzen oder wollen Sie einen Betrachter für Schriftarten programmieren, müssen Sie die TTF- bzw. FOTDateien im System anmelden, bevor Sie diese benutzen können. Das folgende kleine Beispielprogramm installiert für die Laufzeit des Programms eine neue Schriftart auf Ihrem System, verwendet diese zur Anzeige in einem Textfeld und deinstalliert die Schriftart beim Programmende wieder.

Oberfläche Lediglich ein Formular und ein Editierfeld:

27.26 Eine Schriftart temporär installieren

1625

Quelltext Die wichtigsten Änderungen nehmen wir in der Projektdatei vor. Binden Sie zunächst die Units windows, sysutils und messages ein, wir brauchen diese für einige API-Aufrufe: program Project2; uses Forms,windows,sysutils,messages, Unit1 in 'Unit1.pas' {Form1}; {$R *.RES}

Mit der API-Funktion AddFontResource fügen wir der System-Fonttabelle eine neue Schriftart hinzu (die Datei befindet sich im Projektverzeichnis und muss nicht unbedingt in das System\Font-Verzeichnis kopiert werden): begin AddFontResource(Pchar(ExtractFilePath(ParamStr(0))+'FRAKTURN.TTF'));

Mit der folgenden Botschaft werden alle Anwendungen davon in Kenntnis gesetzt, dass sich etwas bei den Fonts getan hat: SendMessage(HWND_BROADCAST,WM_FONTCHANGE,0,0); Application.Initialize; Application.CreateForm(TForm1, Form1); Application.Run;

Nach dem Programmende sollten wir nicht vergessen, die Schriftart wieder zu "deinstallieren". RemoveFontResource(pchar(ExtractFilePath(ParamStr(0))+'FRAKTURN.TTF')); SendMessage(HWND_BROADCAST,WM_FONTCHANGE,0,0); end.

Test Starten Sie das Programm, sollten Sie bereits die neue Schriftart sehen:

HINWEIS: Während das obige Programm läuft, können auch andere Anwendungen mit dieser

Schriftart arbeiten!

1626

Kapitel 27

How-to: System

27.27 Einen systemweiten Hot-Key setzen Soll Ihre Anwendung jederzeit auf Tastendruck verfügbar sein, bietet sich die Verwendung systemweiter Hot-Keys an. Dies können fast beliebige Tastenkombinationen sein, Ihr im Hintergrund schlummerndes Programm ist sofort verfügbar.

Oberfläche Ein Formular und ein Button reichen für die kleine Demo aus.

Quelltext Zunächst verändern wir die Projektdatei, um das Programm vor neugierigen Blicken zu schützen. Dazu genügt es, die ShowMainform-Eigenschaft auf False zu setzen. program Project1; uses Forms, Unit1 in 'Unit1.pas' {Form1}; {$R *.RES} begin Application.Initialize; Application.ShowMainForm := False; // <- !!!! Application.CreateForm(TForm1, Form1); Application.Run; end.

Die eigentliche Formulardefinition wird um eine neue Botschaftsroutine erweitert. type TForm1 = class(TForm) Button1: TButton; procedure FormCreate(Sender: TObject); procedure FormDestroy(Sender: TObject); procedure Button1Click(Sender: TObject); protected procedure hotkey(var msg:TMessage); message WM_HOTKEY; private id : Integer; end;

// !

Die Umsetzung dieser Routine: procedure TForm1.hotkey(var msg:TMessage); begin

Die Routine kontrolliert, ob es sich um die gewünschte Tastenkombination handelt: if (msg.LParamLo = MOD_CONTROL+MOD_ALT) and (msg.LParamHi = 83) then begin self.Visible := not self.Visible; if self.Visible then self.WindowState := wsNormal else

27.27 Einen systemweiten Hot-Key setzen

1627

self.WindowState := wsMinimized end end;

Mit dem Erstellen des Formulars installieren wir auch unseren Hot-Key: procedure TForm1.FormCreate(Sender: TObject); begin id:= GlobalAddAtom('hotkey1'); RegisterHotKey(handle,id,MOD_CONTROL + MOD_ALT,83) end;

Die Übergabewerte an die API-Funktion RegisterHotKey: das Handle des zugeordneten Fensters, ein eindeutiger Wert, die Steuertasten und der virtuelle Tastencode. Folgende Varianten bieten sich für die Steuertasten an: ■ MOD_ALT

Die ALT-Taste muss gedrückt sein.

■ MOD_CONTROL

Die CTRL-Taste muss gedrückt sein.

■ MOD_SHIFT

Die SHIFT-Taste muss gedrückt sein.

Beim Programmende sollten wir wieder alles "aufräumen": procedure TForm1.FormDestroy(Sender: TObject); begin UnRegisterHotKey(handle,id) end;

Test Starten Sie das Programm, so ist zunächst nichts zu sehen. Also alles nur heiße Luft? Nein, denn wenn Sie die Tastenkombination STRG-ALT-S betätigen, ist das Programm sofort zu sehen.

Bemerkung Mit dieser Variante ist es recht einfach möglich, Service-Anwendungen, die über eine Oberfläche verfügen, aufzurufen. Sie müssen sich keine Gedanken darüber machen, wann die Oberfläche angezeigt werden soll, die obige Funktion funktioniert nur bei geöffnetem Desktop.

28

How-to: Desktop

Kapitel

28

How-to: Desktop 28.1 Kontrollieren, ob Delphi aktiv ist Möchten Sie in Ihr Programm oder in Ihre selbst entwickelte Komponente eine Funktion einbauen, mit der Sie unterscheiden können, ob das Programm in der Delphi-Entwicklungsumgebung läuft oder ob es allein ausgeführt wird? Dann finden Sie hier eine Antwort.

Oberfläche Die Anwendung zur Laufzeit:

Quelltext Die Lösung ist relativ simpel, mit Hilfe der API-Funktion FindWindow suchen wir ein Fenster, das zur Delphi-Entwicklungsumgebung gehört. Wir suchen die Klasse "TAppBuilder". Die Umsetzung: procedure TForm1.Button1Click(Sender: TObject); // Läuft Delphi? begin if FindWindow('TAppBuilder',nil) <= 0 then ShowMessage('Delphi läuft nicht') else

1630

Kapitel 28

How-to: Desktop

ShowMessage('Delphi läuft') end;

HINWEIS: Eventuell können Sie mit der Routine ein Demo-Programm erstellen, das nur zusam-

men mit Delphi läuft, oder Sie verändern Parameter von Funktionen, wenn das Programm beim Anwender läuft.

28.2 Einen mehrfachen Programmstart verhindern Wollen Sie verhindern, dass zwei Instanzen Ihres Programms gleichzeitig laufen, müssen Sie sich selbst darum kümmern. Über Eigenschaften oder Methoden besteht keine Chance. Die in der Version 1.0 noch mögliche Abfrage von hPrevInst existiert nicht mehr, bzw. es wird immer NULL zurückgegeben. Der Ausweg ist ein so genannter "Mutex", ein Objekt, das bei der Thread-Programmierung zum Einsatz kommt.

Quelltext Um den Einsatz der Funktion möglichst einfach zu gestalten, verlagern wir den gesamten Code in eine Unit. Für Ihre Projekte genügt es, wenn Sie die Unit einbinden. Funktionsaufrufe etc. benötigen Sie nicht, lediglich den Namen des Mutex sollten Sie im Quellcode anpassen (die entsprechende Stelle ist gekennzeichnet). Der Ablauf ist in wenigen Worten beschrieben. Nach dem Programmstart wird automatisch der Initialization-Abschnitt unserer Unit durchlaufen. An dieser Stelle können wir versuchen, einen neuen Mutex zu erzeugen. Sollte dieser bereits exisitieren, läuft auch schon eine weitere Instanz unseres Programms. Wir schalten zu dieser Instanz um und beenden das laufende Programm. unit Unit2; interface implementation uses windows,Dialogs,sysutils; var mutex : THandle; h : HWnd; Initialization

Statt "MyXYZMutex" tragen Sie einen anderen Namen ein: mutex := CreateMutex(nil,True,'MyXYZMutex'); if getLastError = ERROR_ALREADY_EXISTS then begin h := 0; repeat h := FindWindowEx(0,h,'TApplication',PChar(Application.Title)) until h <> application.handle; if h <> 0 then begin

28.3 Programme in die Systemsteuerung integrieren

1631

Windows.ShowWindow(h, SW_ShowNormal); windows.SetForegroundWindow(h); end; Halt; end;

Beim normalen Beenden der Anwendung müssen wir daran denken, auch die belegten Ressourcen wieder freizugeben. Dafür bietet sich der finalization-Abschnitt an. finalization // ... und Schluss ReleaseMutex(mutex); end.

Test

28.3 Programme in die Systemsteuerung integrieren Haben Sie auch eine Anwendung geschrieben, die es wert ist, ins "Allerheiligste" einzuziehen, d.h. in die Systemsteuerung (Control Panel)? Wenn ja, finden Sie hier die Lösung.

1632

Kapitel 28

How-to: Desktop

Oberfläche Entwerfen Sie eine oder mehrere Dialogboxen, die nach einem Klick auf das zugehörige Icon in der Systemsteuerung angezeigt werden sollen.

Quelltexte (Variante 1) Grundsätzlich werden alle Einträge der Systemsteuerung in DLLs verwaltet. Um dem System die Möglichkeit zu geben, diese DLLs von anderen zu unterscheiden, hat man sich mit "CPL" für eine abweichende Extension entschieden. Sie können die DLL wie gewohnt in Delphi compilieren und später in "*.CPL" umbenennen. Wichtig ist nur, dass Sie die Datei im Verzeichnis "System32" speichern, ein Registrieren ist nicht nötig. Alle Applets verfügen mit der Funktion CPlApplet über eine einheitliche Schnittstelle, die zur Textanzeige, zur Auswahl des Icons und zur Auswahl des Dialogs eingesetzt wird. Doch der Reihe nach. HINWEIS: Im Folgenden erstellen wir die CPL-Datei zunächst "zu Fuß"1. Im nächsten Abschnitt

setzen wir dafür den Delphi-Assistenten ein. Erzeugen Sie über Datei|Neu|Weitere|DLL-Experte eine neue DLL, die Sie wie folgt erweitern: library CPL_Demo; {$R symbole.res} uses SysUtils, Windows, Classes, CPL_API in 'CPL_API.pas', Applet1 in 'Applet1.pas' {Form1}, Applet2 in 'Applet2.pas' {Form2}; var hInstance: THandle;

Die Konstanten für die Anzeigetexte in der Systemsteuerung: const NUM_APPLETS = 2; Title1 = 'Delphi-Alias-Manager'+ Chr(0); Title2 = 'Applet-Demo Nr. 2'+ Chr(0);

Die Schnittstellen-Funktion: function CPlApplet(hwndCPL: THandle; uMsg: Cardinal; const lParam1: LongInt; var lParam2: LongInt): LongInt; stdcall; export; 1

So erfahren Sie wenigstens etwas über die Hintergründe.

28.3 Programme in die Systemsteuerung integrieren

var NewCPLInfo: TNewCPLInfo absolute lParam2; i: Integer; begin i:= lParam1;

Im Folgenden müssen Sie den Parameter uMsg auswerten: case uMsg of

Initialisierung, geben Sie das Handle der DLL zurück: CPL_INIT:

//Erste Nachricht (lParam1, lParam2 ungenutzt) //Rückgabe <> 0 bei Erfolg

begin hInstance:= GetModuleHandle('CPL_Demo.cpl'); Result:= -1; end;

Abfrage, wie viele Applets in der DLL enthalten sind: CPL_GETCOUNT:

//Zweite Nachricht (lParam1, lParam2 ungenutzt) //Rückgabe: Anzahl der Applets Result:= NUM_APPLETS;

Icons und Anzeigetexte über die Struktur NewCPLInfo zurückgeben: CPL_NEWINQUIRE: //Dritte Nachricht try with NewCPLInfo do begin dwFlags:= 0; dwHelpContext:= 0; lData:= 0; if i = 0 then begin hIcon:= LoadIcon(hInstance, 'SYMBOL3'); szName:= Title1; szInfo:= 'Mein erster Alias-Manager in CPL_Demo.cpl' + Chr(0); szHelpFile:= ' ' + Chr(0); end else begin hIcon:= LoadIcon(hInstance, 'SYMBOL2'); szName:= Title2; szInfo:= 'Mein zweites Applet in CPL_Demo.cpl' + Chr(0); szHelpFile:= ' ' + Chr(0); end; dwSize:= SizeOf(NewCPLInfo); end; except Result:= -1; end; CPL_SELECT:; //Icon selektiert

1633

1634

Kapitel 28

How-to: Desktop

Auswerten des Doppelklicks auf das Icon: CPL_DBLCLK: //Doppelklick auf Icon try case i of 0: begin Form1:= TForm1.Create(Application); Form1.ShowModal; Form1.Free; end; 1: begin Form2:= TForm2.Create(Application); Form2.ShowModal; Form2.Free; end; end; except Result:= -1; end; CPL_STOP:; //Nachricht vor Exit CPL_EXIT:; //Letzte Nachricht vor FreeLibrary end; end; exports CPlApplet; ...

Die restliche Programmierung beschränkt sich auf die gewohnte Anzeige von Dialogboxen oder die Ausführung von Routinen.

Variante 2 (Assistent) Die Borland-Entwickler wollen auch an dieser Stelle dem Programmierer die Arbeit abnehmen. Dazu ist in Delphi bereits ein entsprechender Assistent integriert, der die oben erwähnte Schnittstellenfunktion CPlApplet mit einem objektorientierten Interface versieht. Damit stehen die obigen Aufrufparameter als Ereignisse zur Verfügung. Erstellen Sie also zunächst ein neues Applet über Datei|Neu|Weitere|Anwendung für die Systemsteuerung. Sie erhalten folgendes (zur Laufzeit nicht sichtbares) Fenster, das mit seinen Eigenschaften und Ereignissen die Schnittstellen-Funktion kapselt:

28.4 Eine Anwendung in die Registry einbinden

1635

Dreh- und Angelpunkt ist sicher das Ereignis AppletModuleActivate, das ausgelöst wird, wenn der Nutzer das Applet in der Systemsteuerung aktiviert. Hier können Sie zum Beispiel ein weiteres Fenster aufrufen. HINWEIS: Fügen Sie ein neues Fenster in das Projekt ein, müssen Sie in der DPR-Datei die

entsprechende Zeile löschen, andernfalls kommt es später zum Crash. BEISPIEL: Zeilen löschen ... begin Application.Initialize; Application.CreateForm(TAppletModule1, AppletModule1); Application.CreateForm(TForm2, Form2); Application.Run; end.

Das Formular erstellen Sie dynamisch, wenn das Ereignis Activate aufgerufen wird: procedure TAppletModule1.AppletModuleActivate(Sender: TObject; Data: Integer); begin with tform2.Create(nil) do begin showmodal; free; end; end;,

Ein entsprechendes Icon können Sie über die Eigenschaft AppletIcon zuweisen.

Test Erstellen Sie die CPL-Datei mit einem Aufruf von Projekt|Projekt compilieren und kopieren Sie die erzeugte Datei in das Verzeichnis \\Windows\System32. Starten Sie nachfolgend die Systemsteuerung und testen Sie die Funktionsweise der Applets.

28.4 Eine Anwendung in die Registry einbinden Unterstützt Ihre Anwendung einen bestimmten Dateityp (.DB, .XLS etc.), ist es sinnvoll, wenn Sie dem Anwender ein entsprechendes Kontextmenü zur Verfügung stellen.

1636

Kapitel 28

How-to: Desktop

Unterstützen können Sie ■ Open (Öffnen), ■ Print (Drucken) und ■ Print To, indem Sie die Registry um entsprechende Einträge erweitern. Die Variante "Print To" haben Sie sicherlich noch in keinem Kontextmenü gefunden, handelt es sich doch um die Aktion, die ausgeführt wird, wenn ein Dokument mittels Drag & Drop auf ein Druckersymbol gezogen wird. Folgende Einträge müssen Sie in der Registrierdatenbank vornehmen (Beispiel Metafiles): 01: 02: 03: 04: 05: 06:

HKEY_CLASSES_ROOT\.wmf = metafile HKEY_CLASSES_ROOT\metafile = Windows Metafile HKEY_CLASSES_ROOT\metafile\DefaultIcon = c:\delphi\project1.exe,0 HKEY_CLASSES_ROOT\metafile\shell\open\command = project1.exe %1 HKEY_CLASSES_ROOT\metafile\shell\print\command = project1.exe /p %1 HKEY_CLASSES_ROOT\metafile\shell\printto\command = project1.exe /p %1

Zeile 1 definiert den Zusammenhang zwischen Extension und Registry-Einträgen. Zeile 2 stellt eine kurze Beschreibung des Eintrags dar. Die Angabe DefaultIcon ist optional, es handelt sich um den Index des Icons, das dem Dokument zugeordnet wird. Der Eintrag "...\shell\open\command" beschreibt die Aufrufkonventionen für die Anzeige des Dokuments. Analog dazu werden mit "...\print\command" bzw. "...\printto\command" die Aufrufparameter für den Druck des Dokuments festgelegt. HINWEIS: Bei allen Einträgen sind die Werte im Feld "Default" gespeichert, es gibt keine weite-

ren Feldeinträge. Die Umsetzung des oben genannten Beispiels als Delphi-Programm: regist := TRegistry.Create; regist.RootKey := HKEY_CLASSES_ROOT; regist.OpenKey('.wmf',True); regist.WriteString('','metafile'); regist.CloseKey; regist.OpenKey('metafile',True); regist.WriteString('','Windows Metafile'); regist.CloseKey; regist.OpenKey('metafile\DefaultIcon',True); regist.WriteString('','c:\delphi\Project1.exe,0'); regist.CloseKey; regist.OpenKey('metafile\shell\open\command',True); regist.WriteString('','Project1.exe %1'); regist.CloseKey; regist.OpenKey('metafile\shell\print\command',True); regist.WriteString('','Project1.exe /p %1'); regist.CloseKey;

28.5 Control-Panel-Anwendungen aufrufen

1637

regist.OpenKey('metafile\shell\printto\command',True); regist.WriteString('','Project1.exe /p %1'); regist.CloseKey;

Das Resultat in der Registrierdatenbank:

Wenn Sie die Funktionen ausprobieren und die Ergebnisse mit dem Registrierungseditor kontrollieren wollen, müssen Sie die Anzeige nach jeder der oben genannten Funktionen aktualisieren (F5).

28.5 Control-Panel-Anwendungen aufrufen Sollen dem Anwender Systemeinstellungen zur Verfügung gestellt werden, ist das Control Panel bzw. die Systemsteuerung der erste Anlaufpunkt. Über Ihr Delphi-Programm können Sie problemlos auf die einzelnen Elemente der Systemsteuerung zugreifen, d.h., Sie können die Dialogboxen anzeigen. Der Begriff "Elemente" wurde bewusst gewählt, da es sich nicht um eigenständige Anwendungen, sondern um einzelne DLLs handelt, die jedoch die Extension CPL tragen. Der Aufruf selbst kann mit Hilfe einer zusätzlichen Anwendung (rundll32.exe) recht einfach bewerkstelligt werden. Alles, was bleibt, ist der Aufruf dieser Anwendung mit den entsprechenden Parametern. Die folgende Tabelle zeigt die Standard-Applets: Datei

Bedeutung

access.cpl

Zugriffsschutz-Einstellungen

appwiz.cpl

Installation/Deinstallation von Anwendungen

desk.cpl

Bildschirm-Einstellungen

intl.cpl

regionale Einstellungen

joy.cpl

Joystick-Eigenschaften

main.cpl

Maus-Eigenschaften

mmsys.cpl

Multimedia-Optionen

modem.cpl

Modem-Einstellungen

sysdm.cpl

System-Einstellungen

timedate.cpl

Datums-/Zeit-Einstellungen

1638

Kapitel 28

How-to: Desktop

Oberfläche Den Grundaufbau der Beispieloberfläche entnehmen Sie bitte der folgenden Abbildung:

Quelltext Um nicht jedes Mal den vollen Aufruf programmieren zu müssen, erstellen wir eine Prozedur, die uns etwas Arbeit abnimmt: procedure ShowApplet(FileName:string); begin WinExec(PChar('rundll32.exe shell32.dll,'+'Control_RunDLL ' + FileName),SW_SHOWNORMAL) end;

Die Verwendung ist denkbar einfach: procedure TForm1.Button1Click(Sender: TObject); begin ShowApplet('timedate.cpl') end; procedure TForm1.Button2Click(Sender: TObject); begin ShowApplet('sysdm.cpl') end;

Test Starten Sie das Programm und probieren Sie die Funktionen aus.

28.6 Programme vor dem Task-Manager verstecken Für einige Anwendungen kann es durchaus sinnvoll sein, diese vor dem Task-Manager zu verbergen, d.h., das Programm soll nicht in der Task-Liste angezeigt werden. Auf den ersten Blick könnte man auf die Idee kommen, dass sich dafür die Eigenschaft Hide verwenden ließe, dies funktioniert jedoch nicht. Die folgenden Ausführungen zeigen warum.

1639

28.6 Programme vor dem Task-Manager verstecken

Jedes Delphi-Projekt basiert auf einem nicht sichtbaren Parent-Fenster. Die Caption-Eigenschaft dieses Fensters ist der Text, der im Task-Manager angezeigt wird. Das Parent-Fenster wird auf einfache Weise optisch ausgeblendet, sowohl Breite als auch Höhe sind auf 0 Pixel eingestellt. Das Parent-Fenster (nicht sichtbar)

Das sichtbare Fenster

Verstecken Sie ein Fenster Ihrer Applikation, bleiben das Parent-Fenster und damit der Text im Task-Manager erhalten. Mit der API-Funktion ShowWindow können wir das Fenster nicht nur optisch ausblenden, sondern auch aus dem Task-Manager entfernen. Dafür brauchen wir allerdings das Handle des betreffenden Fensters. Dieses ermitteln wir über die API-Funktion GetWindow. Die Abläufe im Detail zeigt das folgende kleine Demo-Programm:

Oberfläche Neben einem Button benötigen wir zwei Timer-Komponenten. Über einen der Timer werden wir das Programm nach ein paar Sekunden beenden. (Wie wollen wir es denn anders beenden? Tasten gibt es keine, und der Task-Manager "kennt" das Fenster nicht.) Mit dem zweiten Timer geben wir im Sekundentakt nervende Pieptöne aus, damit Sie ja nicht vergessen, dass das Programm noch läuft.

1640

Kapitel 28

How-to: Desktop

Quelltext procedure TForm1.Button1Click(Sender: TObject); var owner: THandle; begin Timer1.Enabled :=True; Timer2.Enabled :=True; owner := GetWindow(handle, GW_OWNER); ShowWindow(owner, SW_HIDE); Self.Hide end; procedure TForm1.Timer1Timer(Sender: TObject); begin Close end; procedure TForm1.Timer2Timer(Sender: TObject); begin MessageBeep(0) end;

Test Nach Programmstart klicken Sie den Button. Zwar verschwindet das Fenster, das Programm aber arbeitet weiter im Hintergrund.

Bemerkung Kleiner Tipp für den unverwüstlichen Spaßvogel: Mit obigem Programm können Sie leicht einen Gag-Virus programmieren, um Ihren Chef zu ärgern. Ä 19.20 Grafiken auf dem Screen ausgeben

28.7 Die Taskbar Notification Area verwenden Am rechten Ende der Taskbar sind (links neben der Uhrzeit) oft auch Anwendungen bzw. deren Icons zu finden. Dieser Bereich wird als Taskbar Notification Area, kurz TNA, bezeichnet. Was anderen Applikationen möglich ist, sollte auch für ein Delphi-Programm keine unüberwindliche Hürde sein. Im Folgenden möchten wir Ihnen ein Programm vorstellen, das nach einer kurzen Copyright-Meldung vom Desktop "verschwunden" ist. Weder im Task-Manager noch auf der eigentlichen Taskbar findet sich ein entsprechender Hinweis. Lediglich der TNA ist um ein weiteres Icon bereichert worden. Klicken Sie mit der linken Maustaste auf dieses Symbol, wird eine Dialogbox angezeigt, mit der rechten Maustaste erreichen Sie ein Popup-Menü, über das sich die Anwendung schließen lässt.

28.7 Die Taskbar Notification Area verwenden

1641

Oberfläche Unsere Anwendung besteht aus zwei Formularen. Während Form1 für die Anzeige der CopyrightMeldung und das Registrieren der Anwendung im TNA verantwortlich zeichnet, ist Form2 die eigentliche Dialogbox, die zur Laufzeit angezeigt wird. Wie Sie der folgenden Abbildung entnehmen können, verfügt Form1 über einen Timer (Anzeige der Dialogbox), ein Popup-Menü (dieses Menü wird als Kontextmenü für den TNA verwendet) sowie ein Icon (zur Anzeige im TNA).

Quelltext Bevor es losgeht, definieren wir eine neue Message: const WM_TASKBAREVENT = WM_USER+1;

Danach können wir die Klassendefinition unseres Fensters um ein neues Ereignis bereichern (die Reaktion auf obige Message): type TForm1 = class(TForm) Image1: TImage; PopupMenu1: TPopupMenu; Beenden1: TMenuItem; Anzeigen1: TMenuItem; N1: TMenuItem; Timer1: TTimer; Image2: TImage; Label1: TLabel; procedure Beenden1Click(Sender: TObject); procedure FormCreate(Sender: TObject); procedure Anzeigen1Click(Sender: TObject); procedure FormClose(Sender: TObject; var Action: TCloseAction); procedure Timer1Timer(Sender: TObject); protected procedure WMTASKBAREVENT(var message: TMessage); message WM_TASKBAREVENT; end;

Über die Unit ShellApi importieren wir die benötigten Funktionen und Konstanten: uses shellapi, Unit2; var count : Integer = 0;

1642

Kapitel 28

How-to: Desktop

Mit dem Erstellen des Formulars blenden wir das Parent-Fenster von Form1 (TApplication) aus und rufen die Funktion zum Registrieren unserer Anwendung im TNA auf: procedure TForm1.FormCreate(Sender: TObject); begin ShowWindow(GetWindow(handle,GW_OWNER),SW_HIDE); TaskBarAddIcon end;

Die Funktion TaskBarAddIcon im Einzelnen: procedure TaskBarAddIcon; var tnid : TNOTIFYICONDATA ; begin

Initialisieren der Struktur: tnid.cbSize := sizeof(TNOTIFYICONDATA); // Größenangabe der Struktur tnid.Wnd := Form1.handle; // Handle des Message-Empfängers tnid.uID := 1; // ID beliebig tnid.uFlags := NIF_MESSAGE or NIF_ICON or NIF_TIP; // siehe Tabelle tnid.uCallbackMessage := WM_TASKBAREVENT; // Message# für Form1 tnid.hIcon := form1.image1.picture.icon.handle; // Iconhandle strcopy(tnid.szTip,'Merkzettel'); // Tooltiptext Shell_NotifyIcon(NIM_ADD, @tnid) // Registrieren ... end;

Einige der obigen Parameter bedürfen einer näheren Erläuterung. Nach dem Registrieren Ihrer Anwendung im TNA werden alle Ereignisse über das Icon an Ihre Anwendung gesendet. Dazu muss dem System das Handle des Empfängerfensters sowie die Message bekannt sein (siehe oben). Mit den Flags (uFlags) bestimmen Sie, welche Parameter Sie übergeben bzw. welche Parameter gültig sind: Konstante

Bemerkung

NIF_ICON

... ein Icon-Handle wird übergeben.

NIF_MESSAGE

... die Message wird übergeben.

NIF_TIP

... ein Tooltip-Text wird übergeben.

Damit dürfte auch schon klar sein, welche Bedeutung den Parametern HIcon, szTip und uCallbackMessage zukommt. Die Funktion Shell_NotifyIcon erwartet neben einer Konstanten (NIM_ADD, NIM_DELETE oder NIM_MODIFY) einen Zeiger auf die initialisierte Struktur. In unserer neuen Ereignisprozedur können wir über den Parameter LParam das Ereignis über dem TNA-Icon bestimmen (z.B. Doppelklick oder MouseDown): procedure TForm1.WMTASKBAREVENT(var message: TMessage); var point : TPoint; begin case message.LParamLo of

28.7 Die Taskbar Notification Area verwenden

1643

WM_LBUTTONDBLCLK : form2.show; WM_RBUTTONDOWN : begin GetCursorPos(point); popupmenu1.popup(point.x,point.y); end end end;

HINWEIS: Die Mausposition kann nur noch über GetCursorPos bestimmt werden.

Mit dem Timer verbergen wir das Hauptfenster unserer Applikation, das Fenster TApplication hatten wir ja bereits ausgeblendet. procedure TForm1.Timer1Timer(Sender: TObject); begin Inc(count); if count = 3 then begin Self.Hide; Timer1.Enabled := False end; end;

Beim Programmende sollten Sie den TNA auch wieder aufräumen: procedure TaskBarRemoveIcon; var tnid : TNOTIFYICONDATA ; begin tnid.cbSize := sizeof(TNOTIFYICONDATA); tnid.Wnd := Form1.handle; tnid.uID := 1; Shell_NotifyIcon(NIM_DELETE, @tnid) end; procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin TaskBarRemoveIcon end;

Die beiden Ereignisse des Popup-Menüs: procedure TForm1.Merkzettelanzeigen1Click(Sender: TObject); begin Form2.Show end; procedure TForm1.Beenden1Click(Sender: TObject); begin Close end;

1644

Kapitel 28

How-to: Desktop

Test Starten Sie das Programm und kontrollieren Sie, ob sich im TNA das Icon für die Anwendung befindet. Klicken Sie mit der rechten Maustaste:

28.8 Programmgruppen erzeugen Möchten Sie sich an einem eigenen Installationsprogramm versuchen oder einen eigenen Explorer schreiben? Wenn ja, kommen Sie nicht um das Erzeugen von Programmgruppen, d.h. von Verzeichnissen, herum. Eigentlich kein Problem, könnte man denken, mit der MkDir-Anweisung ist ein Verzeichnis schnell erstellt. Der Knackpunkt: Wo soll das Verzeichnis erzeugt werden? Die Antwort findet sich einmal wieder im API, speziell bei den Windows-Shell-Objekten (Unit shlobj). Ausgangspunkt unserer Aktivitäten sind einige Konstanten, welche die relative Lage von Foldern innerhalb der Shell beschreiben (es sind nur die sinnvollen Konstanten aufgelistet):

CSIDL_PROGRAMS

CSIDL_COMMON_PROGRAMS

1645

28.8 Programmgruppen erzeugen

CSIDL_PROGRAMS CSIDL_PERSONAL CSIDL_FAVORITES CSIDL_STARTUP CSIDL_DESKTOPDIRECTORY CSIDL_COMMON_PROGRAMS CSIDL_COMMON_DESKTOPDIRECTORY

= = = = = = =

$0002; $0005; $0006; $0007; $0010; $0017; $0019;

Das Herzstück unseres Beispiels: Function CreateFolder(Foldername:string; wo:integer): boolean; var pidl : PItemIDList; ProgramPath : PChar; begin result := False; if SUCCEEDED(SHGetSpecialFolderLocation(0, wo, pidl)) then begin ProgramPath := StrAlloc(max_path); SHGetPathFromIDList(pidl, ProgramPath); SetLastError(0); CreateDirectory(PChar(ProgramPath + '\\' + Foldername), nil ); if (GetLastError()=0)or(GetLastError()=ERROR_ALREADY_EXISTS) then result := True; StrDispose(ProgramPath); end; end;

Übergabeparameter sind der Name des neuen Ordners und die Konstante für das Basisverzeichnis. Was läuft intern ab? Diesmal kann die Antwort nicht in einem Satz gegeben werden, das Interface ist objektorientiert, und damit sind auch die Zeiten einfachen und unbekümmerten Programmierens vorbei. (Bei den Shortcuts wird es noch schlimmer!) Grundlage der Arbeit ist ein so genannter Item-Identifier, mit dem jedes Element innerhalb des Shell-Symbolraums (das ist der Windows-Desktop) eindeutig beschrieben werden kann. Wie diese intern aufgebaut sind, ist relativ uninteressant, da im Wesentlichen nur über Objekt-Methoden auf diese Item-Identifier zugegriffen wird. Werden mehrere derartige Identifier verkettet1, spricht man von einer Item-Identifier-List oder zu Neudeutsch ItemIDList. Womit wir auch schon wieder bei unserem Programm angekommen sind. Der Pointer auf eine derartige Liste wird als PItemIDList deklariert. Mit der Funktion SHGetSpecialFolderLocation kann die einer Konstanten entsprechende Item-Identifier-List abgerufen werden (je nach Rechnerkonfiguration kann sich der absolute Pfad unterscheiden). Mit SHGetPathFromIDList lässt sich diese Liste wieder in einen ganz normalen String umwandeln. An diesen brauchen wir jetzt nur noch den neuen Pfad anzuhängen und die API-Funktion CreateDirectory aufzurufen. Ein paar Fehlerprüfungen und das Aufräumen des Speichers schließen unsere Funktion ab.

1

Ähnlich wie eine Liste von Verzeichnisnamen, z.B. \\Programme\Borland\Delphi.

1646

Kapitel 28

How-to: Desktop

BEISPIEL: Verwendung der Funktion procedure TForm1.Button1Click(Sender: TObject); begin CreateFolder('Meine erste selbst erzeugte Programmgruppe', CSIDL_DESKTOPDIRECTORY) end;

Test Starten Sie das Programm und probieren Sie einfach einmal aus, welche Resultate die unterschiedlichen Konstanten auf den Standort Ihres neuen Folders haben.

28.9 Verknüpfungen erzeugen Eigentlich müsste die Überschrift lauten: "Warum einfach, wenn es auch kompliziert geht?". Komplizierter kann man das Erzeugen von Shortcuts nicht mehr gestalten. Aber wie das immer so ist, vermutlich haben sich die Entwickler einfach nichts dabei gedacht. Doch lassen Sie sich nicht abschrecken, nach diesem Rezept haben Sie es statt mit umständlichen Objekten nur noch mit einer ganz trivialen Funktion zu tun.

Oberfläche Erstellen Sie ein Formular entsprechend folgender Abbildung:

28.9 Verknüpfungen erzeugen

1647

Quelltext Bevor es so richtig losgehen kann, müssen wir erst einmal ein paar Units einbinden: uses activeX,comobj,shlobj;

Weiterhin wird noch eine Konstante gebraucht, die bisher in der Unit OLE2 zu finden war, nunmehr aber völlig fehlt: const IID_IPersistFile: TGUID = (D1:$0000010B;D2:$0000;D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));

Die folgende Funktion hält sich im Wesentlichen an ein C-Beispiel aus dem MS-SDK: function CreateLink(PathObj,PathLink,Desc,Workdir:string):Boolean; var psl : IShellLink; ppf : IPersistFile; begin Result := False; if SUCCEEDED(CoCreateInstance(CLSID_ShellLink, nil, CLSCTX_INPROC_SERVER, IID_IShellLinkA, psl)) then begin psl.SetPath(PChar(PathObj)); psl.SetDescription(PChar(Desc)); psl.SetWorkingDirectory(PChar(workdir)); if SUCCEEDED(psl.QueryInterface(IID_IPersistFile,ppf)) then begin ppf.Save(StringToOLEStr(PathLink),TRUE); Result := True end end end;

Mit dem Aufruf von CoCreateInstance wird im Erfolgsfall eine Instanz von ShellLink erzeugt. Über den Parameter psl wird ein Pointer auf das IShellLink-Interface zurückgegeben. Nachfolgend können Sie die Methoden des ShellLink-Objekts aufrufen, um zum Beispiel Pfad und Beschreibung des neuen Links bzw. Shortcuts zu setzen. Eine Methode zum direkten Speichern werden Sie allerdings bei diesem Objekt vermissen, dazu müssen Sie erst ein IPersistFile-Interface erzeugen. Verantwortlich dafür ist die Methode QueryInterface. Sollten unsere bisherigen Bemühungen von Erfolg gekrönt sein, initialisieren wir eine WideChar-Variable. Falls Sie sich wundern, warum 2*MAX_PATH reserviert wird: Ein WideChar-String braucht für jedes Zeichen 2 Byte. Nach der Konvertierung des Link-Namens in einen WideChar-String kann die Save-Methode des PersistFile-Objekts aufgerufen werden. Danach räumen wir nur noch den Speicher auf. Aufruf der Funktion: procedure TForm1.Button1Click(Sender: TObject); begin if CreateLink(Edit1.Text, Edit2.Text, Edit3.Text, Edit4.Text) then ShowMessage('Erfolg!') end;

1648

Kapitel 28

How-to: Desktop

Test Starten Sie das Programm und übernehmen Sie beispielsweise folgende Eintragungen:

Das Ergebnis ist folgender Link:

HINWEIS: Mit "Arbeitsverzeichnis" bestimmen Sie das aktuelle Verzeichnis, wenn der Link

bzw. die Anwendung geöffnet wird.

28.10 Die Desktop-Icons ein-/ausblenden Wen nerven Sie nicht, die zahllosen Desktop-Icons, die einem das Arbeiten mit Delphi nicht gerade erleichtern? Aber Abhilfe ist in Sicht: Mit folgendem Programm blenden Sie die kleinen Quälgeister kurzzeitig aus und bei Gelegenheit auch wieder ein. Der technische Hintergrund des Programms ist eigentlich recht simpel. Wie jedes Control ist auch der Desktop selbst "nur" ein Fenster, das Sie nach Belieben ein- und ausblenden können. Einziges Problem: Woher bekommen Sie das Handle des Desktops? Die API-Funktion FindWindow hilft uns weiter, übergeben Sie dieser Funktion einfach den Namen des gesuchten Fensters (in unserem Fall "Progman").

28.11 Den Windows-Desktop-Folder ermitteln

1649

Oberfläche Ein Formular und zwei Buttons genügen.

Quelltext Die eigentliche Arbeit übernimmt die API-Funktion ShowWindow: procedure TForm1.Button1Click(Sender: TObject); begin ShowWindow(FindWindow('Progman', nil), SW_HIDE) end; procedure TForm1.Button2Click(Sender: TObject); begin ShowWindow(FindWindow('Progman', nil), SW_SHOW) end;

Test Nach dem Start des Programms und dem Klick auf den ersten Button werden Sie von einem absolut leeren Desktop überrascht sein. Vielleicht die richtige Überraschung für den Kollegen?

28.11 Den Windows-Desktop-Folder ermitteln Wollen Sie Links oder Programme/Dateien auf dem Windows-Desktop platzieren, müssen Sie dessen Position bzw. dessen Pfad kennen. Hier hilft nur die Verwendung der Funktion SHGetSpecialFolderLocation weiter.

Oberfläche Lediglich ein Button für den späteren Aufruf der Funktion.

Quelltext Wir verpacken den Aufruf gleich in einer Funktion: uses shlObj; ... function GetDesktopFolder: string; var pidl : PItemIDList; Path : array[0..MAX_PATH] of char; begin if SUCCEEDED(SHGetSpecialFolderLocation(0,CSIDL_DESKTOP,pidl)) then begin SHGetPathFromIDList(pidl,Path); result := Path; end else result := ''; end;

1650

Kapitel 28

How-to: Desktop

BEISPIEL: Aufruf der Funktion procedure TForm1.Button1Click(Sender: TObject); begin showmessage(GetDesktopFolder); end;

Test Starten Sie das Programm und klicken Sie auf den Button.

28.12 Den Desktop als Canvas verwenden Sicher haben Sie schon das Rezept Ä 19.20 Grafiken auf dem Screen ausgeben ausprobiert. Der Nachteil der dort gezeigten Vorgehensweise war der Verzicht auf die Annehmlichkeiten des Delphi-Canvas-Objektes, alle Zugriffe erfolgten mit Hilfe der Windows GDI-Funktionen. Dass es auch anders geht, zeigt die folgende Variante.

Oberfläche Lediglich ein Formular und ein Button sind erforderlich.

Quelltext Der Hintergrund für unser kleines Testprogramm ist die Möglichkeit, einem Canvas-Objekt ein neues Handle, d.h. einen DC (Device Context) zuzuweisen. Wie bekannt, kann mit GetDC(0) der DC des Desktops ermittelt werden. procedure TForm1.Button1Click(Sender: TObject); var i : Integer; ca : TCanvas; begin ca := TCanvas.Create; ca.Handle := GetDC(0);

28.13 Deststellen, ob Active Desktop installiert ist

1651

for i := 15 to 150 do begin ca.Ellipse(i * 2, i * 2, i * 2 + i, i *2 + i) end; ca.Free end;

Test Starten Sie das Programm und klicken Sie auf den Button. Sieht doch toll aus, oder?

28.13 Deststellen, ob Active Desktop installiert ist Möchten Sie feststellen, ob der Active Desktop auf dem System des Anwenders aktiviert ist, hilft Ihnen die folgende kleine Funktion weiter.

Oberfläche Lediglich ein Formular und ein Label sind erforderlich.

1652

Kapitel 28

How-to: Desktop

Quelltext Die folgende Funktion sucht nach einigen Fenstern, die im Zusammenhang mit dem Active Desktop benötigt werden. Ist das Handle in allen Fällen gültig, hat der Anwender die Funktion aktiviert. function IsActiveDeskTop:Boolean; var handle: HWND; begin handle := FindWindow('Progman', Nil); handle := FindWindowEx(handle, 0, 'SHELLDLL_DefView', Nil); handle := FindWindowEx(handle, 0, 'Internet Explorer_Server', Nil); Result := not (handle = 0) end;

Im OnFormCreate-Ereignis wird der aktuelle Status ausgegeben: procedure TForm1.FormCreate(Sender: TObject); begin if IsActiveDeskTop then Label1.Caption := 'Active Desktop aktiviert' else Label1.Caption := 'Active Desktop deaktiviert' end;

Test Über die Systemsteuerung ("Anzeige") haben Sie die Möglichkeit, den Active Desktop zu konfigurieren und natürlich auch ein- bzw. auszuschalten:

28.15 Den Grafikmodus wechseln

1653

28.14 Die Taskbar ausblenden Mitunter stört die Taskbar bei der Ausführung einiger Programme. Das vorliegende Rezept zeigt, wie man sie aus einem Programm heraus aus- und wieder einschalten kann.

Oberfläche Auf das Startformular platzieren wir eine Checkbox, die das Ein- und Ausschalten übernimmt.

Quellcode Auch hier geht nichts ohne die richtige API-Funktion. procedure TForm1.CheckBox1Click(Sender: TObject); begin if Checkbox1.Checked then ShowWindow( FindWindow( 'Shell_TrayWnd',nil), SW_HIDE) else ShowWindow( FindWindow( 'Shell_TrayWnd',nil), SW_SHOW) end;

Test Wer sagt's denn – es funktioniert! In den Becher der Freude fällt allerdings ein kleiner Wermutstropfen: Wollen Sie den frei gewordenen Platz nutzen, indem Sie Ihr Delphi-Programm auf Vollbildgröße vergrößern, so bleibt am unteren Rand des Bildschirms trotzdem alles leer.

28.15 Den Grafikmodus wechseln Sicher ist Ihnen schon aufgefallen, dass es unter Windows mit den meisten Grafikkarten möglich ist, den Grafikmodus zu wechseln, ohne den Rechner neu starten zu müssen. Unser kleines Beispielprogramm nimmt sich dieser Materie an und hat gleich noch zwei weitere Vorteile: ■ Sie erfahren, welche Grafikmodi Ihre Grafikkarte unterstützt (Auflösung, Frequenz, Farbtiefe). ■ Sie erlernen ganz nebenbei den Umgang mit der ListView-Komponente.

Oberfläche Außer einem Form und einer ListView-Komponente benötigen Sie lediglich einen Button, über den wir den Wechsel des Grafikmodus realisieren.

1654

Kapitel 28

How-to: Desktop

Für die ListView-Komponente sind allerdings einige Voreinstellungen zu treffen: Unter Columns fügen Sie eine Spalte ein (Property-Editor). Die Eigenschaft HideSelection setzen Sie auf False, während RowSelect auf True festgelegt wird. Viewstyle ist in vsReport zu ändern.

Quelltext Mit dem Erstellen des Formulars wird auch die ListView mit den Grafikdaten gefüllt. procedure TForm1.FormCreate(Sender: TObject); var devmode : TDEVMODE; d : INTEGER; litem : TListItem; p : ^TDevmode; begin

Festlegen der Spaltenbreite: listview1.Columns[0].Width := 400;

Initialisieren der DevMode-Struktur: devmode.dmSize devmode.dmDriverExtra d := 0;

:= SizeOf(TDEVMODE); := 0;

Die Funktion EnumDisplaySettings kann mit einem fortlaufenden Zähler so lange aufgerufen werden, bis False zurückgegeben wird (eine neue Form von "Callback"). Jeder Aufruf fördert einen neuen Grafikmodus zu Tage. Teilweise unterscheiden Sie die Grafikmodi lediglich bei der Frequenz. While EnumDisplaySettings(nil, d, devmode) do with devmode do begin Inc(d);

Neben der Auflösung in x- und y-Richtung interessiert uns noch die Farbtiefe, die allerdings nur in Bits-per-Pixel angegeben ist. Die Umrechnung ist relativ trivial (2 SHL dmBitsPerPel). litem := listview1.Items.Add; litem.Caption:=Format('Modus %3d : %dx%d, %d Farben (%d Hz)', [d,dmPelsWidth,dmPelsHeight,1 shl dmBitsPerPel,dmDisplayFrequency]);

Alle gewonnenen Erkenntnisse speichern wir uns in einer dynamischen Variablen: new(p); p^ := Devmode;

Der Pointer auf diese Variable wird in der Data-Eigenschaft des aktuellen Listview-Eintrags gespeichert. Zu gegebener Zeit lassen sich somit die kompletten Informationen über den Grafikmodus abrufen. litem.Data := p; end; end;

1655

28.15 Den Grafikmodus wechseln

Womit wir auch schon beim Setzen des Grafikmodus angekommen sind. Die Funktion ChangeDisplaySettings erwartet im Parameter lpDevMode wenigstens Informationen über: ■ dmBitsPerPel ■ dmPelsWidth ■ dmPelsHeight ■ dmDisplayFlags ■ dmDisplayFrequency Für uns kein Problem, "schlau" wie wir waren, haben wir ja gleich den ganzen Record in der dynamischen Variablen gespeichert. Das Abrufen erfordert jetzt lediglich eine Typisierung (Typcasting) der Data-Eigenschaft. Auf den zweiten Parameter der Funktion müssen wir noch kurz eingehen. Drei Varianten sind möglich: Wert

Beschreibung

0

Der Grafikmodus wird nur für die aktuelle Arbeitssitzung geändert, nach einem Neustart des Rechners ist alles wieder beim Alten.

CDS_UPDATEREGISTRY

Der Grafikmodus wird dauerhaft geändert. Dazu wird ein entsprechender Eintrag in der Registry vorgenommen. Allerdings kann es passieren, dass Sie den Rechner für die Änderung des Grafikmodus neu starten müssen (in diesem Fall ist der Rückgabewert der Funktion DISP_CHANGE_RESTART).

CDS_TEST

Testen, ob sich der gewünschte Grafikmodus einstellen lässt (es findet kein Wechsel statt).

procedure TForm1.BitBtn1Click(Sender: TObject); begin ChangeDisplaySettings(TDevmode(listview1.Selected.data^),0); end;

Wir beschränken uns auf das dynamische Ändern des Grafikmodus, eine Fehlerbehandlung können Sie ja noch nachträglich einfügen. HINWEIS: Muss der Rechner neu gestartet werden, sind Sie als Programmierer dafür verant-

wortlich. Eine entsprechende Funktion finden Sie im Rezept 27.22.

Test Starten Sie das Programm und wählen Sie mit Bedacht einen Grafikmodus aus, den Sie setzen möchten.

1656

Kapitel 28

How-to: Desktop

HINWEIS: In der Liste finden sich auch Einträge, mit denen Ihr Monitor nicht unbedingt "ein-

verstanden ist". In diesem Fall ist das jedoch kein Problem, nach einem WindowsNeustart sind Ihre bisherigen Einstellungen wiederhergestellt. PS: Sollte der Monitor Geräusche von sich geben, denken Sie daran: Es handelt sich nicht um eine Soundkarte! Schalten Sie das Gerät also möglichst schnell aus.

28.16 Ermitteln, ob der ScreenSaver läuft Für einige Programme, z.B. zur Zeiterfassung, ist es von Interesse zu wissen, ob der ScreenSaver im Moment aktiv ist. Beispielsweise könnten Sie auf diese Weise schnell feststellen, wie lange wirklich an einem PC gearbeitet wird. Die Windows-API bietet zu diesem Zweck die Funktion SystemParametersInfo an, leider ist die Verwendung aber auf Windows 98/Me bzw. Windows 2000 beschränkt. Mit einem kleinen Trick ist es auch unter Windows NT 4 möglich, die Funktion des ScreenSavers abzufragen, wir zeigen, wie es geht.

Oberfläche Zum Testen der Routinen genügt ein kleines Programm mit einfacher Oberfläche, die lediglich die Auswahl des aktuellen Betriebssystems gestattet. Fügen Sie dazu eine RadioGroup mit zwei Einträgen in das Formular ein. Der Timer fragt zyklisch (1 Sekunde) die Funktion des ScreenSavers ab. Läuft dieser, wird ein Piepton ausgegeben.

28.16 Ermitteln, ob der ScreenSaver läuft

1657

Quelltext Die Funktion zum Testen unter Windows NT nutzt die Besonderheit, dass bei laufendem ScreenSaver der Desktop1 "Screen-Saver" verfügbar ist. Gibt die Funktion OpenDesktop ein gültiges Handle zurück, können wird davon ausgehen, dass an diesem PC gerade nicht gearbeitet wird. function IsWinNTScreenSaverRunning : Boolean; var x : hdesk; begin x := OpenDesktop('Screen-saver',0,FALSE,DESKTOP_READOBJECTS); Result := x <> 0; CloseDesktop(x) end;

Die eigentliche Routine beim Timer-Aufruf: procedure TForm1.Timer1Timer(Sender: TObject); var ok : Bool; begin ok := False; if RadioGroup1.ItemIndex = 0 then // Windows 98/ME/2000 Systemparametersinfo(SPI_GETSCREENSAVERRUNNING, 0 ,@ok,0) if RadioGroup1.ItemIndex = 1 then ok := IsWinNTScreensaverRunning if ok then Beep end;

HINWEIS: Beachten Sie, dass die Funktion SystemParametersInfo einen Bool- und nicht einen

Boolean-Wert erwartet, bei den Autoren kam es zu unerklärlichen Abstürzen.

Test Starten Sie das Programm und wählen Sie Ihr laufendes Betriebssystem aus. Warten Sie ab, bis der ScreenSaver aktiv ist. Es sollte ein Piepton zu hören sein. Möchten Sie das Betriebssystem automatisch erkennen, können Sie das folgende Rezept verwenden: Ä 27.12 Das aktuelle Betriebssystem ermitteln 1

Sie erinnern sich: Unter Windows NT/2000/XP verwaltet das System mehrere Desktops!

1658

Kapitel 28

How-to: Desktop

28.17 Auf Bildschirmeigenschaften zugreifen Nach dem Start von Delphi steht eine Variable Screen (als einzige Instanz von TScreen) zur Verfügung, die den Zugriff auf die Eigenschaften des Bildschirms (Abmessungen, verfügbare Schriftarten, aktives Formular bzw. aktive Komponente u.a.) ermöglicht. Das folgende kleine Testprogramm zeigt am Beispiel, wie man mit diesen Eigenschaften umgehen kann, und demonstriert gleichzeitig die Einsatzmöglichkeiten einer ListBox-Komponente.

Oberfläche Auf das Startformular (Form1) platzieren wir fünf Bezeichnungsfelder (Label1 ... Label5), ein Listenfeld (ListBox1) und zwei Schaltflächen (Button1, Button2):

Quelltext In den Implementations-Teil von Unit1 kopieren Sie folgenden Code: var a: Single; s: String; procedure TForm1.Button1Click(Sender: TObject); begin // Fenster zentrieren: Left:= (Screen.Width - Width) div 2; Top:= (Screen.Height - Height) div 2;

// Start

// Breite und Höhe des Bildschirms in cm : a := Screen.Width / Screen.PixelsPerInch * 2.54; Str(a:4:2,s); Label1.Caption:= 'Bildschirmbreite(cm) = '+s; a := Screen.Height / Screen.PixelsPerInch * 2.54; Str(a:4:2,s); Label2.Caption:= 'Bildschirmhöhe(cm) = '+s;

28.17 Auf Bildschirmeigenschaften zugreifen

1659

// Bildschirmschriftarten anzeigen: with ListBox1 do begin Clear; Sorted := True; Items := Screen.Fonts end; // Zugriff auf aktive Komponente bzw. Formular: Label4.Caption:='Aktives Formular = '+Screen.ActiveForm.Caption; Label3.Caption:='Aktive Komponente = '+Screen.ActiveControl.Name end; // ändert Schriftart bei Klick auf Eintrag: procedure TForm1.ListBox1Click(Sender: TObject); begin Label8.Font.Name := ListBox1.Items[ListBox1.ItemIndex] end;

Test Nach Betätigen des Start-Buttons wird das Formular genau zentriert und könnte, in Abhängigkeit von den verwendeten Gerätetreibern, z.B. folgenden Anblick bieten:

Die Bildschirmabmessungen stimmen in etwa mit denen eines 17"-Monitors überein. Bei anderen Monitoren ist ein Korrekturfaktor einzuführen. Wenn Sie auf einen bestimmten Eintrag in der ListBox klicken, ändert sich die Schriftart im darüber liegenden Label entsprechend.

Bemerkungen ■ Die Eigenschaften von TScreen können nur gelesen werden. ■ Die hier aus Platzgründen nicht mit erfasste Cursors-Eigenschaft von TScreen erlaubt das Zuweisen von Mauszeiger-Ressourcen.

1660

Kapitel 28

How-to: Desktop

■ Im Unterschied zum Namen einer Komponente kann die Name-Eigenschaft eines Formulars nicht zugewiesen werden. Stattdessen wurde der Zugriff auf die Caption-Eigenschaft demonstriert. ■ Gewissermaßen als "Nebenprodukt" haben Sie in diesem Beispiel auch erfahren, wie man den aktiven (angeklickten) Eintrag einer ListBox auslesen kann. Das gleiche Prinzip gilt übrigens auch für die Memo-Komponente. Siehe dazu Ä 17.10 Mit Stringlisten arbeiten

28.18 Testen, ob große oder kleine Fonts installiert sind Der Fluch des Programmierers sind Anwender, die in der Systemsteuerung die Option "Schriftgrad" auf große Fonts geändert haben. Fatales Resultat sind im Allgemeinen zu große oder unbrauchbare Formulare. Selbstverständlich sind Sie als Programmierer auch nicht ganz "wehrlos". Ignorieren Sie doch einfach dieses Problem und treffen Sie entsprechende Maßnahmen!

Quelltext Mit der folgenden Funktion können Sie ermitteln, ob große oder kleine Schriftarten installiert sind: function SmallFonts : Boolean; begin Result := (Screen.PixelsPerInch = 96) end;

Beim Laden des Formulars testen Sie: procedure Form1.FormCreate(Sender: TObject); begin if not SmallFonts then begin Self.ScaleBy(96, Screen.PixelsPerInch); Refresh end end;

Mit obigen Anweisungen bleibt das Formular immer gleich groß, unabhängig von den Einstellungen der Systemfonts.

28.19 Den Bildschirmschoner aktivieren/deaktivieren Führt Ihr Programm z.B. endlose Berechnungen aus, denen Sie folgen müssen, kann das Auftauchen des Bildschirmschoners als störend empfunden werden. In diesem Fall können Sie auf recht einfache Art und Weise den "ungebetenen Gast" deaktivieren. Ein kleines Beispielprogramm zeigt, wie es geht.

28.20 Drag & Drop mit dem Explorer realisieren

1661

Oberfläche

Quelltext Über eine CheckBox ("ScreenSaver An") wird folgendes Ereignis ausgelöst: procedure TForm1.CheckBox1Click(Sender: TObject); begin if not Checkbox1.Checked then SystemParametersInfo(SPI_SETSCREENSAVEACTIVE,integer(False),nil,0) else SystemParametersInfo(SPI_SETSCREENSAVEACTIVE,Integer(True),nil,0) end;

Bemerkung Sollen die ScreenSaver-Einstellungen dauerhaft sein, d.h., auch nach einem Neustart übernommen werden, dann müssen Sie SPIF_SENDWININICHANGE als den letzten Parameter angeben.

28.20 Drag & Drop mit dem Explorer realisieren Drag & Drop innerhalb einer Delphi-Applikation ist problemlos realisierbar, Delphi stellt bereits genügend Ereignisse und Methoden zu diesem Zweck bereit. Soll die Drag & Drop-Funktionalität aber auf den Windows-Explorer erweitert werden, haben Sie schlechte Karten, externe Ereignisse werden von Delphi nicht ausgewertet. Ein kleines Testprogramm soll demonstrieren, wie Sie durch die Auswertung einiger WindowsBotschaften doch noch zum Ziel kommen.

Oberfläche Wir beschränken uns auf ein Formular sowie eine ListBox, in der wir später die Namen der Dateien anzeigen, die mittels Drag & Drop an unser Programm übermittelt wurden.

Quelltext Als Erstes sollten Sie die Unit ShellApi einbinden, die uns unter anderem die Funktionen ■ DragAcceptFiles, ■ DragQueryFile und ■ DragFinish zur Verfügung stellt.

1662

Kapitel 28

How-to: Desktop

Im FormCreate-Ereignis melden wir unsere Anwendung als Drag & Drop-Ziel an. Dazu verwenden wir DragAcceptFiles, Übergabeparameter sind das Handle des betreffenden Fensters sowie True dafür, dass das Fenster DragDrop-Operationen unterstützt. procedure TForm1.FormCreate(Sender: TObject); begin DragAcceptFiles(Form1.Handle, True); end;

Setzen Sie den zweiten Parameter auf False, können Sie die weitere Drag & Drop-Unterstützung Ihrer Anwendung ausschalten. Die eigentliche Kommunikation mit dem Explorer wird über die Windows-Message WM_DROPFILES abgewickelt. Dazu müssen wir die Klassendefinition unseres Fensters um ein neues Message-Handle erweitern: type TForm1 = class(TForm) ListBox1: TListBox; procedure FormCreate(Sender: TObject); protected procedure WMDROPFILES (var Msg: TMessage); message WM_DROPFILES; end;

Die eigentliche Ereignisroutine: procedure TForm1.WMDROPFILES (var Msg: TMessage); var i,anzahl, size : integer; Dateiname : PChar; begin inherited; anzahl := DragQueryFile(Msg.WParam, $FFFFFFFF, Dateiname, 255); for i := 0 to (anzahl - 1) do begin size := DragQueryFile(Msg.WParam, i , nil, 0) + 1; Dateiname:= StrAlloc(size); DragQueryFile(Msg.WParam,i , Dateiname, size); listbox1.items.add(StrPas(Dateiname)); StrDispose(Dateiname); end; DragFinish(Msg.WParam) end;

Nach der Initialisierung der Puffervariablen (Dateiname) bestimmen wir als Erstes die Anzahl der übergebenen Dateinamen. Dazu muss der zweite Parameter von DragQueryFile auf $FFFFFFFF festgelegt werden, der Rückgabewert ist die Anzahl der Dateinamen. Ein weiterer Aufruf von DragQueryFile dient dazu, die Größe des Puffers zu ermitteln.

1663

28.21 System-Icons verwenden

HINWEIS: Dieser Aspekt sollte unbedingt bei der Umstellung von 16 auf 32 Bit berücksichtigt

werden. Ältere Programme verwenden häufig noch einen festen Puffer von 255 Zeichen, der mit den heutigen Dateinamen nicht mehr mithalten kann. Wie üblich müssen Sie die Größe des Puffers mit Size + 1 bemessen, da sonst das letzte Zeichen abgeschnitten wird (es handelt sich um einen nullterminierten String, und die 0 braucht auch ihren Platz). Mit dem nächsten Aufruf von DragQueryFile wird der Puffer mit einem Dateinamen gefüllt, den wir in der ListBox anzeigen. Über die Schleife setzen wir die Bearbeitung so lange fort, bis alle Dateinamen ausgelesen sind.

Test Starten Sie das Programm und verschieben Sie einige Dateien in das Anwendungsfenster:

28.21 System-Icons verwenden Möchten Sie Systems-Icons oder -Bitmaps verwenden, müssen Sie diese nicht unbedingt als Ressourcen in die Anwendung aufnehmen. Sie können sie auch mit Hilfe der LoadIcon- oder LoadBitmap-Funktion direkt aus dem System abrufen. Das spart Speicherplatz. Wichtig ist, dass Sie den hinst-Parameter der LoadIcon-Funktion mit 0 festlegen (Desktop). Folgende Konstanten können Sie für die LoadIcon-Funktion verwenden: IDI_ASTERISK

IDI_QUESTION

IDI_APPLICATION

IDI_HAND

1664

Kapitel 28

IDI_ASTERISK

How-to: Desktop

IDI_QUESTION

IDI_EXCLAMATION

Quelltext Anzeige des Fragezeichens (aus den Standard-Dialogen) in einem Formular. procedure TForm1.Button1Click(Sender: TObject); var icon : TIcon; begin icon := TIcon.Create; icon.Handle := LoadIcon(0,IDI_Question); Canvas.Draw(30,100,icon) end;

Test

Ergänzungen Den gleichen Weg können Sie auch beschreiten, wenn es darum geht, Bitmap-Ressourcen des Systems zu verwenden. Allerdings ist in diesem Fall die Funktion LoadBitmap von Interesse. BEISPIEL: LoadBitmap var bitmap : TBitmap; begin Bitmap := TBitmap.Create; Bitmap.Handle := LoadBitmap(0,MAKEINTRESOURCE(OBM_ZOOM)); Canvas.Draw(30,100,Bitmap) end;

Einige Konstanten für LoadBitmap: Konstante

Konstante

OBM_BTNCORNERS

OBM_OLD_RESTORE

OBM_BTSIZE

OBM_OLD_RGARROW

OBM_CHECK

OBM_OLD_UPARROW

OBM_CHECKBOXES

OBM_OLD_ZOOM

1665

28.22 Den Windows-Dialog "Datei suchen" aufrufen

Konstante

Konstante

OBM_CLOSE

OBM_REDUCE

OBM_COMBO

OBM_REDUCED

OBM_DNARROW

OBM_RESTORE

OBM_DNARROWD

OBM_RESTORED

OBM_DNARROWI

OBM_RGARROW

OBM_LFARROW

OBM_RGARROWD

OBM_LFARROWD

OBM_RGARROWI

OBM_LFARROWI

OBM_SIZE

OBM_MNARROW

OBM_UPARROW

OBM_OLD_CLOSE

OBM_UPARROWD

OBM_OLD_DNARROW

OBM_UPARROWI

OBM_OLD_LFARROW

OBM_ZOOM

OBM_OLD_REDUCE

OBM_ZOOMD

28.22 Den Windows-Dialog "Datei suchen" aufrufen Gewöhnlich wird der Datei-Suchen-Dialog vom Windows-Desktop aus aufgerufen (Start|Suchen|Nach Dateien und Ordnern...). Dank der uns wohl bekannten ShellExecute-Funktion kann das aber auch vom Delphi-Programm aus geschehen.

Oberfläche Auch hier wieder genügen uns ein Formular und ein Button.

Quellcode Vergessen Sie nicht, die Unit ShellAPI einzubinden, das geschieht zweckmäßigerweise im implementation-Abschnitt.: uses ShellAPI;

// !!!

Der Aufruf: procedure TForm1.Button1Click(Sender: TObject); const startDir = 'C:\Windows'; // hier beginnt standardmäßig der Suchvorgang begin ShellExecute(handle,'find', startDir,'','',SW_SHOW) end;

Test Nach Klick auf den Button erscheint der wohl bekannte Dialog.

1666

Kapitel 28

How-to: Desktop

28.23 Dateien in den Papierkorb löschen Wer hat es nicht schon bedauert, wenn eine Datei auf Nimmerwiedersehen gelöscht wurde? Alle von Delphi angebotenen Möglichkeiten, eine Datei zu löschen, haben den Nachteil, den Papierkorb "links liegen zu lassen". Keine Chance, diese Dateien wiederherzustellen. Abhilfe schafft die Funktion SHFileOperation aus der ShellApi, mit der Sie die Dateien erst einmal in den Papierkorb befördern können.

Oberfläche Erstellen Sie ein kleines Formular entsprechend folgender Abbildung und verknüpfen Sie die DirectoryListbox mit der FileListbox. Beide "Veteranen" entnehmen Sie der "Win 3.1"-Seite der Komponentenpalette.

Quelltext Mit dem Klick auf den Button wird die in der FileListbox gewählte Datei in den Papierkorb verschoben: procedure TForm1.Button1Click(Sender: TObject); var shellinfo: TSHFileOpStruct; s : String; begin FillChar(shellinfo, SizeOf(SHFileOpStruct), 0); s := FileListBox1.FileName; with shellinfo do begin Wnd := handle; wFunc := FO_DELETE; pFrom := PChar(s + #0); fFlags := FOF_ALLOWUNDO end; SHFileOperation(shellinfo); FileListBox1.Refresh end;

28.24 Den Papierkorb leeren

1667

HINWEIS: Vergessen Sie nicht, die Struktur TSHFileOpStruct mit FillChar zu initialisieren!

Test Nach dem Programmstart können Sie sich von der Funktionsfähigkeit des Programms überzeugen. HINWEIS: Kontrollieren Sie auch den Inhalt des "Papierkorbs"!

28.24 Den Papierkorb leeren Natürlich ist hier vom Windows-Papierkorb die Rede1.

Oberfläche Lediglich ein Formular mit einem Button – wieder einmal brauchen Sie nicht mehr.

Quelltext Da die gewünschte API-Funktion nicht direkt von einer Unit zur Verfügung gestellt wird, binden wir die Funktion dynamisch zur Laufzeit ein. Dazu ist zunächst ein Funktionsprototyp zu deklarieren: Type TSHEmptyRecycleBin = function (Wnd : HWND; pszRootPath : PChar; dwFlags : DWORD): HRESULT; stdcall ;

Übergeben werden das Handle der aufrufenden Anwendung sowie der Root-Pfad des Papierkorbs. Ist der Root-Pfad auf Nil gesetzt, werden alle Daten im Papierkorb gelöscht. Über den dwFlags-Parameter haben Sie die Möglichkeit, das Verhalten beim Löschen zu beeinflussen. Folgende Konstanten sind möglich: Const SHERB_NOCONFIRMATION = $00000001 ; // Keine Nachfrage SHERB_NOPROGRESSUI = $00000002 ; // Kein Fortschrittsbalken SHERB_NOSOUND = $00000004 ; // Kein Signalton

Nun zum eigentlichen Funktionsaufruf. Nach dem dynamischen Einbinden können wir die Funktion SHEmptyRecycleBin aufrufen: procedure TForm1.Button1Click(Sender: TObject); Var SHEmptyRecycleBin : TSHEmptyRecycleBin; Handle : THandle; Begin 1

Wie Sie Ihren Papierkorb zu Hause leeren, dürfte Ihnen hoffentlich bekannt sein.

1668

Kapitel 28

How-to: Desktop

Handle := LoadLibrary(PChar('Shell32.dll')) ; if Handle <> 0 then begin @SHEmptyRecycleBin := GetProcAddress(Handle, 'SHEmptyRecycleBinA'); if @SHEmptyRecycleBin <> nil then SHEmptyRecycleBin(Application.Handle, nil, 0); @SHEmptyRecycleBin := nil ; FreeLibrary(Handle) end end;

Test HINWEIS: Bevor Sie das Beispiel testen, sollten Sie sich davon überzeugen, dass sich keine

wichtigen Dateien im Papierkorb befinden!

29

How-to: Wissenschaft/Technik

Kapitel

29

How-to: Wissenschaft/Technik 29.1 Einen Wert schätzen Insbesondere bei der Arbeit mit Gleitkommazahlen (Single, Double) sollte der direkte Vergleich zweier Werte vermieden werden, da durch Rundungsfehler geringfügige Abweichungen auftreten können. Um dieses Problem zu vermeiden, verwenden Sie eine Funktion, welche die Übereinstimmung zweier Werte in Abhängigkeit von einer von Ihnen festzulegenden Fehlerschranke bestimmt.

Oberfläche Wir brauchen zum Austesten zwei Edit-Felder, eine ComboBox, ein Label (Font vergrößern!) und zwei Buttons:

Der Items-Eigenschaft der ComboBox weisen Sie über den String-Listen-Editor mehrere Fehlerschranken zu:

1670

Kapitel 29

How-to: Wissenschaft/Technik

Quelltext Die Funktion: function circa(istWert,sollWert,schranke : Double): Boolean; begin result := Abs(istWert - sollWert) < Abs(schranke) end;

Beim Programmstart soll die Combobox den dritten Eintrag anzeigen: procedure TForm1.FormCreate(Sender: TObject); begin ComboBox1.ItemIndex := 3 end;

Das OnClick-Ereignis des Prüfbuttons: procedure TForm1.Button1Click(Sender: TObject); var wert1, wert2,schranke: Double; i: Integer; begin // Konvertieren in Double Datentyp Val(Edit1.Text,wert1,i); Val(Edit2.Text,wert2,i); Val(ComboBox1.Items.Strings[ComboBox1.ItemIndex],schranke,i); // Schätzen der Werte if circa(wert1,wert2,schranke) then Label4.Caption := '=' else Label4.Caption := '<>' end;

Test Wählen Sie eine Fehlerschranke aus, geben Sie zwei Werte ein und klicken Sie auf "Prüfen...". Das übergroße Symbol in der Label-Komponente informiert Sie, ob der Schätzwert stimmt.

29.2 Die Zeit auf eine Viertelstunde genau runden

1671

29.2 Die Zeit auf eine Viertelstunde genau runden Findet auch Ihr Chef es überhaupt nicht lustig, wenn Ihr neues Planungsprogramm den Beginn der Jahreshauptversammlung mit 12:07 Uhr berechnet hat? Dieses Rezept schafft Abhilfe!

Theoretische Überlegungen Ausgangspunkt ist die Überlegung, dass Delphi Datums-/Zeit-Werte als Double-Gleitkommazahlen speichert, wobei der ganzzahlige Anteil der Anzahl Tage seit dem 30.12.1899 entspricht (dieser fiktive "Nullpunkt" ist aber für unsere Berechnungen ohne Bedeutung). Da ein Tag 86.400 Sekunden hat, ist eine Rundung auf ganze Sekunden also elegant durch zeitgerundet auf 1s = Round(zeit * 86400)/86400

möglich. Ein Tag besteht aus 24 * 4 = 96 Viertelstunden-Einheiten. Die gesuchte Rundungsformel ergibt sich demnach zu zeitgerundet auf 15min = Round(zeit * 96)/96

Oberfläche Ein Editierfeld, ein Label und ein Button genügen.

Quelltext Wir wollen die Zeiteingabe mit der Enter-Taste abschließen und besetzen deshalb den OnKeyPressEvent-Handler von Edit1: procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char); var zeit : TDateTime; begin if key = #13 then begin key := #0; zeit := StrToTime(Edit1.Text); zeit := Round(zeit*96)/96; // ! Label1.Caption := 'Die gerundete Zeit beträgt ' +

1672

Kapitel 29

How-to: Wissenschaft/Technik

FormatDateTime('t', zeit) end end;

Test

Bemerkungen ■ Das 't' in der FormatDateTime-Funktion formatiert Zeitangaben entsprechend der globalen Systemvariablen ShortTimeFormat. ■ Es dürfte für Sie nicht schwierig sein, das Programm für das Runden anderer Zeitabschnitte anzupassen.

29.3 Zeitdifferenzen ermitteln Wenn es darum geht, die zwischen zwei Terminen verstrichene Zeit in Stunden und Minuten auszurechnen, muss der Programmierer kühlen Kopf bewahren. Die Standardprozedur DecodeTime (Unit SysUtils) ist bei Zeitdifferenzen oberhalb der 24- Stunden-Grenze überfordert und berücksichtigt die dazwischen liegenden Tage nicht. BEISPIEL: DecodeTime var d1, d2: TDateTime;

Sie können sich gern davon überzeugen, dass z.B. zwischen den Terminen d1 = 3.1.97 8:03 und d2 = 7.1.97 11:11 die Anweisung DecodeTime((d2-d1), std, min, sek, msek);

für std den (falschen) Wert 3 und für min den Wert 8 ermittelt, obwohl tatsächlich 99 Stunden und 8 Minuten vergangen sind. Selbsthilfe ist also wieder einmal angesagt.

Oberfläche Auf das Startformular Form1 platzieren Sie zwei Edit-Felder, ein Panel, zwei Buttons und ein paar Label für Beschriftungszwecke (siehe Screenshot am Schluss).

29.3 Zeitdifferenzen ermitteln

1673

Quelltext Der implementation-Abschnitt: var d1, d2:TDateTime; std, min : Word;

Die Funktion: function zeitDiff(d1, d2:TDateTime; var std, min:Word): Boolean; var days, sek, ms: Word; begin if d2 >= d1 then days := Trunc(d2-d1) // ganze Tage feststellen else begin Result := False; Exit end; DecodeTime((d2-d1), std, min, sek, ms); // Stunden und Minuten decodieren std := days * 24 + std; // Stunden korrigieren Result := True end;

Ehe die Berechnung gestartet werden kann, müssen die Eingangsinformationen vom Stringformat in das Datums-/Zeitformat konvertiert werden: procedure TForm1.Button1Click(Sender: TObject); begin try d1 := StrToDateTime(Edit1.Text); d2 := StrToDateTime(Edit2.Text) except Panel1.Caption := 'Fehler bei der Datums-/Zeiteingabe!'; Exit end; if zeitDiff(d1, d2, std, min) then Panel1.Caption := 'Die Zeitdifferenz beträgt ' + IntToStr(std) + ' Stunden und ' + IntToStr(min) + ' Minuten' else Panel1.Caption := 'Beginn- und Ende-Datum müssen vertauscht werden!' end;

Test Experimentieren Sie mit den unterschiedlichsten Eingaben!

1674

Kapitel 29

How-to: Wissenschaft/Technik

Das Jahr 00 wird richtig als Jahr 2000 interpretiert. HINWEIS: Beachten Sie, dass aufgrund des in der DecodeTime-Funktion verwendeten Daten-

typs Word die beiden Datumsangaben nicht weiter als circa sieben Jahre auseinander liegen dürfen!

29.4 Eine Prüfsumme erstellen Geht es darum, die Sicherheit von Datenübertragungen zu gewährleisten oder die Manipulation von Daten nachzuweisen, werden häufig Prüfsummen eingesetzt. Im Folgenden möchten wir Ihnen zwei verschiedene Varianten vorstellen.

CRC-Prüfsumme Der etwas betagtere und gleichzeitig auch einfachere Algorithmus basiert auf der CCITT-Vorschrift für 32-Bit-Prüfsummen. Zur schnelleren Berechnung verwenden wir ein vordefiniertes Konstanten-Array, das bereits die nötigen Werte enthält: const crctable: ($00000000, $0EDB8832, ... $B40BBE37,

array[0..255] of LongInt = $77073096, $EE0E612C, $990951BA, $79DCB8A4, $E0D5E91E, $97D2D988, $C30C8EA1, $5A05DF1B, $2D02EF8D);

Die eigentliche Funktion ist relativ simpel, übergeben Sie einfach die gewünschten Daten sowie deren Länge. Rückgabewert ist die 32-Bit-Checksumme. function CRC32 (const data; count: Integer): LongInt; var p : PByte; i : Integer; begin p := PByte(data); Result := 0; for i := 1 to count do begin result := (result shr 8) xor crcTable[ p^ xor (result and $000000FF)]; Inc(p) end end;

Natürlich hat der oben vorgestellte Algorithmus auch seine Grenzen. Mit einem 32-Bit-Wert können nun einmal nur 4.294.967.295 verschiedene Werte dargestellt werden. Es ist also nicht ganz unwahrscheinlich, dass zwei verschiedene Texte die gleiche Prüfsumme aufweisen.

29.4 Eine Prüfsumme erstellen

1675

SHA-1-Prüfsumme Eine wesentlich anspruchsvollere Lösung bietet sich mit dem SHA-1-Algorithmus. Bei rund 1048 Möglichkeiten (25520) dürfte eine zufällige Übereinstimmung so gut wie ausgeschlossen sein. Der zugehörige Quelltext (den Sie nicht unbedingt zu verstehen brauchen!) stammt aus dem Internet und wurde von uns geringfügig modifiziert: unit u_sha; interface type TSHA = array[1..20] of Byte; function GetSHA(const Data; len: Word):TSHA; implementation

Aufgrund des drei Seiten umfassenden Umfangs des Implementation-Abschnitts wird auf den kompletten Abdruck des Listings verzichtet. Kopieren Sie sich bitte den Quelltext u_sha.pas von der Buch-CD!

Quelltext (Testprogramm) Alles, was Sie benötigen, ist ein Memo-Feld (für die Eingabe des Textes), eine ComboBox zur Auswahl des Algorithmus und einen Label zur Anzeige der Prüfsumme. procedure TForm1.Memo1Change(Sender: TObject); var s: string; ShaValue: TSHA; hilfs: string; i: Integer; begin s := Memo1.Text; if ComboBox1.ItemIndex=0 then Label1.Caption := Format('CRC-Summe:%.8xh',[crc32(s,Length(Memo1.Text))]) else begin shaValue := GetSHA(s[1],Length(Memo1.Text)); hilfs := ''; for i := 1 to 20 do hilfs := hilfs + Format('%.2x',[shaValue[i]]); Label1.Caption := Format('SHA: %s',[hilfs]) end end;

Im Beispielprogramm wird das Funktionsergebnis des SHA-Algorithmus in eine Folge von Hexadezimalwerten umgerechnet. In Ihren Anwendungen können Sie natürlich auch direkt das ByteArray speichern. HINWEIS: An die Funktion GetSHA müssen Sie das erste Zeichen des Puffers übergeben (in

diesem Falls s[1]), in der letzten Auflage des Buches hatte sich ein entsprechender Fehler eingeschlichen.

1676

Kapitel 29

How-to: Wissenschaft/Technik

Test Starten Sie das Programm, geben Sie etwas in das Memofeld ein und schließen mit Enter. Über die ComboBox wechseln Sie den Algorithmus.

29.5 Einen Text verschlüsseln Wenn Sie in Ihren Programmen Passwörter verwenden, besteht ein Problem darin, das Passwort in einer Datei zu sichern. Dies ist zwar technisch machbar, der Dateiinhalt könnte jedoch mit einem beliebigen Editor durchforstet werden, das Herausfinden des Passwortes dürfte also eine der geringsten Hackerübungen sein. Zum effektiven Verschlüsseln kann ein einfacher, in vielen Fällen ausreichender Algorithmus verwendet werden, der auf der XOR-Verknüpfung basiert. Das Prinzip entnehmen Sie bitte der folgenden Abbildung. A

Binärdarstellung

ANSI-CODE 65 0

1

0

0

0

0

0

1

0

1

1

0

1

0

1

0

1

1

0

0

0

1

XOR Code 0

0

0

1

1

Schlüssel 27

=

Kodierter Buchstabe 0

1

0

1

1

90

XOR Code 0

0

0

1

0

1

0

0

Schlüssel 27

= 65 = A

29.5 Einen Text verschlüsseln

1677

Grundlage des Algorithmus ist die Tatsache, dass die zweimalige XOR-Codierung eines Zeichens den Ausgangszustand wiederherstellt. Ein ähnliches Prinzip finden Sie in Ä 19.30 Einen Markierungsrahmen erzeugen Obiges Verfahren kann auf verschiedenen Wegen "geknackt" werden: ■ Zum einen durch Ausprobieren oder über die Wahrscheinlichkeitstheorie. Letzteres basiert auf der Tatsache, dass die statistische Verteilung der Buchstaben in einem Text nicht gleichförmig ist. Der Buchstabe "E" wird mit hoher Wahrscheinlichkeit einen größeren Anteil am Text besitzen. Diese Methode ist umso erfolgreicher, je mehr verschlüsselter Text vorliegt. ■ Einen weiteren Ansatzpunkt liefern Buchstabenwiederholungen, z.B. Moos, Boot. Auch im verschlüsselten Text treten zwei gleiche Zeichen auf. Ein Demo-Programm soll auf die Probleme dieser Realisierungsmöglichkeit hinweisen. Geben Sie in das obere Textfeld eine Zeichenfolge ein. Nach dem Drücken der Codiertaste wird im unteren Label-Feld das Resultat angezeigt.

Quelltext var s : string[255]; c : array[0..255] of Byte absolute s; i : Integer; begin if button1.Caption = 'Codieren' then begin s := Memo1.Text; for i := 1 to ord(s[0]) do c[i] := Chr(23 Xor ord(c[i])); Button1.Caption := 'Decodieren'; Memo1.Text := ''; Label1.Caption := s end else begin s := Label1.Caption; For i := 1 To Length(s) do s[i] := 23 Xor Ord(s[i])); Button1.Caption := 'Codieren'; Memo1.Text := s; Label1.Caption := '' end end;

1678

Kapitel 29

How-to: Wissenschaft/Technik

Obiges Verfahren reicht für normale Anwendungen aus, stellt jedoch für Hacker auch keine große Hürde dar. Um die Sicherheit zu erhöhen, wird jeder Buchstabe des Passwortes mit einem eigenen Schlüssel codiert. Wir benötigen dafür nur noch einen brauchbaren Algorithmus. Wie wäre es mit dem Zufallszahlen-Generator von Delphi? Wir bestimmen mit seiner Hilfe vor dem ersten Verschlüsseln den "Superkey": procedure TForm1.FormCreate(Sender: TObject); var i :Integer; begin randseed := code; Randomize; for i := 1 to high(superkey) do superkey[i]:=random(255) end;

Der neue Algorithmus: procedure TForm1.Button1Click(Sender: TObject); var s : string[255]; c : array[0..255] of byte absolute s; i : Integer; begin If Button1.Caption = 'Codieren' Then begin s := Memo1.Text; For i := 1 To Ord(s[0]) do c[i] := superkey[i] Xor c[i]; Button1.Caption := 'Decodieren'; Label1.Caption := s end else begin s := Label1.Caption; For i := 1 To Length(s) do s[i] := Chr(superkey[i] Xor ord(s[i])); button1.Caption := 'Codieren'; memo1.Text := s; label1.Caption := '' end end;

Bemerkungen ■ Obiges Verfahren dürfte nicht ganz so einfach zu knacken sein wie das erste. Beachten Sie, dass der Superkey für Strings mit einer maximalen Länge von 1000 Zeichen ausgelegt ist. Eventuell verlängern Sie den Superkey oder Sie wiederholen den Superkey zyklisch, wenn Sie Strings größer 1000 Zeichen codieren wollen. ■ Buchstabenwiederholungen im codierten Text lassen nicht darauf schließen, dass im Ursprungstext ebenfalls Buchstaben doppelt auftreten. Mit der Wahrscheinlichkeitstheorie ist dem obigen Verfahren jedenfalls nicht beizukommen, da die Verteilung allein vom Zufallszahlen-Generator abhängt. ■ Natürlich lässt sich auch dieses Verfahren durch Ausprobieren knacken, der Initialisierungswert des Zufallszahlengenerators ist auch nur ein LongInt, entsprechend viele Versuche würden genügen, um den Code zu entschärfen.

29.6 In einer Datei sortieren und suchen

1679

■ Soll das Verfahren verbessert werden, können Sie mehrere Schlüssel unterschiedlicher Länge einführen, die in zufälliger Folge eingesetzt werden. Zusammen mit einem einfachen PackAlgorithmus (Huffman) erhöht sich die Sicherheit drastisch. ■ Das Verfahren auf Dateien zu verallgemeinern dürfte kein unüberwindliches Problem darstellen, eventuell verwenden Sie gleich einen Stream.

29.6 In einer Datei sortieren und suchen Bei kleineren Datenbankapplikationen kann man durchaus auf die BDE (Borland Database Engine) verzichten und stattdessen die Informationen in einer einfachen Datei abspeichern, siehe Ä 21.26 Typisierte Dateien als BDE-Ersatz verwenden Eine elegantere Möglichkeit bietet sich mit einem FileStream-Objekt, siehe Ä 21.21 Records in einem Stream-Objekt speichern Problematisch, weil quälend langsam, gestaltet sich allerdings das Sortieren/Suchen in einer Datei. Um die Sortier- bzw. Suchoperationen zu beschleunigen, sollte man die Anzahl der Festplattenzugriffe auf ein Minimum reduzieren. Die hier vorgestellte Lösung verwendet deshalb ein dynamisches Array als Zwischenspeicher.

Oberfläche Die etwas aufwändige Oberfläche spricht für sich, Näheres finden Sie in einem der eingangs erwähnten Rezepte.

1680

Kapitel 29

How-to: Wissenschaft/Technik

Quelltext (allgemein) Den kompletten Quelltext finden Sie auf der Buch-CD. Bevor wir auf das Sortieren/Suchen eingehen, soll das Prinzip der Dateioperationen auszugsweise vorgestellt werden, wobei gegenüber dem original Quelltext gewisse Vereinfachungen vorgenommen wurden. Eine Person wird durch einen strukturierten Datentyp definiert: type TPerson = record name: string[20]; geburt: TDateTime; geschlecht: Boolean; nr: Integer end;

// // // //

max. 20 Buchstaben Geburtsdatum männlich = True, weiblich = False Telefonnummer

Die wichtigsten Variablen: var pmax: Integer; // max. Anzahl abgespeicherter Personen personen: array[1..pmax] of TPerson; // strukturiertes Array f: TFileStream; // FileStream-Objekt pfad: string; // Dateipfad i: Integer; // Zählvariable

Das Öffnen der Datei: f := TFileStream.Create(pfad, fmOpenRead) for i := pmax-1 downto 0 do f.ReadBuffer(personen[i],SizeOf(TPerson));

Das Speichern der Datei: f := TFileStream.Create(pfad, fmOpenWrite) for i := pmax-1 downto 0 do f.WriteBuffer(personen[i],SizeOf(TPerson));

Sortieren Wie sortiere ich die im Array enthaltenen Personen in alphabetischer Reihenfolge? Die vorliegende Lösung benutzt das so genannte Austauschverfahren (Exchange-Sort). procedure TForm1.Button8Click(Sender: TObject); // Sortieren (Exchange-Sort) var i,j:Word; s: string; begin if pmax=1 then Exit; for i := 0 to pmax - 2 do // bis zum vorletzten Element for j:= i + 1 to pmax - 1 do // bis zum letzten Element

Was jetzt kommt, ist vielleicht etwas ungewohnt: Auch Zeichenketten kann ich genauso wie Zahlen miteinander vergleichen. Die "größere" Zeichenkette steht in der alphabetischen Reihenfolge weiter hinten: if personen[i].name > personen[j].name then begin s:= personen[i].name; personen[i].name := personen[j].name;

// Austausch

29.6 In einer Datei sortieren und suchen

1681

personen[j].name := s end; index := 0 end;

Suchen Hier der interessierende Quelltextauszug: procedure TForm1.Button8Click(Sender: TObject); // sequenzielle Suche var i:Word; begin if pmax=1 then Exit; for i := 0 to pmax-1 do if UpperCase(personen[i].name) = UpperCase(Edit4.Text) then begin index := i; Exit end; ShowMessage('Datensatz nicht gefunden!') end;

Test Öffnen Sie eine Personaldatei, die Namen in unsortierter Reihenfolge enthält, oder legen Sie eine neue Datei an. Überzeugen Sie sich von der Funktionsfähigkeit der Sortier- und Suchfunktionen. Um zu noch aussagekräftigeren Ergebnissen zu kommen, sollten Sie noch einige Datensätze mehr hinzufügen, als sie die auf der Buch-CD enthaltene Beispieldatei bietet.

Bemerkungen ■ Mit völlig gleichem Quelltext können natürlich auch andere Felder (Geburtsdatum, ...) der typisierten Datei sortiert bzw. durchsucht werden.

1682

Kapitel 29

How-to: Wissenschaft/Technik

■ Sie können auch auf den "Sortieren"-Button verzichten und stattdessen den Sortiervorgang automatisch nach jedem Einfügen eines neuen Datensatzes auslösen. ■ Die hier verwendete sequenzielle Suche ist eine ziemlich langsame Methode, was sich allerdings erst bei einer sehr großen Vielzahl von Datensätzen bemerkbar macht. Im schlimmsten Fall werden alle Werte geprüft, die mittlere Anzahl von Versuchen berechnet sich zu pmax/2.

29.7 Eine Iteration verstehen Eigentlich ist ein Computer ja "dumm" und erscheint uns nur dadurch "intelligent", dass er primitive Rechenoperationen in einer wahnwitzigen Geschwindigkeit erledigt. Der pfiffige Programmierer kann sich dies zunutze machen, indem er dem Computer Aufgaben stellt, die sich nur durch schrittweises Ausprobieren lösen lassen. Typisch für diese Sorte von Aufgaben ist eine so genannte Iterationsschleife, die mit einer Startnäherung beginnt und an deren Ende ein Abbruchkriterium überprüft wird. Wievielmal die Schleife durchlaufen wird, kann nicht exakt vorausbestimmt werden. Ohne auf die mathematischen Grundlagen näher einzugehen, wollen wir in diesem Rezept eine Iterationsschleife für das Ziehen der Quadratwurzel demonstrieren. Wir verzichten also auf die Sqrt-Funktion, wie sie standardmäßig von Delphi bereitgestellt wird (Unit System), und programmieren eine eigene Lösung.

Programmablaufplan Obwohl in der objekt- und ereignisorientierten Programmierung der PAP völlig aus der Mode gekommen ist, eignet er sich nach wie vor gut zur Veranschaulichung von Iterationszyklen. Start

Eingabe: x

Iterationsschleife

y := (1+x)/4 + x/(1+x)

Startnäherung

y' := y y := (y'+x/y')/2 y >= y' ?

nein

Ausgabe: y

Ende

Abbruchbedingung

1683

29.7 Eine Iteration verstehen

Oberfläche Für die Eingabe verwenden wir eine Edit- und für die Ausgabe eine Panel-Komponente. Die ListBox ist nicht unbedingt erforderlich, aber wir sind ja neugierig und wollen auch die Zwischenergebnisse betrachten:

Quelltext Die programmtechnische Umsetzung des obigen Programmablaufplans führt (in Verbindung mit dem Code für die Ein- und Ausgabe und für die Anzeige von Zwischenergebnissen) zu folgender Lösung: procedure TForm1.Button1Click(Sender: TObject); var x, y, ya : Double; s: String; code: Integer; // Fehlercode

// Quadratwurzel berechnen

begin Val(Edit1.Text, x, code); if x > 0 then // Quadratwurzel darf nur aus positiven Werten gezogen werden begin Form1.ListBox1.Items.Clear; // Inhalt der Listbox löschen y := (1+x)/4 + x/(1+x); // Startnäherung

Wie geschaffen für eine Iterationsschleife ist die repeat...until-Anweisung: repeat ya := y; y := (ya + x/ya)/2; Str(y:12:10, s); Form1.ListBox1.Items.Add(s) // Zwischenergebnis anzeigen until y >= ya; // Abbruchbedingung Str(y:8:4, s) end else s := 'Positiven Wert eingeben!'; Panel1.Caption := s // Ergebnis anzeigen end;

1684

Kapitel 29

How-to: Wissenschaft/Technik

Test Die Zwischenergebnisse nähern sich schrittweise der endgültigen Lösung. Sie werden feststellen, dass circa vier bis fünf Iterationen notwendig sind, um die Abbruchbedingung zu erfüllen, d.h., die Quadratwurzel in einer für Double-Zahlen ausreichenden Genauigkeit zu ermitteln:

Ergänzung Der fortgeschrittene Programmierer wird obigen Code – besonders im Hinblick auf seine Wiederverwendbarkeit – in eine Funktion qWurzel verpacken. Da die Testphase abgeschlossen ist, kann auch auf die Anzeige der Zwischenergebnisse in der ListBox verzichtet werden: function qWurzel(x: Double): Double; var y, ya: Double; s: String; begin y := (1+x)/4 + x/(1+x); // Startnäherung repeat ya := y; y := (ya + x/ya)/2 until y >= ya; // Abbruchbedingung Result := y end;

Der Aufruf gestaltet sich nun wesentlich übersichtlicher: procedure TForm1.Button1Click(Sender: TObject); // Quadratwurzel berechnen var x, y : Double; s: String; code: Integer; // Fehlercode begin Val(Edit1.Text, x, code); if x > 0 then begin // Quadratwurzel darf nur aus positiven Werten gezogen werden y := qWurzel(x); Str(y:8:4, s) end else s := 'Positiven Wert eingeben!'; Panel1.Caption := s // Ergebnis anzeigen end;

1685

29.8 Den Abstand zwischen zwei Punkten bestimmen

29.8 Den Abstand zwischen zwei Punkten bestimmen Haben Sie im Mathematikunterricht gut aufgepasst, so wird Ihnen das vorliegende Rezept nicht mehr als ein müdes Lächeln entlocken. Allen anderen soll die folgende Skizze auf die Sprünge helfen:

P2(x2,y2)

y2 (x2-x1)2 + (y2-y1)2

y2-y1

P1(x1,y1) y1 x2-x1

x1

x2

Neben der Umsetzung des Lehrsatzes des Pythagoras mittels der Funktionen Sqr (Quadrat) und Sqrt (Quadratwurzel) werden ganz nebenbei scheinbar triviale Dinge aus dem Grafikbereich (Löschen der Zeichenfläche, Zeichnen einer Linie, Umwandeln von Grafikkoordinaten) sowie der Begriff der Zustandsvariablen geübt.

Oberfläche Es werden nur zwei Labels benötigt, deren Align-Eigenschaft Sie auf alTop bzw. alBottom setzen können (aber nicht müssen).

Quellcode Das Programm muss seinen Zustand "wissen", also ob der Anfangs- oder der Endpunkt der Linie angeklickt wurde. Zu diesem Zweck wird eine Zustandsvariable state eingeführt und mit dem Wert 1 initialisiert: var state: Word = 1; x1, y1, x2, y2, dist: Word;

// Zustandsvariable (1, 2) // Koordinaten // Entfernung

Im Unterschied zu OnMouseClick werden durch OnMouseDown (genauso wie OnMouseUp und OnMouseMove) die aktuellen Mauskoordinaten X, Y (in Pixel) übergeben: procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin Refresh; // Zeichenfläche wird gelöscht

1686

Kapitel 29

if state = 1 then begin x1 := X; y1 := Y; Canvas.MoveTo(x1, y1); Canvas.LineTo(x1+1,y1+1);

How-to: Wissenschaft/Technik

// Startpunkt wird erwartet

// Startpunkt wird gezeichnet // ... und etwas vergrößert

Der vorhergehende "Kunstgriff" war notwendig, da der erste Punkt einer Linie unter Delphi (Windows) nicht gezeichnet wird und die Pixels-Eigenschaft mitunter fehlschlägt. state := 2 end else begin Beep; x2:= X; y2:=y; Canvas.LineTo(x2,y2);

// Zustandsüberführung: "Endpunkt wird erwartet" // zweiter Punkt wurde gesetzt // Aufwachen!

// Verbindungslinie wird gezeichnet

Jetzt kommt endlich der Lehrsatz des guten alten Pythagoras zum Zuge, allerdings muss das Ergebnis (ein Gleitkommawert!) mit der Trunc-Funktion in einen Integer-Wert verwandelt werden: dist := Trunc(Sqrt( Sqr(X2-X1) + Sqr(Y2-Y1))); // Entfernung wird berechnet

Die Anzeige: Label1.Caption := 'Die Länge der Verbindungslinie beträgt ' + IntToStr(dist) + ' Pixel!'; state := 1 // Zustandsüberführung: "Anfangspunkt wird erwartet" end; end;

Test Ohne viele Worte:

1687

29.9 Eine Unit für komplexe Zahlen entwickeln

29.9 Eine Unit für komplexe Zahlen entwickeln Mit diesem Rezept (und mit seinem Nachfolger) wollen wir nicht nur die Lösung eines mathematischen Problems zeigen, sondern (was viel wichtiger ist) grundlegendes Handwerkszeug des Delphi-Programmierers demonstrieren: ■ Logische Strukturierung eines Windows-Programms nach dem EVA-Prinzip (Eingabe-Verarbeitung-Ausgabe). ■ Sinnvolle Auslagerung von Quellcode in eine Unit, um den späteren Übergang zur objektorientierten Programmierung vorzubereiten. Doch ehe wir mit der Praxis beginnen können, scheint ein kurzer Abstieg in die Untiefen der Mathematik unausweichlich.

Was sind komplexe Zahlen? Zur Darstellung einer komplexen Zahl Z bieten sich zwei Möglichkeiten an: ■ Kartesische Koordinaten (Real-/Imaginärteil) ■ Polarkoordinaten (Betrags-/Winkeldarstellung) Die folgende Tabelle zeigt eine Zusammenstellung der Umrechnungsformeln: Kartesische Koordinaten

Polarkoordinaten

Z = Re{Z} + jIm{Z}

Z = |Z| ejϕz

Re{Z} = |Z| cos ϕz

Realteil:

Imaginärteil: Im{Z} = |Z| sin ϕz

Betrag: Phasenwinkel:

Am besten lassen sich diese Zusammenhänge am Einheitskreis erläutern, wobei Z als Punkt in der komplexen Ebene erscheint: jIm

|Z|

Im{Z}

Z

ϕz Re{Z}

Re

Die kartesische Form eignet sich besonders gut für die Ausführung von Addition und Subtraktion:

1688

Kapitel 29

How-to: Wissenschaft/Technik

Mit Z1 = a1 + jb1 und Z2 = a2 + jb2 ergibt sich Z1 + Z2 = a1 + a2 + j(b1 + b2)

bzw. Z1 - Z2 = a1 - a2 + j(b1 - b2)

Andererseits bevorzugt man für Multiplikation und Division die Zeigerform: Mit Z1 = c1 · ejϕ1 und Z2 = c2 · ejϕ2 erhalten wir Z1 · Z2 = c1 · c2 · ej(ϕ1 + ϕ2)

bzw.

Z1/Z2 = c1/c2 · ej(ϕ1 - ϕ2)

Für die Angabe des Phasenwinkels hat man die Wahl zwischen Radiant (Bogenmaß) und Grad. Für die gegenseitige Umrechnung gilt die Beziehung ϕ ( Rad ) =

π 180

ϕ (Grad )

Die Maßeinheit "Grad" wird aufgrund ihrer Anschaulichkeit vom Praktiker für die Ein- und Ausgabe bevorzugt, während "Radiant" für interne Berechnungen günstiger ist.

Quelltext für Unit Die Unit Komplex soll Methoden für Addition, Multiplikation und Division sowie zur Umwandlung zwischen kartesischen und Polarkoordinaten zur Verfügung stellen. Unmittelbar nach dem Start von Delphi klicken wir auf den Menüpunkt Datei|Neu..., wählen Unit und sehen ein Fenster mit einem sehr mageren Rahmencode für eine Unit namens Unit2 vor uns. Wir ändern zunächst den Namen der Unit und speichern sie unter Komplex.pas ab, ehe wir dann mit der Implementierung fortfahren. unit Komplex;

// Komplexe Grundrechenoperationen

interface

Die Unit Komplex exportiert vier Methoden, deren Bedeutung später klar wird: procedure procedure procedure procedure procedure

transR_P(a, b: Double; var x, y:Double); transP_R(a, b: Double; var x, y:Double); addK(a,b,c,d: Double; var e,f: Double); multK(a,b,c,d: Double; var e,f: Double); divK(a,b,c,d: Double; var e,f: Double);

implementation

29.9 Eine Unit für komplexe Zahlen entwickeln

1689

Die Implementierung der beiden Koordinatentransformationen: // Transformation Rechteck => Polar: procedure transR_P(a, b: Double; var x, y: Double); begin x:= Sqrt(a*a+b*b); // Betrag if a<>0 then begin y:=180/Pi*ArcTan(b/a); // Winkel in Grad if a<0 then y:=y+180 end else begin if b<>0 then if b>0 then y:=90 else y:=-90 end end; // Transformation Polar => Rechteck: procedure transP_R(a, b: Double; var x, y:Double); begin b:= b*Pi/180; // Umwandlung Grad => Bogenmaß x:= a*cos(b); // Realteil y:= a*sin(b) // Imaginärteil end;

Die Implementierung der Rechenoperationen: procedure addK(a,b,c,d: Double; var e,f: Double); // Addition kompl. Zahlen begin e:=a+c; f:=b+d end; procedure multK(a,b,c,d: Double; var e,f: Double); // Multipl. kompl. Zahlen begin e:=a*c-b*d; f:=a*d+b*c end; procedure divK(a,b,c,d: Double; var e,f: Double); // Division kompl. Zahlen begin e:=(a*c+b*d)/(c*c+d*d); f:=(b*c-a*d)/(c*c+d*d) end; end.

Oberfläche für Testprogramm Um uns von der Funktionsfähigkeit der Unit Komplex zu überzeugen, brauchen wir ein kleines Testprogramm, das die Ein- und Ausgabe von komplexen Zahlen und die Auswahl der Rechenoperation sowie der Koordinatendarstellung ermöglicht. Wir benutzen dazu das bereits vorhandene Startformular Form1, auf das wir sechs Label und Editierfelder, drei einzelne RadioButtons, eine RadioGroup (mit zwei Einträgen gemäß Abbildung) und zwei Buttons platzieren:

1690

Kapitel 29

How-to: Wissenschaft/Technik

Setzen Sie vorsichtshalber ReadOnly für Edit3 und Edit6 auf True, da Sie diese Felder nur zur Ergebnisanzeige brauchen.

Quelltext für Testprogramm Unser Beispiel soll wieder Mal das altbekannte EVA-Prinzip demonstrieren, welches auch unter Windows seine grundlegende Bedeutung beibehalten hat. Wir fügen deshalb zur Klassendeklaration von TForm1 drei Methoden hinzu: unit Unit1; type TForm1 = class(TForm) ... procedure Eingabe; procedure Verarbeitung; procedure Anzeige; end;

Nun zum implementation-Abschnitt: uses Komplex;

// !!!

Zunächst brauchen wir eine ganze Reihe von Gleitkomma-Variablen zum Zwischenspeichern: var // Rechteck-Koordinaten: Ar, Ai, // erster Operand (Real- und Imaginärteil) Br, Bi, // zweiter Operand (Real- und Imaginärteil) Zr, Zi, // Ergebnis (Real- und Imaginärteil) // Polar-Koordinaten: Ab, Aw, // erster Operand (Betrag und Winkel) Bb, Bw, // zweiter Operand (Betrag und Winkel) Zb, Zw: Double; // Ergebnis (Betrag und Winkel)

Es geht los: procedure TForm1.FormCreate; // Formular laden und Anfangswerte setzen begin Ar := 1; Ai := 1; Br := 1; Bi := 1; addK(Ar, Ai, Br, Bi, Zr, Zi);

1691

29.9 Eine Unit für komplexe Zahlen entwickeln

Anzeige end;

Bei der Eingabe werden die Operanden aus der Maske ausgelesen und in Variablen gespeichert. Während im Anzeigemodus "Rechteck-Koordinaten" die Variablen direkt angezeigt werden, muss im Modus "Polar-Koordinaten" die entsprechende Transformation (transP_R) zwischengeschaltet werden: procedure TForm1.Eingabe; var code: Integer; begin if RadioGroup1.ItemIndex = 0 then begin // Rechteck-Koordinaten Val(Edit1.Text, Ar, code); Val(Edit2.Text, Br, code); Val(Edit4.Text, Ai, code); Val(Edit5.Text, Bi, code) end else begin // Polar-Koordinaten Val(Edit1.Text, Ab, code); Val(Edit2.Text, Bb, code); Val(Edit4.Text, Aw, code); Val(Edit5.Text, Bw, code); // Umwandlung Polar- in Rechteck-Koordinaten: transP_R(Ab, Aw, Ar, Ai); transP_R(Bb, Bw, Br, Bi) end end;

Bei der Verarbeitung werden – in Abhängigkeit von der eingestellten Operation – die entsprechenden Prozeduren aufgerufen. In der Argumenteliste sind jeweils die ersten vier Werte die Übergabeparameter, die letzten beiden tragen das Ergebnis. Alle Parameter sind vom Typ "RechteckKoordinaten": procedure TForm1.Verarbeitung; begin if RadioButton1.Checked then addK(Ar, Ai, Br, Bi, Zr, Zi); if RadioButton2.Checked then multK(Ar, Ai, Br, Bi, Zr, Zi); if RadioButton3.Checked then if (Br <> 0) or (Bi <> 0) then divK(Ar, Ai, Br, Bi, Zr, Zi) end;

// Addition // Multiplikation // Division

Schließlich soll die Anzeige dafür sorgen, dass die Operanden und das Ergebnis entweder in Rechteck- oder in Polar-Koordinatenform erscheinen, im letzteren Fall muss die entsprechende Transformation ( transR_P) zwischengeschaltet werden: procedure TForm1.Anzeige; var s: string; begin if Radiogroup1.ItemIndex = 0 then Label1.Caption := 'Realteil A'; Label3.Caption := 'Realteil C'; Label4.Caption := 'Imaginärteil Label6.Caption := 'Imaginärteil Str(Ar:8:2,s); Edit1.Text:= s; Str(Ai:8:2,s); Edit4.Text:= s; Str(Br:8:2,s); Edit2.Text:= s;

begin // Anzeige in Rechteck-Koordinaten Label2.Caption := 'Realteil B'; A'; Label5.Caption := 'Imaginärteil B'; C'; // Anzeige Realteil A // Anzeige Imaginärteil A // Anzeige Realteil B

1692

Kapitel 29

How-to: Wissenschaft/Technik

Str(Bi:8:2,s); Edit5.Text:= s; // Anzeige Imaginärteil B Str(Zr:8:2,s); Edit3.Text:= s; // Anzeige Realteil Z Str(Zi:8:2,s); Edit6.Text:= s // Anzeige Imaginärteil Z end else begin // Anzeige in Polarkoordinaten Label1.Caption := 'Betrag A'; Label2.Caption := 'Betrag B'; Label3.Caption := 'Betrag C'; Label4.Caption := 'Winkel A'; Label5.Caption := 'Winkel B'; Label6.Caption := 'Winkel C'; transR_P(Ar, Ai, Ab, Aw); // Transformation Rechteck => Polar Str(Ab:8:2,s); Edit1.Text:= s; // Anzeige Betrag A Str(Aw:8:2,s); Edit4.Text:= s; // Anzeige Winkel A transR_P(Br, Bi, Bb, Bw); // Transformation Rechteck => Polar Str(Bb:8:2,s); Edit2.Text:= s; // Anzeige Betrag B Str(Bw:8:2,s); Edit5.Text:= s; // Anzeige Winkel B transR_P(Zr, Zi, Zb, Zw); // Transformation Rechteck => Polar Str(Zb:8:2,s); Edit3.Text:= s; // Anzeige Betrag Z Str(Zw:8:2,s); Edit6.Text:= s // Anzeige Winkel Z end end;

Die "Berechnen"-Schaltfläche zeigt sehr schön das pure EVA-Prinzip: procedure TForm1.Button1Click(Sender: TObject); // Berechnen begin Eingabe; Verarbeitung; Anzeige end;

Die drei einzelnen RadioButtons benutzen einen gemeinsamen Event-Handler, den Sie auf der "Ereignis"-Seite des Objektinspektors extra zuweisen müssen: procedure TForm1.RadioButtonClick(Sender: TObject); begin Verarbeitung; Anzeige end;

// Operation ändern

Wenn Sie die Anzeigeart mittels RadioGroup umschalten, muss natürlich aktualisiert werden: procedure TForm1.RadioGroup1Click(Sender: TObject); begin Anzeige end;

// Anzeige ändern

Damit Sie nicht versehentlich ein Komma als Dezimaltrennzeichen eingeben, wurde dem OnKeyPress-Event von Edit1, Edit2, Edit4 und Edit5 ein gemeinsamer Event-Handler zugewiesen: procedure TForm1.EditKeyPress; begin if key = ',' then Key:= '.' end; ... end.

// Komma in Dezimalpunkt verwandeln

29.9 Eine Unit für komplexe Zahlen entwickeln

1693

Test Starten Sie das Programm und überzeugen Sie sich von der Funktionsfähigkeit der Unit. Wenn als Beispiel die Aufgabe (2.5 + 3j) / (-2 + j)

gelöst werden soll, erhalten Sie als Ergebnis die komplexe Zahl -0.4 -1.7j.

Die Polarkoordinaten liefern einen Zeiger mit der Länge 1.75 und einem Winkel von 256.76 Grad.

Bemerkungen ■ Eine besondere Bedeutung haben komplexe Rechenoperationen beispielsweise in der Schwingungslehre und in der Wechselstromtechnik. ■ Eine stark vereinfachte und für Einsteiger besser geeignete Version dieses Programms sowie weitere Beispiele aus Wissenschaft und Technik finden Sie im Grundlagenteil dieses Buchs.

1694

Kapitel 29

How-to: Wissenschaft/Technik

29.10 Klassen für wissenschaftliche Anwendungen Der routinierte Programmierer kapselt seinen Code in Klassen anstatt nur in einfachen Units. Um das zu zeigen, soll dieses Rezept seinen Vorgänger Ä 29.9 Eine Unit für komplexe Zahlen entwickeln auf ein ansprechendes OOP-Niveau heben. Es ist deshalb besonders für den fortgeschrittenen Programmierer geeignet, der sich durch Vergleich mit der klassischen Programmiertechnik schnell mit den objektorientierten Delphi-Konzepten anfreunden will.

Quelltext für Unit Die Unit stellt zwei Klassen bereit: ■ Klasse TKomplexN ... repräsentiert eine komplexe Zahl. ■ Klasse TKomplexOp ... repräsentiert Rechenoperationen mit komplexen Zahlen. Die zweckmäßige Aufteilung einer praktischen Problemstellung in verschiedene Klassen und die Definition der Abhängigkeiten ist sicherlich der schwierigste Part der OOP und erfordert einige Übung und Routine, bis das dazu erforderliche abstrakte Denken schließlich zur Selbstverständlichkeit wird1. unit Komplex; interface

// Klassen für komplexe Zahlen und Rechenoperationen

Die Klasse TKomplexN speichert in den Feldern bzw. Zustandsvariablen Re und Im (die in unserem Fall aus Gründen der Einfachheit gleichzeitig Eigenschaften sind) den Wert der komplexen Zahl in Kartesischen Koordinaten. Die beiden anderen Eigenschaften (Ang und Len) repräsentieren die Zahl in Polar-Koordinaten. Allerdings werden sie nicht direkt abgespeichert, sondern in privaten Eigenschaftenprozeduren jeweils aus Re und Im berechnet. Dieses Feature ist auch der Grund, warum für TKomplexN eine einfacher Strukturtyp (Record) weniger geeignet ist. type TKomplexN = class(TObject) // Klasse für komplexe Zahlen private function getAngle: Double; // Eigenschaftenprozedur für Lesezugriff auf Ang procedure setAngle(a: Double); // dto. für Schreibzugriff function getLength: Double; // Eigenschaftenprozedur für Lesezugriff auf Len procedure setLength(l: Double); // dto. für Schreibzugriff public Re, Im: Double; // Eigenschaften: Real- und Imaginärteil (speichern Zustand) property Ang: Double read getAngle write setAngle; // Eigenschaft: Winkel property Len: Double read getLength write setLength; // Eigenschaft: Betrag constructor Neu(r, i:Double); // zum Erzeugen und Initialisieren end; 1

Die UML (Unified Modelling Language) stellt dazu spezielle Werkzeuge bereit, wie sie teilweise auch in den Tools von Borland Delphi 7 Architect umgesetzt wurden.

1695

29.10 Klassen für wissenschaftliche Anwendungen

Die Klasse TKomplexOp stellt die drei Methoden addK, multK und divK als so genannte Klassenmethoden (Präfix class) zur Verfügung. Diese Methoden werden nicht auf Objekten, sondern direkt auf der Klasse ausgeführt, was den clientseitigen Code vereinfacht (es brauchen keine Instanzen gebildet werden). Eine weitere Methode init sorgt dafür, dass ein Objekt Z für die Rückgabe des Ergebnisses einer komplexen Rechenoperation zur Verfügung gestellt wird. type TKomplexOp = class(TObject) // Klasse für komplexe Rechenoperationen public // Klassenmethoden: class function addK(A, B: TKomplexN): TKomplexN; class function multK(A, B: TKomplexN): TKomplexN; class function divK(A, B: TKomplexN): TKomplexN; class procedure init; end; implementation var Z: TKomplexN;

// Objektvariable für Rückgabewert

Bei der Implementierung der Methoden von TKomplexN fällt auf, dass sie ausschließlich auf die Objektfelder Re und Im zugreifen: constructor TKomplexN.Neu(r, i: Double); // erzeugt und initialisiert Objekt begin Re := r; Im := i end; function TKomplexN.getAngle: Double; // liefert Winkel in Grad var g: Double; begin if Re<>0 then begin g:=180/Pi*ArcTan(Im/Re); if Re<0 then g:=g+180 end else begin if Im<>0 then if Im>0 then g:=90 else g:=-90 end; Result := g end; procedure TKomplexN.setAngle(a: Double); // setzt Winkel (in Grad) var b, l: Double; begin b:= a*Pi/180; // Umwandlung Grad => Bogenmaß l := getLength; Re := l*cos(b); // neuer Realteil Im := l*sin(b) // neuer Imaginärteil end; function TKomplexN.getLength: Double; begin

// liefert Betrag

1696

Kapitel 29

How-to: Wissenschaft/Technik

Result := Sqrt(Re * Re + Im * Im) end; procedure TKomplexN.setLength(l: Double); // setzt Betrag var b: Double; begin b := ArcTan(Im/Re); Re := l * cos(b); Im := l * s in(b) end;

Bei der Implementierung der Klassenmethoden für TKomplexOp werden Objektvariablen vom Typ TKomplexN miteinander verknüpft: class procedure TKomplexOp.Init; begin Z := TKomplexN.Create() end;

// erzeugt einmalig Objektvariable für Rückgabewert

class function TKomplexOp.addK(A, B: TKomplexN): TKomplexN; begin Z.Re := A.Re + B.Re; Z.Im := A.Im + B.Im; Result := Z end;

// Addition kompl. Zahlen

class function TKomplexOp.multK(A, B: TKomplexN): TKomplexN; // Multiplikation kompl. Zahlen begin Z.Re:=A.Re*B.Re-A.Im*B.Im; Z.Im:=A.Re*B.Im+A.Im*B.Re; Result := Z end; class function TKomplexOp.divK(A, B: TKomplexN): TKomplexN; begin Z.Re:=(A.Re*B.Re+A.Im*B.Im)/(B.Re*B.Re+B.Im*B.Im); Z.Im:=(A.Im*B.Re-A.Re*B.Im)/(B.Re*B.Re+B.Im*B.Im); Result := Z end; end.

// Division kompl. Zahlen

Vielleicht sticht Ihnen bereits jetzt ein gravierender Unterschied zum Vorgänger-Rezept ins Auge: Die beiden Methoden zur Umrechnung zwischen Kartesischen- und Polar-koordinaten sind weggefallen, da ein Objekt vom Typ TKomplexN beide Darstellungen bereits als Eigenschaften kapselt!

Quelltext für Testprogramm Der clientseitige Quellcode entspricht vom prinzipiellen Ablauf her dem Vorgänger-Rezept, ist allerdings erheblich übersichtlicher und problemnäher geworden, denn wir arbeiten jetzt mit drei

29.10 Klassen für wissenschaftliche Anwendungen

1697

Objektvariablen, die bereits komplexe Zahlen modellieren, und nicht mehr mit einer Vielzahl skalarer Variablen. Der interessante Teil des implementation-Abschnitts: uses Komplex; var A, B, Z: TKomplexN;

// Klassen TKomplexN und TKomplexOp einbinden! // Objektvariablen (drei komplexe Zahlen)

procedure TForm1.FormCreate; // Formular laden und Objekte initialisieren begin A := TKomplexN.Neu(1, 1); B := TKomplexN.Neu(1, 1); TKomplexOp.init; // initialisiert Z Z := TKomplexOp.addK(A, B); Anzeige end; procedure TForm1.Eingabe; var z: Double; code: Integer; begin if RadioGroup1.ItemIndex = 0 then begin // Rechteck-Koordinaten Val(Edit1.Text, A.Re, code); Val(Edit2.Text, B.Re, code); Val(Edit4.Text, A.Im, code); Val(Edit5.Text, B.Im, code) end else begin // Polar-Koordinaten Val(Edit1.Text, z, code); A.Len := z; Val(Edit2.Text, z, code); B.Len := z; Val(Edit4.Text, z, code); A.Ang := z; Val(Edit5.Text, z, code); B.Ang := z end end; procedure TForm1.Verarbeitung; begin if RadioButton1.Checked then Z := TKomplexOp.addK(A, B); // Addition if RadioButton2.Checked then Z := TKomplexOp.multK(A, B); // Multiplikation if RadioButton3.Checked then if (B.Re <> 0) or (B.Im <> 0) then // Division Z := TKomplexOp.divK(A, B) end; procedure TForm1.Anzeige; var s: string; begin if Radiogroup1.ItemIndex = 0 then begin // Rechteck-Koordinaten Label1.Caption := 'Realteil A'; Label2.Caption := 'Realteil B'; Label3.Caption := 'Realteil C'; Label4.Caption := 'Imaginärteil A'; Label5.Caption := 'Imaginärteil B'; Label6.Caption := 'Imaginärteil C'; Str(A.Re:8:2,s); Edit1.Text:= s; // Anzeige Realteil A Str(A.Im:8:2,s); Edit4.Text:= s; // Anzeige Imaginärteil A

1698

Kapitel 29

How-to: Wissenschaft/Technik

Str(B.Re:8:2,s); Edit2.Text:= s; // Anzeige Realteil B Str(B.Im:8:2,s); Edit5.Text:= s; // Anzeige Imaginärteil B Str(Z.Re:8:2,s); Edit3.Text:= s; // Anzeige Realteil Z Str(Z.Im:8:2,s); Edit6.Text:= s // Anzeige Imaginärteil Z end else begin // Polarkoordinaten Label1.Caption := 'Betrag A'; Label2.Caption := 'Betrag B'; Label3.Caption := 'Betrag C'; Label4.Caption := 'Winkel A'; Label5.Caption := 'Winkel B'; Label6.Caption := 'Winkel C'; Str(A.Len:8:2,s); Edit1.Text:= s; // Anzeige Betrag A Str(A.Ang:8:2,s); Edit4.Text:= s; // Anzeige Winkel A Str(B.Len:8:2,s); Edit2.Text:= s; // Anzeige Betrag B Str(B.Ang:8:2,s); Edit5.Text:= s; // Anzeige Winkel B Str(Z.Len:8:2,s); Edit3.Text:= s; // Anzeige Betrag Z Str(Z.Ang:8:2,s); Edit6.Text:= s // Anzeige Winkel Z end end;

Der weitere Quellcode ist identisch zum Vorgänger-Rezept.

Test Es gibt rein äußerlich keinerlei Unterschied zum Vorgänger-Rezept! Man sieht also einem objektorientierten Programm seine Herkunft nicht an. Die Vorteile liegen aber bekanntermaßen in der leichteren Lesbarkeit des Quellcodes ("sprechender" Code) und in der problemlosen Wartbarkeit und Erweiterungsfähigkeit.

30

How-to: Sonstiges

Kapitel

30

How-to: Sonstiges 30.1 Den Fensterinhalt in die Zwischenablage kopieren Jeder, der einigermaßen mit Windows vertraut ist, kennt die Möglichkeit, durch Drücken der PrintTaste den kompletten Bildschirminhalt in die Zwischenablage zu übertragen, um die Bitmap von dort aus in andere Applikationen (z.B. Textverarbeitungsprogramm) einzufügen. Wenn nur der Inhalt des aktuellen Fensters kopiert werden soll, dann sind Alt- und Druck-Taste gemeinsam zu betätigen. Wir aber wollen diese Aufgabe nicht manuell, sondern per Programmsteuerung erledigen. Das folgende Testprogramm ist hervorragend geeignet, das Zusammenspiel der wichtigsten Grafikund GDI-Funktionen anschaulich zu demonstrieren.

Oberfläche Zusätzlich zu den Buttons füllen Sie das Formular (Form1) mit irgendwelchen Symbolen (ShapeControls) und Image-Komponenten, so dass auch einige Steuerelemente in der Fenstergrafik vorhanden sind und wir überprüfen können, ob tatsächlich alles in der Zwischenablage landet.

1700

Kapitel 30

How-to: Sonstiges

Quelltext Der erste Event-Handler procedure TForm1.Button1Click(Sender: TObject); var fensterinhalt: TBitmap; begin fensterinhalt := GetFormImage; Clipboard.Assign(fensterinhalt); end;

// Fenster kopieren

kopiert den Clientbereich des aktuellen Fensters in die Zwischenablage. Die Methode GetFormImage liefert uns gleich eine fix und fertige Grafik. Einfacher kann es eigentlich nicht mehr gehen. Um aber den ganzen Screen in die Zwischenablage zu kopieren, müssen wir schon etwas mehr Aufwand betreiben. Ohne GDI läuft hier nichts mehr. Auf diese Weise lernen Sie ganz nebenbei auch, wie die Zwischenablage ohne Objekte programmiert wird. procedure TForm1.Button2Click(Sender: TObject); var dx,dy : integer; // Abmessungen der Bitmap in Pixeln hSourcDC,hDestDC, // Handles auf Quell- und Ziel-DC hBM, hbmOld : THandle; // Handle auf Bitmap begin dx := screen.width; dy := screen.height;

// Breite des Bildausschnitts // Höhe des Bildausschnitts

Einen Gerätekontext vom Screen holen: hSourcDC := CreateDC('DISPLAY',nil,nil,nil);

"Kompatiblen" Gerätekontext und Bitmap vom Screen erstellen: hDestDC := CreateCompatibleDC(hSourcDC); hBM := CreateCompatibleBitmap(hSourcDC, dx, dy); hbmold := SelectObject(hDestDC, hBM);

Bitmap kopieren: BitBlt(hDestDC, 0, 0, dx, dy, hSourcDC, 0, 0, SRCCopy);

Clipboard auf, OpenClipBoard(form1.handle);

löschen, EmptyClipBoard;

füllen SetClipBoardData(CF_Bitmap, hBM);

und wieder zu: CloseClipBoard;

30.2 Die Zwischenablage automatisch speichern

1701

Bitmap-Objekt löschen: SelectObject(hDestDC,hbmold); DeleteObject(hbm);

Gerätekontext löschen: DeleteDC(hDestDC); DeleteDC(hSourcDC); end;

Test Starten Sie das Programm und klicken Sie auf die Tasten "Fenster kopieren" bzw. "Screen kopieren". Anschließend überzeugen Sie sich (z.B. in Windows Paintbrush oder Word) davon, dass tatsächlich der komplette Inhalt des Formulars/Screens in der Zwischenablage gelandet ist.

Ergänzungen ■ Möchten Sie das eigene Fenster nicht auf dem Screenshot haben, blenden Sie es einfach mit Hide aus. Siehe dazu Ä 19.32 Einen Desktop-Screenshot anfertigen ■ Es dürfte auch von Interesse sein, mittels Maus einen beweglichen Rahmen aufzuziehen, um nur einen begrenzten Bildschirmausschnitt zu kopieren. Verwenden Sie hierfür die API-Funktion SetCapture, mit der sämtliche Mausereignisse (unabhängig von der Mauszeigerposition) an ein bestimmtes Fenster gesendet werden. Siehe auch Ä 19.30 Einen Markierungsrahmen erzeugen

30.2 Die Zwischenablage automatisch speichern Wer hatte nicht schon einmal das Problem, mehrere Grafiken oder Textabschnitte über die Zwischenablage in eine andere Anwendung zu kopieren? Möchten Sie zum Beispiel eine Grafik aus einer Anwendung ausschneiden und als Datei speichern, müssen Sie mehr Tasten drücken, als Ihnen lieb ist. Das Beispielprogramm soll diesem Missstand abhelfen. Ändert sich der Zwischenablageinhalt, sichert das Programm die Daten auf der Festplatte. Voraussetzung ist allerdings, dass es sich um Texte (TXT), Bitmaps (BMP) oder Vektorgrafiken (WMF, EMF) handelt. Gleichzeitig erfahren Sie, wie Sie mit Delphi eine Windows-Botschaft abfangen und auswerten können (Ereignisprozeduren dieser Art sind nicht vordefiniert!).

Oberfläche Den grundsätzlichen Aufbau der Oberfläche entnehmen Sie bitte der Abbildung (links neben Memo1 ist eine Image-Komponente platziert):

1702

Kapitel 30

How-to: Sonstiges

Image und Memo werden wir dafür verwenden, den Zwischenablageinhalt aufzunehmen. Mit den Objektmethoden lassen sich dann die Grafiken bzw. der Text speichern. Über die Checkboxen können Sie wählen, welche Datentypen gespeichert werden sollen. Die vom Programm erzeugten Dateien erhalten eine laufende Nummer, deren Startwert Sie mit den SpinButtons festlegen. Bereits vorhandene Dateien werden natürlich gnadenlos gelöscht. Das große Memofeld auf der rechten Seite dient als Protokoll, jede gespeicherte Datei wird aufgelistet.

Quelltext Das Hauptproblem dieser Anwendung besteht darin, eine Änderung des Zwischenablageinhalts zu registrieren. Eine Polling-Schleife und der dauernde Vergleich mit dem letzten Durchlauf dürften sich aus Performance-Gründen verbieten. Ein Blick in die Windows-API verrät, dass die Änderung des Zwischenablageinhalts mit einer Windows-Botschaft "angezeigt" wird. Zwei Probleme bleiben allerdings bestehen: ■ Wie erhalte ich diese Botschaft? ■ Wie werte ich sie aus? Die Lösung des ersten Problems besteht darin, sich in die Kette von Zwischenablagebetrachtern "einzuklinken", da nur diese die Botschaft WM_DrawClipboard erhalten. Problem Nummer zwei lösen wir mit einem eigenen Message-Handler. Fügen Sie dazu in den protected-Abschnitt der Objektdefinition folgende Zeile ein: procedure WMDrawClipboard(var Message: TMessage); message WM_DrawClipboard;

Der hinter message eingefügte Bezeichner muss der Name einer Windows-Botschaft sein. Sie finden diese in der API-Hilfe. Der Bezeichner der neuen "Ereignisprozedur" leitet sich aus dem Namen der Botschaft ab (entfernen Sie einfach den Unterstrich). Als Parameter verwenden Sie den Type TMessage, dieser kapselt bereits die Parameter WParam und LParam, die bei der "normalen" Windows-Botschaftsbehandlung Verwendung finden.

30.2 Die Zwischenablage automatisch speichern

1703

Im private-Abschnitt deklarieren Sie einige Variablen, die wir für die interne Verwaltung benötigen: private { Private-Deklarationen } nextviewer : hwnd; wmf_counter, bmp_counter, txt_counter : Integer;

Nach dem Programmstart ordnen wir das Programm in die Kette der Zwischenablagebetrachter ein und merken uns das Handle des nächsten Viewers. procedure TForm1.FormCreate(Sender: TObject); begin nextviewer:= setClipboardViewer(Form1.Handle); wmf_counter := 0; bmp_counter := 0; txt_counter := 0 end;

Dieses Handle benötigen wir beim Beenden des Programms, unser Programm muss aus der Kette entfernt werden: procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin ChangeClipboardChain(Form1.Handle, nextviewer) end;

In diesem Zusammenhang tritt ein weiteres Problem auf, mit dem wir uns herumschlagen müssen: Wir haben zwar das Handle des nächsten Viewers in der Clipboard-Viewer-Kette gespeichert, was passiert aber, wenn sich dieses Fenster zwischenzeitlich von selbst aus der Kette ausklinkt? In diesem Fall ist für uns die Message WM_CHANGECBCHAIN von Interesse, Übergabeparameter sind die Handle des entfernten und des folgenden Fensters in der Kette. Ähnlich wie bei WM_DRAWCLIPBOARD müssen Sie dem protected-Abschnitt eine weitere Deklaration hinzufügen: procedure WMChangeCBChain(var Message: TMessage); message WM_CHANGECBCHAIN;

Die Realisierung: procedure TForm1.WMChangeCBChain(var Message: TMessage); begin if Message.wParam = NextViewer then NextViewer := Message.lParam else if (NextViewer <> NULL) then SendMessage(NextViewer,WM_CHANGECBCHAIN,Message.wParam, Message.lParam) end;

Nach dem Test, ob die Message für unsere Anwendung überhaupt interessant ist, wird gegebenenfalls das Handle des neuen Viewers gespeichert. Sollten sich weitere Fenster in der Betrachterkette befinden, reichen wir die Message weiter.

1704

Kapitel 30

How-to: Sonstiges

Die eigentliche Botschaftsbehandlung erfolgt in der Ereignis-Methode WMDrawClipboard. Nach Änderung des Zwischenablageinhalts müssen wir prüfen, ob eines der drei unterstützten Formate vorhanden ist. Wenn ja, übernehmen wir dieses in die Komponenten und speichern den Inhalt. procedure TForm1.WMDrawClipboard(var Message: TMessage); var s,s1:string; begin inherited; // vererbte Behandlungsroutine aufrufen s1 := DirectoryListbox1.Directory; if Length(s1) = 3 then s1 := Copy(s1,1,2); if Clipboard.Hasformat(CF_Picture) then begin Image1.Picture.Assign(Clipboard); if (Clipboard.Hasformat(CF_Metafilepict))and(Checkbox1.Checked) then begin wmf_counter:= SpinEdit1.Value; s := s1 + '\bild' + IntToStr(wmf_counter) + '.wmf'; inc(wmf_counter); SpinEdit1.Value:=wmf_counter; MessageBeep(0); Image1.Picture.SaveToFile(s); Memo2.Lines.Add(s) end; if (Clipboard.Hasformat(CF_Bitmap))and(Checkbox2.Checked) then begin bmp_counter:= SpinEdit2.Value; s := s1 + '\bild' + inttostr(bmp_counter) + '.bmp'; Inc(bmp_counter); SpinEdit2.Value:=bmp_counter; MessageBeep(0); Image1.Picture.SaveToFile(s); Memo2.Lines.Add(s) end end; if (Clipboard.Hasformat(CF_Text))and(Checkbox3.Checked) then begin txt_counter:= SpinEdit3.Value; Memo1.SelectAll; Memo1.Clear; Memo1.PasteFromClipboard; s := s1 + '\text' + IntToStr(txt_counter) + '.txt'; Inc(txt_counter); SpinEdit3.Value:=txt_counter; Memo1.Lines.SaveToFile(s); MessageBeep(0); Memo2.Lines.Add(s) end; if (NextViewer <> NULL) then SendMessage(NextViewer,WM_DrawClipboard,Message.wParam, Message.lParam) end;

Sie sollten nicht vergessen, die Botschaft an eventuelle weitere Betrachterfenster weiterzugeben.

30.3 Eine Pause realisieren

1705

Test Starten Sie das Programm und markieren Sie die zu speichernden Formate. Legen Sie ein Verzeichnis fest, in dem die Dateien abgelegt werden sollen.

Kopieren Sie nun aus einer anderen Anwendung etwas in die Zwischenablage oder drücken Sie einfach Alt-Druck. Konnte der Zwischenablageinhalt gesichert werden, gibt das Programm einen Piepton aus.

30.3 Eine Pause realisieren Einen Delay-Befehl werden Sie unter Delphi vergeblich suchen, und das ist auch gut so, schließlich ist Windows ein Multitasking-System. Das alte DOS-Delay (Unit CRT) würde das halbe System lahm legen, unser Pausenbefehl sollte sich aber auf die aktuelle Task beschränken.

Variante 1 Mit einer kleinen Prozedur können Sie sich selbst helfen: procedure pause(zeit: LongInt); // Pausenzeit in Millisekunden var zeit1:LongInt; begin zeit1 := GetTickCount; repeat Application.ProcessMessages until (GetTickCount - zeit1 > zeit) end;

Wichtig ist vor allem der Aufruf von ProcessMessages, damit nicht unnötig Systemressourcen verschwendet werden. Ä 27.1 Systemzeit freigeben

1706

Kapitel 30

How-to: Sonstiges

Variante 2 Besser ist allerdings die Verwendung einer API-Funktion. Geben Sie einfach die Anweisung Sleep (5000);

ein. Ihre Anwendung ist für fünf Sekunden in den Tiefschlaf versetzt und benötigt überhaupt keine Rechenzeit mehr. Allerdings lässt sich die Anwendung nicht mehr bedienen, der gesamte Prozess, und dazu gehören auch alle Funktionen der Oberfläche, schläft. Anders verhält sich die obige Prozedur Pause, die auch Ihrer Anwendung Gelegenheit gibt, notwendige Funktionen auszuführen. Lediglich der aktuelle Programmablauf (Ereignisprozedur etc.) ist unterbrochen, andere Ereignisse, z.B. Timer oder MouseClick, können weiterhin ausgelöst werden.

Oberfläche und Test

30.4 Schleifen mit der ESC-Taste abbrechen Wer kennt Sie nicht, die Meldung "Abbruch mit ESC", aber wie kann man dieses Feature in die eigene Anwendung integrieren? Statt umständlich mit Application.ProcessMessages herumzudoktern, gibt es eine elegantere Möglichkeit, um eine Endlosschleife oder eine lange Bearbeitungsschleife abzubrechen.

Oberfläche Ein Button mit der Beschriftung "Starten ..." – und schon kann es losgehen.

Quelltext procedure TForm1.Button1Click(Sender: TObject); begin Button1.Caption := 'Schleife läuft !!!'; while True do if (GetAsyncKeystate(VK_ESCAPE)) <> 0 then Break Button1.Caption := 'Fertig !!!' end;

1707

30.5 Eine Schleife unterbrechen und fortsetzen

Test

30.5 Eine Schleife unterbrechen und fortsetzen Es kommt in der Programmierpraxis öfters vor, dass eine Schleife nicht abgebrochen, sondern nur per Tastatur oder Mausklick unterbrochen werden soll, um anschließend wieder fortgesetzt zu werden. Die Demo zeigt, wie ein solches Verhalten mit Hilfe der ProcessMessages-Methode des Application-Objekts zu realisieren ist.

Oberfläche

Quelltext Zu Beginn des implementation-Abschnitts deklarieren wir zwei initialisierte Variablen: var stop:Boolean = True; i: Integer = 0;

// Stoppsignal // Zählvariable

Als Beispiel dient uns eine Schleife, die von 1 bis zu einer Million hochzählt und dann wieder von vorne beginnt. Ein Abbruch ist nur dann möglich, wenn die Variable stop auf False gesetzt wird: procedure schleife; begin while not stop do begin

1708

Kapitel 30

How-to: Sonstiges

Inc(i); // erhöht i um eins Form1.Panel1.Caption := IntToStr(i);

Die folgende Anweisung ist dringend erforderlich, da ansonsten die Schleife nicht "mitbekommen" würde, wenn sich die Variable stop in False geändert hat: Application.ProcessMessages; if i = 1000000 then i := 0 end end;

// Schleife beginnt wieder von vorne

Der Anwender kann per Mausklick die Schleife unterbrechen bzw. fortsetzen: procedure TForm1.Button1Click(Sender: TObject); begin stop := not stop; if stop then Button1.Caption := 'Weitermachen' else Button1.Caption := 'Anhalten'; schleife end;

Test Trotz Pentium 1000 können doch einige Minuten vergehen, bis die Millionengrenze erreicht ist, da ProcessMessages und die Anzeige im Panel relativ viel Zeit in Anspruch nehmen:

Ein Beenden des Programms bei laufendem Zähler ist nicht möglich, Sie müssen also vorher auf "Anhalten" klicken.

Bemerkungen ■ Ein Anhalten ist auch durch Betätigen der Enter- oder Space-Taste möglich, da der Button den Fokus besitzt. ■ Der Zähler "steht" übrigens auch dann, wenn Sie das Formular verschieben oder die Größe verändern.

30.6 Copyright-Meldungen in eine DLL integrieren

1709

30.6 Copyright-Meldungen in eine DLL integrieren Sie haben eine DLL geschrieben und möchten diese als Demo weitergeben? Damit sich nicht andere Leute mit fremden Lorbeeren schmücken, soll eine Copyright-Meldung beim ersten Aufruf angezeigt werden.

Quelltext Der Grundaufbau der DLL: library ; ... exports ... begin end.

Wenig beachtet, aber nicht überflüssig, ist der begin-end-Teil zum Schluss der DLL. Dieser Teil entspricht etwa dem Hauptprogramm einer EXE-Datei (Sub Main) und wird beim ersten Laden der DLL abgearbeitet (wenn nötig). Wir werden also diesem Abschnitt unsere besondere Aufmerksamkeit widmen. Für das Meldungsfenster verwenden wir die Funktion MessageBox (Unit Windows), die analog zur Methode des Application-Objektes funktioniert. Der Vorteil dieser Funktion ist, dass nicht unbedingt die ganze Objekt-Library eingebunden werden muss. Der erste Parameter ist das Handle des Elternfensters (WndParent). Um auf die Übergabe verzichten zu können, setzen wir diesen auf null (entspricht dem Screen). Mit dem zweiten und dritten Parameter definieren wir den Inhalt der Textbox bzw. deren Überschrift. Abschließend folgt der Typ-Parameter, der sich aus einzelnen Konstanten zusammensetzt. BEISPIEL: Verwendung MessageBox MessageBox(0,'(c) 2000 by Doberenz & Kowalski', 'DLL-DEMO', 64);

Test Zum Austesten verwenden wir eine bereits vorhandene DLL (FormDLL.dll, siehe Buch-CD"). Beim Programmstart erscheint die Copyright-Meldung:

1710

Kapitel 30

How-to: Sonstiges

Bemerkung Da es immer noch Möglichkeiten gibt, die Copyright-Meldung zu ändern, an dieser Stelle ein kleiner Verbesserungsvorschlag für obige Lösung: Verwenden Sie den Verschlüsselungs-Algorithmus aus Ä 29.5 Einen Text verschlüsseln

30.7 Eine Callback-Funktion schreiben Im Zusammenhang mit der Systemprogrammierung werden Sie als Delphi-Programmierer auch mit Callback-Funktionen konfrontiert. Worum handelt es sich? Wie der Name schon andeutet, werden Callback-Funktionen durch eine externe Funktion aufgerufen. Auslöser ist eine Funktion, der ein Pointer auf die Callback-Funktion übergeben wurde. Modul 1

Aufruf externe Funktion

Modul 2

externe Funktion

Callback Funktion

Den prinzipiellen Ablauf können Sie sich wie folgt vorstellen: ■ Modul 1 ruft eine Funktion in Modul 2 auf und übergibt dabei den Zeiger auf eine Funktion in Modul 1. ■ Modul 2 kann jetzt mit Hilfe dieses Pointers die Funktion in Modul 1 beliebig oft aufrufen. Sinnvollerweise legt Modul 2 jedoch vorher Daten auf dem Stack oder in den Registern ab (je nach Aufrufkonvention), die über die Callback-Funktion in Modul 1 ausgewertet werden können. Zwei Beispiele sollen die Anwendung verdeutlichen.

Beispiel 1 (API) Geht es darum, Informationen über die verfügbaren Schriftarten zu ermitteln, können Sie über das Screen-Objekt zwar die Namen abfragen, Informationen über den Schrifttyp (Raster/-TrueType) erhalten Sie jedoch nicht. In diesem Zusammenhang hilft Ihnen eine Callback-Funktion weiter. An die Funktion EnumFonts übergeben Sie neben dem DC, über den Sie Informationen abfragen wollen, einen Pointer auf eine Callback-Funktion.

1711

30.7 Eine Callback-Funktion schreiben

SYNTAX:

function EnumFonts(DC: HDC; lpszFace: Pchar; fntenmprc: TFNFontEnumProc; lpszData: Pchar ): Integer; stdcall;

// // // //

der gewünschte DC Font-Typeface Pointer auf Callback-Routine optionale Daten

procedure TForm1.FormClick(Sender: TObject); begin EnumFonts(canvas.handle, nil, @EnumFontsCallback, nil); end;

Die Callback-Funktion (wichtig ist die Deklaration als stdcall): function EnumFontsCallback(var LogFont: TLogFont; var TextMetric: TTextMetric; FontType: Integer; Data: Pointer): Integer; stdcall; var zw : string; begin case Fonttype of DEVICE_FONTTYPE : zw := ' (Geräte-Font)'; RASTER_FONTTYPE : zw := ' (Raster-Font)'; TRUETYPE_FONTTYPE : zw := ' (TrueType-Font)'; end; form1.Listbox2.items.Add(LogFont.lfFaceName + zw); Result := 1; end;

Nach der Ausführung von EnumFonts wird die obige Funktion für jeden verfügbaren Font einmal durch das System aufgerufen. Voraussetzung für die obigen Aufrufe ist allerdings die Definition in der Unit Windows: ... TFarProc = Pointer; TFNFontEnumProc = TFarProc; ... function EnumFonts(DC: HDC; lpszFace: PChar; fntenmprc: TFNFontEnumProc; lpszData: PChar): Integer; stdcall;

HINWEIS: Möchten Sie die Aufrufe der Callback-Funktion abbrechen, geben Sie statt des Rück-

gabewertes 1 einfach eine 0 zurück (Result).

Beispiel 2 (selbst definierte Funktion) In einem weiteren Beispiel wollen wir eine eigene Callback-Funktion entwickeln. Dazu werden wir zunächst ein Listenfeld (ListBox1) mit den verfügbaren Schriftarten füllen. procedure TForm1.FormCreate(Sender: TObject); begin ListBox1.Items:= Screen.Fonts end;

Über eine Callback-Funktion soll ein weiteres Listenfeld (ListBox2) mit den Einträgen gefüllt werden, die im ersten Listenfeld markiert (Selected = True) sind.

1712

Kapitel 30

How-to: Sonstiges

Definition eines Callback-Prototyps: TTestCallback = function(s: string): integer;

Realisierung der Initialfunktion, über die wir die Callback-Funktion aufrufen werden. Wie oft das geschieht, hängt von der Anzahl der Einträge im Listenfeld ab. procedure GetFonts(TestCallBack:TTestCallBack ); var i: Integer; begin for I:= 0 to Form1.ListBox1.Items.Count-1 do if Form1.ListBox1.Selected[i] then TestCallback(Form1.ListBox1.Items[i]) end;

Damit ist der erste Teil realisiert, wir können uns der Aufrufer-Seite zuwenden. Definition der Callback-Funktion: function MyCallback(s:String): Integer; begin Form1.ListBox2.Items.Add(s) end;

Aufruf der Initialfunktion mit Übergabe der Callback-Funktionsadresse: procedure TForm1.Button1Click(Sender: TObject); begin GetFonts(MyCallback) end;

Test Nach Programmstart werden links alle verfügbaren Schriftarten angezeigt. Selektieren Sie mehrere Schriftarten und befördern Sie diese nach rechts!

30.8 Eine Backup-Funktion schreiben

1713

Bemerkungen ■ Anwendungsmöglichkeiten finden sich beispielsweise in DLLs. Statt einer endlosen Liste von Funktionsrückgabewerten können Sie eine Callback-Schnittstelle bereitstellen, über welche die Daten bei Bedarf angefordert werden. ■ Ähnlich arbeitet auch die Funktion LineDDA, mit der Sie selbst definierte Linien zeichnen können. Sie müssen die Umsetzung in einer Funktion LineDDAProc realisieren, wenn Windows diese für einen neuen Punkt anfordert.

30.8 Eine Backup-Funktion schreiben Folgendes Problem soll durch ein kleines Delphi-Programm gelöst werden: Sie möchten eine Datei von 8 MByte (z.B. eine Datenbank) auf Disketten sichern. Der Kopieralgorithmus sollte also in der Lage sein, eine Datei auf mehrere Disketten aufzuteilen. Der umgekehrte Weg (Restore) muss ebenfalls implementiert werden. Natürlich wollen wir an dieser Stelle keine Komplettlösung vorstellen, es geht vielmehr darum, die grundsätzliche Vorgehensweise zu erläutern. Ganz nebenbei ist die Anwendung ein gutes Beispiel für den Einsatz von Streams.

Oberfläche Den grundsätzlichen Aufbau der Oberfläche entnehmen Sie bitte der folgenden Abbildung.

Sie erkennen zwei DriveComboBoxen, eine DirectoryListBox, eine FileListBox und (rechts mittig) eine normale ListBox.

1714

Kapitel 30

How-to: Sonstiges

Auf der zweiten Seite der PageControl-Komponente befinden sich die Komponenten für den Restore-Vorgang.

Quelltext Bevor wir uns auf den Quellcode stürzen, sollten wir uns einige Details näher ansehen. Beim Backup wird es sicherlich nicht ausreichen, einfach alle Bytes der Quelldatei in entsprechenden Häppchen auf n Disketten zu verteilen. Was wir brauchen, sind einige zusätzliche Informationen, die es uns ermöglichen, die Datei auch wiederherzustellen. Das betrifft vor allem die Reihenfolge, in der die Daten abgelegt wurden (Diskettennummer), der ursprüngliche Dateiname sowie die Dateigröße. Wir werden diese Informationen in einem Header auf jeder Datendiskette speichern: type Tinfo = record Volume : Byte; dateiname: String[255]; fileSize : Longint; end; var Info : TInfo;

Sollten spätere Erweiterungen nötig werden, genügt es, den Header zu verändern. Mit einer Konstanten legen wir weiterhin fest, ab wie vielen verfügbaren Bytes eine Diskette als leer interpretiert wird: const MinByteFrei = 10000;

// mindestens freie Bytes

Mit der Hilfsfunktion LeereDisketteEinlegen werden wir prüfen, ob die mindestens erforderliche Anzahl von Bytes frei ist. Gegebenenfalls wird der Anwender aufgefordert, eine leere Diskette einzulegen.

30.8 Eine Backup-Funktion schreiben

1715

Weiterhin testen wir zur Sicherheit auf das Vorhandensein einer älteren Backup-Datei. function LeereDisketteEinlegen(lw:char): Boolean; begin while (diskfree(ord(lw)-64) < MinByteFrei) do begin if Messagebox(0,'Legen Sie eine leere Diskette ein!','Hinweis', 33) = 2 then begin Result := False; Form1.Listbox1.Visible := False; Exit end end; while FileExists(lw + ':\Backup.dat') do begin if Messagebox(0,'Backup-File existiert bereits!','Hinweis', 33) = 2 then begin Result := False; Form1.Listbox1.Visible := False; Exit end end; Result := True end;

Der eigentliche Backup-Algorithmus: procedure TForm1.BitBtn2Click(Sender: TObject); var von,nach : TFileStream; anzahl : LongInt; lw : String[1]; begin

Falls keine Datei in der Listbox ausgewählt wurde: if FileListbox1.ItemIndex = -1 then begin ShowMessage('Es muss eine Datei gewählt werden!'); Exit end; lw := UpperCase(Copy(DriveCombobox2.Drive,1,1));

Öffnen der Quelldatei als Stream: von := TFileStream.Create(FileListbox1.FileName,fmOpenRead); info.Volume := 0; info.Dateiname := FileListbox1.Items[FileListbox1.ItemIndex]; info.FileSize := von.Size; Listbox1.Items.Clear; Listbox1.Visible := True;

So lange der Position-Zeiger im Quell-Stream nicht das Ende erreicht hat, müssen weitere Disketten beschrieben werden: While (von.position < von.Size) do begin Listbox1.Items.Add('Leere Diskette einlegen ...'); if not LeereDisketteEinlegen(lw[1]) then Exit; Inc(info.Volume);

1716

Kapitel 30

How-to: Sonstiges

Anlegen der neuen Datei auf Diskette über einen Stream: nach := TFileStream.Create(lw + ':\Backup.dat', fmCreate); Listbox1.Items.Add('Kopiere Diskette' + IntToStr(info.Volume)); Application.ProcessMessages;

Den Datei-Header in den Stream (sprich die Datei) schreiben: nach.Write(info,SizeOf(Info)); anzahl := Diskfree(ord(lw[1])-64) - SizeOf(info); if (von.Size - von.Position) < anzahl then anzahl := (von.Size - von.Position);

Der eigentliche Kopiervorgang: nach.CopyFrom(von, anzahl);

Geschrieben werden so viele Bytes, wie noch auf den Datenträger passen. Sollte dieser Wert größer als die noch zu schreibende Datenmenge sein, wird deren Größe verwendet. Schließen des Streams (Ziel-Datei): nach.Free end; Listbox1.Items.Add('Backup abgeschlossen!'); von.Free; ShowMessage('Backup abgeschlossen!'); Listbox1.Visible := False end;

Damit sind die Daten erst einmal auf den Datenträgern. Für das Zurücklesen (Restore) brauchen wir ebenfalls einen Algorithmus. In diesem Zusammenhang wird Anhängern der strukturierten Programmierung ein Jump wie ein Dorn ins Auge stechen, die Autoren waren jedoch der Meinung, dass die gefundene Lösung besser ist als eine weitere Repeat-Until-Schleife. procedure TForm1.BitBtn3Click(Sender: TObject); var disknr : Byte; von,nach : TFileStream; s, p : string; p : PChar; label m1; begin disknr := 1; ziel := DirectoryListbox2.Directory; if Copy(ziel,Length(ziel),1) <> '\' then ziel := ziel + '\'; repeat s := Format('Legen Sie die Diskette Nr %d ein', [disknr]); m1: P := StrAlloc(Length(s)); StrPCopy(p,s); If Messagebox(0,p,'Hinweis', 33) = 2 Then Exit; StrDispose(p);

30.8 Eine Backup-Funktion schreiben

1717

An dieser Stelle wird versucht, auf der Diskette die Datei Backup.dat zu öffnen: von := TFileStream.Create(Copy(DriveCombobox3.Drive,1,1) + ':\Backup.dat',fmOpenRead);

Sollte dies von Erfolg gekrönt sein, lesen wir den Datei-Header aus: von.Read(info, SizeOf(info));

Wenn es jetzt auch noch die richtige Diskette ist (Diskettennummer), können wir damit beginnen, die Datei zu kopieren, andernfalls ist eine erneute Aufforderung an den Programmnutzer fällig: if info.Volume <> disknr then begin {falsche Diskette} von.Free; goto m1 end; if info.Volume = 1 then nach := TFileStream.Create(ziel + info.dateiname,fmCreate); Inc(disknr); nach.CopyFrom(von, von.Size - von.Position); von.Free;

Das Ganze betreiben wir so lange, bis auch das letzte Byte wieder auf der Festplatte gelandet ist: until nach.Size = info.FileSize; nach.Free; ShowMessage('Restore abgeschlossen!') end;

Test Probieren Sie die verschiedenen Backup-Medien aus!

1718

Kapitel 30

How-to: Sonstiges

Ergänzungen ■ Durch die Flexibilität bei der Arbeit mit Streams dürfte es kein großes Problem darstellen, zusätzliche Pack- oder Verschlüsselungs-Algorithmen zu implementieren. ■ Eine Erweiterung auf mehr als eine Datei ist ebenfalls denkbar, dazu müsste der Header entsprechend mehr Einträge aufweisen.

30.9 Daten im MS Excel-Format exportieren Häufig steht der Programmierer vor dem Problem, nicht nur Daten anzuzeigen oder zu verwalten, sondern diese Daten auch anderen Programmen zur Verfügung zu stellen. Insbesondere im Bereich "Statistische Auswertung" hat sich das XLS-Format als Quasi-Standard durchgesetzt. Doch wie bekommt man die Daten in das Excel-Format konvertiert? Die Variante per OLE-Automatisierung ist zum einen langsam, zum anderen setzt sie auch eine lauffähige Installation von Excel voraus. Die Verwendung der Jet-Engine ist auch nicht die ideale Lösung, das Programm wird unnötig aufgebläht, und eine vorinstallierte Engine ist auch nötig. Eine einfache, dafür aber schnelle und effiziente Lösung bietet sich mit dem BIFF-Format. Bis auf einige Dateifunktionen (ganz nebenbei lernen Sie auch die Verwendung von FileStreams kennen) brauchen wir keine externen Funktionen oder Objekte. Diese Vorteile bezahlen wir jedoch mit dem Nachteil, keinerlei Formatierungen innerhalb der Zellen vornehmen zu können. Lediglich den Datentyp (Integer, Double oder String) können wir für die Tabellenzellen bestimmen.

Quelltext (Unit) Die vorgestellte Umsetzung soll Ihnen neben der reinen Exportlösung auch die Vorteile der objektorientierten Programmierung verdeutlichen: ■ Wir realisieren die Export-Funktionen im Rahmen einer Klasse TXlsExport. ■ Sowohl für den Export von Integer-/Double-Werten als auch für String-Werte wird die gleiche Methode (Write) verwendet, mit Hilfe der Overload-Anweisung können unter dem gleichen Methodenbezeichner gänzlich andere Datentypen oder auch Parameter übergeben werden. Der Compiler kann anhand der übergebenen Datentypen die richtige Methode auswählen. Die Deklaration der Klasse: unit u_ExportEXCEL; interface uses Classes; type TXLSExport = class(TObject) private fs : TFileStream; public constructor Create(filename : string); destructor Destroy; override;

1719

30.9 Daten im MS Excel-Format exportieren

procedure Write(const Col, Row: Word; const Value: Integer); overload; procedure Write(const Col, Row: Word; const Value: Double); overload; procedure Write(const Col, Row: Word; const Value: string); overload; end; implementation

Einige Konstanten für die Umsetzung der BIFF-Syntax: const CXlsBof CXlsEof CXlsLabel CXlsNumber CXlsRk

: : : : :

array[0..5] array[0..1] array[0..5] array[0..4] array[0..4]

of of of of of

Word Word Word Word Word

= = = = =

($809, 8, 00, $10, 1, 0); ($0A, 00); ($204, 0, 0, 0, 0, 0); ($203, 14, 0, 0, 0); ($27E, 10, 0, 0, 0);

Im Konstruktor öffnen wir einen FileStream (der Name muss übergeben werden): constructor TXLSExport.Create(filename : string); begin inherited Create; fs := TFileStream.Create(filename,fmCreate); fs.WriteBuffer(CXlsBof, SizeOf(CXlsBof)) end;

Der Destruktor ist für das saubere Schließen der Datei verantwortlich: destructor TXLSExport.Destroy; begin fs.WriteBuffer(CXlsEof, SizeOf(CXlsEof)); inherited Destroy end;

Die erste Export-Methode zum Schreiben eines Integer-Wertes in eine bestimmte Zelle: procedure TXLSExport.Write(const Col, Row: Word; const Value: Integer); var v: Integer; begin CXlsRk[2] := Row; CXlsRk[3] := Col; fs.WriteBuffer(CXlsRk, SizeOf(CXlsRk)); v := (Value shl 2) or 2; fs.WriteBuffer(v, 4) end;

Die zweite Implementation von Write unterscheidet sich sowohl bei den Parametern als auch bei der Umsetzung: procedure TXLSExport.Write(const Col, Row: Word; const Value: Double); begin CXlsNumber[2] := Row; CXlsNumber[3] := Col; fs.WriteBuffer(CXlsNumber, SizeOf(CXlsNumber));

1720

Kapitel 30

How-to: Sonstiges

fs.WriteBuffer(Value, 8) end; procedure TXLSExport.Write(const Col, Row: Word; const Value: string); var l: Word; begin l := Length(Value); CXlsLabel[1] := 8 + l; CXlsLabel[2] := Row; CXlsLabel[3] := Col; CXlsLabel[5] := l; fs.WriteBuffer(CXlsLabel, SizeOf(CXlsLabel)); fs.WriteBuffer(Pointer(Value)^, l) end; end.

Oberfläche (Testprogramm) Unser kleines Testprogramm soll den Export einer Datenbanktabelle demonstrieren. Sie können jedoch auf dem gleichen Weg auch beliebige andere Daten in das XLS-Format umsetzen. HINWEIS: Beachten Sie die jeweiligen Datentypen. Damit Excel auch mit den Werten rechnen

kann, müssen diese auch als Integer oder Double gespeichert werden. Fügen Sie einem Formular eine Table-, eine DataSource- und eine DBGrid-Komponente hinzu ("BDE"-, "Datenzugriff"- bzw. "Datensteuerung"-Seite der Komponentenpalette). Die DatabaseName-Eigenschaft der Table legen Sie mit DBDemos fest, als TableName wählen Sie bitte "employee.db" aus. Table- und DataSource-Komponente verknüpfen Sie über die DataSet-Eigenschaft. Das DBGrid binden Sie über die DataSource-Eigenschaft an die DataSource. Die Tabelle kann schon zur Entwurfszeit geöffnet werden, setzen Sie dazu die Active-Eigenschaft der Table-Komponente auf True. Fügen Sie noch eine SaveDialog-Komponente ("Dialoge"-Seite) ein.

30.9 Daten im MS Excel-Format exportieren

1721

Quelltext (Testprogramm) Binden Sie die neue Unit ein: uses u_ExportEXCEL;

Zur Bestimmung des Dateinamens benutzen wir den SaveDialog: procedure TForm1.Button1Click(Sender: TObject); var XLSFile : TXLSExport; x, y : Integer; begin if SaveDialog1.Execute then begin

Ist die Datei bereits vorhanden, wird sie gelöscht: if fileExists(SaveDialog1.Filename) then DeleteFile(SaveDialog1.Filename);

Wir erzeugen eine neue Instanz der Klasse: XLSFile := TXLSExport.Create(SaveDialog1.Filename); try y := 0; Table1.DisableControls; Table1.First;

Für alle Tabellenzeilen: while not Table1.Eof do begin

Handelt es sich um die erste Zeile, tragen wir vor den Daten noch schnell die Tabellenköpfe (Spaltennamen) ein: if y = 0 then begin // Kopfzeilen for x := 0 to Table1.FieldCount-1 do XLSFile.Write( x, y, Table1.Fields[x].displayname); end else for x := 0 to Table1.FieldCount-1 do begin

Je nach Feld-Datentyp speichern wir als String, Integer oder Double: case Table1.Fields[x].DataType of ftDate,ftTime, ftDateTime, ftBoolean, ftString, ftFixedChar : XLSFile.Write( x, y, Table1.Fields[x].asstring); ftAutoInc, ftSmallint, ftInteger, ftWord : XLSFile.Write( x, y, Table1.Fields[x].asInteger); ftFloat, ftCurrency : XLSFile.Write( x, y, Table1.Fields[x].asFloat); end

1722

Kapitel 30

How-to: Sonstiges

end; Inc(y); Table1.Next end;

Endgültiges Speichern der Tabelle: XLSFile.Free; finally end; Table1.EnableControls; end end;

Test Starten Sie das Programm und speichern Sie die Tabellendaten. Die Datei können Sie wie gewohnt in MS Excel öffnen oder auch in andere Anwendungen importieren:

Bemerkung Wollen Sie Excel direkt nach dem Erzeugen der Datei starten, so tritt das Problem auf, dass nicht auf die Datei zugegriffen werden kann. Abhilfe schafft eine Erweiterung des Destruktors für den Typ TXLSExport:

30.10 Ressourcen einbinden

1723

destructor TXLSEcxport.Destroy; fs.WriteBuffer(CXlsEof, SizeOf(CXlsEof)); fs.Free; inherited Destroy; end;

30.10 Ressourcen einbinden Eigentlich ist die Verwendung von Ressourcen mit Delphi wieder aus der Mode gekommen, obwohl es in vielen Fällen sinnvoll ist, Beschriftungen oder Messagebox-Texte nicht in den Quelltext zu integrieren. Ä 30.12 Mehrsprachige Anwendungen entwickeln Für das folgende Beispiel sollten Sie über einen Ressourcen-Editor verfügen (zum Beispiel den von MS VC++) oder Sie verwenden einen normalen Texteditor, erstellen ein Ressourcen-Script und compilieren dieses mit dem Borland-Ressource-Compiler (BRC32.EXE).

Oberfläche Den Aufbau der Oberfläche entnehmen Sie bitte der Grafik. Über den Button werden wir eine Messagebox anzeigen, im Label wird ein Copyright aus der Ressourcen-Datei ausgegeben.

Ressourcen-Editor Falls Sie nicht über einen komfortablen Ressourcen-Editor verfügen, so öffnen Sie das Programm Notepad und erstellen damit ein Ressourcen-Script mit folgenden Einträgen:

Die ID-Werte benötigen Sie für den späteren Aufruf. Speichern Sie die Datei als Test.rc im Projektverzeichnis ab und compilieren Sie sie anschließend mit dem zu Delphi mitgelieferten Ressourcen-Editor brc32.exe in die Datei Test.res.

1724

Kapitel 30

How-to: Sonstiges

Der Aufruf am DOS-Prompt: brc32 –r Test.rc

Quelltext Nach dem Einbinden der Ressourcen-Datei {$R TEST.RES}

können Sie auf die enthaltenen Strings, Mauszeiger etc. zugreifen. Strings lassen sich auf zwei verschiedene Arten laden: BEISPIEL: Übergabe als Pointer: procedure TForm1.Button1Click(Sender: TObject); var puffer: array[0..255] of Char; begin LoadString(HINSTANCE,1,@puffer,255); messagebox(0,@puffer,'Information',64); end;

BEISPIEL: Übergabe an String-Datentyp: procedure TForm1.FormCreate(Sender: TObject); var puffer: array[0..255] of char; begin LoadString(HINSTANCE,3,@puffer,255); Label1.Caption := strpas(puffer); end;

Wem beide Varianten zu umständlich sind, der kann auch die folgende Funktion verwenden: function GetResString(Nr: Integer): String; var p: PChar; begin p := StrAlloc(256); LoadString(Hinstance,nr+offset,p,255); result := p; StrDispose(p); end;

Der Vorteil der auf diese Weise eingebundenen Texte ist, dass diese später in der EXE-Datei wieder geändert werden können. Sie brauchen dazu lediglich die EXE in den Ressourcen-Editor zu laden.

30.10 Ressourcen einbinden

1725

Test

Weitere Anwendungsbeispiele für Ressourcen finden Sie in folgenden Rezepten: Ä 20.7 Sound-Ressourcen in ein Programm einbinden Ä 18.31 Eigene Mauszeiger verwenden

Ergänzung Die folgenden Ausführungen sind vor allem für jene interessant, die über keinen komfortablen Ressourcen-Editor verfügen und sich, wie in unserem Beispiel, mit einem simplen Texteditor und dem Programm brc32.exe behelfen müssen. Grundsätzlich sind zwei Typen von Ressourcen interessant: ■ String-Ressourcen ■ Binär-Ressourcen (Icons, Bitmaps, Cursor, Sound, Video) Das Skript im Einzelnen: String-Ressourcen ... werden direkt im Ressourcen-Skript gespeichert. Geben Sie neben dem eigentlichen String einen eindeutigen Integerwert an. SYNTAX:

STRINGTABLE [load-option] [mem-option] BEGIN stringID string ... END

Die Parameter load-option und mem-option sind optional.

1726

Kapitel 30

How-to: Sonstiges

Konstanten für load-option: Konstante

Beschreibung

PRELOAD

Ressource wird sofort geladen.

LOADONCALL

(Default) Ressource wird beim Aufruf geladen.

Konstanten für mem-option: Konstante

Beschreibung

FIXED

Ressource wird fest im Speicher abgelegt.

MOVEABLE

Ressource kann im Speicher verschoben werden, falls nötig.

DISCARDABLE

Ressource kann entfernt werden, wenn sie nicht länger gebraucht wird.

BEISPIEL: Verwendung STRINGTABLE STRINGTABLE BEGIN 1 , "Datei" 2 , "Datei Neu ..." 1001 , "File" 1002 , "File New ..." END

Binäre Ressourcen ... sind lediglich Links zu separaten Dateien der Typen: ■ Icon (.ICO) ■ Bitmap (.BMP) ■ Cursor (.CUR) ■ Sound (.WAV) ■ Video (.AVI) SYNTAX:

ID keyWord [load-option] [mem-option] fileName

ID: spezifiziert einen Namen oder Integerwert, mit dem die Ressource eindeutig gekennzeichnet wird. Konstanten für keyWord: KeyWord

BITMAP CURSOR ICON

30.11 Die Programm-Versionsnummern ermitteln

1727

KeyWord

SOUND VIDEO Die Werte für load-option und mem-option entnehmen Sie bitte den Tabellen auf der vorhergehenden Seite. Der Parameter fileName spezifiziert die gewünschte Datei, Sie können vollständige Pfadangaben verwenden. BEISPIEL: Einbindung zweier Bitmaps 10 11

BITMAP BITMAP

Tree.bmp PRELOAD "c:\test\hintergrund.bmp"

Compiler-Optionen Der eigentliche Aufruf des Compilers ist relativ simpel: brc32.exe -r test.rc

Er compiliert das Ressourcen-Skript in die Datei TEST.RES, die Sie problemlos in Ihr Delphi-Programm einbinden können.

30.11 Die Programm-Versionsnummern ermitteln Besteht Ihr Projekt aus mehr als einem Programm bzw. aus verschiedenen DLLs, die zusammenarbeiten müssen? Wenn ja, dann empfiehlt sich die Verwendung der Versionsinformationen, wie Sie sie unter Projekt|Optionen|Versionsinfo einstellen können:

1728

Kapitel 30

How-to: Sonstiges

Leider haben die Delphi-Entwickler vergessen, entsprechende Routinen zum einfachen Auslesen zu implementieren. Unser kleines Beispielprogramm zeigt Ihnen die nötige Vorgehensweise.

Oberfläche Mehr als ein Button und ein Label zur Anzeige der gewünschten Information sind nicht erforderlich.

Quelltext Die folgende Funktion gibt uns die Versionsinformation gleich in einem String zurück, die Anzeige ist also selten einfach: function GetVersionInfos(filename:String):string; var iSize : Integer; data : Pointer; dw : DWord; FileInfo : PVSFixedFileInfo; begin Result := '?';

Ermitteln der Größe der Versionsinformation: iSize := GetFileVersionInfoSize(PChar(filename),dw);

Soweit derartige Informationen vorhanden sind, wird die Größe in Bytes zurückgegeben: if iSize > 0 then begin

Datenblock reservieren und Daten abrufen: GetMem(data,iSize); if GetFileVersionInfo(PChar(filename),0,iSize,data) then if VerQueryValue(data,'\',Pointer(FileInfo),dw) then

Da sich die Informationen sowohl im höher- als auch im niederwertigen DWord-Wert befinden, müssen wir diese dekodieren: result := Format('%d.%d.%d.%d',[(FileInfo^.dwFileVersionMS (FileInfo^.dwFileVersionMS (FileInfo^.dwFileVersionLS (FileInfo^.dwFileVersionLS FreeMem(data,iSize) end end;

shr and shr and

16), $FFFF), 16), $FFFF)]);

Sie können aus der Struktur PVSFixedFileInfo noch weitere Informationen über das Programm gewinnen: tagVS_FIXEDFILEINFO = packed dwSignature: DWORD; dwStrucVersion: DWORD; dwFileVersionMS: DWORD;

record { e.g. $feef04bd } { e.g. $00000042 = "0.42" } { e.g. $00030075 = "3.75" }

30.12 Mehrsprachige Anwendungen entwickeln

dwFileVersionLS: DWORD; dwProductVersionMS: DWORD; dwProductVersionLS: DWORD; dwFileFlagsMask: DWORD; dwFileFlags: DWORD; dwFileOS: DWORD; dwFileType: DWORD; dwFileSubtype: DWORD; dwFileDateMS: DWORD; dwFileDateLS: DWORD; end;

{ { { { { { { { { {

1729

e.g. $00000031 = "0.31" } e.g. $00030010 = "3.10" } e.g. $00000031 = "0.31" } = $3F for version "0.42" } e.g. VFF_DEBUG | VFF_PRERELEASE } e.g. VOS_DOS_WINDOWS16 } e.g. VFT_DRIVER } e.g. VFT2_DRV_KEYBOARD } e.g. 0 } e.g. 0 }

Die Verwendung der Funktion: procedure TForm1.FormCreate(Sender: TObject); begin Label1.Caption := 'Version ' +GetVersionInfos(paramstr(0)) end;

Test Starten Sie das Programm, wird Ihnen die aktuelle Versionsnummer angezeigt:

30.12 Mehrsprachige Anwendungen entwickeln Da wächst Europa zusammen, und Sie schreiben Ihre Anwendungen immer noch ausschließlich in Deutsch? Oder Sie entwickeln eine deutsche, eine englische und eine französische Variante Ihres Programms und haben später die Arbeit, alle zu warten und zu aktualisieren? Wie es auch anders geht, zeigt Ihnen das folgende Beispiel, für das Sie über einen Ressourcen-Editor verfügen sollten (zum Beispiel den von VC++).

Oberfläche Die Oberfläche besteht aus einem beliebigen Menü sowie einigen weiteren Komponenten, die lediglich zeigen sollen, wie Sie unterschiedlichen Komponenten eine neue Beschriftung zuweisen. Wichtig ist die Radiogroup, mit der wir zwischen zwei verschiedenen Landeseinstellungen umschalten können (natürlich können Sie beliebig viele Sprachversionen unterstützen). Legen Sie beim Entwurf der Oberfläche für alle Komponenten, deren Beschriftung mehrsprachig sein soll, die Tag-Eigenschaft auf einen eindeutigen, von 0 verschiedenen Wert fest. Anhand dieses

1730

Kapitel 30

How-to: Sonstiges

Wertes werden wir später die Caption-Eigenschaft durch einen String aus der Ressourcen-Tabelle ersetzen.

Ressourcen-Editor Starten Sie den Ressourcen-Editor und legen Sie eine Stringtabelle an. Wichtig ist die Vergabe der Value-Eigenschaft für die einzelnen Einträge. Jede Sprache beginnt mit einem neuen Offset-Wert (Deutsch = 0, Englisch = 1000, Spanisch = 2000 etc.). Die einzelnen Stringwerte erhalten jetzt jeweils den Value, den Sie in der Tag-Eigenschaft festgelegt haben.

30.12 Mehrsprachige Anwendungen entwickeln

1731

Quelltext In das Delphi-Projekt nehmen Sie die Unit Sprache auf, die alle wichtigen Funktionen bereitstellt: program Project1; uses Forms, Unit1 in 'Unit1.pas' {Form1}, Unit2 in 'Unit2.pas' {Form2}, sprache in 'sprache.pas'; {$R *.RES} begin ...

Die Unit Sprache: unit sprache; interface

Offset-Werte für die Stringtabelle: const sp_deutsch = 0; sp_englisch = 1000;

Auswahl einer Sprache: procedure Spracheinstellung(offset:Integer); implementation uses Forms, StdCtrls, ExtCtrls, Menus, SysUtils, Windows;

Einbinden der neuen Ressourcen: {$R Sprache.res} procedure Spracheinstellung(offset:Integer); var i,j: Integer; c : TObject; function GetResString(Nr: Integer): string; var p: PChar; begin p := StrAlloc(256); LoadString(Hinstance,nr+offset,p,255); Result := p; StrDispose(p) end;

1732

Kapitel 30

How-to: Sonstiges

begin with Application do for i := 0 to ComponentCount-1 do begin for j := 0 to Components[i].ComponentCount-1 do begin if Components[i].Components[j].tag <> 0 then begin c := Components[i].Components[j]; if (c is TLabel) then (c as TLabel).Caption := GetResString((c as TLabel).Tag); if (c is TButton) then (c as TButton).Caption := GetResString((c as TButton).Tag); if (c is TCheckbox) then (c as TCheckbox).Caption := GetResString((c as TCheckbox).Tag); if (c is TMenuItem) then (c as TMenuItem).Caption := GetResString((c as TMenuItem).Tag); // Hier stehen die weiteren Typen, die von der Sprachumwandlung betroffen sind // ... z.B. ComboBox end end end end; end.

In zwei ineinander geschachtelten Schleifen wird für jedes Formular und jede Komponente geprüft, ob die Tag-Eigenschaft auf einen Wert ungleich null festgelegt ist. Ist dies der Fall, wird mittels Offsetwert und Tag-Eigenschaft der Value für die Ressourcen-Tabelle bestimmt und ausgelesen. Im Listing ist auch die Stelle auskommentiert, an der Sie gegebenenfalls weitere Anpassungen vornehmen können (z.B. Beschriftung in Listenfeldern). Für die Auswahl einer neuen Sprache braucht jetzt lediglich die Prozedur Spracheinstellung aufgerufen zu werden, übergeben Sie der Funktion eine der Offset-Konstanten, die in der obigen Unit definiert wurden. procedure TForm1.RadioGroup1Click(Sender: TObject); begin if RadioGroup1.ItemIndex = 0 then spracheinstellung(sp_deutsch) else spracheinstellung(sp_englisch) end;

Test Nach dem Start können Sie über die RadioGroup eine Landessprache auswählen. Die Änderungen in den Beschriftungen werden sofort sichtbar:

30.13 Den Quellcode versionsabhängig compilieren

1733

30.13 Den Quellcode versionsabhängig compilieren Leider (oder auch Gott sei Dank) wartet jede neue Version von Delphi mit einigen Änderungen auf, die einen uneingeschränkten Austausch der Quelltexte zwischen den einzelnen Versionen erschweren. Sei es eine geänderte Unit oder auch nur der korrigierte Fehler in einer API-Deklaration (ein relativ häufiges Problem). Mit Hilfe von Compilerschaltern und bedingter Compilierung können Sie derartige Probleme lösen, auch wenn der Quelltext dadurch nicht gerade lesbarer wird. Ausgehend von selbst definierten oder vordefinierten Symbolen können Sie mit Hilfe der folgenden Schalter {$IF xxx} ... {$ELSE} ... {$ENDIF}

den Ablauf der Compilierung bestimmen. Einsatzgebiete wären zum Beispiel das wahlweise Compilieren als DLL oder EXE, eine 16- oder 32-Bit-Version etc.

1734

Kapitel 30

How-to: Sonstiges

Folgende Symbole sind vordefiniert: Symbol

Beschreibung

VER80

Delphi 1.x

VER90

Delphi 2.x

VER93

CBuilder 1.0

VER100

Delphi 3.x

VER120

Delphi 4

VER130

Delphi 5

VER140

Delphi 6

VER150

Delphi 7

WIN32

32-Bit-Programm

LINUX

Betriebssystem Linux

CPU386

CPU-Typ "Intel 386" oder besser

CONSOLE

Ein Konsolenprogramm, d.h. ohne GUI

BEISPIEL: Unterscheidung zwischen Delphi 2 und Delphi 7 {$IFDEF VER90} uses System, Windows, OleAut; {$ENDIF} {$IFDEF VER150} uses System, Windows, ComObj; {$ENDIF}

30.14 Programmeinstellungen automatisch speichern Beim wiederholten Öffnen eines Programms kann es lästig werden, zu Beginn immer wieder dieselben Benutzereingaben vornehmen zu müssen. Abhilfe schafft eine Konfigurationsdatei (oder auch INI-Datei genannt), die bei jedem Programmstart die Einstellungen der vorangegangenen Sitzung übernimmt.

Oberfläche Es geht in unserem Beispiel (simuliert die Eingabemaske eines FTP-Clients) lediglich darum, die Einträge in den drei Editierfeldern zu speichern. Die PasswordChar-Eigenschaft von Edit3 haben wir spaßeshalber auf "*" gesetzt, was aber für unser Beispiel ohne Bedeutung ist.

30.14 Programmeinstellungen automatisch speichern

1735

Quelltext var cfgDatei: TFileStream; verz: string; serverName: string[20]; kennung: string[8]; passwort: string[12];

// Verzeichnis // Serverkennung // Benutzerkennung

Bei Programmstart wird das aktuelle Verzeichnis festgestellt. Danach erfolgt der Versuch, die Konfigurationsdatei Test.cfg zu öffnen. Schlägt dieser Versuch fehl, so wird diese Datei neu angelegt. procedure TForm1.FormCreate(Sender: TObject); begin GetDir(0, verz); // aktuelles Verzeichnis feststellen verz := verz + '\Test.cfg'; try cfGDatei := TFileStream.Create(verz, fmOpenRead); cfgDatei.ReadBuffer(serverName, SizeOf(serverName)); cfgDatei.ReadBuffer(kennung, SizeOf(kennung)); cfgDatei.ReadBuffer(passwort, SizeOf(passwort)); except cfgDatei := TFileStream.Create(verz, fmCreate); serverName := ''; kennung := ''; passwort := '' end; Edit1.Text := serverName; Edit2.Text := kennung; Edit3.Text := passwort; cfgDatei.Free end;

Beim Beenden des Programms werden die Einstellungen in den Filestream geschrieben: procedure TForm1.FormClose(Sender:TObject; var Action: TCloseAction); begin serverName := Edit1.Text; kennung := Edit2.Text; passwort := Edit3.Text; cfgDatei := TFileStream.Create(verz, fmOpenWrite); cfgDatei.WriteBuffer(serverName, SizeOf(serverName)); cfgDatei.WriteBuffer(kennung, SizeOf(kennung)); cfgDatei.WriteBuffer(passwort, SizeOf(passwort)); cfgDatei.Free end;

1736

Kapitel 30

How-to: Sonstiges

Test Nach dem ersten Programmstart sind die Eingabefelder für Server, Benutzerkennung und Passwort zunächst leer. Beim zweiten Start finden Sie Ihre alten Eingabewerte wieder.

Bemerkungen ■ Das Abspeichern eines Passwortes in einer Konfigurationsdatei auf die beschriebene Weise ist ziemlich leichtsinnig, da es nicht schwierig ist, diese Datei mit einem beliebigen Texteditor zu öffnen. Außerdem wächst die Gefahr, dass über das Internet so genannte "Trojanische Pferde" in Ihren PC eingeschleust werden, die unter anderem auch Ihre INI-Dateien ausspähen und unsichtbar per Mail verschicken können. Abhilfe schafft u.a. ein Verschlüsseln, siehe dazu Ä 29.5 Einen Text verschlüsseln ■ Weitere Informationen zur Arbeit mit Stream-Objekten siehe Ä 21.21 Records in einem Stream-Objekt speichern

30.15 Verschwundene Komponenten aufspüren Hilfe! Eine dumme Sache ist passiert, die TMainMenu-Komponente ist plötzlich auf Nimmerwiedersehen entschwunden. Wahrscheinlich geschah es, als mehrere Komponenten gemeinsam verschoben wurden, dabei ist der Ausreißer außerhalb der Formulargrenzen "abgetaucht", denn ein Nachsehen unterhalb diverser Panels etc. blieb erfolglos. Zwar funktioniert das Programm noch, wie aber z.B. neue Menüpunkte hinzufügen?

Lösung Nach mehreren genauso verzweifelten wie erfolglosen Versuchen (Deklarationen aus Form-Objekt entfernen und neue TMainMenu-Komponente hinzufügen, ...) endlich die Lösung in Stichpunkten: ■ Menü: Bearbeiten|Alles auswählen. ■ Den gesamten markierten Block so verschieben, dass auch die außerhalb liegenden Komponenten wieder sichtbar werden. ■ Nun die Markierung aufheben und den Ausreißer an einen "sicheren" Platz ziehen, dann wieder Bearbeiten|Alles auswählen klicken und alles wieder ordentlich an seinen alten Platz verschieben.

30.16 Word-Dokumente in HLP-Dateien umwandeln

1737

Bemerkung Es lohnt sich, bei größeren Projekten, von Zeit zu Zeit einmal auf die beschriebene Weise nach "verloren gegangenen" Komponenten Ausschau zu halten, eventuell werden einige gar nicht vermisst und unbemerkt als Ballast mit herumgeschleppt.

30.16 Word-Dokumente in HLP-Dateien umwandeln Mit dem Microsoft Help-Workshop (HCW.EXE) können Sie ohne großen Mehraufwand ein "Electronic Book" erstellen und dabei gleichzeitig die grundsätzliche Vorgehensweise beim Anfertigen professioneller Hilfedateien erlernen. Der Help-Workshop gehört zum Lieferumfang von Delphi (Verzeichnis C:\Programme\Borland,\Delphi7\Help\Tools).

Vorbereitungen Als geeignetes Beispiel nehmen die Autoren kurzerhand das erste Kapitel eines ihrer (älteren) Delphi-Bücher. Sie aber knöpfen sich besser gleich Ihr eigenes Dokument vor, das allerdings für einen ersten Versuch auf dem Gebiet der Hilfeprogrammierung nicht gar zu umfangreich sein sollte. ■ Starten Sie Microsoft Word und öffnen Sie Ihr Word-Dokument. ■ Befreien Sie das Dokument von unnötigem Ballast: Entfernen Sie eventuelle Kopf- und Fußzeilen. (Menü Ansicht|Kopf- und Fußzeile; mit Maus markieren und dann Entf-Taste) Beseitigen Sie auf die gleiche Weise auch die Anzeige von Seitennummern. Entfernen Sie alle Tabellenumrandungen, Textspalten und sonstige Extravaganzen. Beseitigen Sie alle Fußnoten. (Menü Bearbeiten|Ersetzen...; Taste "Sonstiges", Fußnotenzeichen) ■ Entfernen Sie aus dem Text die Formatierung "Absätze nicht trennen". Markieren Sie dazu das gesamte Dokument (Menü Bearbeiten|Alles markieren), wählen Sie anschließend den Menüpunkt Format|Absatz... und deaktivieren Sie in der Registerkarte Zeilen- und Seitenumbruch das Kästchen "Absätze nicht trennen". Es kann nicht schaden, wenn Sie außerdem auch noch die anderen Optionen deaktivieren, die sich ebenfalls auf den Seitenumbruch beziehen, der in der Help-Datei sowieso seinen ursprünglichen Sinn verloren hat.

1738

Kapitel 30

How-to: Sonstiges

■ Entfernen Sie auf gleiche Weise die Formatierung "Ausgeblendet", die Sie auf der Registerkarte Schrift des Menüs Format|Zeichen... finden.

■ Jetzt geht es den manuell eingefügten Seitenumbrüchen an den Kragen. Wir spüren sie mit Hilfe des Menüs Bearbeiten|Ersetzen... auf (Taste "Sonstiges", manueller Seitenumbruch) und beseitigen sie.

30.16 Word-Dokumente in HLP-Dateien umwandeln

1739

■ Nehmen Sie jetzt, falls erforderlich, auch noch kosmetische Korrekturen an Ihrem Dokument vor. Dazu gehören z.B. farbliche Hervorhebungen bestimmter Textpassagen (Listings, Hinweise, ...) oder auch die Vergrößerung der Schrift (vorteilhaft sind 12 dpi für normalen Text). Nutzen Sie dazu ebenfalls die "Ersetzen..."-Funktionen von Word. ■ Setzen Sie (falls noch nicht vorhanden) ein Inhaltsverzeichnis an den Anfang des Dokuments (Menü Einfügen|Index und Verzeichnisse...; Registerkarte Inhaltsverzeichnis). Das Inhaltsverzeichnis darf keine Seitennummern haben und sollte nicht zu stark untergliedert sein (maximal drei bis vier Ebenen). ■ Da der Helpcompiler mit automatisch nummerierten Überschriften nichts anfangen kann, sollten Sie diese Art der Nummerierung entfernen und die Abschnittsnummern anschließend per Hand (oder besser durch ein geeignetes Word-Makro) wiederherstellen. ■ Speichern Sie das überarbeitete Word-Dokument im Rich Text-Format ab (Menü Datei| Speichern unter...). Es wird dann eine neue Datei (*.RTF) vorliegen, in unserem Paradebeispiel ist es Einfuehrung.RTF, die in diesem unfertigen Stadium gewissermaßen als "Rohling" für die weiteren Entwicklungsphasen der Help-Datei dient.

Ein erster Test Spätestens jetzt sollten Sie überprüfen, ob sich Ihr RTF-Dokument mit dem Help-Compiler verträgt, und einen ersten Versuch wagen: ■ Starten Sie den Help-Workshop (HCW.EXE), wählen Sie den Menüpunkt File|New und im sich öffnenden Dialogfenster den Eintrag Help Projekt:

■ Im nächsten Dialogfenster werden Sie aufgefordert, Verzeichnis und Namen für Ihr Projektfile *.HPJ anzugeben. Zweckmäßigerweise wählen Sie den gleichen Namen und das gleiche Verzeichnis wie für das RTF-Dokument und speichern anschließend. ■ Nun öffnet sich das Dialogfenster, in dem Sie schon ein (allerdings rudimentäres) HPJ-File mit teilweise "vorgefertigter" [Option]-Sektion vorfinden. Klicken Sie jetzt noch nicht auf den "Save and Compile"-Button, denn das führt garantiert zu einem Fehler, da die [Files]-Sektion noch leer ist. Stattdessen wählen Sie die "Files..."-Schaltfläche, es öffnet sich ein Fenster:

1740

Kapitel 30

How-to: Sonstiges

■ Klicken Sie hier die "Add..."-Schaltfläche, um die Themendatei Einfuehrung.rtf hinzuzufügen. Wie Sie sehen, können hier auch noch weitere RTF-Dokumente ausgewählt werden. ■ Wählen Sie nun OK, im HPJ-Fenster sehen Sie eine anwendungsbereite Projektdatei:

■ Jetzt können Sie einen ersten Start des Help-Compilers wagen. Klicken Sie auf "Save und Compile", warten Sie einige Sekunden und lassen Sie sich durch eventuell anschließend erscheinende Fehlermeldungen nicht verwirren:

30.16 Word-Dokumente in HLP-Dateien umwandeln

1741

■ Sie dürfen jetzt den Help-Workshop verlassen und sich im Datei-Manager (Arbeitsplatz-Icon) davon überzeugen, dass tatsächlich ein Help-File hinzugekommen ist:

■ Starten Sie das Help-File (doppelklicken) und betrachten Sie sich das Ergebnis. Haben Sie, wie verlangt, alle manuellen Seitenumbrüche entfernt, so wird die Help-Datei aus nur einer einzigen Seite bestehen, benutzen Sie also die Bildlaufleiste, um durch den Text zu scrollen. Verändern Sie die Breite des Hilfefensters, so wird sich die Zeilenlänge automatisch anpassen. Übrigens können Sie Ihre Help-Files auch testen, ohne den Help-Workshop zu verlassen. Öffnen Sie dazu den Menüpunkt File|RunWinHelp.

Formatieren der Themendatei Erst durch spezielle Formatierungen (Fußnoten, verborgener Text) mausert sich unsere einfache RTF-Datei zum ernst zu nehmenden Hypertext. Hilfeseiten aufteilen: Wir wollen, dass das Inhaltsverzeichnis auf einer extra Hilfeseite (der ersten) erscheint. Es empfiehlt sich, pro Kapitel eine einzige Hilfeseite zu verwenden, durch die dann gescrollt wird. Das ist viel übersichtlicher als ein Durchblättern durch viele einzelne Hilfeseiten. Für unser Beispieldokument Einfuehrung.rtf brauchen wir also insgesamt nur zwei Hilfeseiten. Natürlich ist die Entscheidung über die Anzahl der Hilfeseiten auch vom Umfang des jeweiligen Kapitels abhängig und bleibt letztendlich Ihnen überlassen.

1742

Kapitel 30

How-to: Sonstiges

Formatierung: Platzieren Sie am Ende einer jeden Hilfeseite einen manuellen Zeilenumbruch (Menü Einfügen|ManuellerUmbruch...; Seitenumbruch). Context-Strings (ThemenIDs) einfügen: Fürs Erste sollte es genügen, wenn nur die Einträge des Inhaltsverzeichnisses als Hotspots zur Verfügung stehen. Formatierung: Die Sprungziele (nicht die Hotspots!) müssen mit einem #-Fußnotenzeichen markiert werden. Setzen Sie also die Einfügemarke unmittelbar vor jede Abschnittsüberschrift im RTF-Dokument und wählen Sie den Menüpunkt Einfügen|Referenz|Fußnote... (benutzerdefinierte Nummerierung):

Nach dem OK ist als Fußnotentext ein unverwechselbarer Context-String einzutragen, am einfachsten ist es, wenn Sie dazu ein Wort aus der entsprechenden Überschrift verwenden. Hotspots einfügen: Es fehlen nun noch die Formatierungen, die den Sprung zu den einzelnen Themen-IDs veranlassen. Später, in der fertigen HLP-Datei, erscheinen diese Hotspots dann als i.A. grün gefärbte Textstellen. Formatierung: ■ Markieren Sie das komplette Inhaltsverzeichnis und unterstreichen Sie alles doppelt (Menü Format|Zeichen...; Schrift-Registerkarte; Rollbox "Unterstreichung"; Eintrag "Doppelt"). ■ Unmittelbar hinter dem unterstrichenen Eintrag (also ohne Leerzeichen dazwischen!) fügen Sie den entsprechenden Context-String ein. ■ Aktivieren Sie im Menü Extras|Optionen...in der Registerkarte Ansicht in der Gruppe "Formatierungszeichen" das Kästchen "Ausgeblendeter Text".

30.16 Word-Dokumente in HLP-Dateien umwandeln

1743

■ Markieren Sie den Context-String als "Ausgeblendet" (Menü Format|Zeichen...,"Schrift"). Schließlich sollte das Inhaltsverzeichnis im RTF-Dokument etwa so aussehen:

1744

Kapitel 30

How-to: Sonstiges

Abschlusstest Vergessen Sie nicht, alle in der RTF-Datei vorgenommenen Änderungen auch abzuspeichern. Danach starten Sie erneut den Help-Compiler, indem Sie das Projekt-File (Einfuehrung.hpj) öffnen. Haben Sie beim Formatieren alles richtig gemacht, werden sich die "Warnings" auf relativ harmlose "Meckereien" beschränken. Beim Aufruf Ihrer neu compilierten Hilfe-Datei werden Sie vom Inhaltsverzeichnis begrüßt, von dem aus Sie direkt zu den entsprechenden Textabschnitten verzweigen können:

Ergänzungen Ihr Electronic Book funktioniert zwar, ist aber in vielen Punkten noch verbesserungsbedürftig: ■ Fügen Sie Title-IDs und Keywords hinzu, um Suchfunktionen zu ermöglichen. ■ Ergänzen Sie den Text durch weitere Hotspots und lagern Sie bestimmte Textpassagen mit rein erklärendem Charakter als PopUp-Hilfeseiten aus. ■ Bedenken Sie, dass sich die meisten Formatierungsarbeiten an Ihrer RTF-Datei durch WordMakros erheblich vereinfachen lassen. Weitere Anregungen finden Sie in den Rezepten Ä 30.17 Eine HLP-Hilfedatei erzeugen Ä 30.18 Eine HLP-Inhaltsdatei hinzufügen Ä 30.19 In einer HLP-Hilfedatei blättern

30.17 Eine HLP-Hilfedatei erzeugen

1745

30.17 Eine HLP-Hilfedatei erzeugen Zu jeder vermarktungsfähigen Delphi-Applikation gehört eine Hilfedatei. In diesem Rezept wollen wir zu der Applikation "Taschenrechner" (Quellcode siehe Buch-CD) eine Hilfedatei hinzufügen. Bevor Sie allerdings beginnen, sollten Sie sich über den grundsätzlichen Umgang mit dem Microsoft Help-Workshop informieren und das folgende, relativ unkomplizierte Rezept ausprobieren: Ä 30.16 Word-Dokumente in HLP-Dateien umwandeln

1. Schreiben und Formatieren der RTF-Themendatei mit Word 2000 ■ Starten Sie Microsoft Word 2000 und schreiben Sie die Hilfetexte. Trennen Sie die einzelnen Hilfeseiten durch jeweils einen manuell eingefügten Seitenumbruch Einfügen|ManuellerUmbruch ... "Seitenumbruch"). ■ Fügen Sie dann die #-Fußnoten für die Context-Strings, die $-Titelfußnoten und die K-KeyWord-Fußnoten hinzu. ■ Tragen Sie die Hotspots ein (doppelt oder einfach unterstreichen) und direkt dahinter die Sprungziele (Context-Strings). Letztere formatieren Sie als als "verborgener" Text (Menü Format|Zeichen..., "Schrift", Kästchen "Ausgeblendet" aktivieren). ■ Aktivieren Sie auch das Kästchen "Ausgeblendeten Text" in Extras|Optionen... , "Ansicht", ansonsten bleibt der verborgene Text unsichtbar. ■ Weiterhin ist es zu empfehlen, die Menüpunkte Ansicht|Normal und Ansicht|Fußnoten zu aktivieren. Im Folgenden werden aus Übersichtlichkeits- und Platzgründen die einzelnen Hilfeseiten eingerahmt. HINWEIS: Die folgenden Fußnoten entsprechen denen der Hilfeseiten. Aus Übersichtlichkeits-

gründen wurden sie hier für mehrere Hilfeseiten zusammengefasst und am unteren Seitenrand angeordnet.

#

Der Taschenrechner

AllgemeinesAllgemeines Was ist bei der Zahleneingabe zu beachten?Zahleneingabe Erweiterungen und VerbesserungenErweiterungen

#

Inhalt

1746

Kapitel 30

K $ #

How-to: Sonstiges

Allgemeines zur Bedeutung von Taschenrechnern

Elektronische Taschenrechner begannen ihren Siegeszug mit fortschreitender Entwicklung der Mikroelektronik. Sie lösten den logarithmischen Rechenstab ab, der vorher zum unverzichtbaren Handwerkszeug des Ingenieurs gehörte. Mittlerweile gibt es diese Taschenrechner auch als kleine Rechnerprogramme:

Auffällig ist der fehlende Einschalterkein Einschalter. Die Bedienung ist im Prinzip genauso wie bei einem "richtigen" Taschenrechner, nur dass man anstatt mit den Fingern die Tasten per Mausklick betätigen muss. Siehe auch: "Was ist bei der ZahleneingabeZahleneingabe zu beachten?" # K $

Was ist bei der Zahleneingabe zu beachten?

Sie werden feststellen, dass Sie zwar einen Dezimalpunkt eingeben, beim Ergebnis allerdings ein Dezimalkomma erscheint. Dies hat seine Ursache in der Format-Anweisung, die nach "angloamerikanischen" Prinzipien funktioniert. Der Punkt übernimmt hier die Rolle des Tausender-Trennzeichens. # K $

Die vier Grundrechenarten

... sind Addition, Subtraktion, Multiplikation und Division. # K $

Erweiterungen und Verbesserungen

Dieser Taschenrechner ist sehr einfach und kann nur die vier GrundrechenartenGrundrechenarten. Es fehlt noch eine ganze Menge, so z.B. Klammerrechnung oder wissenschaftliche Funktionen. Außerdem könnte man dafür sorgen, dass nur noch das Komma als Dezimaltrenner akzeptiert wird. K $ # # K $ # K $ # K $

Taschenrechner; Mikroelektronik; Rechenstab; Rechnerprogramme Allgemeines zur Bedeutung von Taschenrechnern Allgemeines Zahleneingabe Zahlen; Dezimalpunkt; Format-Anweisung; Trennzeichen Besonderheiten der Zahleneingabe Grundrechenarten Addition; Subtraktion; Division; Multiplikation Die 4 Grundrechenarten Erweiterungen Grundrechenarten; Dezimalpunkt; Komma Erweitern und Verbessern

30.17 Eine HLP-Hilfedatei erzeugen

# $

1747

Warum hat unser Taschenrechner keinen Einschalter?

Die Antwort auf diese Frage hat unmittelbar etwas mit objektorientierter ProgrammierungOOP zu tun. Unser Taschenrechner wird gewissermaßen beim Ausschalten "zerstört", es existiert also keine Instanz des Programmes mehr, demzufolge wäre ein Einschalter sinnlos. # $ K

Objektorientierte Programmierung

OOP ist ein Konzept moderner Software-Entwicklung. Auch Delphi ist konsequent objektorientiert aufgebaut. Unser Taschenrechner-Programm ist eine Klasse, sozusagen der "Bauplan" des Taschenrechners. Um tatsächlich unseren Taschenrechner auf dem Bildschirm zu sehen, muss das Programm gestartet, also eine so genannte Instanz abgeleitet werden. Man kann auch mehrere Instanzen von ein und derselben Klasse bilden. Speichern Sie das Dokument im RTF-Format als TR.rtf ab.

Bemerkungen ■ Achten Sie auf die zugehörigen Fußnotenzeilen! ■ Kümmern Sie sich nicht um den Zeilenumbruch, der wird später automatisch der Breite des Hilfefensters angepasst.

2. Anlegen der HPJ-Steuerdatei mit dem MS Help-Workshop ■ Starten Sie HCW.EXE (Sie finden den Help-Workshop normalerweise im Verzeichnis ...\Programme\Borland\Delphi7\Help\Tools.) und klicken Sie auf den Menüpunkt File|New. ■ Klicken Sie in dem kleinen Dialogfenster auf "Help Project", denn Sie wollen ja ein HPJProjekt-File und keine Inhaltsdatei erstellen. ■ Geben Sie im nächsten Dialogfenster Ihrer Projektdatei einen Namen, z.B. TR.hpj. Nun öffnet sich das Hauptfenster des Workshops mit einer vorerst noch rudimentären HPJ-Projektdatei. ■ Klicken Sie zunächst den "Options"-Button, um die [Options]-Sektion zu vervollständigen. Tragen Sie auf der "General"-Seite des Dialogfensters nur das Wichtigste ein: "Default Topic" = Inhalt, "Help title" = Beispiel einer Hilfedatei, "Display this Text in the Version dialog box": Ihren Namen.

# $ # $ K

Kein Einschalter Kein Einschalter? OOP OOP OOP; Objektorientierte Programmierung; Klasse; Instanz

1748

Kapitel 30

How-to: Sonstiges

Als Nächstes klicken Sie auf den Button der "Files..."-Sektion. Im folgenden noch leeren Dialogfenster klicken Sie auf die "Add"-Schaltfläche und wählen im sich nun öffnenden Dateidialog die RTF-Themendatei TR.rtf aus. Ihre HPJ-Projektdatei sieht nun folgendermaßen aus:

30.17 Eine HLP-Hilfedatei erzeugen

1749

3. Compilieren und Testen der Hilfedatei mit dem MS Help-Workshop Klicken Sie nun auf die Schaltfläche "Save and Compile". Wenn Sie abschließend folgendes Fenster erfreut, ist alles in Ordnung:

Schließen Sie nun den Help-Workshop und schauen Sie im Arbeitsverzeichnis nach. Sie werden dort eine neu hinzugekommene Windows-Hilfedatei TR.hlp entdecken. Durch Doppelklick können Sie diese Datei so wie jede andere Help-Datei aufrufen und testen:

1750

Kapitel 30

How-to: Sonstiges

Auch die Indexsuche nach Schlüsselwörtern (K-Fußnoten) ist sofort verfügbar. Probieren Sie auch die "Suchen"-Seite des Hilfefensters aus. Hier wird eine Volltextsuche durchgeführt, und Sie erkennen die Bedeutung der Titelfußnoten ($):

Bemerkungen Falls beim Compilieren Fehlermeldungen auftreten, sind diese im Allgemeinen harmloser Natur. Die Hilfedatei ist dann mit leichten Mängeln behaftet, funktioniert aber meistens trotzdem. Korrigieren Sie die Fehler schrittweise im RTF-Dokument. HINWEIS: Vergessen Sie nicht, das RTF-Dokument in Word zu schließen, bevor Sie die Hilfe-

datei erneut compilieren. Andernfalls werden die Änderungen nicht übernommen! Wie Sie die Hilfedatei praktisch einsetzen, erfahren Sie in Ä 30.20 Eine HLP-Datei in Delphi einbinden

30.18 Eine HLP-Inhaltsdatei hinzufügen Sie können, müssen aber nicht, Ihre Help-Dateien durch eine Inhaltsdatei (Content-File) bereichern. Das dürfte vor allem dann für mehr Übersicht sorgen, wenn die Help-Datei aus einer größeren Anzahl von Hilfeseiten besteht. Wir wollen die in Ä 30.17 Eine HLP-Hilfe-Datei erstellen

30.18 Eine HLP-Inhaltsdatei hinzufügen

1751

von uns erstellte TR.hlp so ergänzen, dass sich uns nach Öffnen der Hilfe auf der "Inhalt"- (Content)-Registerseite folgender Anblick bieten sollte:

Wie Sie es von anderen Hilfedateien auch kennen, dienen die Buchsymbole nur zur Strukturierung. Sie können "aufgeklappt" werden, auch eine hierarchische Staffelung mehrerer Ebenen ist möglich, was bei unserem einfachen Beispiel natürlich nicht zutrifft. Die eigentlichen Topics, hinter denen sich die Hilfeseiten verbergen, befinden sich auf der untersten Ebene.

Erzeugen der Inhaltsdatei ■ Bevor Sie beginnen, sollten Sie sich das Inhaltsverzeichnis Ihres RTF-Dokuments zurechtlegen. Wählen Sie dann den Menüpunkt File|New... des Help-Workshops und im anschließenden Dialogfenster den Eintrag "Help Contents".

■ Geben Sie als Namen für die Inhaltsdatei den der bereits vorhandenen Hilfedatei (TR.hlp) ein und einen Titel (Inhaltsverzeichnis) und klicken Sie anschließend auf den Button "Add Above...". Im folgenden Dialogfenster müssen Sie nun entscheiden, ob im Inhaltsverzeichnis das Buchsymbol erscheinen soll (es handelt sich dann nur um eine Überschriftenebene) oder ob eine Hilfeseite (Topic) aufgerufen werden soll. ■ Wir wollen mit der Überschrift des ersten Abschnitts beginnen, klicken Sie also die "Heading"-Option und tragen Sie den Titel ein:

1752

Kapitel 30

How-to: Sonstiges

■ Nach dem OK wieder im CNT-Fenster, klicken Sie auf den Button "Add Below...", wählen aber diesmal in der Dialogbox die "Topic"-Option. Außer dem Titel wird diesmal noch die zugehörige Themen-ID abgefragt, die dem von uns vergebenen Context-String (#-Fußnote) entsprechen muss:

■ Die letzten beiden Einträge (Help file und Windows type) brauchen uns jetzt nicht unbedingt zu interessieren. ■ Dieses Hin und Her wiederholen Sie, bis das Inhaltsverzeichnis komplett ist:

30.19 In einer HLP-Hilfedatei blättern

1753

■ Um möglichst bequem die IDs der entsprechenden Fußnoten zu gewinnen, empfiehlt es sich, in einem zweiten (verkleinerten) Fenster die Textverarbeitung mit der geöffneten Datei TR.rtf laufen zu lassen. ■ Speichern Sie die Inhaltsdatei unter TR.cnt im Arbeitsverzeichnis ab, das damit weiteren Zuwachs erhält:

Test Öffnen Sie im Help-Workshop erneut die Projektdatei TR.hpj und compilieren Sie diese. Nach Aufruf von TR.hlp wird sich Ihnen diesmal das eingangs gezeigte Fenster mit dem funktionsfähigen Inhaltsverzeichnis präsentieren.

30.19 In einer HLP-Hilfedatei blättern Die einzelnen Hilfeseiten einer Help-Datei stehen normalerweise lose nebeneinander. Wenn Sie die Hilfedatei TR.hlp aus Ä 30.17 Eine HLP-Hilfedatei erzeugen öffnen, stellen Sie fest, dass ein Blättern unmöglich ist, denn die beiden Schaltflächen zum Vorwärts- bzw. Rückwärtsbewegen fehlen. Im folgenden Beispiel soll gezeigt werden, wie Sie diese Hilfedatei so ergänzen, dass Sie zwischen den drei im Inhaltsverzeichnis angegebenen Hilfeseiten blättern können.

1754

Kapitel 30

How-to: Sonstiges

Einfügen von (+)-Fußnoten in die RTF-Datei ■ Starten Sie MS Word und öffnen Sie die Datei TR.rtf. Fügen Sie an den Anfang der mit dem Context-String "Allgemeines" bezeichneten Hilfeseite eine weitere benutzerdefinierte Fußnote + ein:

■ Als zugehörigen Fußnotentext geben Sie eine Ziffernfolge, z.B. 001 ein:

■ Verfahren Sie analog mit den übrigen beiden Hilfeseiten, geben Sie hier allerdings der Reihenfolge entsprechende höhere Zahlen ein, z.B. 005 und 009. Die Lücken zwischen den Zahlen können Sie für spätere Ergänzungen nutzen. Speichern Sie die Datei und vergessen Sie auch das Schließen nicht.

Ergänzen der [Config]-Sektion in der HPJ-Datei Sie können BrowseSequences nur dann nutzen, wenn Sie in der Projektdatei die entsprechenden Schaltflächen aktiviert haben. ■ Rufen Sie den Microsoft Help-Workshop auf und laden Sie das Projektfile TR.hpj. ■ Klicken Sie im Hauptfenster rechts den "Config..."-Button und im anschließenden Fenster die "Add..."-Schaltfläche. ■ Im Dialogfenster "Add Macro" fügen Sie nun den Makro-Aufruf BrowseButtons() hinzu. Nach dem OK sehen Sie im Hauptfenster, dass die Projektdatei einen zusätzlichen Eintrag erhalten hat: [CONFIG] BrowseButtons()

■ Nun können Sie das Help-File erneut compilieren ("Save and Compile").

Test Wenn Sie die überarbeitete Help-Datei TR.hlp nun öffnen, verfügt jede der drei Hilfeseiten über Browse-Buttons, mit denen Sie hin und her blättern können:

30.20 Eine HLP-Datei in Delphi einbinden

1755

Bemerkungen ■ Um später leichter Themen hinzufügen zu können, verwenden Sie für die einzelnen Fußnoten in einer Sequenz den gleichen Namen, jedoch keine Zahlen. Der Help-Workshop ordnet Ihre Anzeigereihenfolge später in der Reihenfolge, in der die Themen geschrieben wurden. ■ Wenn die Hilfe-Datei nur über eine einzige Anzeigesequenz verfügt, können Sie als Fußnotentext auto einsetzen. Die Hilfeseiten erscheinen dann in der gleichen Reihenfolge wie in der Themendatei.

30.20 Eine HLP-Datei in Delphi einbinden Unser im Rezept 30.17 erstelltes Help-File soll endlich in eine Delphi-Applikation eingebunden werden. Wir verwenden dazu das Projekt "Taschenrechner" (siehe Buch-CD). Bevor es aber so weit ist, sind noch einige Vorbereitungen zu treffen.

Ergänzen der HPJ-Projektdatei ■ Rufen Sie nochmals den MS Help-Workshop auf und laden Sie das Projektfile Taschenrechner.hpj. ■ Im Hauptfenster klicken Sie auf die "Map..."-Schaltfläche und im nachfolgenden Map-Fenster auf den "Add..."-Button. Es öffnet sich die Dialogbox AddMapEntry. ■ Tragen Sie im Feld "Topic ID" den Context-String "Inhalt" ein und ordnen Sie ihm im Feld "Mapped numeric value" eine frei wählbare Integer-Zahl (100) zu. ■ Verfahren Sie analog mit all den Hilfeseiten, die über die F1-Taste aufrufbar sein sollen. ■ Schließlich zeigt das Map-Fenster folgende [MAP]-Sektion:

1756

Kapitel 30

How-to: Sonstiges

■ Klicken Sie OK und compilieren Sie erneut ("Save and Compile"). ■ Kopieren Sie die fertige Datei TR.hlp in das Verzeichnis, in dem sich die Delphi-Quelltexte des Projekts "Taschenrechner" befinden. ■ Laden Sie das Delphi-Projekt von der Buch-CD und öffnen Sie es.

Oberfläche ■ Ergänzen Sie die Oberfläche des Taschenrechners durch eine zusätzliche "Hilfe"-Schaltfläche (Button19) und durch ein einfaches Hilfe-Menü, "Standard"-Seite MainMenu1-Komponente. Doppelklicken Sie dazu auf MainMenu1 und erzeugen Sie die Unterpunkte Info und Inhalt.

■ Nun weisen Sie im Objektinspektor allen Button-Komponenten des Ziffernblocks die gewünschte Hilfeseite "Zahleneingabe", sprich HelpContext-Eigenschaft 102, zu. ■ Auf analoge Weise erhalten die vier Operations-Buttons den Wert 103. ■ Form1 bekommt den HelpContext 100, ebenso wie der Inhalt-Unterpunkt des Hilfe-Menüs.

30.21 Ein HLP-Makro aufrufen

1757

Quelltext Beim Öffnen des Programms muss zunächst die Hilfe-Datei eingebunden werden: procedure TForm1.FormCreate(Sender: TObject); begin Application.HelpFile := 'TR.hlp' end;

Nun müssen wir uns noch um den Direktaufruf der Hilfe-Datei kümmern. Beim Klicken der "Hilfe"-Schaltfläche soll die durch den Context-String "Inhalt" bezeichnete Seite erscheinen: procedure TForm1.Button19Click(Sender: TObject); begin Application.HelpJump('Inhalt') end;

Gleiches soll passieren, wenn Sie in der Menüleiste den Inhalt-Eintrag anklicken: procedure TForm1.Hilfe2Click(Sender: TObject); begin Application.HelpJump('Inhalt') end;

Test Starten Sie das Programm (F9) und überprüfen Sie als Erstes die Hilfefunktion der F1-Taste. Hat z.B. eine Schaltfläche des Ziffernblocks den Fokus, so muss nach Betätigen von F1 die Hilfeseite "Zahleneingabe" erscheinen. Da der "="-Taste keine HelpContext-Eigenschaft zugewiesen wurde, erscheint hier die dem Formular zugeordnete Hilfeseite "Inhalt". Auch beim Aktivieren des InhaltEintrags des Hilfe-Menüs muss F1 diese Seite zeigen.

30.21 Ein HLP-Makro aufrufen Möchten Sie aus Ihrem Delphi-Programm gezielt Hilfemakros aufrufen, müssen Sie neben der recht gewöhnungsbedürftigen Typumwandlung (ein Integer wird erwartet!) auch darauf achten, die Kurzbezeichnung der Makros zu verwenden. BEISPIEL: Aufruf des ALINK-Makros (Sprung zu einem ALink innerhalb der Hilfe-Datei) aus Delphi procedure GotoHelpBookmark(Bookmark:string); var cmd:string; begin cmd := 'AL("' + bookmark + '",1)'; Application.HelpCommand(HELP_COMMAND,Integer(PChar(cmd))) end;

1758

Kapitel 30

How-to: Sonstiges

30.22 HTML-Hilfe-Dateien erstellen Mittlerweile ist das altbekannte Windows-HLP-Hilfesystem in die Jahre gekommen. Als Nachfolger beginnt sich Microsofts HTML-Hilfe langsam durchzusetzen, auch wenn Borland/Inprise den benötigten HTML-Help-Workshop nicht mitliefert. Sie können den Microsoft HTML-Workshop aber auch herunterladen von der Internet-Adresse http://msdn.microsoft.com/library/enus/htmlhelp/html/hwMicrosoftHTMLHelpDownloads.asp

Vor- und Nachteile Die Vorteile auf einen Blick: ■ Die Hilfe basiert auf HTML-Dateien, die mit diversen Tools leicht erstellt werden können. Gleichzeitig kann die Hilfe für die Gestaltung von Webseiten genutzt werden. ■ Sie können ActiveX, Java, JavaScript und VBScript verwenden, um aktive Inhalte zu erstellen. ■ Die Hilfe unterstützt nun die Bildformate .jpeg, .gif, .png. ■ Help-Dateien können nun wesentlich größer werden. Wie wohl nicht anders zu erwarten, hat dieses Hilfesystem auch seine Nachteile, die nicht verschwiegen werden sollen: ■ Zur Anzeige sind Komponenten des MS Internet Explorers nötig. ■ Es müssen eventuell zusätzliche Komponenten installiert werden. ■ Die Hilfe ist langsamer als die bekannte Windows-Hilfe. ■ Der Hilfe-Compiler ist wieder einmal nicht ganz ausgereift. ■ Sie können keine Popup-Fenster verwenden.

Unterschiede zwischen WinHelp und HTMLHelp Wer früher bereits Hilfe-Dateien entwickelt hat, dem werden die Analogien sofort ins Auge stechen: Microsoft WinHelp

Microsoft HTMLHelp

Compiler

hcw.exe

hhw.exe

Hilfedatei

.hlp

.chm

Projekt-File

.hpj

.hhp

Topic-Files

.rtf (z.B. mit Word erstellt)

.htm (z.B. mit Microsoft FrontPage erstellt)

Index-Files

#K-Fußnoten

.hhk

Inhaltsdatei

.cnt

.hhc

Bildformate

.bmp/.wmf

.gif/.jpg

30.22 HTML-Hilfe-Dateien erstellen

1759

Lieferumfang Zum Entwicklungssystem gehören: ■ ein ActiveX-Control oder ein Java-Applet zwecks Einfügen in HTML-Files ■ der HTML-Workshop (Hhw.exe) ■ ein Bildbearbeitungsprogramm (Flash.exe) ■ ein Anzeigeprogramm für HTML-Files (Hh.exe) ■ die Anleitung zum Erstellen eines Hilfesystems und zur Bedienung des HTML-Workshops ■ eine Referenz zu HTML, HTML-API und zum Konvertieren vorhandener Hilfe-Dateien (.hlp) in HTML-Hilfe-Dateien (.chm) Sie finden die Programme nach der Installation in einem separaten Verzeichnis, wie C:\Programme\HTML Workshop.

Der HTML-Help-Workshop Dieses komplexe Autorentool unterstützt Sie bei der Anfertigung von HTML-Hilfedateien: ■ Erstellen eines Projekt-Files (.hhp) ■ Formatieren von Hilfeseiten (.htm, .html) ■ Erstellen von Inhaltsdateien (.hhc) ■ Index-Files (Navigieren zwischen den Topics) ■ Einbinden von Bild- und Multimedia-Dateien ■ Hilfefenster und Styles definieren ■ Hilfe-Dateien compilieren (.chm) ■ Testen und Debuggen von Hilfe-Dateien Die folgenden Ausführungen sollen Ihnen den Einstieg erleichtern. Auf die Generierung von HTML-Seiten werden wir nicht weiter eingehen, dafür stehen zum Beispiel MS Frontpage oder auch eine ganze Reihe von Freeware- bzw. Shareware-Tools zur Verfügung.

Bedienung am Beispiel Die Hilfe zur neuen HTML-Help ist teilweise ziemlich verwirrend. Hier der Versuch, einen besseren Einstieg zu vermitteln: ■ Schreiben Sie mit einem HTML-Editor (z.B. Word oder MS Frontpage) die einzelnen Hilfeseiten. Fügen Sie Hotspots ein, so dass jede Seite erreichbar ist. ■ Öffnen Sie den Microsoft HTML-Workshop (C:\Program Files\hhw.exe). ■ File|New im Dialogfenster "Project" wählen.

1760

Kapitel 30

How-to: Sonstiges

■ Unaufgefordert drängt Ihnen nun ein Wizard seine Dienste auf. An dem Dialogfenster mit der Option "Convert WinHelp Project" gehen Sie achtlos vorbei, das Häkchen setzen Sie nur in dem Fall, wenn Sie ein bereits existierendes älteres Hilfe-Projekt (.hpj) in das neue HTMLFormat konvertieren wollen. Dies dürfte besonders für den Umsteiger hilfreich sein, beantworten sich doch durch Vergleich des ursprünglichen mit dem konvertierten Projekt-File viele Fragen von selbst. ■ Über den "Browse"-Button spezifizieren Sie Ihr .hhp-Projekt-File, zweckmäßigerweise legen Sie es im gleichen Verzeichnis an, in dem sich auch die .htm-Dateien befinden (z.B. als Garten.hhp). ■ Wählen Sie die Option "Htm-Files", da Sie die HTML-Dateien ja bereits erstellt haben. ■ Im nächsten Fenster fügen Sie über "Add" die .htm-Dateien hinzu:

■ Klicken Sie nacheinander auf den vorletzten (Save project, contents and index files) und auf den letzten Button (Save all project files and compile) der linken (senkrechten) Symbolleiste des HTML-Help-Workshops. Im Logfenster (rechts) können Sie sich vom Erfolg überzeugen.

30.22 HTML-Hilfe-Dateien erstellen

1761

■ Wählen Sie "View compiled file" (vorletzter Button auf der oberen Symbolleiste), so können Sie in einem einzelnen Hilfefenster bereits die erste Hilfeseite sehen und sich über die von Ihnen angelegten Links zu den anderen Seiten bewegen:

■ Um das Inhaltsverzeichnis zu erstellen, öffnen Sie die Contents-Seite. Option "Create a new contents file" bestätigen und als garten.hhc in das Projektverzeichnis speichern. ■ Klicken Sie auf den Button "Insert a heading" (links, zweiter von oben). ■ Wählen Sie als Entry-Titel: Mein Garten. Klicken Sie den"Edit"-Button im Fenster "Path or URL" und stellen Sie oben das Projekt-File Garten.hhp und unten über den "Browse"-Button die Seite allgemein.htm ein. ■ Klicken Sie auf den Button "Insert a page" (links, dritter von oben). Das Meldungsfenster "Do yo want to insert at the beginning?" mit "Nein" quittieren. ■ Weisen Sie auf die gleiche Art die html-Dateien der ersten untergeordneten Seite zu.

1762

Kapitel 30

How-to: Sonstiges

■ Die gleiche Prozedur wiederholen Sie für alle weiteren untergeordneten Seiten. Beginnen Sie dabei immer im Hauptfenster mit dem Button "Insert a page". Hier keinen der "Add"-Buttons benutzen, sonst kommt es zu einem Compilerfehler! ■ Nach Verlassen des HTML-Workshops öffnen Sie die Hilfe, indem Sie auf die compilierte Hilfe-Datei garten.chm doppelklicken.

■ Das Hinzufügen einer Indexdatei (garten.hkk) funktioniert ähnlich wie bei einer Inhaltsdatei. Diesmal öffnen Sie die Index-Seite über den Button "Insert a keyword". Die einzelnen Keywords ordnen Sie auf analoge Weise ("Edit"-Button) den jeweiligen htm-Seiten zu. Das Ergebnis im Hilfefenster (nach Verlassen des Workshops) zeigt die folgende Abbildung.

30.23 HTML-Hilfe-Dateien in Delphi einbinden

1763

30.23 HTML-Hilfe-Dateien in Delphi einbinden Leider ist eine Antwort auf diesen "Hilferuf" weder der Online-Hilfe noch der gedruckten Dokumentation zu entnehmen. Die Lösung des Problems liegt in der HTML-Help-API von Microsoft. Mit einer zusätzlichen Unit1, welche die HtmlHelp.h nachbildet, sollten Aufruf und Ansteuerung der HTML-Hilfe auch für den Delphi-Programmierer kein Problem sein.

Oberfläche Den Grundaufbau der Programmoberfläche entnehmen Sie bitte der folgenden Abbildung:

Weisen Sie über den Menüpunkt Projekt|Optionen die Datei Garten.chm aus dem vorhergehenden Rezept als Anwendungshilfedatei zu.

Quelltext Auf den Abdruck der Unit HHAPI verzichten wir an dieser Stelle, Sie finden die Datei auf der Buch-CD. Wesentlich ist für uns die API-Funktion HTMLHelp: SYNTAX:

function HtmlHelp(hwndCaller : HWND; pszFile: PChar; uCommand : Integer; dwData : DWORD) : HWND; stdcall; external 'hhctrl.ocx' name 'HtmlHelpA';

Übergeben Sie das Handle des aufrufenden Fensters, den Namen der Hilfe-Datei, eine Konstante für das jeweilige Kommando sowie einen DWord-Wert mit zusätzlichen Informationen. Einbindung der Unit: uses HHAPI;

Anzeige einer bestimmten Hilfeseite: procedure TForm1.Button1Click(Sender: TObject); begin HtmlHelp(0, PChar(Application.HelpFile+'::rasen.htm'), HH_DISPLAY_TOPIC, 0) end;

1

Der Quelltext dieser Unit stammt aus dem Internet.

1764

Kapitel 30

How-to: Sonstiges

Anzeige des Inhaltsverzeichnisses: procedure TForm1.Button3Click(Sender: TObject); begin HtmlHelp(0, PChar(Application.HelpFile), HH_DISPLAY_TOC, 0) end;

Anzeige der Indexseite: procedure TForm1.Button4Click(Sender: TObject); begin HtmlHelp(0, PChar(Application.HelpFile), HH_DISPLAY_INDEX, 0) end;

Auf das Drücken der F1-Taste reagieren wir über das Ereignis FormHelp: function TForm1.FormHelp(Command: Word; Data: Integer; var CallHelp: Boolean): Boolean; begin HtmlHelp(0, PChar(Application.HelpFile), HH_DISPLAY_TOPIC, 0); callhelp := False end;

Vergessen Sie nicht den Parameter callhelp auf False zu setzen, andernfalls ist eine Fehlermeldung zu erwarten.

Test Starten Sie das Programm und testen Sie alle Varianten des Hilfeaufrufs.

30.24 Auf InstallShield verzichten Halten Sie InstallShield (siehe Bemerkungen) nicht für das Nonplusultra aller Installationsprogramme? Für einige Aufgaben zu groß und unflexibel, für andere fehlen Ihnen Möglichkeiten, die nur in der kommerziellen Version vorhanden sind. Dass es auch sehr gute Alternativen gibt, die nicht unbedingt viel kosten müssen, zeigt ein Blick ins Internet. Unter der folgenden Web-Adresse können Sie z.B. eine Trial-Version des Ghost Installer herunterladen: http://www.ginstall.com

Features des Ghost Installer Die wichtigsten Eigenschaften auf einen Blick: ■ Selbstextrahierendes Setup (nur eine Datei zur Weitergabe) ■ Sehr gute Kompression (wesentlich besser als ZIP oder Rar) ■ Mehrsprachen-Unterstützung ■ Versions-/Datumskontrolle ■ Zugriff auf Registrierungsdatenbank und INI-Dateien

30.24 Auf InstallShield verzichten

1765

■ Windows 95/98/Me/NT/2000/XP-kompatibel, je nach System unterschiedliche InstallationsSkripte möglich ■ Erzeugen und Löschen von Programmgruppen/Links ■ Registrierung von COM-Servern ■ Autostart von installierten und externen Programmen ■ Vordefinierte Dialoge ■ Komplettes Uninstall ■ Passwort-Schutz ■ Sehr kleines Install-Modul Einen kleinen Nachteil bei einer derartigen Fülle von Vorteilen wollen wir nicht verschweigen: Über einen Assistenten für das Erzeugen der nötigen Installations-Skripte verfügt der Ghost Installer nicht. Auf der Webseite findet sich jedoch ein Link auf ein derartiges Tool (auch Freeware), das auch für den Einsteiger einfach zu bedienen ist.

Skriptdateien Ein Setup besteht im Wesentlichen aus zwei Skriptdateien: BEISPIEL: Die APP.INS-Datei, in der neben dem Erstellen von Verzeichnissen, dem Kopieren von Dateien

etc. auch das Ausführen von Programmen vor oder nach der Installation möglich ist: [CopyFiles] Files_System=%System%\MyFiles

1766

Kapitel 30

How-to: Sonstiges

[Files_System] test.sys=test.sys,DONT_ASK_USER Test.exe=Test.exe,DONT_ASK_USER [RunApp] RunAfter000="%InstallPath%\Test.exe","127.0.0.1","%InstallPath%",0,"",0

Die GINS.INI-Datei, in der neben dem Aussehen und Verhalten des Installationsprogramms (Sprache, Farben, Dialog) auch das Betriebssystem, die Kompression etc. eingestellt werden kann: [Config] CompressionLevel=7 PreInstallDialogSequence=DLG_LICENSE PostInstallDialogSequence= Languages=Deu InsFiles=App LogFile=%InstallPath%\install.log Uninstall=0 CheckAdminRights=1 SupportedOS=nt4,2k MinOSVersion= NeedReboot=0 ExtraDiskSpace=0 CheckWindow= CheckMutex= RemoveOldReferences=1 [Display] ShowMainWindow=1 GradientTopColor=$00FF0000 GradientBottomColor=$00000000 ... ShowMainTitle=1 ShowDialogTitle=1 ShowFinalDialog=0 ... [Variables] InstallPath=%System%\MyFiles\ ProgramName=Testprogramm Ver.1.1 ProgramGroup= AppFolder=%ProgramsMenu%\%ProgramGroup%

Bemerkung Das erzeugte Installationsprogramm bietet sich schon aufgrund seiner Größe ideal für die Distribution im Internet an. Beispielsweise konnten die Autoren 4,2 MByte Installationsdaten in einem 1,14 MByte großen Setup-Programm unterbringen.

30.25 Ein selbstinstallierendes Programm schreiben

1767

30.25 Ein selbstinstallierendes Programm schreiben Möchten Sie auf ein extra Installationsprogramm verzichten, weil Ihr Projekt nur aus einer einzigen Anwendung besteht, die selbst in der Lage ist, alle nötigen Systemeinstellungen vorzunehmen? Wenn ja, bieten wir Ihnen an dieser Stelle ein kleines Grundgerüst, das die wichtigsten Aufgaben übernimmt: ■ Eintragen/Löschen von Werten in die Registry ■ Erstellen/Löschen von Autostart-Einträgen ■ Kopieren der Datei in ein vordefiniertes Verzeichnis ■ Löschen der Datei beim Deinstallieren ■ Erzeugen/Löschen eines Shortcuts im Startmenü

Oberfläche So gut wie keine, lediglich ein Formular.

Quelltext Binden Sie zunächst die folgende Unit SelfInstall in Ihr Hauptprogramm (*.dpr) ein. Diese Unit definiert einige Hilfsfunktionen, die uns die Arbeit erleichtern sollen. unit u_SelfInstall; interface function IsNT : Boolean; function GetPath_System32 : String; function GetPath_Windows : String; function GetPath_Programs : string; function GetPath_StartMenue : string; function CreateLink(lpszPathObj,lpszPathLink,lpszDesc:string):Boolean; function GetFullDir(dir: string):String; Procedure Delete_Self; implementation

Einige nötige Units: uses ActiveX, ComObj, SHLobj, SysUtils, Windows, Dialogs, Classes; const IID_IPersistFile: TGUID = (D1:$0000010B;D2:$0000;D3:$0000;D4:($C0,$00,$00,$00,$00,$00,$00,$46));

Über diese Funktion können Sie zwischen den Windows NT- und den Windows 9x-Betriebssystemen unterscheiden: function IsNT : Boolean; var VersionInfo : TOSVersionInfo;

1768

Kapitel 30

How-to: Sonstiges

begin VersionInfo.dwOSVersionInfoSize:=SizeOf(VersionInfo); GetVersionEx(VersionInfo); Result := (VersionInfo.dwPlatformId = VER_PLATFORM_WIN32_NT) end;

Einen Shortcut im Startmenü erzeugen: function CreateLink(lpszPathObj,lpszPathLink,lpszDesc : string):Boolean; var psl : IShellLink; ppf : IPersistFile; begin Result := False; CoInitialize(nil); if SUCCEEDED(CoCreateInstance(CLSID_ShellLink, nil, CLSCTX_INPROC_SERVER, IID_IShellLinkA, psl)) then begin psl.SetPath(PChar(lpszPathObj)); psl.SetDescription(PChar(lpszDesc)); if SUCCEEDED(psl.QueryInterface(IID_IPersistFile,ppf)) then begin ppf.Save(StringToOLEStr(lpszPathLink),TRUE); Result := true end end end;

Die folgende Funktion liefert den Standardpfad für Programme (meist "C:\Programme" oder "C:\Programs"): function GetPath_Programs : string; var pidl : PItemIDList; ProgramPath : PChar; begin if SUCCEEDED(SHGetSpecialFolderLocation(0, CSIDL_PROGRAMS, pidl)) then begin ProgramPath := StrAlloc(max_path); SHGetPathFromIDList(pidl, ProgramPath); Result := ProgramPath; StrDispose(ProgramPath); if Copy(Result,Length(Result),1) <> '\' then Result := Result + '\'; end else Result := '' end;

Diese Funktion liefert den Pfad für das Start-Menü (auch nur ein Verzeichnis): function GetPath_StartMenue : string; var pidl : PItemIDList; ProgramPath : PChar; begin if SUCCEEDED(SHGetSpecialFolderLocation(0, CSIDL_COMMON_PROGRAMS, pidl)) then

30.25 Ein selbstinstallierendes Programm schreiben

1769

begin ProgramPath := StrAlloc(max_path); SHGetPathFromIDList(pidl, ProgramPath); Result := ProgramPath; StrDispose(ProgramPath); if Copy(Result,Length(Result),1) <> '\' then Result := Result + '\'; end else Result := '' end;

Um den Pfad des System32-Verzeichnisses zu ermitteln, hilft Ihnen diese Funktion weiter: function GetPath_System32 : String; var p : PChar; i : Integer; begin P:=StrAlloc(MAX_PATH+1); i := GetSystemDirectory(P,MAX_PATH+1); Result := Copy(p,1,i); StrDispose(P); if Copy(Result,Length(Result),1) <> '\' then Result := Result + '\' end;

Auf dem gleichen Weg ermitteln wir auch das Windows-Verzeichnis: function GetPath_Windows : String; var p : PChar; i : Integer; begin P:=StrAlloc(MAX_PATH+1); i := GetWindowsDirectory(P,MAX_PATH+1); Result := Copy(p,1,i); StrDispose(P); if Copy(Result,Length(Result),1) <> '\' then Result := Result + '\' end;

Soll sich das Programm beim Deinstallieren selbst löschen, müssen wir etwas mehr Aufwand treiben. Mit Hilfe einer Batch-Datei lässt sich jedoch auch die widerspenstigste EXE-Datei löschen: Procedure Delete_Self; var batchFile : TStringList; batchName : string; begin batchName := 'c:\__delme.bat'; batchFile := TStringList.Create; batchFile.Add(':Label1'); batchFile.Add('del "' + Paramstr(0)+ '"'); batchFile.Add('if exist "' + Paramstr(0) + '" goto Label1'); batchFile.Add('del ' + batchName); batchFile.SaveToFile(batchName);

1770

Kapitel 30

How-to: Sonstiges

WinExec(PChar(batchName),sw_hide) Halt end;

Weitere Hintergrund-Informationen finden Sie in Ä 27.22 Eine laufende EXE-Datei löschen Die Funktion GetFullDir liefert Ihnen für eine Pfadangabe mit Variablen den realen Namen zurück: function GetFullDir(dir: string):String; begin dir := UpperCase(dir); if pos('%WINDOWS%',dir) > 0 then dir := StringReplace(dir,'%WINDOWS%\',GetPath_Windows,[rfReplaceAll]); if pos('%SYSTEM32%',dir) > 0 then dir := StringReplace(dir,'%SYSTEM32%\',GetPath_System32,[rfReplaceAll]); if pos('%PROGRAMME%',dir) > 0 then dir := StringReplace(dir,'%PROGRAMME%\',GetPath_Programs,[rfReplaceAll]); Result := dir; if Copy(Result,Length(Result),1) <> '\' then Result := Result + '\' end; end.

Das eigentliche Projekt, d.h. die DPR-Datei, müssen Sie wie folgt anpassen: program Project1; uses Forms, ComObj, Classes, SysUtils, Registry, Windows, ShellAPI, Unit1 in 'Unit1.pas' {Form1}, u_SelfInstall in 'u_SelfInstall.pas';

Mit den folgenden Konstanten können Sie das Programmverhalten schnell an Ihre Bedürfnisse anpassen, ohne sich mit den eigentlichen Routinen herumzuärgern. const

Ist lediglich eine laufende Programminstanz zulässig: instOnlyOne : Boolean = True;

Soll das Programm automatisch beim Windows-Start geladen werden: instAutoRun : Boolean = True;

In welchem Registry-Zweig sollen die Autostart-Einstellungen gespeichert werden (zulässig ist HKEY_LOCAL_MACHINE oder HKEY_CURRENT_USER)? instRegRoot : HKEY

= HKEY_LOCAL_MACHINE;

Wie heißt Ihre Firma (für den Eintrag in der Registrierungsdatenbank)? instFirma

: String = 'Software-Sch...';

30.25 Ein selbstinstallierendes Programm schreiben

Welchen Namen hat das Programm? instProgramm : string = 'MeineTestApp';

In welchem Verzeichnis soll das Programm installiert werden? instDir

: string = '%WINDOWS%\Testverzeichnis';

Zulässig sind die Variablen %WINDOWS%, %PROGRAMME% und %SYSTEM32%. Soll ein Shortcut im Startmenü erzeugt werden: instShortCut : Boolean = True; {$R *.RES} var reg : TRegistry; mutex : THandle; begin

Zunächst unterscheiden wir zwischen Installation und Deinstallation: if paramcount > 0 then begin // Install oder Uninstall if UpperCase(Paramstr(1)) = '-U' then begin // UnInstall

Löschen der Registry-Einstellungen: reg := TRegistry.Create; reg.RootKey := instRegRoot; reg.DeleteKey('Software\' + instFirma + '\' + instProgramm); reg.CloseKey;

Löschen der Autostart-Option, wenn vorhanden: if instAutoRun then begin reg.OpenKey('Software\Microsoft\Windows\CurrentVersion\Run', True); if reg.ValueExists(instProgramm) then reg.DeleteValue(instProgramm) end; reg.Free;

Die Uninstall-Einträge aus der Registry entfernen: reg := TRegistry.Create; reg.RootKey := HKEY_LOCAL_MACHINE; reg.DeleteKey('SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\' + instProgramm); reg.Free;

Den Shortcut aus dem Startmenü entfernen: if instShortCut then DeleteFile(PChar(GetPath_StartMenue + instProgramm + '.lnk')); // der Link

Und last, but not least löschen wir das Programm selbst: Delete_Self end;

1771

1772

Kapitel 30

How-to: Sonstiges

Handelt es sich um eine Installation ... if UpperCase(Paramstr(1)) = '-I' then begin // Install

Den Standard-Registry-Eintrag erzeugen; hier können Sie eigene Optionen sichern. reg := TRegistry.Create; reg.RootKey := instRegRoot; reg.OpenKey('Software\' + instFirma + '\' + instProgramm, True); // Hier können diverse Programm-Optionen eingetragen werden // z.B. reg.WriteString('ServerIP',paramstr(2)); reg.CloseKey;

Soll das Programm mit dem Systemstart automatisch geladen werden, muss ein entsprechender Eintrag in die Registrierungsdatenbank vorgenommen werden: if instAutoRun then begin reg.OpenKey('Software\Microsoft\Windows\CurrentVersion\Run', True); reg.WriteString(instProgramm, GetFullDir(instDir) + ExtractFilename(Paramstr(0))); end; reg.Free;

Wir erzeugen das Programmverzeichnis: CreateDirectory(Pchar(GetFullDir(instDir)),nil);

An dieser Stelle lassen wir Ihnen noch etwas Arbeit übrig, Sie könnten hier z.B. noch einen Versions-Vergleich zwischen einer eventuell schon installierten Version Ihres Programms und der neuen Version durchführen. if FileExists(GetFullDir(instDir) + ExtractFilename(Paramstr(0))) then begin // schon einmal da // hier evtl. Versionsinfos vergleichen // wenn Datei neuer, dann löschen der anderen end;

Falls erwünscht, wird ein Programm-Shortcut erzeugt: if instShortCut then CreateLink(GetFullDir(instDir) + ExtractFilename(Paramstr(0)), GetPath_StartMenue + instProgramm + '.lnk', instProgramm);

Für die Deinstallation per Systemsteuerung müssen wir einen Eintrag in der Registry vornehmen: reg := TRegistry.Create; reg.RootKey := HKEY_LOCAL_MACHINE; reg.OpenKey('SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\' + instProgramm, True); reg.WriteString('DisplayName',instProgramm); reg.WriteString('UninstallString',GetFullDir(instDir) + ExtractFilename(Paramstr(0)) + ' -U'); reg.Free;

30.25 Ein selbstinstallierendes Programm schreiben

1773

Wir müssen noch das eigentliche Programm kopieren: if CopyFile(PChar(paramstr(0)), PChar(GetFullDir(instDir) + ExtractFilename(Paramstr(0))), False) then begin

Danach starten wir das Programm aus dem neuen Verzeichnis und beenden die laufende Programminstanz: ShellExecute(0,nil,PChar(GetFullDir(instDir) + ExtractFilename(Paramstr(0))),'','',SW_SHOW); halt(0) end end end;

An dieser Stelle prüfen wir, ob schon eine Instanz des Programms läuft: if instOnlyOne then begin mutex := CreateMutex(nil, True, PChar(instProgramm)); if getLastError = ERROR_ALREADY_EXISTS then halt; end;

Die folgenden drei Zeilen dürften Ihnen bekannt vorkommen: Application.Initialize; Application.CreateForm(TForm1, Form1); Application.Run;

Hier löschen wir noch den Mutex zur Erkennung der Instanzen: if instOnlyOne then ReleaseMutex(mutex); end.

Test Starten Sie das Programm mit der Option "-i", um das Programm zu installieren (Start|Ausführen):

Kontrollieren Sie, ob die Einstellungen in der Registry korrekt vorgenommen wurden. Die Deinstallation können Sie über die Systemsteuerung starten:

1774

Kapitel 30

How-to: Sonstiges

Ergänzung Verwenden Sie einen EXE-Packer (ja, so etwas gibt es immer noch!), so ergeben sich noch einige weitere Vorteile: ■ Die Dateigröße schrumpft bei Delphi-Programmen auf ca. 40 %. ■ Die Datei passt meist auf eine Diskette oder ist schnell aus dem Internet geladen. ■ Der schnelle Blick in die EXE-Ressourcen bleibt dem Home-User verwehrt1. Ein entsprechendes Freeware-Programm (UPX = Ultimate Packer for eXecutables) können Sie unter der folgenden Adresse kostenlos herunterladen: http://upx.tsx.org

Das Programm selbst läuft nur am Prompt, was aber für den ambitionierten Programmierer kein Problem darstellen dürfte.

1

Für den Profi stellen diese und andere Kompressionen kein Hindernis dar.

30.26 Die ZIP-Routinen richtig einsetzen

1775

30.26 Die ZIP-Routinen richtig einsetzen Aufgrund häufiger Leseranfragen zum Thema "ZIP-Routinen" finden Sie an dieser Stelle ein Beispielprogramm sowie ein paar Funktionen, die Ihnen die Routinearbeiten abnehmen sollen. Dabei wurde auf möglichst einfache Verwendbarkeit Wert gelegt; sollten Sie weitere Optionen und Parameter einfügen wollen, steht dem nichts im Wege. HINWEIS: Die mit Delphi mitgelieferten ZIP-Routinen sind nicht kompatibel mit der vor-

liegenden Unit. Sie finden auf der Buch-CD bzw. unter der unten angegebenen Adresse eine aktualisierte Version der ZIP-Routinen. http://home.t-online.de/home/PeterJHaas/delphi.htm

Quelltext (Unit) Unsere Unit hat drei verschiedene Aufgabengebiete: ■ Packen/Entpacken von Strings (das können auch Memofelder etc. sein) ■ Packen/Entpacken von MemoryStreams (z.B. Bilder, Datenbank-Blobfelder etc.) ■ Packen von Dateien in einen Stream (dies kann auch wieder eine Datei oder auch ein MemoryStream sein) bzw. Entpacken eines Streams in eine Datei (sinnvoll für den Import/Export von Dateien in Datenbank-Blobfelder) Die Umsetzung: unit u_Packer; interface uses Classes;

1776

Kapitel 30

function CompressString(source:string): string; function DeCompressString(source:string): string; procedure CompressStream (var src:TMemoryStream); procedure DeCompressStream(var src:TMemoryStream); procedure CompressFileToStream(srcfilename: string; dest:TStream); procedure DeCompressStreamToFile(src:TMemoryStream; destfilename: String); implementation uses Zlib, Dialogs, SysUtils ;

Soll es schneller gehen, können Sie die Puffergröße anpassen: const BufferSize = 4096; procedure CompressStream(var src:TMemoryStream); var dest : TMemoryStream; ZStream : TCustomZLibStream; begin dest := TMemoryStream.Create; src.position := 0; ZStream := TCompressionStream.Create(clFastest, dest); try ZStream.CopyFrom(src, 0); finally ZStream.Free end; src.size := 0; src.CopyFrom(dest,0); src.Position := 0; dest.Free end; procedure CompressFileToStream(srcfilename: string; dest:TStream); var src : TFileStream; ZStream : TCustomZLibStream; begin src := TFileStream.Create(srcfilename,fmOpenRead + fmShareDenyNone); ZStream := TCompressionStream.Create(clDefault, dest); try ZStream.CopyFrom(src, 0); finally ZStream.Free; end; src.Free end;

How-to: Sonstiges

30.26 Die ZIP-Routinen richtig einsetzen

procedure DeCompressStream(var src:TMemoryStream); var dest : TMemoryStream; ZStream : TCustomZLibStream; Count : Integer; Buffer : array[0..BufferSize-1] of Byte; begin dest := TMemoryStream.Create; src.position := 0; ZStream := TDecompressionStream.Create(src); while True do begin Count := ZStream.Read(Buffer, BufferSize); if Count <> 0 then dest.WriteBuffer(Buffer, Count) else Break; end; ZStream.Free; src.size := 0; src.CopyFrom(dest,0); src.Position := 0; dest.Free end; procedure DeCompressStreamToFile(src:TMemoryStream; destfilename: String); var dest : TFileStream; ZStream : TCustomZLibStream; Count : Integer; Buffer : array[0..BufferSize-1] of Byte; begin dest := TFileStream.Create(destfilename,fmCreate); src.position := 0; ZStream := TDecompressionStream.Create(src); while True do begin Count := ZStream.Read(Buffer, BufferSize); if Count > 0 then dest.WriteBuffer(Buffer, Count) else Break; end; ZStream.Free; src.Position := 0; dest.Free end; function CompressString(source:string): string; var src, dest : TMemoryStream; ZStream : TCustomZLibStream; begin src := TMemoryStream.Create; dest := TMemoryStream.Create; src.write(source[1],length(source)); src.position := 0; ZStream := TCompressionStream.Create(clFastest, dest); try

1777

1778

Kapitel 30

How-to: Sonstiges

ZStream.CopyFrom(src, 0); finally ZStream.Free; end; src.Free; setlength(result,dest.size); dest.position := 0; dest.read(result[1],dest.size); dest.Free end; function DeCompressString(source:string): string; var src, dest : TMemoryStream; ZStream : TCustomZLibStream; Count : Integer; Buffer : array[0..BufferSize-1] of Byte; begin src := TMemoryStream.Create; dest := TMemoryStream.Create; src.write(source[1],length(source)); src.position := 0; ZStream := TDecompressionStream.Create(src); while True do begin Count := ZStream.Read(Buffer, BufferSize); if Count <> 0 then dest.WriteBuffer(Buffer, Count) else Break; end; ZStream.Free; src.Free; setlength(result,dest.size); dest.position := 0; dest.read(result[1],dest.size); dest.Free; end; end.

Oberfläche (Testprogramm) Unser Testprogramm demonstriert alle drei Varianten des Packens und Entpackens. Neben zwei Memofeldern brauchen Sie lediglich drei Buttons:

30.26 Die ZIP-Routinen richtig einsetzen

1779

In das linke Memofeld fügen Sie zur Entwurfszeit schon etwas Text ein, der zur Laufzeit gepackt wird.

Quelltext (Testprogramm) Einbinden der neuen Unit: uses u_Packer;

Das Packen und Entpacken von Strings: procedure TForm1.Button1Click(Sender: TObject); var zw : string; begin zw := CompressString(Memo1.Text); Memo2.Text := DeCompressString(zw); ShowMessage('Originallänge:' + IntToStr(Length(Memo1.Text)) + ' Gepackt:' + IntToStr(Length(zw))) end;

Nach dem Entpacken wird der String im Memofeld2 angezeigt, quasi als Beweis, dass die Routine richtig arbeitet. HINWEIS: Der gepackte String kann nicht angezeigt werden, da er Steuerzeichen enthalten

kann. Das Packen und Entpacken von MemoryStreams: procedure TForm1.Button2Click(Sender: TObject); var ms : TMemoryStream; begin ms := TMemoryStream.Create; Memo1.Lines.SaveToStream(ms); CompressStream(ms); ShowMessage('Originallänge:' + IntToStr(Length(Memo1.Text)) + ' Gepackt:' + IntToStr(ms.Size)); Memo2.Lines.Clear; DeCompressStream(ms); Memo2.Lines.LoadFromStream(ms) end;

Bei der Variante des Packens von Dateien benutzen wir einen MemoryStream als Zwischenpuffer: procedure TForm1.Button3Click(Sender: TObject); var ms : TMemoryStream; begin ms := TMemoryStream.Create; CompressFileToStream('.\zlib\zlib.pas',ms); ms.SaveToFile('.\test.zip'); ms.Free ms := TMemoryStream.Create;

1780

Kapitel 30

How-to: Sonstiges

ms.LoadFromFile('.\test.zip'); DeCompressStreamToFile(ms, '.\test.pas'); ms.Free; Memo2.Lines.LoadFromFile('.\test.pas') end;

Test Starten Sie das Programm und probieren Sie alle drei Varianten aus. Während des Tests wird Ihnen die Größe der gepackten Daten angezeigt.

Anhang

Anhang A: Glossar Begriff

Bedeutung

Bemerkung

ADO

ActiveX Data Objects

ältere Datenzugriffstechnologie von Microsoft

ADO.NET

neue Datenzugriffstechnologie von Microsoft für .NET

ANSI

American National Standard Institute

US-amerikanische Standardisierungsbehörde

API

Application Programming Interface

allgemeine Schnittstelle für den Anwendungsprogrammierer

ASCII

American Standard Code for Information Interchange

klassisches Textformat

ASP

Active Server Pages

Webseiten mit serverseitig ausgeführten Skripten

BDE

Borland Database Engine

Lokales Datenbanksystem von Borland

BDP

Borland Data Provider

hauseigener Datenprovider von Borland

BLOB

Binary Large Object

binäres Objekt, z.B. Grafik

BO

Business Object

Geschäftsobjekt

CAO

Client Activated Objects

vom Client aktiviertes Objekt (.NET Remoting)

CGI

Common Gateway Interface

Möglichkeit für die Verarbeitung von Anfragen auf einem Webserver

CLI

Common Language Infrastructure

Standard für alle .NET-Programmiersprachen

COM

Common Object Model

allgemeines Objektmodell von Microsoft

CSV

Comma Separated Variables

durch bestimmte Zeichen getrennte Daten (meist Komma)

CTS

Common Type System

Datentypen, die von .NET unterstützt werden

DAO

Data Access Objects

klassische Datenzugriffsobjekte

DC

Device Context

Gerätekontext

DCOM

Distributed Component Object Model

auf mehrere Rechner verteiltes COM

DISCO

WebService Discovery

XML-Protokoll zum Aufsuchen von Webdiensten

1782

Anhang

Begriff

Bedeutung

Bemerkung

DLL

Dynamic Link Library

Laufzeitbibliothek, die von mehreren Programmen benutzt werden kann

DQL

Data Query Language

Untermenge von SQL zur Datenabfrage

DDL

Data Definition Language

Untermenge von SQL zur Datendefinition

DML

Data Manipulation Language

Untermenge von SQL zur Datenmanipulation

DMO

Distributed Management Objects Objekte z.B SQLDMO zum Administrieren des SQL Servers

DNS

Domain Name Service

Umwandlung von Domain-Namen in IP-Adresse

DOM

Document Object Model

objektorientiertes Modell für den Zugriff auf strukturierte Dokumente

DSN

Data Source Name

Name einer Datenquelle

DTS

Data Transformation Services

SQL-Server-Dienst, zum Transformieren von Daten

FCL

Framework Class Library

.NET-Klassenbibliothek

FSM

Finite State Machine

Endlicher Zustandsautomat

FTP

File Transfer Protocol

Internet-Protokoll für Dateitransfer

FQDN

Full Qualified Domain Name

Host-Name des Servers in URL

FSO

File System Objects

Objektmodell für Zugriff auf Laufwerke, Verzeichnisse und Dateien

GAC

Global Assembly Cache

allgemein zugänglicher Speicherbereich für Assemblies

GDI

Graphical Device Interface

Grafikfunktionen der Windows API

GLS

Gleichungssystem

Begriff der numerischen Mathematik

GUI

Graphical User Interface

grafische Benutzerschnittstelle

GUID

Global Unique Identifier

eindeutiger Zufallswert (128 Bit) zur Kennzeichnung von Klassen

HTML

Hypertext Markup Language

Sprache zur Gestaltung statischer Webseiten

HTTP

Hypertext Transfer Protocol

Protokoll für Hypertextdokumente

IBX

Interbase-Komponenten

ICMP

Internet Control Message Protocol

Nachrichtenprotokoll im Internet

ID

Identifier

Identifikationsschlüssel

IDC

Internet Database Connector

... enthält Infos zum Herstellen einer Verbindung bzw. Ausführen von SQL

IDE

Integrated Development Environment

Integrierte Entwicklungsumgebung

1783

Anhang

Begriff

Bedeutung

Bemerkung

IE

Internet Explorer

... oder Internet Browser

IIS

Internet Information Server

... oder Internet Information Services

IL

Intermediate Language

Zwischencode von .NET

ISAM

Indexed Sequence Access Method

indexsequenzielle Zugriffsmethode

ISAPI

Internet Server API Interface

Web-Anwendung (DLL) für IIS und IE

Jet

Joint Engineers Technology

lokales Datenbanksystem von Microsoft

LAN

Local Area Network

lokales Rechnernetzwerk

MDAC

Microsoft Data Access Components

Datenzugriffskomponenten (ab Version 2.6), müssen auf Zielcomputer installiert sein

MIDAS

Multi-tier Distributed Application Services

ehemalige Bezeichnung für Technik verteilter Anwendungen

MS

Microsoft

Software-Gigant

MSDE

Microsoft Data Engine

abgerüstete SQL Server-Datenbank-Engine

MSDN

Microsoft Developers Network

eine (fast) unerschöpfliche Informationsquelle für den Windows-Programmierer

MSIL

Microsoft Intermediate Language

Zwischencode für .NET

MSXML

Microsoft XML Core Services

ODBC

Open Database Connectivity

OLAP

On-Line Analytical Processing

OLE

Object Linking and Embedding

Microsoft-Technologie zum Verknüpfen und Einbetten von Objekten

OOP

Object Oriented Programming

Objektorientierte Programmierung

PAP

Programmablaufplan

POP3

Post Office Protocol Version 3

Posteingangsserver

PWS

Personal Web Server

abgerüstete Version des IIS

RAD

Rapid Application Development schnelle Anwendungsentwicklung

RDBMS

Relational Database Management System

Relationales Datenbank-Management-System

RDS

Remote Data Services

Objektmodell für Datenverkehr mit Remote Server

RPC

Remote Procedure Call

Aufruf einer entfernten Methode

RTL

Runtime Library

Laufzeitbibliothek

SAO

Server Activated Object

vom Server aktiviertes Objekt (.NET Remoting)

OLE DB

allgemeine Datenbankschnittstelle

Schnittstelle für den universellen Datenzugriff

1784

Anhang

Begriff

Bedeutung

Bemerkung

SDK

Software Development Kit

Entwickler-Tools

SGML

Standard Generalized Markup Language

Regelwerk zur Definition von Auszeichnungssprachen für Dokumente

SMTP

Simple Mail Transport Protocol

TCP/IP-Protokoll für die Übertragung von Nachrichten zwischen einzelnen Computern

SOAP

Simple Object Access Protocol

Protokoll zum XML-basierten Zugriff auf Objekte

SOM

Schema Object Model

zusätzliche APIs für den Zugriff auf XML Schema-Dokumente

SQL

Structured Query Language

Abfragesprache für Datenbanken

SSL

Secure Socket Layer

Sicherheitsprotokoll für Datenübertragung

TCP/IP

Transmission Control Protocol/ Internet Protocol

Netzwerkprotokoll zum Datentransfer, IP-Adresse ist 32-Bit-Zahl

UDL

Unified Data Link

standardisierte Datenverbindung

UDP

Unified Data Protocol

standardisiertes Datenprotokoll

UI

User Interface

Benutzerschnittstelle

UML

Unified Modelling Language

Sprache zur Beschreibung von Objektmodellen

UNC

Uniform Naming Convention

System zur Benennung von Dateien in vernetzten Umgebungen

URL

Uniform Resource Locator

Web-Adresse

VCL

Visual Component Library

Delphi-Klassenbibliothek

WMI

Windows Management Instrumentation

Klassen zur Windows-Administration

WSDL

Web Services Description Language

XML-basierte Beschreibungssprache für Webdienste

W3C

Consortium

Standard

WWW

World Wide Web

Teil des Internets

XML

Extensible Markup Language

universelle textbasierte Beschreibungssprache

XSD

XML Schema Definition Language

XML-Dialekt zur Beschreibung von Datenstrukturen

XSLT

Extensible Stylesheet Language Transformations

Technologie zum Transformieren der Struktur von XML-Dokumenten

1785

Anhang

B: ANSI-Tabelle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

BS TAB LF

CR

32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

[space] ! " # $ % & ' ( ) * + , . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?

64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95

@ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _

96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127

` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~

1786

Anhang

128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159

160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191

[space] ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª « ¬ ® ¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿

192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223

À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ü Ý Þ ß

224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255

à á â ã ä å æ ç è é ê ë ì í î ï ð ñ ò ó ô õ ö ÷ ø ù ú û ü ý þ ÿ

Index

Index

2D-Vektorgrafik, 364, 377 7-Segmentanzeige, 566 .NET, 622 .NET-Assembly, 622 .NET-Komponenten, 624 {$ELSE}, 1733 {$ENDIF}, 1733 {$IF xxx}, 1733

A Abbildungsmodi, 765 abgerundetes Rechteck, 343 Abort, 506 Aborted, 505 Abs, 106, 1670 absolute, 71 abstract, 284, 539 Access , 1443 Access-Datenbank, 1418 Action, 180 Active Desktop, 1651 ActiveControl, 195 ActiveX, 577 ActiveX-Control, 612 ActiveX-DLL, 1542 ActiveX-Documents, 578 ActiveX-Form, 619 AddChild, 1592 AddExitProc, 492 AddFontResource, 1625 Addr, 120

Address, 1550 ADO, 1377 ADOQuery, 1380, 1398 Advanced-Grafikmodus, 1138 Alias, 447, 1325, 1329 Align, 186, 1094 Alignment, 203 AllowAllUp, 1022 and, 71, 955 Animation, 351, 825, 1097 ANSI, 386, 387, 487, 1262 AnsiChar, 76 AnsiString, 82 AnsiUpperCase, 1353 Append, 381, 387 APPEND, 1395 AppendMenu, 1017 AppendStr, 109 Application, 1707 ApplicationEvents, 980 ApplyUpdates, 1548, 1560 Arbeitsspeicher, 1597 Arc , 344 ArcCos, 108 ArcSin, 108 ArcTan, 106 ArrangeIcons, 179 Array, 71, 1265 Array-Eigenschaften, 537 Arrays, 91, 655 as, 71

1788

Index

ASCII, 386, 1262 ASCII-Zeichen, 960 asm, 71 assembler , 71 AssemblyKeyFile-Attribut, 624 Assign, 1099, 1100 Assigned, 1003 AssignFile, 381 AssignPrn, 1430 AssignStr, 109 AsText, 482 at, 72 Attribute , 287 Audio-CD, 1214 Aufrufkonvention, 486 Aufrufkonventionen, 497 Aufzählungstyp, 532 Auslagerungsdatei, 1597 Ausschneiden, 483 Austauschverfahren, 1680 Austrittsprozedur, 491, 496 Auswahlverfahren, 657 Autorun, 1217 AUTORUN.INF, 1217 AutoScroll, 195 AVI, 1197 AVI-Videos, 1201

B Backup, 1714 Backupfile, 1332 BAS, 1244 BAT, 1244 BatchMove, 845, 1414 Baumansicht, 1297 BDE, 1284, 1314, 1317 Bedienoberfläche, 149 bedingte Kompilierung, 1733 Beep, 1190

Befehlsschaltfläche, 202 BeforeDelete, 1334 BeforeNavigate, 1517 begin, 72 BeginDoc, 506 BeginDrag, 194 BeginPaint, 764 BeginPath, 797, 1143 BeginUpdate, 1592 benannte Parameter, 594 Berechnete Felder, 1342 Bericht, 1443 Betriebssystem, 1496 Bezeichner, 71 Bezeichnungsfeld, 202 Bézierkurven, 794, 1140 BIFF-Format, 1718 Bildeditor, 1000 Bildlaufleisten, 1018 Bildschirmauflösung, 978, 1597 Bildschirmkoordinaten, 1436 Bildschirmschoner, 1135 Binärdateien, 393 Binäre Bäume, 736 BitBlt, 1116, 1121, 1125 Bitmap, 563, 778, 967, 1115, 1128, 1699 BlockRead, 382, 431 BlockWrite, 382, 431 BMP, 1244 Bogenmaß, 1140 Bogenstück, 344 Boolean, 76 BorderIcons, 195 BorderStyle, 195, 226, 965 Borland Database Engine, 1314 Borland Socket Server, 1549, 1559 Botschaftsbehandlung, 484, 1182 brc32.exe, 1106 Break, 103 Break , 105

1789

Index

Breakpoint, 249 BringToFront, 194 Browser, 1516 Brush, 775, 1071, 1156 Bubble-Sort, 659 Busy, 1517 Byte, 76 ByteBool, 76 ByVal, 501

C C, 53 C#, 625 caFree, 180 CalcOp, 1449 CalcText, 1452 CALLBACK, 486 Callback-Funktion, 1710 Callback-Prozedur, 1603 CancelUpdates, 1548, 1560 Canvas, 337, 340, 505, 762, 905, 999, 1051, 1089, 1650 Canvas.Handle, 505, 511 CapsLock-Taste, 1623 Caption, 186, 195, 202 Cascade, 179, 198 case, 72, 104 CD-Laufwerk, 1213 cdecl, 72, 490 CellRect, 223 Cells, 1293, 1430 CF_BITMAP, 482 CF_METAFILE, 482 CF_OBJECT, 482 CF_PICTURE, 482 CF_TEXT, 482 ChangeFileExt, 382 Char, 76 CharSet, 787 Chart, 1092

Checkbox, 207, 1653 Checked, 212, 982, 1417 CheckListBox, 1417 Chord , 344 Chr, 120 circa, 1670 class, 284 ClassInterfaceAttribute, 624 Clear, 481 Client, 1581 ClientDataSet, 1346, 1547, 1554 ClientHeight, 195, 979, 1169 ClientWidth, 195, 979, 1169 Clipboard, 1100 ClipBrd, 1006 ClipCursor, 998 Clipping, 795, 1142 ClipPrecision, 788 Close, 198, 482 CloseCurrentDatabase, 1444 CloseFile, 381, 1430 CloseHandle, 1596 CloseKey, 1771 CloseQuery, 198 CLR, 622 Cluster, 1225 CM_MOUSEENTER, 1003 CMD, 1244 CoCreateInstance, 1647 Code-Komponenten, 578 Col, 220 ColCount, 220 Color, 186, 195 ColorDialog , 357 ColWidths, 220, 1052 COM, 577 CombineRgn, 796, 1212 Combobox, 1038, 1053 CommandStateChange, 1517 Commit, 1338 Common Language Runtime, 622

1790

Index

comobj, 1443 Comp, 76 CompareStr, 109 CompareText, 109 ComponentIndex, 316 Components, 316 CompressFileToStream, 1776 CompressionQuality, 1110 CompressStream, 1776 CompressString, 1776 Computername, 1496, 1597 Concat, 109 ConnectionString, 1377, 1394, 1397 CONSOLE, 1734 const, 72 constructor, 284, 1486 Contextstrings, 1742 Continue, 104 Control Panel, 1631 ControlCount, 1071 Copy, 109, 990, 1033 CopyFile, 431 CopyFrom, 397, 431 CopyRect, 1115, 1163 Cos, 106 Cosmetic Pens, 771 CPL, 1632 CPlApplet, 1632 CPU386, 1734 CRC-Prüfsumme, 1674 Create, 199, 314, 540 CreateCaret, 995 CreateCompatibleDC, 765 CreateDC, 765 CreateDirectory, 1645, 1772 CreateEllipticRgn, 795, 1208, 1212 CreateFile, 398 CreateFileMapping, 399 CreateFont, 786, 1119 CreateForm, 175

CreateFromID, 1107 CreateHatchBrush, 776 CreateIC, 765 CreateKey, 405 CreateMutex, 1773 CreateOleObject, 587, 1443 CreatePalette, 1167 CreateParams, 970, 974, 977 CreatePatternBrush, 968 CreatePen, 772 CreatePolygonRgn, 1212 CreateProcess, 1576, 1578, 1596 CreateRectRgn, 795 CreateResFmt, 257 CreateSolidBrush, 775, 1151 CreateToolhelp32Snapshot, 1607 CreateWithComment, 784 Ctl3D, 186, 195 Currency, 76 CurrencyDecimals, 911 CurrencyString, 911 Cursor, 186, 196, 1726 Cursor-Eigenschaft, 999

D Damerau-Levenstein, 1352 Data, 1296 DatabaseName, 450, 452, 1329 DataChange, 549, 1357 DataSetProvider, 1544 DataSource, 440, 451 DataToStr, 927 Date, 115 Datei, 429 Datei-Menü, 150 Dateibetrachter , 1244 Dateidialog, 409, 411, 1271 Dateien, 381 Dateinamen, 1264

1791

Index

Dateiverknüpfungen, 407, 1635 Datenbank, 1345 Datenbankapplikation, 1329 Datenbankformate, 434 Datenbankstruktur, 896 Datenexport, 846 Datensatz, 435 Datensatznavigator, 452 Datentypen, 75, 487 Datenverknüpfungsdatei, 1383 DateSeparator, 915 DateTimePicker, 1076 DateTimeToStr, 115, 915, 923 DateTimeToString, 115 DateToStr, 115, 923 Datum, 114, 925, 928 Datumsdifferenzen, 922 Datumsformat, 915 DayOfWeek, 115 dBASE, 1335 DBCheckListbox, 1360 dbclient.dll, 1346 DBGrid, 1306, 1307, 1308, 1311, 1720 DbiDoRestructure, 1319 DBIPackTable, 1336 DBIPROCS, 1336 DBNavigator, 460, 897, 1547 DC, 763, 1138, 1147 DCOM, 1543 DCOMConnection, 1545 DDB, 779 Debugger, 243 Dec, 120 DecimalSeparator, 911 Declarations-Abschnitt, 500 DecodeDate, 115 DecodeTime, 115, 952, 1076, 1672 DeCompressStream, 1776 DeCompressStreamToFile, 1776 DeCompressString, 1776 default, 284

DefaultColWidth, 220 DefaultDrawing, 220 DefaultExt, 1275 DefaultRowHeight, 220, 1430 Definitionsdatei, 495 DegToRad, 1140 Deinstallationsroutine, 1593 Dekadischer Logarithmus, 108 Deklarationsabschnitt, 538 Delay, 1705 delChar, 942 Delete, 109, 1035, 1418 DeleteDC, 765 DeleteFile, 382, 1771 DeleteKey, 1771 DeleteObject, 1146 DeleteRow, 1056 DELPHIMM.DLL, 487 dereferenzieren, 722 Desktop-Icon, 1648 Destroy, 199, 314, 541 destructor, 284 Destruktor, 541 Device, 356 Dezimaltrenner, 63 DFM-Datei, 1086 Diagramm, 1155 DIB, 779 Differentialgleichung, 677 Digitalanzeige, 566 DirectoryListbox, 410, 1064, 1231, 1245, 1249, 1666 DirList, 1064, 1249 DiskCopyRunDll, 1220 Diskette, 1219 DiskFree, 382, 1227 Diskretisierungsfehler, 681 DiskSize, 382, 1227 DisplayLabel, 1341 DisposeStr, 109 div, 72, 81

1792

Index

DLL, 485, 524 DllMain, 496 do, 72 Double, 76 DownloadBegin, 1517 DownloadComplete, 1517 downto, 72 Drag & Drop, 1063, 1065, 1159, 1298, 1496 DragAcceptFiles, 1661 DragCursor, 186 DragFinish, 1661 Dragging, 194 DragMode, 186, 1064, 1300 DragQueryFile, 1661 Draw, 969, 1051, 1123 DrawCell, 905 DrawGrid, 234, 897, 905 DrawText, 792, 1040, 1043, 1148 Drehen, 1128 Drehwinkel, 1118 DriveCombobox, 410, 415, 1064, 1215, 1245, 1249 Druckausgabe, 908 Drucker, 504, 516, 518, 1423 Druckerauflösung, 766, 1425 Druckerdialog, 507, 837, 1078 Druckerkoordinaten, 1436 Druckvorschau, 443, 1432 DSeg, 120 dynamic, 284, 539 Dynamic Link Library, 485 Dynamische Arrays, 743 Dynamische Variablen, 725

E EditorMode, 220, 221 Eigenschaften, 38, 530, 609 Einbetten, 579 Einfügen, 483

Eingabemaske, 465 Electronic Book, 1737 Elektrotechnik, 889 Ellipse, 342, 1160, 1170 else, 72 EMail, 1525, 1527 Embedding, 579 Enabled, 186, 196, 212 EncodeDate, 115 EncodeTime, 115 end, 72 EndDoc, 506, 511 EndPaint, 764 EndPath, 797, 1143 EndUpdate, 1593 Enhanced Metafiles, 782 Enter-Taste, 64, 1059 Entitätsbeziehungen, 435 EnumFonts, 1710 EnumWindowsProc, 1603, 1605 Eof, 382 EoLn, 381 Erase, 382 Ereignisprozedur, 1571 Ereignisse , 39 Event, 39, 542, 1571 Event Handler , 291 Excel, 587, 593, 626, 1718 except, 72 Exception, 256 Exchange-Sort, 656, 1680 EXE-Packer, 1774 Execute, 1125 Exit, 105, 990 Exitprozedur, 492 Exp, 106 ExpandFileName, 382 Explorer, 1661 export, 72 exports, 486, 490

1793

Index

ExtCreatePen, 772, 1145 ExtDeviceMode, 510 extended, 76 external, 72, 494 ExtractFileExt, 382, 1109 ExtractFilename, 1772 ExtractFileName, 382 ExtractFilePath, 382, 1331

F far, 72 Farbauflösung, 1496 Farbauswahl, 1485 Farbeigenschaften, 348 Farben, 346, 1126 Farbkonstanten, 347 Farbpalette, 1152 Farbtausch, 1127 Farbtiefe , 1111 Farbverlauf, 1151, 1152 Fehler, 252 Fehlerbehandlung, 251, 494 Fehlerklassen, 256 Feld, 435 Festplattenseriennummer, 1615 FieldByName, 1291 FieldCount, 1293 FieldDefs, 1340, 1347 FieldKind, 1341 FieldName, 1293, 1341 file, 72 File of Byte, 1240 FileCreate, 384 FileExists, 382, 1772 FileGetAttr, 382 FileGetDate, 383 FileListbox, 410, 1064, 1245, 1249, 1666 FileOpen, 385 FilePos, 382 FileRead, 384

FileSearch, 383 FileSeek, 384 FileSetAttr, 383 FileSetDate, 383 FileSize, 382 FileStream, 421, 1044, 1240, 1268, 1718 Fileviewer, 1244 FileWrite, 384 FillChar, 1596 FillRect, 968, 1041, 1071, 1090 Filter, 1275, 1300 FilterCombobox, 410 FilterIndex, 1275 FilterRecord, 1353 finally, 72 FindClose, 383, 384, 1215, 1219, 1243 FindComponent, 1470 FindField, 1340 FindFirst, 383, 426, 1215, 1219, 1240, 1243 FindFirstChangeNotification, 1239 FindNext, 383, 426, 1243 FindText, 1291 FindWindow, 1648, 1653 FixedColor, 220 FixedCols, 220, 1293 FixedRows, 220, 1293 Floodfill, 819 Fluchtpunktperspektive, 812 Flush, 382 FmtLoadStr, 109 Folder, 1644 Font, 186, 196 Fontabmessungen, 354 Fontdialog, 355, 837, 1078 Fonts, 219, 505, 785, 1660 for, 72, 102 Format, 146, 912, 1430 Format-Strings, 111 FormatCount, 482 FormatDateTime, 115, 915, 919, 921, 927, 1076 Formatierungsanweisungen, 112

1794

Index

Formats, 482 Formatstrings, 146 Formel-Parser, 872 FormMouseMove, 1161 FormMouseUp, 1161 FormPaint, 1160 FormStyle, 196, 966, 973 Formular, 38, 171, 962 forward, 72 Frames , 214 Framework, 622 FreeMem, 721, 753, 1278 FTP, 1511 Füllfarbe, 348 Füllmuster, 348 function, 72, 122 Funktionsparameter, 490, 497

G GAC, 626 Gauge, 415 Gauss, 667, 669 GDI, 1135 Geometric Pens, 771 Gerätekontext, 763, 770 GetActiveOleObject, 587, 1443 GetAsHandle, 482 GetAsyncKeystate, 1706 GetCurrentProcess, 1610 GetDC, 764, 1163, 1650 GetDCEx, 764 GetDeskTopWindow, 1163 GetDeviceCaps, 518, 1441 GetDir, 382, 1230 GetDiskFreeSpace, 1225 GetFileVersionInfo, 1728 GetFileVersionInfoSize, 1728 GetFormImage, 199, 1165, 1700 GetHostByName, 1509

GetIPAddress, 1509 GetKeyboardState, 1623 GetMem, 120, 721, 725, 753, 1278 GetModuleFileNameEx, 1608 GetPort, 1190 GetPrinter, 506 GetProcAddress, 494 GetShortFilename, 1264 GetShortPathName, 1264 GetStockObject, 771, 776, 1119 GetSysColorBrush, 776 GetSystemMenu, 1016, 1017 GetSystemMetrics, 1147 GetSystemPaletteEntries, 1167 GetTableNames, 1325 GetTickCount, 1610 GetVolumeInformation, 1213, 1216, 1225, 1615 GetWindowDC, 1147 GetWindowLong, 1604 GetWindowText, 1604 GetWindowThreadProcessID, 1603, 1605 Gleichungssysteme, 667 Gleitkommazahlen, 1669 Global Assembly Cache, 626 Glyph, 1101 GoBack, 1517 GoForward, 1517 GoHome, 1517 GoSearch, 1517 goto, 72 Grafik, 337 Grafikanimation, 1121 Grafikmodus, 1653 Graphic, 1107 Graphics, 784 GrayScale, 1107 GridHeight, 220 GridLineWidth, 220 GridWidth, 220 Großbuchstaben, 304, 940

1795

Index

H Halt, 120 Handle, 505, 762, 908 HasFormat, 482 Hatch Brush, 776 Hauptformular, 173 Hauptindex, 437 HDC, 763 Heap, 488, 892, 1277 Height, 186, 219, 340 Help-Workshop, 1745 HelpCommand, 1757 HelpContext, 186 HelpFile , 217 Hexadezimalzahlen, 77 Hi, 120 Hide, 194, 199 Hierarchie, 1295 High, 77 Hilfedatei, 1745 Hilfeprogrammierung, 1737 HInstance, 1107 Hint, 186 Hintergrundbitmap, 362 HKEY_CLASSES_ROOT, 403 HKEY_CURRENT_USER, 403, 405 HKEY_LOCAL_MACHINE, 403, 1587 HKEY_USERS, 403 HlinkGoBack, 1526, 1529 HlinkGoForward, 1526, 1529 HlinkNavigateString, 1526, 1529 Host, 1550 Hotkey, 1626 HOTKEY, 1626 Hotspot, 1208, 1209 hPrevInst, 1630 HTML, 443, 619, 1517 HTML Help Workshop, 1759 HTML-Datei, 1512 HTML-Help, 1758, 1759

HTTP, 1553 httpsrvr.dll, 1553 Hyperlink, 1526, 1529

I ICO, 1244 Icon, 1726 if, 72, 104 IL, 622 Image, 358, 1089, 1113 Image-Komponente, 1113 ImageList, 1096, 1098 implementation, 702, 1486 in, 72, 750 In-Process, 578 In-Process-Server, 605 Inc, 120 Index, 72, 434, 1326 IndexDefs, 1313 Indextypen, 437 inherited, 284, 562 INI, 1244 INI-Datei, 401 Initialize, 175 inline, 72 InputBox, 258, 264, 268 InputQuery, 265 Insert, 109 InsertRow, 1056, 1074 Installation, 35 Installationsdisketten, 1365 Installationsprogramm, 1767 InstallShield, 1365, 1764 Instancing, 606 Instanz, 286, 1630 Int, 106 Integer, 76, 488 Integration, 683 Integrationsverfahren, 681 Interface, 609, 701, 1465

1796

Index

Internet Explorer, 620, 1517 Internet Information Server, 1553 InternetGetConnectedState, 1509 Interval, 216, 964 IntToStr, 109, 924, 1090 InvertRgn, 796 IOResult, 251, 382, 388 IP-Adresse, 1508 IPersistFile, 1647 is, 284 IsDate, 925 isDigit, 941, 942 IsEmpty, 1293 isFloat, 942 isGerade, 941, 942 IShellLink, 1647 IsIconic, 1604 isLower, 750, 940, 942 IsTCPIP, 1507 IsTime, 925 isUpper, 750, 940, 942 IsValidIdent, 109 IsWindowVisible, 1604 ItemHeight, 1098 ItemIndex, 210, 982, 1031, 1595 Items, 209, 933, 935, 1053, 1417 Items.Count, 210 Iterationsschleife, 1682 IUnknown, 1527, 1529

J Jahr 2000, 119, 922, 952 Jahreszahlen, 929 Java, 53 JavaScript, 1517 Join, 1345 Joystick, 1179 JPEG, 1105, 1108

K Kalender, 1076 Kartesische Koordinaten, 1687 KeyFields, 1338, 1341 KeyPress-Ereignis, 987 KeyPreview, 191, 987 KeyValues, 1338 KillProcessByPID, 1606 Kindfenster, 201 Klassen, 528 Klassendefinition, 538 Kleinbuchstaben, 940 Komma, 63 Kompilerschalter, 1733 komplexe Zahlen, 1687, 1694 Komponente, 38, 527, 1470, 1478, 1485 Komponenten-Experte, 564 Komponentenpalette, 219 Kompression, 1764 Konfigurationsdatei, 1734 Konsolenanwendung, 930 Konstanten, 88 Konstantenarrays, 1042 Konstruktor, 323, 540 Kontextmenü, 407, 1635 Koordinaten, 339, 996 Koordinatensystem, 415, 765, 1137 Kopieren, 429, 483, 1248 Kopierschutz, 1615 Kreis, 342 Kreisstück, 344 Kreuzworträtsel, 894 Kurve, 1140

L label, 72 Längenbyte, 720 LargeChange, 211 Laufwerk, 1219, 1222

1797

Index

Laufwerkstyp, 1222 Leerzeichen, 939 Left, 186, 196, 340 LeftCol, 220 Length, 109, 931, 949 library, 72, 490 LIKE, 1290, 1349, 1416 Lines, 935 LineTo, 342, 1090 Linie, 342 Linienbreite, 349 Linieneigenschaften, 349 Linienfarbe, 348 Linientyp, 349 Linkeroptionen, 495 Linking, 579 Listbox, 1030, 1031, 1034, 1098 Listenfeld, 209 ListIndex, 1029 ListView, 1298, 1603 Lizenznehmer, 1613 Ln, 106 Lo, 120 LoadBitmap, 1663 LoadFromFile, 371, 383, 1101, 1114 LoadFromStream, 383 LoadIcon, 1663 LoadLibrary, 494 LoadStr, 109 Locate, 1289, 1338 LockRessource, 1194 Long String, 719 LongBool, 76 LongDateFormat, 915 LongDayNames, 915 LongMonthNames, 915 LongTimeFormat, 920 Lookup-Feld, 1340 Lookup-Methode, 1338 LookupDataSet, 1341 LookupKeyFields, 1341

LookupResultField, 1341 Löschen, 1248 Low, 77 LowerCase, 109 lStrCmp, 1216

M Mail, 1520 MainMenu, 1014 MAKEINTRESOURCE, 1664 Managed Code, 622 mapi, 1520 MapiSendMail, 1520 MapViewOfFile, 399 Markierungsrahmen, 369, 1157 Mathematik, 667 Matrizen, 668 Mauszeiger, 997, 999, 1000 Max, 211, 1353 MaxLength, 204 MCI, 1207 MCI-Befehle, 1197 mciSendString, 1196, 1218 MDI, 837, 1078 MDI-Anwendung, 199, 1067 MediaPlayer, 1198 Meldungsfenster, 266 Memo, 988 Memofeld, 993, 1289 Memory Manager, 487 Memory Mapped Files, 398, 424 Memory-Arrays, 744 Memory-Streams, 741, 1775 Mengentypen, 99, 533 Menü, 1005, 1012, 1015 Menüentwurf, 837, 1078 Menüleiste, 1005 MergeChangeLog, 1348 message, 284 MessageBeep, 926

1798

Index

MessageBox, 258, 259, 1596 MessageDlg, 263, 1621 messages, 1625 Metafiles, 781 Methoden, 38, 537, 610 Microsoft Intermediate Language, 622 MIDAS, 1542 MidasClient, 1559 MidasServer, 1556 Min, 211 MinIntValue, 1353 MkDir, 382, 1229 MM_ANISOTROPIC, 512, 766 MM_ISOTROPIC, 766 MM_LOMETRIC, 766 MM_TEXT, 766 MMF, 398 mmsystem, 1189, 1200 mod, 72 Mode, 370 Mode-Eigenschaft, 1157 ModifyMenu, 1015 Monitor, 1168 MouseMove, 370, 1158 MouseToCell, 223 MoveTo, 342, 1160 MoveToEx, 1144 MSIL, 622 Multimedia, 1192, 1197, 1201 Multimedia-Timer, 571 MultiSelect, 1029 Musik-CD, 1214 Muster, 346 Mutex, 1630 MW_NCPAINT, 1148

N Name, 72, 186 Named Pipes, 1581

Namespace, 624 Navigate, 1517, 1518 Navigator, 845 near, 72 Netzwerkfunktionen, 1611 NewPage, 506 NewStr, 109 Next, 199 nil, 72, 725, 973 nodefault, 72 Normalisierung, 1320 not, 72, 954 Notification, 536, 549, 1357 Now, 115 NTFS-Dateisystem, 1225 nullterminierte Strings, 719, 750 Numerische Integration, 676

O ObjClass, 581 object, 284 Objekt-Browser, 300 Objekte, 317 Objekteigenschaften, 187, 533, 1474 Objektinspektor, 172, 530 Objektklasse , 285 Objektreferenz, 562 Objekttyp , 285 Objektvariable, 740 Objektvariable , 286 of, 72 Ofs, 120 OLE, 577, 579, 1443, 1504 OLE-Automation, 586, 599, 602, 626 OLE-Client, 579 OLE-Container, 593 OLE-Server, 579 oleauto, 587 OLEContainer, 580, 627

1799

Index

OleObject, 580 on, 72 OnActivate, 198 OnCalc, 1342 OnChange, 192 OnClick, 188 OnClose, 198 OnCloseQuery, 198 OnCreate, 198 OnDblClick, 188 OnDeactivate, 198, 980 OnDestroy, 198 OnDragDrop, 192 OnDragOver, 192 OnDrawCell, 1041, 1043, 1051, 1058 OnDrawPanel, 1069 OnEnter, 192, 194 OnException, 251, 255 OnExecute, 240 OnExit, 192 OnFilterRecord, 1289 OnHide, 198 OnKeyDown, 959 OnKeyDown , 190 OnKeyPress, 190, 984 OnKeyUp, 190, 959 OnMessage, 1571 OnMouseDown, 188 OnMouseMove, 188, 189 OnMouseUp, 188 OnPaint, 198 OnResize, 198 OnShow, 198, 1070 OnTopLeftChanged, 224 OOP, 277 Open, 482 OpenCurrentDatabase, 1444 OpenDataEx, 1094 OpenDesktop, 1657 OpenDialog, 935, 1271 OpenDialogs, 1114

OpenKey, 405, 1771 OpenKeyReadOnly, 1592, 1595 OpenPictureDialog, 1108 OpenProcess, 1606, 1608 OpenReport, 1444 Operationen, 81 Operatoren, 69 optionale Parameter, 595 Options, 220 Optionsfeld, 207 or, 72, 955 Ord, 77, 120, 960 Orientation, 505, 510 Out-of-Process, 578 Outlook , 1523 OutputPrecision, 788 override, 284, 970

P Pack, 1335 packed, 73 PageControl, 845, 896, 1092, 1400 PageHeight, 505 PageNumber, 505 PageWidth, 506 PainBox, 188 PaintBox, 358, 827, 1089, 1096, 1097, 1121 Papierkorb, 1666 Paradox, 434 Parallelprojektion, 812 ParamByName, 904 Parameterübergabe, 121 Params, 1415 Params.ExStyle, 970 Parent, 1067, 1069 Parser, 944 PAS, 1244 pascal, 490 PASCAL, 486 Pascal-DLL, 490

1800

Index

Paste, 586 Paste Special, 586 Path, 797, 1142 Pattern Brush, 777, 1146 Pause, 1705 PChar, 83, 487, 719, 750 PDF, 443 Pen, 370, 771, 1156, 1157 PenStyle, 772 Perform, 988, 993, 1066, 1069 Performance, 1173 persistente Felder, 1398 Phasenverschiebung, 678 PitchAndFamily, 789 PixelFormat, 1107 Pixels-Eigenschaft, 819 PixelsPerInch, 219 Platform Invoke, 623 PlgBlt, 807, 1119, 1128 Pointer, 83, 721, 722, 753, 1590 Pointerarithmetik, 725 Polarkoordinaten, 1687 Polygon, 345, 1133 PolyLine, 345 Polymorphie, 329 PopUp-Menüs, 228, 1010 PopUpMenu, 186 Port, 1550 Pos, 109 Position, 962 Pred, 77 Preview, 1432 Previous, 199 Primärschlüssel, 1312 Print, 199 PrintDialog , 507 Printer, 505, 518, 1430, 1440 Printer.Handle, 511 PrinterIndex, 506, 1424, 1430 Printers, 506

PrinterSetupDialog, 507, 508, 1423 Printing, 506 private, 284, 538, 1465 procedure, 73, 122 Process Status Helper-API, 1607 Process32First, 1608 Process32Next, 1608 ProcessMessages, 217, 1122, 1563, 1592, 1707 program, 73 Programmgruppe, 1644 Programmierumgebung, 150 ProgressBar, 1294 ProgressChange, 1517 Projekteinstellungen, 171 Projektoptionen, 173 Properties, 38 property, 284 PropertyPages, 617 protected, 284, 538 ProviderName, 1546, 1560 Prozess-Priorität, 1609 Prozesse, 1581 Prozessortyp, 1496, 1597 Prüfsumme, 1674 PSAPI, 1607 PtInRegion, 797, 1209 Ptr, 120 public, 284, 530, 538, 1465 published, 284, 530 Punkt, 63 Pythagoras, 1685

Q Query, 1293 Query-Builder, 443 Query2Table, 1413 QueryPerformanceCounter, 1173 QueryPerformanceFrequency, 1173 QuickReport, 1455

1801

Index

R RadioGroup, 932, 1026 Rahmen, 206 Raise, 73, 254 random, 1178 Random, 107, 1610 Randomize, 107 Rave Reports, 441, 1445 Read, 284, 382, 931 ReadBuffer, 1046 ReadComponentResFile, 1087 Readln, 382 ReadString, 1595 Real, 76 RealizePalette, 1154 ReAlloc, 721 Rechteck, 343 Rechteckapproximation, 676 record, 73 RecordCount, 1293 Recordset, 1322 Recordstrukturen, 1265 Rectangle, 1156 Referenz, 491 Refresh, 194, 994, 1127, 1517 REG_BINARY, 404 REG_DWORD, 405 REG_EXPAND_SZ, 405 REG_MULTI_SZ, 405 REG_SZ, 404 REGEDIT.EXE, 402 Region, 795, 1176, 1211 Regions, 1130, 1208 Register, 486, 1479 RegisterComponents, 562, 1003 RegisterHotKey, 1627 Registrierdatenbank, 402, 1586, 1589, 1591, 1613, 1616 Registrierungseditor, 402 registry, 1614

Relation, 1320 relationale Datenbank, 434 ReleaseDC, 764, 1163 ReleaseMutex, 1773 Remote-Anwendungsserver, 1553 RemoteServer, 1546, 1554, 1560 RemoveFontResource, 1625 RemoveMenu, 1016 Rename, 382 RenameFile, 383 Repaint, 194 repeat, 73, 102 Reportgenerator, 1443, 1503 Reset, 382, 387 resident, 73, 490 Ressourcen, 291, 1193, 1723 Ressourcen-Editor, 1723, 1730 Ressourcendatei, 291, 563, 1102 Rewrite, 382, 387, 1430 RGB, 346, 1151 RGB-Farben, 346 RichEdit, 1290 RichText, 837, 1078 Ringpuffer, 734 RmDir, 382 rol, 957 RootKey, 1771 ror, 958 Rotation, 769, 815, 831, 1137 rotieren , 364 Round, 924, 1077, 1671 Row, 220 RowCount, 220, 1430 RowHeights, 220, 1052 RTF, 443 Run, 217 RundDll.exe, 1220 runden, 1671 rundll32, 1637 RvCustomConnection, 442 RvDatasetConnection, 442, 1445

1802

Index

RvProject, 442, 1445 RvTableConnection, 442

S Save, 383 SaveDialog, 935, 1271, 1413, 1720 SaveToFile, 383, 390 SaveToStream, 383, 394, 1590 SC_MOVE, 1066 ScaleBy, 979 Scaled, 979 schätzen, 1669 Scherung, 769, 1137 Schleife, 1707 Schleifenanweisungen , 102 Schlüssel, 435 Schriftarten, 785, 1624, 1658 Schrittweitensteuerung, 681 ScktSrvr.exe, 1549 SCR, 1175 Screen, 979, 1135, 1658 Screen-Eigenschaften, 219 Screen-Saver, 1174, 1656 Screenshot, 779, 1162, 1165 ScrollBars, 220, 1018, 1020 Scrollbox, 1113 ScrollDC, 1123 SDK, 782 Seek, 382 SeekEof, 382 SeekEoln, 382 Seg, 120 Sektor, 1225 Sekundärindex, 437 Selbstextrahierendes Setup, 1764 SelCount, 1030 SelectClipPath, 797, 1143 SelectedField, 1307, 1311 Selection, 220

SelectObject, 1146 SelectPalette, 1154 Self, 178, 293 SelLength, 204 SelStart, 204 SelText, 204 Sender, 292, 1011 SendMessage, 989, 990, 993, 1034, 1038, 1625 SendToBack, 194 Server, 1581 ServerGUID, 1546 ServerName, 1545, 1560 Session, 1325 set, 73 SetAsHandle, 482 SetBkMode, 790, 798, 1143 SetFocus, 194, 199 SetKeyboardState, 1623 SetLength, 1216, 1353 SetMapMode, 765, 785, 1137, 1441 SetPort, 1191 SetPrinter, 506 SetPriorityClass, 1610 SetTextAlign, 791, 1440 SetTextbuf , 482 SetTextCharacterExtra, 791 SetViewportExtEx, 767 SetWindowExtEx, 767 SetWindowLong, 976 SetWindowOrgEx, 767 SetWindowPos, 966 SetWindowRgn, 1212 SetWorldTransform, 767, 1137 SHA-1 -Prüfsumme, 1675 Shape, 363 SHAPE, 1393 ShareMem, 487 SHBrowseForFolder, 1236 SHDOCVW.DLL, 1517 Shell, 1576

1803

Index

Shell-Sort, 661 SHELL32.DLL, 1221 ShellApi, 1250, 1641, 1661, 1665, 1666 ShellExecute, 1220, 1527, 1576, 1665, 1773 Shellfunktionen, 1248 SHEmptyRecycleBin, 1668 SHFileOperation, 1249, 1666 SHFormatDrive, 1221 SHGetPathFromIDList, 1645 SHGetSpecialFolderLocation, 1645, 1649 shl, 73, 956 shlobj, 1235, 1644 Short String, 719 Shortcut, 1646 ShortDateFormat, 915 ShortDayNames, 915 ShortInt, 76 ShortMonthNames, 915 ShortString, 82 ShortTimeFormat, 920 Show, 172, 199 ShowCaret, 995 ShowHint, 186 ShowMainform, 1626 ShowMessage, 258, 267, 502, 1156 ShowMessagePos, 267 ShowModal, 199, 493, 1018 ShowWindow, 1649, 1653 shr, 73, 957 SimpleText, 1595 Sin, 107 Single, 76 Size, 1240 Skalierung, 768, 815, 1137 Sleep, 1706 Slice, 1133 SmallChange, 211 SmallInt, 488 sndPlaySound, 1193 SocketConnection, 1549 Solid Brush, 775

Sorted, 210 Sortieralgorithmus, 655 Sound, 1195, 1726 SoundEx, 1349, 1352 Speaker, 1190 Speicher, 1496 Speicherblöcke, 725 Speicherzugriff, 1265 Spiegeln, 1126 Sprach-Exceptions, 925 Sprite, 826 Sprünge, 105 SQL, 907, 935, 1293, 1413 SQL-IN, 1417 Sqr, 107 Sqrt, 107, 1682 SRCCOPY, 827 Standarddialog, 355 Standardeigenschaften, 187 Standardereignisse, 188, 544 StartTransaction, 1338 Statusbar, 1069, 1075 stdcall, 486, 490, 496 Stifte, 1145 Stock Brush, 776 stored, 284 Str, 109 StrAlloc, 1264 StrComp, 1290 StrDispose, 1213, 1264 Stream, 394, 1265, 1713 Stretch-Eigenschaft, 1113 StretchBlt, 1117 StretchDraw, 511, 1428 StretchtBlt, 1125 String, 73, 82, 487, 939 StringGrid, 234, 1039, 1040, 1043, 1051, 1058, 1293, 1430 Stringlist, 944, 1513 Stringlisten, 837, 1078 StringReplace, 1770

1804

Index

Strings, 719, 1775 StringToOleStr, 1527, 1529 StrToDate, 115, 926, 928 StrToDateTime, 115, 952 StrToInt, 109, 1606 StrToTime, 115 Strukturvariable, 89 Style, 210, 974 Succ, 77 Suchen, 665, 1033, 1242 Synchronize, 1125, 1239 SysCommand, 1066 System Directory, 1496 System-Verzeichnis, 1597 Systemkonfiguration, 1597 Systemmenü, 1015, 1017 SystemParametersInfo, 1656 Systemressourcen, 1597 Systemsteuerung, 1631, 1637 Systemzeit, 1563 SysUtils, 383, 426, 492, 931

T Tab-Taste, 1059 TabbedNotebook, 1400 TabControl, 1397 Tabelle, 435 Tabelle erstellen, 1342 Tabellenentwurf, 445 Tabellenstruktur, 1332 Table, 845 TableName, 452 TabOrder, 187 TabSheet, 1092, 1400 TabStop, 187 TActionList, 237 Tag, 187 Tagesdifferenz, 1077 Tan, 108

TApplication, 217 Task-Manager, 1605 Taskbar, 1653 Taskbar Notification Area, 1640 Taskliste, 1605 Taskmanager, 1496, 1638 Tastenkombinationen, 191 TBitBtn, 1024 TBitmap, 362, 371, 778, 826, 1101, 1115, 1126 TBitmapFileHeader, 1112 TBitmapInfoHeader, 1112 TButton, 202, 981 TCanvas, 762 TCheckBox, 981 TClipboard, 218, 1099 TColor, 819 TComboBox, 935, 981 TComponent, 528 TControl, 543 TCP/IP-Netzwerk, 1549 TCustomMemoryStream, 743 TDataSource, 439 TDateTime, 928, 951, 1077 TDBNavigator, 441 TDrawGrid, 219 TEdit, 64, 205, 981 TEMP-Dateiname, 1263 Terminate, 217, 1239 TerminateProcess, 1606 Testbild, 1168 Text, 210 Textabmessungen, 792 Textausgabe, 793 Textausrichtung, 791 Textbildschirm, 930 Textbox, 987 Textdatei, 386, 413 Textdateien, 837, 1078 Textfarbe, 348 TextHeight, 354, 1149

1805

Index

Texthintergrund, 790 Texthöhe, 792 Textkursor, 994 TextOut, 353, 1090, 1119, 1148, 1156 TextRect, 353, 793 Textverarbeitung, 837 TextWidth, 354, 1049 TFieldDefs, 1342 TFileStream, 395, 431, 1776 TForm, 195 TGraphicControl, 529, 567 Themendatei, 1741 then, 73 ThousandSeparator, 911 Thread, 1124, 1238, 1566, 1581, 1630 TIcon, 362 Tile, 179 Time, 116 TimeAMString, 920 TimePMString, 920 Timer, 216, 571, 920, 964, 1075, 1097, 1169 TimeSeparator, 920 TimeToStr, 116, 921, 927 Title, 506 TJPEGImage, 1107 TList, 737 TListBox, 935 TMemo, 935, 981 TMemoryStream, 395, 741, 1590, 1776 TMessage, 1702 TMetafile, 362, 783 TMetafileCanvas, 783 TNA, 1640 TNotifyEvent, 542 to, 73 Tokenizer, 745 Töne, 1190 Toolhelp32, 1607 Tools-Menü, 156 Toolwindow, 973 Top, 186, 196, 340

TopRow, 220 Tortenstück , 343 TProcessInFormation, 1596 TQuery, 1294 Trackbar, 1075, 1096 TRadioGroup, 981 Transaktionen, 1337 Translation, 768, 814 TRect, 994 TreeView, 1294, 1325, 1591 TRegIniFile, 409 TRegistry, 405, 1587, 1594 TResourceStream, 1107 Trim, 1349 TrueType-Schrift, 1119 Trunc, 107 Truncat, 382 try, 73 Try-Except, 251, 253, 272, 926, 985, 1326 Try-Finally, 251, 254 try...except-Blöcke, 922 TScreen, 218, 1659 TScrollBar, 211 TSearchRec, 1215, 1219, 1240 TSpeedButton, 1021, 1024 TStartupInfo, 1596 TStream, 395 TString, 988 TStringField, 1340 TStringGrid, 219, 222 TStringList, 1595 TStrings, 935, 1072 Turbo Pascal, 55 TWinControl, 543, 1066, 1069 TXT, 1244 type, 73 TypeLibraries, 579 typisierte Datei, 390

1806

Index

U UDL, 1383 Uhr, 1075 Undo, 992 UNICODE, 487 Unicode-Strings, 719 Uninstall, 1765 Uninstall-Routine, 1619 Uninstaller, 1593 Unit, 278, 303, 932, 1478 Unit-Referenzen, 282 UnRegisterHotKey, 1627 until, 73 UpperCase, 109, 1034, 1349 UPX, 1774 URL, 1518, 1554 UrlDownloadToFile, 1511 URLMon, 1511 Username, 1496, 1597 uses , 282

V Val, 109, 146 ValueExists, 1595, 1771 ValueListEditor, 1072 var, 73 Variablen, 74 Variant, 84, 753 VARIANT, 496 VB, 500 VBA, 626 VBScript, 1517 VCL, 65, 299 Vektorgrafik, 510, 809, 829 VER120, 1734 Vererbung, 329 Verkette Listen, 727 VerQueryValue, 1728 Verschieben, 1248

Verschiebung, 1137 Verschlüsseln, 1676 Versionsinformation, 1727 Versionskontrolle, 504 Verzeichnisbaum, 1231 Verzweigungen, 104 Video, 1197, 1207, 1726 ViewportExtEx, 512 ViewStyle, 1603 virtual, 284, 539 Visible, 187, 212 VisibleButtons, 1548 VisibleColCount, 220 VisibleRowCount, 220 Visio, 596 Visual Basic, 55, 595 Visual C++, 53 Visual Components Library, 299 VolumeName, 1215

W Währungen, 913 Währungsformat, 911 WaitForSingleObject, 1239, 1578, 1596 WAV, 1192, 1193 WAV-Dateie, 1195 WebBrowser, 1517 WebConnection, 1553 while, 73, 102 WideChar, 76, 719 WideString, 1527, 1529 Width, 186, 219, 340 WIN.INI, 401 WINAPI, 486 WINCROSS, 894 Windows Directory, 1496 Windows-Botschaft, 1701 Windows-Messages, 1571 Windows-Shell-Objekte, 1644

1807

Index

Windows-Verzeichnis, 1597 WindowsExtEx, 512 WindowState, 196, 975 WinExec, 1638 Wininet.dll, 1553 Winkelfunktion, 1140 winsock, 1508 Winsock, 1507 WinSound, 1190 with, 73 WM_CHANGECBCHAIN, 1703 WM_DrawClipboard, 1702 WM_DRAWCLIPBOARD, 484 WM_DROPFILES, 1662 WM_ERASEBKGND, 967 WM_LBUTTONUP, 1066 WM_MOVE, 1571 WM_NEXTDLGCTL, 988 WM_Paint, 1135 WM_QUERYOPEN, 975 WM_SYSCOMMAND, 1017 WMF, 1244 WndProc, 1180, 1571 Word, 76, 601, 1503 WordBool, 76 WordWrap, 914, 991 Write, 284, 382, 931 Write-Option, 531 WriteBinaryData, 1590 WriteBuffer, 1046, 1777 WriteComponentResFile, 1087

WriteLn, 382, 1430 WritePrivateProfileString, 401 WSAStartup, 1508 WYSIWYG, 1432

X XFORM, 768, 1137 XLS-Format, 1718 xor, 73, 370, 956, 1157, 1160

Z Zeichenabstand, 791 Zeichenmodus, 349 Zeichenwerkzeuge, 770 Zeigertypen, 723 Zeilenumbruch, 991 Zeit, 114, 925 Zeitdifferenz, 1672 Zeitformat, 920 Zeitmessungen, 1173 Zentralprojektion, 812 Ziffer, 941 ZIP-Routinen, 1775 zirkuläre Referenz, 283 Zlib, 1776 Zufallsgenerator, 899 Zugriffsmethoden, 327 Zwischenablage, 481, 513, 837, 1078, 1099, 1699, 1701 Zwischenablage-Betrachter, 484