Objektorientiertes Programmieren - uni-wuppertal.de · Project1.opt Die für das Projekt eingestellten Optionen (Compiler, Verzeichnispfade, Editor) Unit1.dcu Die compilierte und

Fachbereich 12 – Maschinentechnik

Fachgebiet 5

Mess-, Steuerungs- und Regelungstechnik

E i n f ü h r u n g i n

Ob jek to r ien t ie r tes Programmieren

( O b j e c t - P a s c a l )

m i t B o r l a n d D e l p h i

Prof. Dr.-Ing. U. Pietzsch

Wintersemester 1999

2

��

��

��

�� 1.2.1 Eigenschaften (Properties) ........................................................................................... 41.2.2 Ereignisse (Events)....................................................................................................... 41.2.3 Methoden (Methods)..................................................................................................... 4

�� 1.3.1 Strukturierung ............................................................................................................... 51.3.2 Arbeitsverzeichnis erstellen .......................................................................................... 5

��

��!��"��#�� 2.1.1 Die Werkzeugleiste ....................................................................................................... 52.1.2 Das Formular ................................................................................................................ 62.1.3 Der Objektinspektor ...................................................................................................... 62.1.4 Das Quelltext-Fenster ................................................................................................... 72.1.5 Das Projekt ................................................................................................................... 8

��!��$��%��%�� &2.2.1 Standard ....................................................................................................................... 92.2.2 Zusätzlich...................................................................................................................... 92.2.3 Win32.......................................................................................................................... 102.2.4 System ........................................................................................................................ 102.2.5 Datenzugriff................................................................................................................. 112.2.6 Datensteuerung .......................................................................................................... 112.2.7 Dialoge........................................................................................................................ 11

��'��#�� 2.3.1 Datei............................................................................................................................ 122.3.2 Bearbeiten................................................................................................................... 122.3.3 Suchen........................................................................................................................ 132.3.4 Ansicht ........................................................................................................................ 132.3.5 Projekt......................................................................................................................... 142.3.6 Start ............................................................................................................................ 142.3.7 Tools ........................................................................................................................... 15

��!��"��#��(��

�� )��*�� +

��,�-�� &

��

��.� �� /

��0��12��)�� 3

��"�� %��

��)%� �� 3.4.1 Funktionen und Prozeduren........................................................................................ 223.4.2 Variablen und Datentypen .......................................................................................... 223.4.3 Integer-Typen.............................................................................................................. 233.4.4 Real-Typen ................................................................................................................. 233.4.5 Boolean-Typen............................................................................................................ 24

3

3.4.6 Strings......................................................................................................................... 243.4.7 Arrays.......................................................................................................................... 253.4.8 Typen .......................................................................................................................... 253.4.9 Records....................................................................................................................... 263.4.10 Zeiger........................................................................................................................ 263.4.11 Dynamische Arrays................................................................................................... 273.4.12 Variant....................................................................................................................... 283.4.13 Mengen ..................................................................................................................... 283.4.14 Konstanten................................................................................................................ 283.4.15 Kommentare ............................................................................................................. 29

�� ) ��#�� /3.5.1 Repeat-Schleife .......................................................................................................... 293.5.2 While-Schleife ............................................................................................................. 303.5.3 For-Schleife................................................................................................................. 303.5.4 Break&Continue.......................................................................................................... 32

��,�4��5�� 3.6.1 if-Anweisung ............................................................................................................... 323.6.2 case-Anweisung.......................................................................................................... 32

��+�)%��#��

��

��"��'��

��!��

��!��.�� ,

��!�� ,

�� (��$�� +

��,�)%� �� +

��+�)��%�� +

��&�.��6�"��)�� &

��

��7�#�� /

��!�� 3

��"��#��

!�"��

,��!��

,��!��#�8 ��

,��4��

#��!

4

� �7��

��Der grundlegende Unterschied zwischen einem herkömmlichen Programm unter DOS und ei-nem Windowsprogramm besteht im wesentlichen in folgendem:

• Im DOS-Programm werden die Befehle �9�� abgearbeitet; d.h. Schritt für Schritthintereinander. Die Kommunikation mit der Peripherie erfolgt dabei direkt über das Anwen-dungs-Programm.

• Unter Windows laufen alle Aktionen �� ab. Eine streng vorge-gebene Reihenfolge für die Eingabe und Abarbeitung der Befehle gibt es nicht mehr. Für je-de Aktivität des Anwenders ist ein Programmteil zuständig, das weitgehend unabhängig vonden anderen Programmteilen agiert und in dem Moment in Aktion tritt, in dem er aufgerufenwird. Kurz hintereinander aufgerufene Programmteile werden entsprechend der Aufeinan-derfolge in einer Liste abgearbeitet. Die Kommunikation mit der Peripherie erfolgt via 'Mes-sage-Handling' über das Betriebssystem.

��Objekte sind ganz allgemein die Elemente der Bedienoberfläche, denen wiederum Eigenschaf-ten (1.3.1), Ereignisse (1.3.2) und Methoden (1.3.3) zugeordnet sind. Beschränkt man sich aufdie visuelle Benutzerschnittstelle, auf die eine grafische Bedienoberfläche besonders zuge-schnitten ist, so hat man es in Delphi mit folgenden Objekten zu tun:

• (�� (Fenster)Windows-Fenster, in denen eine Delphi-Anwendung (Pascal-Programm) aus-geführt wird. In einem Formular können weitere untergeordnete Formulare,Komponenten (siehe unten), Text und Grafik enthalten sein.

• $��%��Komponenten sind vorgefertigte Objekte, die z.B. als Schaltflächen (Button),Bildlaufleisten (Scrollbar), Auswahlfenster (Listbox) usw. auftauchen.

• �� (Screen, Printer, Clipboard,...)

Der Informationsfluß innerhalb des Gesamtprogramms entsteht durch Kommunikation der Ob-jekte untereinander, d.h. durch das Versenden von Botschaften (Messages). Eine solche Bot-schaft besteht normalerweise aus dem Namen einer Methode (→ Absatz 1.2.3), die das aufge-rufene Objekt bei Empfang ausführen soll.

��-�� #��:��%��;

... sind die "�� von Objekten, wie z.B. die Höhe (Height), die Breite (Width) und die Farbe(Color). Jedes Objekt verfügt über einen eigenen Satz von Eigenschaften, die teilweise nur zurEntwurfszeit oder nur zur Laufzeit veränderbar sind.

��-��:-��;

... sind <� �� , die vom Objekt empfangen werden und damit die eigentliche Schnittstellezum Betriebssystem darstellen. So ruft z.B. das Anklicken eines Objektes mit der Maus dasOnClick-Ereignis hervor. Aufgabe des Delphi-Programmes ist es, auf alle Ereignisse gemäßden Vorgaben des Programmierers zu reagieren. Realisiert wird die dann folgende Aktion insogenannten Ereignisbehandlungsroutinen, die anwendungsspezifisch erstellt werden.

��'��:'��;

... sind die im Objekt definierten (��, die gewissermaßen das Ver-

5

halten beim Eintreffen einer Nachricht bestimmen. So erzeugt z.B. die LineTo-Methode eineLinie auf der Zeichenfläche (Canvas) eines Objektes. Eine Methode kann auch das Verhaltendes Objekts bei einem Mausklick oder einer Tastatureingabe definieren. Im Unterschied zu

• den -�� #��, die die �� Eigenschaften eines Objekts liefern,• bestimmen die '�� die �=�� Fähigkeiten.

��

��)��

Sequentiell strukturierte Programme erfordern als erste Aktivität das Erstellen eines Pro-grammablaufplans und Überlegungen zur Gestaltung der unterschiedlichen Schnittstellen. Del-phi erfordert in dieser Beziehung ein Umdenken und erlaubt eine systematische Programment-wicklung in drei Stufen:

1. 4��#�8 � visuell entwerfen, indem die benötigten Komponenten in der ge-wünschten Form auf dem Bildschirm plaziert werden.

2. �� #�� zuweisen; d.h. in welcher Form die plazierten Komponenten beimStart des Programms erscheinen sollen.

3. -�� schreiben. Diese Stufe beinhaltet die eigentliche anwendungs-orientierte Programmierung und legt fest, wie die verwendeten Komponenten auf dasEintreten eines Ereignisses oder einer Botschaft reagieren sollen.

��"��

Vor dem Erstellen eines neuen Projektes empfiehlt es sich, für dieses Projekt einen eigenen�� anzulegen, um die mit dem Projekt verknüpften Dateien in übersichtlicher Form zu-sammenzuhalten. Auf diese Weise ist es später leicht möglich, über den Dateimanager odereine ähnliche Windows-Funktion z.B. eine Sicherungskopie von einem Projekt zu erstellen.

� �" � � � � �� ! � %� �

��!��"��#��Nach dem Starten von Delphi wird der Bildschirm so aufgebaut, wie er in der letzten Sitzungverlassen worden ist. Beim ersten Starten werden das die für die Programmerstellung wichtig-sten vier Fenster sein, die in den folgenden Abschnitten vorgestellt werden sollen.

��!��1��

Wichtigstes Arbeitsfenster unter Delphi mit Bereitstellung der zur Verfügung stehenden '��#��, einer )=��%%, in der die wichtigsten Menufunktionen über ein Symbol auf-gerufen werden können, und der $��%��%��, die die Programmierbausteine für eineProgrammentwicklung beinhaltet.

Menuzeile

Häufig benutzteMenupunkte

In Karteikarten angeordneteKomponenten-Palette

6

��!��(��

Das Formular, das Delphi mit dem Namen Form1 vorschlägt, ist das zur Laufzeit sichtbare Fen-ster der Anwendung, in dem alle anderen sichtbaren Komponenten zusammengefaßt sind. Diewichtigsten Eigenschaften des Formulars sind:

WindowState ob das Formular nach dem Programmstart in der aktuellen Größe, als Symbol oderBildschirm füllend aufgebaut werden soll.

Position Lage und Größe des Formulars auf dem Bildschirm.

FormStyle wie das Formular sich später auf der Oberfläche verhalten soll, wenn andere Formula-

re (Windows-Anwendungen) angewählt werden.

BorderStyle ob es zur Laufzeit in der Größe veränderbar ist

BorderIcons welche Standardschalter zur Größenregulierung in der Titelleiste erscheinen

Name Der Variablenname mit dem das Formular angesprochen wird

Caption Der Texteintrag in der Kopfzeile des Fensters

��!��%��

Im Objektinspektor können die -�� #�� der Objekte eingestellt werden, die auf dasFormular plaziert worden sind, und er enthält die Verwaltung der zu den Objekten gehörenden-��, d.h. wie und in welcher Form das Objekt auf ein Ereignis odereine Botschaft zu reagieren hat.

In der Zeile direkt unterhalb der Titelleiste sind durch einen Doppelpunkt getrennt, der <��und der >=% des Objektes (Variable) dargestellt (z.B. Form1: TForm1). Durch Anklicken desdreieckigen Pfeilsymbols kann eine ?�� mit allen zumProjekt gehörenden Objekten aufgeklappt werden.Durch das Anklicken eines Objektes in der Liste wirddieses mit seinen Eigenschaften und Ereignissen imFenster des Objekt-Inspektors eingeblendet. Für dieEinstellungen der Eigenschaften stehen drei wesent-liche Eingabefenster zur Verfügung:

• )��#�� wie "Caption" oder"ClientHeight", in die alfanumerische Stringsoder Zahlen eingegeben werden können. Abge-schlossen wird eine Eingabe, wenn die Zeilemit der Tastatur (↑↓) oder einem Mausklick aufeine andere Zeile verlassen wird.

• !�%�!��(�� wie "ActiveControl", die esermöglichen, einen Eintrag aus einer vorbereite-ten Liste auszuwählen. Zum Aufklappen derListe muß der nach unten weisende Dreieckpfeilangeklickt werden.

• $�� wie "+BorderIcons". Die Akti-vierung der Konstantenliste durch Doppel-klicken auf das "+"-Symbol blendet eine leichteingerückte Liste ein, aus der mittels Mausklickein Eintrag selektiert werden kann; in der auf-geklappten Liste wird das "+"-Symbol durch ein"–"-Symbol ersetzt. Durch Doppelklick auf das"–"-Symbol kann die Liste wieder geschlossenwerden.

Name Typ Liste

7

• '�� wie "+Font". Einfaches Anklicken des Fensters macht einen durch dreiPunkte gekennzeichneten Schalter sichtbar. Das Anklicken des Schalters öffnet einunter Windows bekanntes Dialogfenster, in dem umfangreichere Einstellungen vorge-nommen werden können.

��@��#�#A��-�� #�� "�� -�� #�� B��!A ��(��>��

��!��C��D��(��

Die Unit, für die Delphi hinter der Bezeichnung 'unit' den Namen "Unit1" vorschlägt, ist ein Fen-ster, in dem der Quelltext der Anwendung enthalten ist. Es enthält eine Liste der eingebunde-nen Dateien, die zur Handhabung des Formulars erforderlich sind, und eine Beschreibung des(noch leeren) Formulars Form1.

Neue Prozeduren oder Funktionen werden von Delphiunmittelbar vor der Direktive "end." am Ende der Uniteingefügt.

Die Einstellung der im Editor verwendetenFarben erfolgt über den Menupunkt: Tools / Umgebungsoptionen... / Farben

Während ein Formular immer an eine Unit gekoppelt ist, kann eine Unit auch eigenständig,ohne eine dazugehörendes Formular existieren. Sehr häufig ist dies der Fall bei Bibliothekenoder sonstigen Unterprogrammsammlungen.

Hinweise:

!��4�� E*��E��#� �� C��D�� *�� 8��6� ��B�A��'��#��E!��F)%� ��E��

!�"�� GH0�I�!('J��#�� #��6��#�� @��#��5��A%#��(��8��

8

�� !��

Nach dem Speichern eines Projektes wird man feststellen, daß die eigene Anwendung nicht nuraus der Formulardatei und der Quelltext-Unit besteht, sondern daß Delphi noch eine Reihe an-derer Dateien angelegt hat.

Project1.dpr

Projektdatei, in der die zum Projekt gehörenden Dateien in einer Liste eingetragensind. Die Zuordnung von zueinander gehörenden Formularen und Units ist dieserListe eindeutig zu entnehmen. Die Projektdatei sollte vom Programmierer niemalsmanuell editiert werden.

Project1.dskDatei zur Verwaltung der aktuellen Desktop-Oberfläche. Mit Hilfe dieser Datei kannein Projekt nach seinem Öffnen in derselben Form aufgebaut werden, wie es verlas-sen worden ist.

Project1.exeDas compilierte und gelinkte ausführbare Programm. Das Programm kann auch aufRechnern laufen, auf denen Delphi nicht installiert ist.

Project1.resDie Windows-Ressourcendatei, in der die Komponenten (z.B. Formular, Button,Bildlaufleiste) verwaltet werden.

Project1.opt Die für das Projekt eingestellten Optionen (Compiler, Verzeichnispfade, Editor)

Unit1.dcuDie compilierte und in Maschinencode vorliegende Quelltextdatei, die vom Compileraus der Unit1.pas erstellt worden ist.

Unit1.dfm Die Formulardatei zu Form1

Unit1.pas Die Quelltextdatei zu Unit1

Die vom Programmierer zu bearbeitenden Dateien sind in der obigen Liste grau hinterlegt dar-gestellt.

��!��$��%��%��... stellt eine Reihe an ��#�� zur Verfügung, die die Grundlage des Anwen-derprogramms darstellen. Die Komponenten sind entsprechend ihren Funktionen gruppenweiseauf Karteikarten untergebracht, deren Bedeutung oder Wichtigkeit im Prinzip von links nachrechts abnimmt. Eine Komponente wird in zwei Schritten folgendermaßen auf das Formularübertragen:

1. Durch das Anklicken mit der Maus wird sie für die Übertragung ��. Der aktive Zustandwird durch eine helle Hinterlegung des Symbols angezeigt.

2. Durch das Anklicken einer bestimmten Stelle auf dem Formular wird die markierte Kompo-nente genau an dieser Stelle ��. Name und Typ der Komponente erscheinen imKopffenster (oberste Zeile) des Objektinspektors, in dem die Eigenschaften sofort eingestelltwerden können. Nach dem Anklicken im Formular wird die Hervorhebung in der Kompo-nentenleiste wieder deaktiviert.

Die für den Standardgebrauch wichtigsten Komponenten werden auf den folgenden Seiten inKurzform erläutert. Eine ausführliche Beschreibung der einzelnen Komponenten ist der Delphi-Hilfe entnehmbar, die in folgenden Schritten aufgerufen wird: Komponente auf das Formular%��, Komponente auf dem Formular (einfach) anklicken und (��>�� drücken.

9

��)��

Grundausstattung der Windows-typischen Dialogelemente, die in nahezu jeder Windows-Anwendung auftreten wie Menus, Texteingabe, Textausgabe, Auswahlelemente und Darstel-lungsflächen.

Komponenten-zeiger

Bei markiertem Komponentenzeiger kann eine beliebige Komponente durchAnklicken selektiert werden. Die Hervorhebung wechselt dann auf die ange-klickte Komponente.

MainMenu Entwurf einer '��. Starten des Menu-Editors durch Doppelklicken desSymbols auf dem Formular. Die Menueinträge erfolgen dann über den Editor.

PopupMenu Entwurf eines PopupMenus, das zur Laufzeit mit der rechten Maustaste geöff-net werden kann. Die Handhabung entspricht der des Menu-Editors.

Label >D�� ohne Nutzerzugriff. Darstellung von Texten an beliebigen Bild-schirmstellen. Durch Zuweisung der Texte zur Laufzeit können auch mehrzeili-ge Labels dargestellt werden.

Edit Einzeilige >D�� und –anzeige. Bei der Eingabe von Zahlen ist darauf zuachten, daß auch diese als Text vorliegen und vor der Verwendung im Pro-gramm u.U. erst in Zahlen konvertiert werden müssen.

Memo Mehrzeilige� >D�� und –anzeige. Der Text in sogenannte "Lines" (Zei-len) abgelegt, die über Indizes angesprochen werden können.

Button ) �� zum Starten einer Operation (Prozedur, Funktion)

CheckBox Ja / Nein – Option

RadioButton Exklusive Ja / Nein – Option; d.h. in einer zusammenhängenden Gruppe kann(im Gegensatz zur CheckBox) immer nur �� Element markiert sein

ListBox Auswahlliste

ComboBox Editierbare Auswahlliste; der selektierte Eintrag wird in die Kopfzeile des Fen-sters übernommen

ScrollBar 4��#�� zur Darstellung von Flächen, die größer sind als der zur Veerfü-gung stehende Sichtbereich

GroupBox Ein ) ��#�8 ��#�� zur Aufnahme mehrerer Komponenten, in dem eineBezeichnung eingetragen werden kann

RadioGroup Vorbereitetes ) ��#�� mit RadioButtons

Panel !��#�8 � zur Aufnahme einer Komponentengruppe. Das Panel kannauch zur Darstellung von Text auf unterschiedlich gestalteten Hintergründenverwendet werden.

��.��8��

Weitere Standardelemente zur Vervollständigung der obigen Gruppe wie Schalter mit eingela-gerten Grafiksymbolen, Tabellen und Grafiken.

BitButton ) �� mit eingelagerter Grafik. Die Grafik kann als bereits bestehende Bit-map aus einer beliebigen Bibliothek importiert oder mit dem Bildeditor (→ Ab-schnitt 6.3) erstellt werden

SpeedButton ) �� mit eingelagerter Grafik zur Unterbringung auf einer ToolBar

MaskEdit Formatierte Dateneingabe (z.B. Datum, Uhrzeit)

StringGrid >�� "�� von Zeichenketten (alfanumerische Zeichen)

DrawGrid Tabellenförmige allgemeine Datenanzeige

10

Image 7�#��"�� (*.BMP, *.ICO, *.WMF)

Shape Anzeige von Kreis, Ellipse oder Rechteck

Bevel Rechteck oder Rahmen mit 3D-Effekt

ScrollBox Erzeugen einer Liste mit Bildlaufleisten

CheckListBox Auswahlliste mit Bildlaufleiste

StaticText Beschriftungsfeld ähnlich dem Label mit Fenster-Handle

Chart Grafische Darstellung einer Datenbank wie unter MS-Excel

��1��

Dialogelemente für Windows-32-Bit-Systeme, mit denen über die Maus Auswahlen oder Ein-stellungen vorgenommen werden können.

TabControl Notizbuchregister

PageControl Notizbuchregister für mehrseitige Dialogfelder

ImageList Bilderliste für TreeView und ListView

RichEdit Memo-Komponente für Textdateien unbegrenzter Länge und Formatierungs-möglichkeiten

TrackBar Regler zum Einstellen von Werten in einem bestimmten Bereich

ProgressBar Fortschrittsanzeige eines Hintergrundprozesses

UpDown schrittweises Verändern von Einstellwerten

HotKey Tastenfunktionen mit Strg, Umsch und Alt

TreeView hierarchische Baumdarstellung einer Liste

HeaderControl größenveränderliche Darstellung eines Tabellenkopfes

StatusBar Statusleiste mit mehreren Einzelfeldern am unteren Bildschirmrand

ToolBar Werkzeugleiste, auf der vorzugsweise BitButtons plaziert werden können

CoolBar Symbolleiste mit untergeordneten Steuerelementen, die selbständig verscho-ben werden können

��)=��

Timer Bereitstellung eines Timer-Intervalls, mit dem eine Prozedur in einstellbaren regelmäßi-gen Abständen automatisch aufgerufen werden kann. Der Timer entspricht einem 'Soft-ware-Interrupt', der allerdings den Nachteil hat, daß sein schnellstes Arbeitsraster auf 10Millisekunden beschränkt ist. Für Anwendungen in der Meß-, Steuer- und Regelungs-technik ist er ein wertvolles Hilfsmittel.

PaintBox Zeichenfläche zum Zeichnen auf einer rechteckicken Fläche innerhalb eines Formulars.Im Gegensatz zum Image wird die PaintBox vom Betriebssystem nicht automatischaufgefrischt, wenn sie durch ein anderes Fenster verdeckt war. Ihr Vorteil ist, daß zuentfernende Zeicheninhalte nicht aufwendig gelöscht werden müssen, sondern es reichtein Neu-Zeichnen mit dem erforderlichen PaintBox-Inhalt.

11

�� !��##

Nichtvisuelle Datenbankelemente

TTable bildet eine physikalische Tabelle inklusive Indizes ab. Über dieses Objekt kön-nen Such- und Sortiervorgänge gestartet werden.

TDataSource verknüpft eine Tabelle mit einer datensensitiven Komponente

��,�!��

Visuelle Datenbankelemente

TDBGrid Anzeige und Bearbeitung von Datensätzen in einer Tabelle

TDBNavigator Steuertasten zum Bewegen und Arbeiten in einer Datenbanktabelle (TDBGrid)

TDBText Anzeige eines Feldes der Datenbank als Label

TDBEdit Anzeige- und Eingabefeld für eine Textzeile

TDBMemo Anzeige und Eingabefeld für Mehrfachzeilen

TDBImage Anzeige und Bearbeitungsmöglichkeit für Grafik

TDBListBox Listenfeld. Der in der Liste gewählte Eintrag (ItemIndex) wird in der Tabellegespeichert

TDBComboBox ComboBox. Der in der ComboBox gewählte Eintrag (ItemIndex) wird in derTabelle gespeichert

TDBCheckBox Eine Checkbox wird in Abhängigkeit eines Feldes der Datenbank gesetzt odernicht

TDBRadioGroup Setzen eines RadionButtons in Abhängigkeit eines Feldes der Datenbank

TDBLookupList Listenfeld. Der in der Liste gewählte Eintrag (ItemIndex) wird in der Tabellegespeichert. Im Unterschied zur TDBListbox werden die Listeneinträge auseiner zweiten Tabelle geladen

TDBLookup-ComboBox

Combobox. Der in der ComboBox gewählte Eintrag (ItemIndex) wird in derTabelle gespeichert. Im Unterschied zur TDBComboBox werden die Listenein-träge aus einer zweiten Tabelle geladen

��+�!��

Windows-Standarddialoge für Dateihandling, Frbvorgaben und Druckereinstellungen.

OpenDialog Dialogfenster: Datei öffnen. Begleitparameter zum Öffnen einer Datei können inder Komponente vorgegeben werden.

SaveDialog Dialogfenster: Datei speichern.

OpenPictureDialog wie OpenDialog, aber mit Bereich für Grafikvorschau

SavePictureDialog wie SaveDialog, aber mit Bereich für Grafikvorschau

FontDialog Dialogfenster Zeichensatz einstellen

ColorDialog Dialogfenster Farben definieren

PrintDialog Dialogfenster Druckerausgabe

PrinterSetupDialog Dialogfenster Drucker einrichten

12

��'��#��

Die Steuerung der Entwicklungsoberfläche erfolgt über die Menufunktionen der Werkzeugleiste,von denen nur die wichtigsten vorgestellt werden, um mit Delphi prinzipiell arbeiten zu können.Tiefer greifende Informationen stellt die Delphi-Hilfe zur Verfügung, wenn ein Menupunkt durchMausklick aktiviert und anschließend die F1-Taste gedrückt wird.

��!��

Dateifunktionen zum Speichern des entwickelten Programms, das in seiner Gesamtheit alsProjekt bezeichnet wird, und zum Generieren einer neuen Anwendung.

Neu ... öffnet das Dialogfeld "Neue Einträge", aus dem heraus ein neues Projektvon einem bestimmten vordefinierten Typ erstellt werden kann

Neue Anwendung eröffnet ein neues Projekt mit einem Standardformular

Neues Formular fügt dem Projekt ein weiteres Formular hinzu

Neues Datenmodul fügt dem Projekt ein spezielles Daten-Formular hinzu

Öffnen Öffnen eines Projektes oder einer beliebigen Datei

Neu Öffnen Öffnen eines Projektes oder einer Datei über eine Liste, in der die letztenEintragungen gespeichert sind

Speichern Strg S Speichern der aktuell vorgenommenen Änderungen

Speichern unter ... Speichern der aktiven Datei unter einem neuen Namen

Projekt speichernunter...

Speichern der Projektdatei (∗.dpr) unter einem neuen Namen

Alles speichern Speichern aller geöffneten Dateien eines Projektes

Schließen Schließen der angewählten, aktivierten Datei

Alle Schließen Schließen aller Dateien eines Projektes

Unit verwenden ... Verwenden Sie dieses Dialogfeld, um eine Unit innerhalb der aktuellenUnit zu verwenden. In dem angebotenen Feld wird eine Liste aller Units indem Projekt angezeigt, die nicht von der aktuellen Unit benutzt werden.

Dem Projekt hinzu-fügen ...

Eine Datei zum aktuellen Projekt hinzufügen

Aus dem Projektentfernen ...

Eine Datei aus dem aktuellen Projekt entfernen

Drucken ... Drucken der aktuell markierten Datei oder eines markierten Textblocks

Beenden Schließen der Delphi-Entwicklungsumgebung

��4��

Menufunktionen zum Arbeiten im Quelltexteditor (bis zum Punkt 'Löschen') und auf dem For-mular (unterhalb des Punktes 'Löschen').

'��%��"��*��C��D��

Rückgängig Strg Z macht die vorangegangene Operation rückgängig

Widerrufen Umsch Strg Z macht den letzten "Rückgängig-Schritt" unwirksam

Ausschneiden Strg X überschreibt die Zwischenablage mit dem markierten Text oder denmarkierten Elementen

Kopieren Strg C kopiert markierten Text oder markierte Elemente in die Zwischenablage

Einfügen Strg V fügt den Inhalt der Zwischenablage ein

Löschen Strg Entf entfernt die markierten Elemente aus dem Speicher

13

'��%��"��#��(��

Alles auswählen alle Komponenten eines Formulars markieren

Am Raster ausrichten verschiebt die markierten Komponenten zum nächsten Rasterpunkt

Nach vorne setzen stellt die markierte Komponte vor die anderen, so daß sie diese bei Überlappun-gen überdeckt

Nach hinten setzen stellt die markierte Komponte hinter die anderen, so daß sie von diesen im Über-lappungsfall überdeckt wird

Ausrichten ... öffnet das Dialogfenster zum Ausrichten von Komponenten

Größe ... öffnet das Dialogfenster zur Einstellung von Breite und Höhe

Skalierung ... öffnet das Dialogfenster zur proportionalen Größenänderung

Tabulatorreihenfolge...

öffnet das Dialogfenster zur Bearbeitung der Tabulatorreihenfolge

Erstellungsfolge ... öffnet das Dialogfenster 'Erstellungsfolge', in dem die Reihenfolge der Erzeugungder unsichtbaren Komponenten editiert werden kann

Elemente sperren verankert alle Komponenten in ihrer momentanen Position und Größe, so daß siedurch die Maus nicht mehr unbeabsichtigt verändert werden können. Änderungenüber den Objektinspektor sind weiterhin möglich.

Zur Schnittstelle hin-zufügen ...

fügt eine neue Funktion oder Prozedur zur ActiveX-Komponente hinzu

��)� ��

Suchfunktionen zum Aufsuchen von Quelltext und Laufzeitfehlern.

Suchen ... Strg F öffnet das Dialogfenster "Text suchen", in dem ein beliebiger Textabschnittin der aktiven Datei gesucht wird

In Dateien suchen ... erweiterte Suchfunktion "Suchen", die in mehreren Dateien vorgenommenwird

Ersetzen ... Strg R öffnet das Dialogfenster "Text ersetzen", in dem ein beliebiger Textab-schnitt in der aktiven Datei gesucht und durch einen eingegebenen Textersetzt wird

Suche wiederholen F3 setzt den Suchvorgang ab der aktuellen Stelle fort

Inkrementelle Suche Strg E Suche ohne Dialogfenster

Gehe zu Zeile ... geht zu einer bestimmten Zeile des Quelltextes

Laufzeitfehler suchen ... stoppt in der Zeile des letzten Laufzeitfehlers

Symbol anzeigen ... öffnet Dialogfenster zur Eingabe eines Bezeichners

��"��

Auswahlmöglichkeiten zur Darstellung unterschiedlichster Fenster, Hilfspaletten, Informationenund Arbeitshilfen. Der wichtigste Unterpunkt steht mit der 'Projektverwaltung' sofort in der erstenZeile.

Projektverwaltung öffnet das Fenster für die Projektverwaltung, in dem alle im Pro-jekt eingebundenen Dateien eingesehen werden können, sowiederen Pfade und Verzeichnisse.

Projekt-Quelltext öffnet das Fenster des Quelltexteditors

Objektinspektor F11 öffnet das Fenster des Objektinspektors

Ausrichtungspalette öffnet eine Werkzeugleiste zum komfortablen Ausrichten vonKomponenten

Symbolanzeige öffnet den Objekt-Browser

Haltepunkte öffnet die Liste der aktuellen Haltepunkte

Aufruf-Stack zeigt die Liste der Unterprogramm-Aufrufe

14

Überwachte Ausdrücke zeigt die Lister der vom Debugger überwachten Variablen

Module DLL oder Package zur Laufzeit hinzuladen

Komponentenliste zeigt eine Lister der verfügbaren Komponenten an

Fensterliste ... Alt O zeigt die Liste der geöffneten Fenster

Umschalten Formu-lar/Unit

F12 schaltet um zwischen Formular und zugeordneter Unit

Units ... Strg F12 Liste der Quelltextdateien im Projekt

Formulare ... Umsch F12 Lister der Formulare im Projekt

Neues Editierfenster öffnet ein Fenster mit einer Kopie des aktuellen Quelltextes

Symbolleiste zeigt die Symbolleiste an

Komponentenpalette zeigt die Komponentenpalette an

��

Die ersten beiden Menupunkte können auch über das Menu 'Ansicht / Projektverwaltung' er-reicht werden und dienen der Verwaltung der im Projekt befindlichen Dateien. Die wichtigstenFunktionen in dieser Menugruppe betreffen aber das Compilieren (Übersetzen) und das Linken(Zusammenbinden) des Projektes zu einer ausführbaren EXE-Datei. Die Randbedingungen fürCompiler und Linker sind im Unterpunkt 'Optionen...' einzustellen.

��

Dem Projekt hinzufügen ... eine Datei zum aktuellen Projekt hinzufügen

Aus dem Projekt entfernen...

eine Datei aus dem aktuellen Projekt entfernen

Der Objektablage hinzufü-gen ...

selbst erstellte Objekte als Vorlagen für spätere Verwendungenin der Objektablage ablegen

K��%��?��

Compilieren Strg F9 startet die Compilierung der geänderten Dateien

Projekt neu compilieren startet die Compilierung aller Dateien eines Projektes

Syntaxprüfung startet die Compilierung ohne Linken

Information ... informiert nach dem Compilieren über Programm-, Stack-, Da-tengröße usw.

Optionen ... Einstellungen der Parameter für Compiler und Linker, sowie derStartoptionen zum Aufbau der Formulare zur Laufzeit.

��,�)��

Die Gruppe ’Start’ dient dem Starten des fertig compilierten und gelinkten Programmes, sowiedem Debuggen zum Auffinden von Fehlerursachen (→ 6.1).

L<��L��#A��

Start F9 compiliert das Programm, linkt es und führt es aus

Parameter ... öffnet ein Dialogfeld zur Eingabe von Kommandozeilenparame-tern

!��(��

Gesamte Routine F8 das Programm wird vom Debugger zeilenweise ausgeführt; d.h.eine Prozedur wird in einem Schritt abgearbeitet

15

Einzelne Anweisung F7 das Programm wird einschliesslich auszuführender Prozedurenzeilenweise abgearbeitet

Nächste Quellzeile Umsch F7 Programm hält bei der nächsten Quelltextzeile an

Gehe zur Cursorposition F4 das Programm wird bis zu der Position im Quelltext abgearbeitet,an der sich der Cursor befindet

Zeige Ausführungsposition setzt den Cursor in die Zeile, in der sich der Debugger bei derProgrammausführung befindet

Programm Pause unterbricht vorübergehend die Programmausführung

Programm zurücksetzen Strg F2 beendet das Programm und gibt den belegten Speicherplatz frei

Ausdruck hinzufügen ... Strg F5 öffnet das Dialogfenster zur Eingabe überwachter Ausdrücke

Neuer Haltepunkt ... öffnet das Dialogfenster zum Eingeben eines Haltepunktes

Auswerten/Ändern ... Strg F7 öffnet das Dialogfenster zum Anzeigen und Editieren einer Varia-blen zur Laufzeit

��+�>��

Umgebungsoptionen ... öffnet das Dialogfenster zur Einstellung der Umgebungsoptionen. Das Menu wird imallgemeinen einmal von einem Programmierer zu Beginn seiner Arbeiten benutzt, umsich die Arbeitsoberfläche entsprechend seinen Wünschen einzustellen.

Objektablage ... öffnet das Dialogfenster "Objektablage"

Tools konfigurieren ... erlaubt das Hinzufügen, Löschen und Bearbeiten von Tools

Editor für Package-Sammlungen

Anzeigen und Bearbeiten von Package-Libraries

Bildeditor pixelorientiertes Zeichenprogramm zur Erstellung eigener Bitmaps (→ 6.2)

Datenbankoberfläche Programm zur Bearbeitung von Datenbanktabellen (→ 6.3)

��!��"��#��(��Das Formular ist die visuelle Grundlage eines Delphi-Programms und dient der Aufnahme derKomponenten, mit denen der Anwender später in direktem Dialog arbeiten wird. Das Plaziereneiner Komponente auf dem Formular ist im allgemeinen der erste Schritt bei der Bearbeitungeiner Komponente. Die Einstellungen der auf dem Formular plazierten Komponente erfolgendann über den Objekt-Inspektor oder durch Ziehen mit der Maus, falls z.B. die Abmessungenoder die Position der Komponente verändert werden sollen.

Ein sehr nützliches Instrumentarium ist die Möglichkeit, mehrere Objekte gleichzeitig bearbeitenzu können. Wenn zum Beispiel mehrere Labels die gleiche Breite haben sollen, so muß dieEigenschaft nicht für jedes Objekt separat im Objekt-Inspektor eingetragen werden, sondern dieObjekte können vorübergehend zu einer Gruppe zusammengefaßt werden, und der einmaligeingetragene Breitenwert wird in jede Komponente übernommen. Das Zusammenfassen vonObjekten zu einer 7�%% kann auf zwei Arten erfolgen:

1. Das erste Objekt der Gruppe wird ganz normal angeklickt, und die Objekte, die nun dieserGruppe hinzugefügt werden sollen, werden bei gedrückter Umschalttaste angeklickt. Abdem zweiten Objekt werden die 8 Markierungspunkte eines Objektes nun nicht mehr inschwarz sondern in Grau dargestellt.

2. Bei gedrückter Steuerungstaste wird mit der Maus ein rechteckförmiger Rahmen um dieObjekte gezogen, die in einer Gruppe zusammengefaßt werden sollen. Um ein Objekt zuselektieren, muß es nicht komplett umschlossen werden, sondern der Rahmen braucht eslediglich zu berühren. Auch bei dieser Methode werden die selektierten Objekte durch graueRahmenpunkte gekennzeichnet.

16

Die Gruppierung wird aufgehoben, wenn irgendein nicht markiertesElement angeklickt wird. Neben der Möglichkeit, an gruppierten Ele-menten effizient Eigenschaften zu ändern, können die Elemente ei-ner Gruppe auch ohne viel Aufwand angeordnet und ausgerichtetwerden. Die dazu erforderlichen Befehle bietet der Menupunkt "Be-arbeiten" mit den rechts dargestellten Funktionen an.

Größe und Position eines Objektes sind die am häufigsten einzu-stellenden Eigenschaften und können sowohl für ein einzelnes Ob-jekt, wie auch für eine Objekt-Gruppe besonders exakt mit der Ta-statur vorgenommen werden. Die Positionierung erfolgt bei ge-drückter )�� mit den K��; die Größe wird ebenfalls durch die K�� eingestellt, wenn gleichzeitig die *�� gedrückt gehalten wird. Die Verände-rung von Größe und Position erfolgt bei jedem Cursor-Tastendruck mit einer bestimmten dis-kreten Schrittweite, deren Größe durch die Rasterung des Hilfsgitters auf dem Formular defi-niert ist. Das Raster der Gitterpunkte ist im Menupunkt "Tools / Umgebugsoptionen / Vorgaben"einzustellen.

Am Raster ausrichten Die markierten Elemente werden so verschoben, daß sie mit ihrer oberen linken Ecke anden nächst gelegenen Raserpunkt positioniert werden.

Nach vorne setzen

Nach hinten setzen

Während der Entwurfszeit können sich auf dem Formular durchaus mehrere Komponen-ten überlappen, mit den beiden Befehlen kann bestimmt werden, welche Komponentekomplett sichtbar und welche überdeckt werden.

Ausrichten ... Die gruppierten Komponenten werden zueinander ausgerichtet; z.B. links- oder rechts-bündig, an einer unteren oder oberen Bezugskante, oder auf einen gleichmäßigen Ab-stand untereinander.

Größe für alle markierten Elemente kann die Größe absolut in Bildschirmpixeln eingestellt wer-den.

Skalierung Die markierten Elemente können in Relation zur aktuellen größe relativ, proportionalverändert werden.

Tabulatorreihenfolge... Schaltelemente können zur Laufzeit über die Maus oder über die Tastatur betätigt wer-den. Um einen Schalter mit der Tastatur betätigen zu können, muß er allerdings denFocus besitzen (das Schaltelement ist optisch hervorgehoben), der mit der Tabulatortastevon Element zu Element bewegt wird. Die Reihenfolge, in der die Elemente den Focuszugeteilt bekommen, wird über die Tabulatorreihenfolge geregelt. Man kann damit alsobewirken, daß der Focus nicht willkürlich zur nächsten Komponente springt, sondern dieKomponenten in einer geordneten Reihenfolge aktiviert.

Erstellungsfolge... Benutzen Sie dieses Dialogfeld, um die Reihenfolge zu bestimmen, in der Ihr Programmdie nicht-visuellen Komponenten erzeugt, wenn Sie das Formular während der Program-mentwicklung oder während des Programmablaufs laden. Das Listenfeld zeigt aus-schließlich die nicht sichtbaren Komponenten des aktuellen Formulars sowie ihren Typund ihre momentane Erstellungsreihenfolge an. Standardmäßig entspricht die Erstel-lungsreihenfolge der Reihenfolge, in der Sie die Komponenten in das Formular eingefügthaben.

Elemente sperren Benutzen Sie diese Funktion, um Komponenten des aktuellen Formulars an ihrer mo-mentanen Position zu verankern. Wenn diese Option aktiviert ist, können Sie keine derKomponenten verschieben oder in ihrer Größe verändern. Sie können jedoch den Objek-tinspektor verwenden, um die Eigenschaften Height, Left, Top und Width einer markiertenKomponente zu verändern.

Hinweis: Der Befehl Elemente sperren hat keine Wirkung auf das Formular selbst. Auchnach Aktivieren des Befehls können Sie das Formular frei bewegen oder in der Größeverändern.

17

�� )��*��Zu einem Formular gehört zwangsläufig immer eine Unit, in der hinterlegt wird, wie die einzelneKomponente auf dem Formular auf ein bestimmtes Ereignis reagieren soll. Die Unit enthält da-mit den anwendungsspezifischen Teil des Programms, wobei der prinzipielle Aufbau einer Unitfest vorgegeben ist.

�� MAIN2;��

{-$DEFINE UseBvKarte}�� SysUtils,WinTypes,WinProcs,Messages,Classes,Graphics,Controls;�� TFMain = �(TForm) Beenden1: TMenuItem; BBCycOK: TBitBtn; procedure Beenden1Click(Sender: TObject); procedure BBCycOKClick(Sender: TObject); �� procedure NewData; procedure DisposeData; �� procedure Sinus1Click(Sender: TObject); procedure Ellipse1Click(Sender: TObject); ��;�� LEN_EINGABE = 8;�� FMain: TFMain; Polygon: ^Tpolygon;

�� {$R *.DFM}�� Bv, BvImage, DefData, Comm, Hilfe;�� ODatName,OFullName: string;

�� TFMain.MMeldung (text: string);�� FAKTOR = 5.575;�� Wert1,Wert2: single;�� ...��;

�� TFMain.Bildverarbeitung1Click(Sender: TObject);�� ...��;

�� MainInit;

�� Speicher freigeben;

��

18

��,�-��Der Ablauf eines Windowsprogrammes ist ��; d.h. es bedarf eines bestimmtenAnlasses, wie z.B. dem Drücken einer Taste auf der Tastatur, einem Mausklick oder eines Ti-mer-Ereignisses, damit eine Funktion oder Prozedur ausgeführt wird. Die Ereignisse, die füreine bestimmte Komponente eintreten können, sind in der Seite "Ereignisse" des Objekt-Inspektors aufgelistet, deren Standardereignisse in der folgenden Tabelle zusammengestelltsind.

-�� 6��

OnClick ... mit der auf dem Desktop definierten Standard-Maustaste auf die Komponente �� wird.

OnDblClick ... mit der Standard-Maustaste ein !�%%�� auf die Komponente erfolgt.

... eine Maustaste ��A �� wird. Anhand der Variablen Shift, Button und X,Y imProzedurkopf kann auch unterschieden werden, welche Maustaste gedrückt worden ist,und an welcher Koordinatenposition sich der Mauscursor befindet.

Shift Button Bedeutung

OnMouseDown

ssLeft

ssMiddle

ssRight

mbLeft

mbMiddle

mbRight

linke Maustaste gedrückt

mittlere Maustaste gedrückt

rechte Maustaste gedrückt

OnMouseUp ... eine Maustaste losgelassen wird. Es gelten dieselben Randbedingungen wie für dasOnMouseDown-Ereignis.

OnMouseMove ... die Maus bewegt wird. Im Gegensatz zu OnMouseDown und OnMouseUp tritt dasEreignis auch dann ein, wenn ��'��A �� wird.

OnKeyPressed ... eine Taste gedrückt wird. Im Prozedurkopf wird der ASCII-Code der gedrückten Tasteübergeben.

OnKeyDown ... eine Taste nach unten gedrückt wird.

OnKeyUp ... eine Taste losgelassen wird.OnKeyDown und OnKeyUp können auf alle Tasten einschließlich Funktionstasten und Tastenkom-binationen reagieren. Da der übergebene Parameter aber vom Typ 'Word' ist, müssen hier die unterWindows definierten ��>�� verwendet werden (→ Delphi-Hilfe).

OnChange ... die Komponente geändert worden ist.

OnEnter ... die Komponente den Focus erhält.

OnDragDrop ... ein gezogenes Objekt in der Komponente abgelegt wird.

OnDragOver ... ein Objekt über die Komponente bewegt wird.

OnEndDrag ... Drag&Drop beendet worden ist.

OnExit ... die Komponente den Focus verliert.

Bei Doppelklicken auf eine leere Ereigniszeile legt Delphi das Gerüst für eine Prozdur an, derenBezeichnung aus dem Namen der Komponente und dem Namen des Ereignisses zusammen-gesetzt wird.

%� �� Button1Click (Sender: TObject);��

��;

Die Deklaration des Ereignisses wird auch automatisch in der Klassendefinition des übergeord-neten Formulars eingetragen. Beim Entfernen einer Ereignisprozedur ist also darauf zu achten,daß sowohl die Prozedur, als auch deren Deklaration gelöscht wird.

Hinweis:Detaillierte Informationen zu den Ereignissen bietet auch hier die Delphi-Hilfe, indem das ent-sprechende Ereignisfeld im Objekt-Inspektor angeklickt und die Funktionstaste F1 gedrückt wird.

19

� � )% � � � ��

Eine Programmiersprache besteht in den wesentlichen Merkmalen aus 5��, "�� und 5��A%#��. Die als Informationsträger dienenden Variablen sind im allgemeinennahezu unabhängig von der Sprache; ihre Wahl und Gestaltung bleibt bis auf kleine Einschrän-kungen allein dem Programmierer überlassen. Fest definiert sind hingegen die zu verwenden-den Anweisungen oder Befehle, die auch als reservierte Wörter bezeichnet werden und derZeichensatz, über den Zuweisungen und Verknüpfungen erfolgen.

��.� ��

)=�� -��8��

MN Zuweisung

O Addition, Vorzeichen, Vereinigungsmenge, Stringverkettung

� Subtraktion, Vorzeichen, Differenzmenge

∗ Multiplikation

F Division (Gleitkomma-Arithmetik)

N Gleichheitsabfrage

P��Q Abfrage auf größer als und Abfrage auf kleiner als

PN��QN Abfrage auf größer/gleich als und Abfrage auf kleiner/gleich als

QP Abfrage auf Ungleichheit

� Dezimalpunkt

�� Bereichsangabe

6 Trennung von Listenelementen

R Trennung von Deklarationen bzw. Anweisungsblöcken

M Variablendeklaration, Case-Separator

L Zeichenkettenanfang und –ende

S�T Anfang / Ende von Mengenkonstanten

:�; Anfang / Ende von Listen bzw. Klammerausdrücken

G�J Anfang / Ende von Kommentaren, die über mehrere Zeilen gehen dürfen

FF Einleitung einer Kommentarzeile

U Zeichen für Zeiger (Pointer)

V Adreßzeichen

H Einleitungssymbol einer Hexadezimalzahl

W Einleitungssymbol einer ASCII-Darstellung

:��; Ersatzdarstellung für [ ]

:∗��∗; Ersatzdarstellung für { }

20

��0��12��)��

Dem Programmierer steht es frei, welche Namen er an seine Variablen, Funktionen oder Pro-zeduren in der Anwendung vergibt. Eine Ausnahme bilden aber Bezeichner, die vom Compilerbereits reserviert sind und als Befehle oder Schlüsselworte fungieren.

4�� -��8��absolute Adressendefinition

and logisches UND

array Feld (Tabelle)

as Überprüfung von Typumwandlungen

at @-Operator zur Adressenberechnung

asm Zugriff auf den integrierten Assembler

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 Alternativ- bzw. Neinzweig einer Abfrage

end Blockende

except Abschnitt für Fehlerbehandlungscode

exports exportiert Funktionen / Prozeduren aus DLLs

external Deklaration extern compilierter Funktionen / Prozeduren

far Aufruf von Routinen von anderen Modulen aus

file Datei

finalization abschließender Abschnitt einer Unit

finally immer ausgeführter Abschnitt eines geschützten Blocks

for Anfangswert einer Schleife

forward Deklaration einer Funktion / Prozedur im voraus

function Funktionsdeklaration

goto Sprungbefehl

if Bedingung

implementation Runpf einer Unit

interface globale Deklarationen einer Unit

label Sprungmarke

library dynamische Linkbibliothek (DLL)

mod Divisionsrest

name Namensangabe innerhalb einer ��-Klausel

near Aufrufkonvention

nil undefinierter Zeiger

nodefault Standardwert einer Eigenschaft wird gesteuert

not Verneinung

of Benennung eines Grundtyps

on ... bildet zusammen mit �� eine Fehlerbehandlungsroutine

or logisches ODER

packed gepackte Struktur

21

procedure Prozedur-Deklaration

program Programm-Deklaration

raise Auflösen einer Exception (Fehlerbehandlung)

record Datensatz

repeat Schleifenwiederholung mit Endabfrage

resident Exportinformation bleibt 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 Exeption-Behandlung

type Datentyp

unit eigenständiges Programm-Modul

until Ende einer ��-Schleife

uses Unit-Deklarationen

var Datenvariable

while Schleifen-Wiederholung mit Anfangsabfrage

with Zugriff auf ��-Strukturen

xor Exclusiv-ODER

��"�� %��

Die Gruppe der Operatoren ist im Prinzip lediglich eine Zusammenstellung bestimmter Ele-mente aus dem Zeichensatz und der Gruppe der reservierten Wörter, mit denen die meistenrechentechnischen Verknüpfungen von Variablen durchgeführt werden. Besonders interessantist in diesem Zusammenhang allerdings, welche Ergebnisse sich einstellen, wenn unterschiedli-che Typen von Variablen miteinander verarbeitet werden.

�%�� %�� %�� %�� -��=%

O Addition Integer Integer Integer

Real Real Real

Real Integer Real

� Subtraktion ��

∗ Multiplikation Integer Integer Integer

Real Real Real

Real Integer Real

F Division (Gleitkomma) Integer Integer Real

Real Real Real

Real Integer Real

�� Ganzzahlige Division Integer Integer Integer

Real Integer Integer

Real Real Integer

�� Rest ��

22

��)%� ��

��(��

Die wichtigsten Programmbausteine in einem Windows-Programm sind Funktionen und Proze-duren, die in Form von Unterprogrammen eine exakt umrissene Aufgabe abarbeiten und nachder Abarbeitung beendet werden.

Eine (�� ist ein Unterprogramm, das Funktionsparameter übergeben bekommt, dieseverarbeitet und in der aufrufenden Programmzeile in Form einer Zuweisung ein Ergebnis zu-rückgibt. Nach Abarbeitung der Funktion wird das Programm unmittelbar mit der Zeile hinterdem Funktionsaufruf fortgesetzt.

...a := 15.3;b := 2.5;c := 2.2;s := Summe (b,c,d);......

#�� Summe (x,y,z: single): single;�� result := x + y + z; �� Summe := x + y + z;��;

Die �� ist ein Unterprogramm, das der Funktion weitgehend identisch ist. Der Unter-schied besteht darin, daß die Prozedur der aufrufenden Programmzeile keinen separaten Er-gebniswert zuweist, sondern daß das oder die Ergebnisse als Variable in der Liste der Überga-beparameter erscheinen.

...a := 15.3;b := 2.5;c := 2.2;Summe (b,c,d,s);......

%� �� Summe ( x,y,z: single; �� s: single);�� s := x + y + z;��;

��5��!��=%�

Jedes Programm lebt in erster Linie von seinen Variablen. Mit Variablen wird gerechnet oderihnen wird mittels Ergebnisanweisung (:=) ein Wert zugewiesen, oder sie werden als Parameteran Funktionen bzw. Prozeduren übergeben.

a := 2 ∗ b;y := sin (a);

Im allgemeinen haben Variablen einen bestimmten Datentyp (Single, Integer, String ...), derihnen in der Deklaration der Variablen zugewiesen wird. Deklarationen werden in einem zu-sammenhängenden Block vorgenommen, der durch das Schlüsselwort "var" gekennzeichnetist.

�� kurs, dm, dollar: single; code: integer; vorname: string;

Innerhalb von Prozeduren und Funktionen deklarierte Variable bezeichnet man als ��, au-ßerhalb von Prozeduren/Funktionen deklarierte als��. Für globale Variable muß darüber-hinaus noch unterschieden werden, ob sie im ��%�� oder im ��#� �� dekla-riert worden sind. Im Implementationsteil angelegte Variable sind innerhalb der Unit jeder Funk-tion und Prozedur bekannt; sie können aber nicht von anderen Units verwendet werden. Im In-terfaceteil deklarierte globale Variable können dagegen auch von anderen Units benutzt wer-den.

23

��#�

�� s0: string; // globale Variable, die für andere Units verwendbar ist

��%�� s1, s2: string; // globale Variable, die nur innerhalb der Unit verwendet werden können

%� �� test1;�� FF�lokale Variable, die nur innerhalb der Prozedur 'test1' gültig sind s3,s4: string;�� s3 := 'Müller'; s4 := 'Meier';��;

%� �� test2;�� s1 := 'Vorname'; s2 := 'Nachname';��;

Globalen Variablen kann bereits bei der Deklaration ein Anfangswert zugewiesen werden; d.h.sie können bereits mit der Deklaration initialisiert werden.

�� s1: string = 'Müller'; i: integer = 5;

��>=%�

Zu dieser Gruppe zählen die in der folgenden Tabelle zusammengestellten Ganzzahl-Variablen,die mit Wortlängen bzw. Auflösungen von 8-bit, 16-bit oder 32-bit arbeiten.

>=% 1�� (��

)�� -128..127 Acht Bit einschließlich Vorzeichen

)�� -32768..32767 16 Bit einschließlich Vorzeichen

?�� -2147483648..2147483647 32 Bit einschließlich Vorzeichen

4=� 0..255 8 Bit, besitzt kein Vorzeichen

1�� 0..65535 16 Bit, besitzt kein Vorzeichen

��:�,��)=��; -32768..32767 16 Bit einschließlich Vorzeichen

K�� 0..65535 16 Bit, besitzt kein Vorzeichen

��:��)=��; -2147483648..2147483647 32 Bit einschließlich Vorzeichen

K�� 0..2147483647 32 Bit, besitzt kein Vorzeichen

��0��>=%�

Für das eigentliche "Rechnen" in Programmen werden in der Regel Gleitkommavariablen ver-wendet, deren Darstellung mit 32-bit bis 80-bit-Genauigkeit vorgenommen werden kann. Bei derDeklaration von Gleitkomma-Variablen wird man die Auflösung nicht höher als erforderlichwählen, da höhere Auflösungen im allgemeinen mehr Speicherplatz und längere Rechenzeitenbedeuten. Für die reine Ablage von Daten auf der Festplatte ist eine Darstellungsbreite von 32Bit in der Regel vollkommen ausreichend.

24

>=% 1�� )��#��.�##�

72B��4=�

)�� 1.5 x 10^-45 .. 3.4 x 10^38 7-8 4

0�� 2.9 x 10^-39 .. 1.7 x 10^38 11-12 6

!�� 5.0 x 10^-324 .. 1.7 x 10^308 15-16 8

-D�� 3.4 x 10^-4932 .. 1.1 x 10^4932 19-20 10

K��% -2^63+1 .. 2^63 –1 19-20 8

K�� = -922337203685477.5808..

922337203685477.5807

19-20 8

Hinweis:

Der Typ Real wird nur noch aus Kompatibilitätsgründen zu früheren Pascal-Versionen "mitgeschleppt". Dadas Real-Speicherformat mit 6 Byte von Intel-CPUs nicht unterstützt wird, sind Operationen mit diesemDatentyp deutlich langsamer als die coprozessorunterstützten Datentypen Single, Double und Extended.

Der Datentyp Extended ist die Basis für alle Gleitkommaberechnungen. Auch wenn nur Singleoder Double-Variablen in mathematischen Ausdrücken verwendet werden, werden die Re-chenoperationen intern immer mit der imposanten 10 Byte-Datenbreite des Extended-Formatsdurchgeführt.

�� 4��>=%�

Der logische Datentyp boolean kann nur die Zustände False und True annehmen, die als Kon-stantenbezeichner fest vordefiniert sind. Der Speicherbedarf dieser Variablen beschränkt sichdamit auf ein einziges Byte. Die hauptsächliche Verwendung erfolgt in Abfragen für bedingteVerzweigungen.

��,�)��

Der wichtigste Datentyp neben den Integer-, Boolean- und Realtypen ist die Deklaration vonText- oder Zeichenketten, die als Strings bezeichnet werden. Strings sind Zeichen des erwei-terten ASCII-Zeichensatzes, sind in Apostrophe (') einzuschließen und müssen im Quelltext ineiner Zeile stehen.

�� s1: string; // Deklaration einer Zeichenkette��.. s1 := ’Hallo’; // Zuweisung des Wortes ’Hallo’ an die Stringvariable s1 s1 := ’’; // Leerstring��;

Ab Delphi 2.0 werden neben den üblichen "kurzen" Strings mit maximal 255 Zeichen nun auch"lange" Strings mit einer Länge von 2 GByte unterstützt.

>=% -�8�� 72B

"��)�� Zeichenkette unbegrenzter Länge 4 Byte (Zeiger!)

)��)�� Zeichenkette mit max. 255 Byte (Länge + 1) Byte

�� AnsiString bei Compilereinstellung ($H+)

ShortString bei Compilereinstellung ($H-)

Für alle Typen der Tabelle kann nach wie vor das reservierte Schlüsselwort 'string' verwendetwerden. Die Grundeinstellung ist über den Menupunkt "Projekt/Optionen/Compiler" durch Mar-

25

kieren des Feldes "Huge-String" vorzunehmen, das in der Standardeinstellung auch aktiviert ist.{$H+} // lange Strings einschalten; kann entfallen, wenn ’Huge-Strings’ markiert ist�� s1: string; // langer String, abhängig von $H s2: string [40]; // kurzer String mit max. 40 Zeichen, unabhängig von $H s3: AnsiString; // langer String, unabhängig von $H s4: ShortString; // kurzer String, unabhängig von $H

In einem String läßt sich jedes einzelne Zeichen als Element eines Feldes gezielt ansprechenund auch 'herausschneiden'. Das einzelne Zeichen entspricht einem String der Länge 1, kannaber auch durch den speziellen Datentyp �� aufgenommen werden.

�� z: char; s: string;�� s := ’Hallo’; // Dem String s wird der Test Hallo zugewiesen z := s[1]; // Die Variable z enthält nun den Buchstaben 'H'��;

Im Falle sehr langer Strings oder im Sinne einer übersichtlicheren Darstellung des Quelltexteskann eine Stringzuweisung auch über mehrere Zeilen gehen. Die in Apostrophe eingekleidetenTeilstrings werden dabei durch das Zeichen "+" über die Zeilen hinweg miteinander verbunden.

�� ls: string;�� ls := ’Dies ist ein relativ langer String, ’ +

'der sich im Quelltext über zwei Zeilen erstreckt.';��;

��+�"�=�

Im allgemeinen ist die Aufgabe eines Rechnerprogramms die Bearbeitung großer Datenmen-gen, wie z.B. von Meßdaten. Große Mengen gleichartiger Zahlenwerte werden dann nicht mitseparaten Variablennamen belegt, sondern als Datenfeld (Array) betrachtet, das mit �� Va-riablennamen versehen wird, und in dem die einzelnen Werte über einen Zählerindex ange-sprochen werden. Die Erscheinungsform des Datenfeldes ist bei der Behandlung von Stringsbereits aufgetaucht, da ein String im Grunde genommen nichts anderes ist als ein Array vonZeichen (char).

�� Kundenname : array [1..1000] of string; Alter : array [1..1000] of integer; MessWert : array [1..50000] of single; Matrix : array [1..100,1..10] of double;�� Kundenname [52] := 'Müller'; // Der 52. String im Array Kundenname ist 'Müller' Alter [13] := 22; // Der 13. Eintrag im Array Alter ist die Zahl 22 MessWert [2560] := 155.25; // Der 2560 te Meßwert ist 155.25 Element := Matrix [20,5]; // Die Variable Element bekommt den Wert zugewiesen, der im

// Array Matrix in der Zeile 20 und der Spalte 5 steht��;

��&�>=%�

Das Beispiel Array zeigt, daß man bereits bestehende Datentypen kombinieren kann, was dannim Grunde genommen zu einem neuen Datentyp führt. Die Deklaration einer Array-Variablenkann unter diesem Blickwinkel auch über den Umweg einer Typdeklaration vorgenommen wer-den, die über das Schlüsselwort �=% eingeleitet wird. Besonders interessant ist die "Typisie-rung" von Arrays bei der Verwendung von Zeigern und beim effizienten Aufrufen von Funktio-

26

nen und Prozeduren.�=% TKundenname = array [1..1000] of string; TAlter = array [1..1000] of integer; TMessWert = array [1..50000] of single; TMatrix = array [1..100,1..10] of double;�� Kundenname: TKundenName; Alter: TAlter; MessWert: TMessWert; Matrix: TMatrix;�� Kundenname[487] := ’Schmidt’; // Der Kunde mit der Indexnummer 487 heißt Schmidt Alter[487] := 33; // Herr Schmidt ist 33 Jahre alt MessWert := 127.52; Matrix[75,1] := MessWer; // MessWert wird mit der lfd. Nummer 75 (Zeile )in Spalte 1 abgelegt��;

��/�0 ��

Den Vorteil, eine eigene Typdeklaration durchführen zu können, macht die Benutzung derStrukturvariablen �� deutlich, die es erlaubt ein Datenfeld zu definieren, in das Variableunterschiedlicher Gattungen aufgenommen werden können.

�=% TPerson = �� FF�Definition des neuen Typs "TPerson" Name: string [30]; Alter: integer; Gewicht: single; ��;�� Person1, Person2: TPerson; // Deklaration von Variablen vom Typ TPerson�� Person1.Name := 'Müller'; // Zuweisung des Namens von Person1 Person1.Alter := 37; // Zuweisung des Alters von Person1 Person1.Gewicht := 75.3; // Zuweisung des Gewichts von Person1 Person2 := Person1; // Name, Alter und Gewicht von Person1 an Person2 zuweisen��;

Eine Vereinfachung des Zugriffs auf Record-Strukturen schafft die with-Anweisung, die es ge-stattet innerhalb eines Blockes direkt auf die Feldbezeichner des Records zuzugreifen.

�� Person1 do �� Name := 'Müller'; // Zuweisung des Namens von Person1 Alter := 37; // Zuweisung des Alters von Person1 Gewicht := 75.3; // Zuweisung des Gewichts von Person1 ��; Person2 := Person1; // Name, Alter und Gewicht von Person1 an Person2 zuweisen��;

��3�.��

Ein Zeiger ist im Gegensatz zu einer Variablen ein Wert, der auf eine Variable eines bestimm-ten Typs zeigt, also deren Adresse enthält. Das Symbol einer Zeigervariablen ist '∧' und wirdauf der Tastatur durch das getrennt hintereinanderfolgende Drücken der Tasten '∧' und Leerta-ste erzeugt.

Während der Laufzeit eines Programmes wird der Zeigervariablen im allgemeinen eine Adressezugeordnet werden, die auf irgend eine andere Variable zeigt. Das Feststellen und Auslesen

27

solch einer Adresse erfolgt mit dem Operator @.�� Zahl1,Zahl2: integer; // Die Variablen ’Zahl1’ und ’Zahl2’ als Ganzzahlvariable deklarieren Zeiger: ^integer; // Deklaration einer Zeigervariablen�� Zeiger := NIL; // Initialisierung der Zeigervariablen auf einen noch nicht definierten Zeiger Zahl1 := 100; // ’Zahl1’ wird der Zahlenwert 100 zugewiesen Zeiger := @Zahl1; // Die Zeigervariable wird auf die Adresse der Variablen ’Zahl1’ gerichtet Zahl2 := Zeiger^; // ’Zahl2’ wird der Inhalt der Speicheradresse zugewiesen, auf die ’Zeiger’ zeigt��;

Das obige Beispiel zeigt die Anwendung eines �=%��.��, d.h. eines Zeigers, der füreinen bestimmten Datentyp definiert worden ist.

Ein ��ist ein�untypisierter Zeigertyp, der auf eine beliebige Variable zeigen kann.

Ein �K�� ist ein spezieller Zeiger, der auf einen sogenannten null-terminierten String zeigt.Der normale Pascal-String besteht aus einer Zeichenkette, in deren erstem Element (Position 0)die Länge des Strings steht. Auf den Positionen 1 bis N folgen dann die N Zeichen des Strings.Ein 'PChar'-String beginnt direkt an der Adresse, auf die der Zeiger zeigt, und zur Indikation desStringendes wird der ASCII-Code "00" an die Zeichenkette angehängt, womit diese Variante derentspricht, die auch in C verwendet wird. Bei Stringoperationen ist also darauf zu achten, ob essich um einen Pascal-String oder einen nullterminierten String handelt.

Nullterminierte Strings werden als Arrays von Zeichen gespeichert. Als Index fungiert ein Inte-ger-Wert, wobei die Elementzählung bei Null beginnt. Somit ist ein nullterminierter String einArray der folgenden Form: ��= [0..X] �# Char.

6 ’S’ ’o’ ’m’ ’m’ ’e’ ’r’Pascal-String

Stringlänge

Nullterminierter String #00'S' 'o' 'm' 'm' 'e' 'r'

Endezeichen

��!=�� "�=�

Besonders interessant ist die Verwendung von Zeigern bei der Erstellung dynamischer Arrays;d.h. bei der Deklaration von Datenfeldern, deren Größe den Laufzeit-Verhältnissen dynamischangepaßt werden soll.

�=% TMessWert = �� // Definition des Typs TMessWert x,y: single; // x- und y-Koordinate��; TAMessWert = array [1..1] of TMessWert; // Definition eines ArrayTyps vom Typ TMessWert�� MeWe: ^TAMessWert; // Zeiger auf ein Array des Typs TAMessWert deklarieren AnzMeWe: LongInt; // Anzahl der Messwerte�� AnzMeWe := 950; // Anzahl der Messwerte zur Laufzeit GetMem (MeWe, AnzMeWe∗Sizeof(TAMessWert)); // Speicher für AnzMeWe Messwerte reservieren .. x := MeWe^[150].x; // x-Koordinate des 150. Messwertes aus dem Array auslesen y := MeWe^[150].y; // y-Koordinate des 150. Messwertes aus dem Array auslesen .. MeWe^[200].x := x ∗ 2.5; // x-Koordinate in Messwert 200 abspeichern MeWe^[200].y := y + 100 ; // y-Koordinate in Messwert 200 abspeichern FreeMem (MeWe); // Nicht mehr benötigten Speicher zum Programmende wieder freigeben��;

28

��5��

Wenn der Datentyp, der in einer Funktion oder Prozedur bearbeitet werden soll, zur Zeit derCompilierung noch nicht bekannt ist, kann der Datentyp �� benutzt werden, der zur Lauf-zeit jedes Datenformat annehmen kann. Den Vorteil der hohen Flexibilität erkauft man sich abermit dem beachtlichen Speicherplatz von 16 Byte für eine Variable und deutlich längeren Re-chenzeiten.

�� V1, V2, V3, V4, V5: Variant; I: Integer; D: Double; S: string;�� V1 := 1; { Integer } V2 := 1234.5678; { Real } V3 := ’Hallo Welt’; { String } V4 := ’1000’; { String } V5 := V1 + V2 + V4; { Reelle Zahl 2235,5678 } I := V1; { I = 1 } D := V2; { D = 1234,5678 } S := V3; { S = ’Hallo Welt’ } I := V4; { I = 1000 } S := V5; { S = ’2235,5678’ }��;

��'��

Das reservierte Wort �� definiert eine Menge von Elementen eines Typs. Beim Feststellen derMengenzugehörigkeit verwendet man zur Laufzeit das reservierte Wort �� als Bezugsoperator.

�=% TVokal = �� of Char; // TVokal als Menge vom Typ char definieren�� Vokale: TVokal; // Eine Variable des Mengentyps deklarieren Zeichen,Vokal: char; // Variable zur Aufnahme eines beliebigen Zeichens und eines Vokals s: string = ’abcdef’; // zu untersuchende Zeichenfolge�� Vokale := [’a’,’e’,’i’,’o’,’u’]; // Menge der Vokale definieren Zeichen := s[1]; // Zeichen 1 dem String entnehmen und in Variable ’Zeichen’ ablegen �# Zeichen �� Vokale �� FF�Abfragen ob ’Zeichen’ in der Menge der Vokale vorkommt Vokal := Zeichen; // wenn ja, ’Zeichen’ in Vokal abspeichern��;

��$��

Variablen enthalten Werte, die sich während der Ausführung des Programms ändern können.Konstanten enthalten dagegen unveränderliche Werte, die ihren Wert zu dem Zeitpunkt erhal-ten, zu dem sie deklariert werden. Gerade so, wie Variablen in einer Variablendeklaration dekla-riert werden, werden Konstanten in einer Konstantendeklaration deklariert. Eine Konstantende-klaration beginnt mit dem reservierten Wort ��, die Zuweisung wird wie bei der Typ-Definition mit dem Zeichen "=" gemacht. Um sie im Quelltext besser von 'normalen' Variablenunterscheiden zu können, werden die Bezeichner oft in Großbuchstaben geschrieben (Anmer-kung: PASCAL unterscheidet auch hier �� zwischen Groß- und Kleinschreibung).

�� PI = 3.14159; ANTWORT = 342; STAMM_VERZEICHNIS = ’C:\ANWENDUNG\’;

29

"�#�8��$��

Die Deklaration eines Aufzählungstyps verzeichnet alle Werte, die der Typ haben kann. Hiereinige Beispiele für Aufzählungstypdeklarationen:

�=% TTage = (Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag); TAbteilung = (Finanzen, Personal, Konstruktion, Marketing, MIS); THund = (Pudel, GoldenRetriever, Dachshund, NorwegischerElkhound, Beagle);�� Wochentag: TTage; Abteilung: TAbteilung; Hunderasse: THund;

Zu jedem der in Klammern in einer Aufzählungstyp-Deklaration verzeichneten Werte gehörteine 7��, die durch die Position des Wertes in der Liste festgelegt ist. Zum Beispiel hatMontag in der Typdeklaration TTage den Wert 0, Dienstag hat den Wert 1 usw. man könnte dasgleiche Ergebnis erhalten, wenn man die Variable Wochentag als Typ Integer deklarierten unddann einen Integer-Wert zuweisen würde, um die Wochentage zu repräsentieren. Währenddieses System in geordneten und vorhersagbaren Abfolgen - wie Wochentagen oder Monaten -funktionieren mag, hilft es kaum weiter, wenn die Reihenfolge der repräsentierten Werte zufälligist. Kaum jemand kann sich merken, welche Bedeutung einer Zahl zugewiesen wurde. Die Zu-weisung

Hunderasse := Dachshund;

ist dementsprechend aussagekräftiger als

Hunderasse := 2;

�� $��

Um ein Programm zu dokumentieren und leserlich zu gestalten besteht die Möglichkeit, Kom-mentare in den Text einzuflechten. Da Kommentartexte nicht vom Compiler übersetzt werdendürfen, muß dieser sie erkennen können. Die folgenden Konstrukte und Kommentare werdenvom Compiler ignoriert:

G Beliebiger Text, der keine schließende geschweifte Klammer enthält J

:I Beliebiger Text, der kein Sternchen zusammen mit einer schließenden Klammer enthält I;

FF Beliebiger Text zwischen einem doppelten Backslash und dem Ende der Zeile

�� ) ��#��Object Pascal kennt drei Anweisungen, die Quelltext-Blöcke wiederholt ausführen, und zwar dieAnweisungen %��, �� und #�.

�� 0%��) ��#

Die Anweisung %�� wiederholt eine Anweisung oder eine in einen begin/end-Block einge-kleidete Folge von Anweisungen, bis eine Bedingung am Ende der Schleife True ergibt. DieAnweisung beginnt mit dem reservierten Wort %�� und endet mit dem reservierten Wort ��, das von der auszuwertenden Bedingung gefolgt wird. Die Bedingung ist immer ein boole-scher Ausdruck.

%� �� TForm1.RepeatButtonClick (Sender: TObject);�� I: Integer;�� I := 0; // Variable auf Startwert setzen %�� FF�Beginn des „repeat“-Blocks I := I + 1; // Variable inkrementieren

30

RepeatButton.Caption := IntToStr (I); // Beschriftung des Buttons mit der aktuellen Zahl versehen Delay (1000); // 1 Sekunde warten�� I = 10; // Schleife beenden, wenn Variable I den Wert 10 hat��;

Wenn die Anwendung gestartet und die Schaltfläche Repeat angeklickt wird, werden die Zahlen1 bis 10 als Beschriftung der Schaltfläche ausgegeben. Der boolesche Ausdruck I = 10 wird erstam Ende des Blocks repeat..until ausgewertet. Das bedeutet, daß die Anweisungen innerhalbdes repeat..until-Blocks in jedem Fall �� ausgeführt werden.

�� 1��) ��#

Während die repeat-Anweisung einen Ausdruck am Ende der Schleife auswertet, nimmt dieAnweisung �� diese Prüfung am Anfang der Schleife vor. Sie beginnt mit dem reserviertenWort �� und der überprüften Bedingung, die immer ein boolescher Ausdruck sein muß.

%� �� TForm1.WhileButtonClick (Sender: TObject);�� J: Integer;�� J := 0; // Initialisierung der Schleifenvariable �� J < 10 �� FF�Abfragebedingung prüfen �� J := J + 1; WhileButton.Caption := IntToStr (J); // Beschriftung des Buttons mit der aktuellen Zahl versehen Delay (1000); // 1 Sekunde warten��;��;

Wird die Bedingung erfüllt (der Ausdruck ergibt True), wird der Quelltext in der while-Anweisungausgeführt, bis das Ende der Anweisung erreicht und die Bedingung erneut überprüft wird. So-bald die Bedingung den Wert False annimmt, wird die Ausführung der while-Anweisung abge-brochen und die Programmausführung nach der while-Schleife fortgesetzt.

Wenn die Anwendung gestartet und die Schaltfläche While angeklickt wird, wird der boolescheAusdruck "J < 10" als erstes ausgewertet. Ergibt er True, wird der restliche Quelltext innerhalbder while-Anweisung ausgeführt und der Ausdruck anschließend erneut ausgewertet. Ergibt derAusdruck False, wird die Ausführung der while-Anweisung abgebrochen. In dem Beispiel er-scheinen also die Zahlen 1 bis 9 im Sekundenabstand als Beschriftung des angeklicktenSchalters. Die while-Schleife muß also nicht wie die repeat-Schleife zwingend durchlaufen wer-den.

�� (��) ��#

Bisher sind zwei Schleifentypen vorgestellt worden, die Anweisung repeat und die Anweisungwhile. Die Anweisung repeat wird ausgeführt, �� eine Bedingung True ergibt, und die Anwen-dung while wird ausgeführt, �� eine Bedingung True ergibt. Die Anweisung #� stellt dendritten Schleifentyp in Object Pascal dar. Der Quelltext innerhalb einer for-Schleife führt einefestgelegte Anzahl von Wiederholungen aus.

Der Wert einer Steuervariablen, die tatsächlich nur ein einfacher Zähler ist, bestimmt, wie ofteine for-Anweisung ausgeführt wird. Für jede for-Schleife, die im Quelltext verwendet wird, mußeine Variable deklariert werden. Die Variable ist normalerweise ein Integertyp, kann aber auchein Boolean- und Char-, Aufzählungs- oder Unterbereichstyp sein.

Die allgemeine Syntax lautet

#� Laufvariable MN Startwert �� Endwert ��

wenn der Endwert größer ist als der Zielwert; d.h. wenn die Laufvariable inkrementiert wird, und

#� Laufvariable MN Startwert �� Endwert ��

wenn die Laufvariable dekrementiert werden soll. Der Absolutwert der Schrittweite der Laufva-

31

riablen beträgt immer 1 und ist nicht weiter einstellbar. Andere Schrittweiten müssen also miteiner while- oder repeat-Schleife realisiert werden.

%� �� TForm1.ForButtonClick (Sender: TObject);�� K: Integer;��#� k:=1 �� 10 �� // Schleifendefinition mit Startwert 1 und Zielwert 10 �� ForButton.Caption := IntToStr (K); // Beschriftung des Buttons mit der aktuellen Zahl versehen Delay (1000); // 1 Sekunde warten (Unterprogramm)��;��;

Diese for-Anweisung definiert einen Anfangswert (1) und einen Endwert (10) für die Variable K.Wenn die Ausführung der for-Anweisung beginnt, wird K der Anfangswert zugewiesen und dieBeschriftung des Schalters ausgeführt, die den aktuellen Wert von K anzeigt. Der Wert von Kwird dann am Ende des for-Blocks in der end-Anweisung um eins erhöht und mit dem Zielwertverglichen. Da der neue Wert von K, jetzt 2, nicht größer als der Endwert (10) ist, wird die Be-schriftung erneut ausgeführt und gibt diesmal den Wert von K als 2 aus. Dieser Vorgang wirdfortgesetzt, bis der Wert von K größer wird als der Endwert 10, und die Ausführung der for-Anweisung endet.

1� ��: Der Wert der Steuervariablen �� der Schleife darf durch Zuweisun-gen nicht verändert werden, da ansonsten Fehler kaum vermeidbar sind.

5�� #��) ��#�

Eine for-Schleife in einer anderen for-Schleife zu verschachteln ist sehr nützlich, wenn Daten ineiner Matrix, Tabelle oder einem Gitter angezeigt oder bearbeitet werden müssen. Dieses Bei-spiel verwendet das Gitternetz. Der Quelltext gibt einfache Zeilen- und Spaltentitel in den Fel-dern des Gitters aus und zeigt die Zeilen- und Spaltenkoordinaten mit einem Schrägstrich ge-trennt in jeder Zelle an.

%� �� TForm1.GitterBeschriftenClick (Sender: TObject);�� Spalte, Zeile: Integer;�� { Beschriftung der Zellen 1 bis 5 in der ersten Zeile als Spaltenüberschriften. Zelle 0 bleibt } { leer, da hier in der folgenden Schleife die Zeilenkommentare eingetragen werden. } #� Spalte := 1 �� 5 do StringGrid1.Cells[Spalte, 0] := 'Spalte ' + IntToStr(Spalte);{ Beschriftung der Zellen in der ersten Spalte als Zeilenkommentar. }{ Auch hier wird Zelle 0 nicht beschrieben. }#� Zeile := 1 �� 5 do StringGrid1.Cells[0, Zeile] := 'Zeile ' + IntToStr(Zeile);{ Beschriftung der übrigen Zellen im Innern des Gitters mit der Zeilen- und Spaltenposition } #� Spalte := 1 �� 5 do #� Zeile := 1 �� 5 do StringGrid1.Cells[Spalte, Zeile] := IntToStr (Spalte) + ' / ' + IntToStr(Zeile);��;

"�� ) ��#��=%�

Die #�-Schleife wird verwendet, wenn die Zahl der Schleifendurchgänge genau bekannt ist; sieist sehr schnell und effizient.

Die %��-Schleife wird verwendet, wenn die Zahl der erforderlichen Schleifendurchgän-ge nicht bekannt ist, aber man genau weiß, daß die Schleife �� durchlaufenwerden muß.

Die ��-Schleife wird verwendet, wenn die Zahl der erforderlichen Schleifendurchgängeunbekannt ist und die Schleife unter Umständen gar nicht ausgeführt werden muß.

32

�� 4��XK��

Die Prozedur 4�� bewirkt, daß eine for, while oder repeat-Anweisung beendet und die Aus-führung mit der nächsten Anweisung nach der Schleife fortgesetzt wird. Wird Break außerhalbeines for-, while- oder repeat-Konstrukts verwendet, gibt der Compiler eine entsprechendeFehlermeldung aus. Ist zwischen Break und dem Schleifenende ein finally-Block definiert, wirddie Ausführung mit diesem fortgesetzt.

Die Prozedur K�� bewirkt, daß direkt zum Kopf des Blockes gesprungen und der nächsteDurchlauf der aufrufenden for-, while- oder repeat-Anweisung ausgeführt wird. Wird Continueaußerhalb eines for-, while- oder repeat-Konstrukts aufgerufen, gibt der Compiler eine entspre-chende Fehlermeldung aus.

��,�4��5��

��,��#�"��

Das gebräuchlichste Mittel zur Realisierung einer einfachen Verzweigung in einem Programmist die bedingte Abfrage. Die Syntax dieser sogenannten �#-Anweisung lautet folgendermaßen:

�# Bedingung = True �� FF�Prüfen der logischen Bedingung hinter if �� FF�Auszuführender Block, falls die Bedingung #A�� ist Mach_dies; �� FF��.��#��)��Y�� FF .. andernfalls .. �� // Auszuführender Block, falls die Bedingung �� #A�� ist Mach_das; ��R

Das Ergebnis der Bedingung muß vom Typ Boolean sein. Wenn der if-Ausdruck True ergibt,wird die auf das reservierte Wort then folgende Anweisung (Anweisungsblock) ausgeführt.Wenn der if-Ausdruck False ergibt und ein ��-Zweig existiert, wird die auf das reservierteWort else folgende Anweisung ausgeführt. Fehlt der else-Zweig, wird die Programmausführungmit der Anweisung fortgesetzt, die auf die if-Anweisung folgt. Eine else-Alternative ist also �� zwingend erforderlich.

��,�� "��

Die zweite Möglichkeit, um eine Verzweigung zu den entsprechenden Quelltext-Zeilen vorzu-nehmen, ist die Verwendung der ��-Anweisung, die besonders dann effizient eingesetzt wer-den kann, wenn mehrere Alternativen eines Zustandes geprüft werden müssen.

Die Anweisung �� ist einer Folge von if-Anweisungen besonders dann vorzuziehen, wenn dieauszuwertende Variable ein �� Typ ist (Aufzählungstyp wie z.B. Byte oder Integer). DieLogik einer case-Anweisung ist auf Grund ihrer übersichtlichen Gestaltung normalerweiseleichter zu verstehen als die von komplex geschachtelten if-Anweisungen, und darüber hinauswird der Quelltext in case-Anweisungen schneller ausgeführt.

Eine case-Anweisung besteht aus einem Ausdruck ()��) und einer Reihe von "��. Jeder Anweisung geht entweder eine oder mehrere Konstanten (sogenannte case-Konstanten) oder das reservierte Wort �� voran.

Der Selektor muß ordinal sein (darf also beispielsweise nicht vom Typ String sein). Alle case-Konstanten müssen ebenfalls von einem ordinalen Typ sein, der zum Typ des Selektors kom-patibel ist. In einer Selektionszeile kann entweder ein einzelner Selektor aufgeführt sein, dervon der folgenden Anweisung durch einen Doppelpunkt abgetrennt wird, oder aber mehrereSelektoren, die dann untereinander durch Kommata getrennt werden. Die dritte Variante ist dieAngabe eines Bereiches, der durch den unteren Selektionswert und den oberen Selektionswertmit zwei dazwischenliegenden Punkten definiert wird.

33

%� �� TForm1.ZahlenTestClick (Sender: TObject);�� Zahl: Integer;�� Zahl := StrToInt (Edit1.Text); // Zahl aus einem EditFeld lesen

�� Zahl �# FF�Zahl ist die Steuergröße der case-Anweisung 0: // Zahlenwert 0 testen Label2.Caption := 'Zahl 0'; 1, 3, 5, 7, 9: // Selektoren für ungerade einziffrige Zahl Label2.Caption := 'Ungerade einziffrige Zahl'; 0, 2, 4, 6, 8: // Selektoren für gerade einziffrige Zahl Label2.Caption := 'Gerade einziffrige Zahl'; 10..100: // Zahl im Bereich von 10 bis 100 Label2.Caption := 'Zwischen 10 und 100'; �� FF�alle anderen Fälle Label2.Caption := 'Größer als 100 oder negativ'; ��; // Ende-Marke des case-Blocks��;

Wie die Anweisung if kann auch die Anweisung case optional einen ��-Teil enthalten, derausgeführt wird, wenn keine der zuvor geprüften Alternativen zugetroffen hat. Case-Anweisungen enden mit dem reservierten Wort end. Wenn mehr als eine Anweisung in denAnweisungsteil (den Teil hinter dem Doppelpunkt (:)) einer case-Anweisung einzufügen ist,setzt man die mehrfachen Anweisungen zwischen die reservierten Wörter begin und end.

�� Zahl �# 1, 3, 5, 7, 9: // Selektor-Liste �� FF��auszuführender Block für den Fall, daß der Label2.Caption := 'Ungerade Zahl'; // Selektor zutrifft Form1.Color := clBlue; ��; ��; // Ende des case-Blocks

��+�)%��#��Unbedingte Sprünge können mittels des Befehls �� durchgeführt werden, wobei das Sprung-ziel als sogenanntes ?�� deklariert sein muß. Im Sinne einer sauberen Programmierungsollte man auf diese Hilfe aber nur zugreifen, wenn es unbedingt erforderlich ist.

�� label 10, 20; s: string;�� .. �� 10; ... 10: s := ’Hier ist das Sprungziel label 10’; ...��;

"�� (��#A��

Es kann sich während der Abarbeitung einer Funktion oder Prozedur herausstellen, daß eineWeiterführung des Programmteils keinen Sinn mehr macht und ein Abbruch erfolgen kann(muß). Die einfachste Art ein Unterprogramm abzubrechen, besteht im Aufrufen der ProzedurD��, die die gleiche Wirkung hat wie der Befehl 'break' in einer Schleife. Trifft das Programm aufden Befehl, springt es sofort auf die end-Zeile der Funktion oder Prozedur und beendet diesedamit. Alle Variablen im Kopf des Unterprogramms behalten dabei ihre aktuellen Werte. Esempfiehlt sich also bei Vorhandensein eines exit-Befehls, die Ergebniswerte der Funktion oderProzedur �� diesem Befehl zu initialisieren.

34

� �! � %� � � ( ��

Der Delphi-Funktionskatalog ist erreichbar über den Menupunkt "Hilfe / VCL-Referenz / VCLObjekt- und Komponenten-Referenz", in dem das Kapitel "VCL Alphabetische Liste der Routi-nen" den Zugriff auf die zur Verfügung stehenden Funktion ermöglicht. Die Funktionen sind hierin alphabetischer Reihenfolge geordnet.

Die wichtigsten Funktionen sind im folgenden nach (��%%� aufgelistet. Um nähereInformationen über die zu verwendende Funktion zu erhalten, muß der Funktionsname lediglichim Quelltext eingetippt und F1 gedrückt werden. Artverwandte Begriffe lassen sich leicht auffin-den, wenn der Funktionsname in der Stichwortsuche (Index) eingetippt wird, da zu der aktuelleingegebenen Zeichenfolge automatisch eine Positions-Korrektur in der Liste der zur Verfügungstehenden Indexwörter vorgenommen wird.

��"��'��

Abs gibt einen absoluten Wert (Betrag) zu einer Zahl zurück

ArcCos berechnet den inversen Cosinus des übergebenen Arguments

ArcCosh berechnet den Kehrwert des hyperbolischen Cosinus

ArcSin berechnet den inversen Sinus des Arguments

ArcSinh berechnet den inversen hyperbolischen Sinus des Arguments

ArcTan berechnet den Arcustangens des Arguments

ArcTanh berechnet den inversen hyperbolischen Tangens des Arguments

Cos berechnet den Cosinus

Cosh berechnet den hyperbolischen Cosinus

Cotan berechnet den Cotangens eines Winkels

CycleToRad wandelt eine Winkelgröße von Kreiszyklen in Bogenmaß um

Dec dekrementiert eine Variable um 1 oder N

DegToRad konvertiert einen in Grad angegebenen Winkel in das Bogenmaß

Exp gibt die Potenz von X zurück

Floor rundet Variablen ab

FPower10 multipliziert einen Wert mit der angegebenen Potenz von 10

Frac gibt den Nachkommaanteil einer reellen Zahl zurück

High gibt den größten Wert im Bereich des Arguments zurück

Hypot berechnet die Länge der Hypotenuse in einem rechtwinkligen Dreieck

Inc inkrementiert eine Variable um den Wert 1 oder N

Int gibt den ganzzahligen Anteil einer reellen Zahl zurück

35

IntPower gibt das Ergebnis von Basis (Parameter Base) hoch Exponent zurück

Ln gibt den natürlichen Logarithmus eines Real-Ausdrucks zurück

Lo gibt das niederwertige Byte eines Integer-Werts zurück

Log10 berechnet den Logarithmus zur Basis 10 (dekadisch)

Log2 berechnet den Logarithmus zur Basis 2

LogN berechnet den Logarithmus zur Basis N

Hi gibt das höherwertige Byte einer Integerzahl als vorzeichenlosen Wert zurück.

Low gibt den kleinsten Wert eines bestimmten Datentyps zurück

MaxIntValue gibt den größten vorzeichenbehafteten Wert in einem Integer-Array zurück

MaxValue gibt den größten vorzeichenbehafteten Wert eines Arrays zurück

Mean gibt den Mittelwert der Elemente eines Arrays zurück

MeanAndStdDev berechnet den Mittelwert und die Standardabweichung der Elemente eines Arrays

MinIntValue liefert den kleinsten vorzeichenbehafteten Wert eines Integer-Arrays zurück

MinValue gibt den kleinsten vorzeichenbehafteten Wert eines Arrays zurück

Ord gibt den Ordinalwert eines Ausdrucks des Typs Ordinal zurück

Pi gibt den Wert von Pi zurück (3,1415926535897932385)

Poly wertet ein einheitliches Polynom einer Variable für den Wert X aus

Power errechnet aus der Basis Base und dem beliebigen Wert Exponent die Potenz

RadToCycle wandelt einen im Bogenmaß angegebenen Winkel in Kreiszyklen um

RadToDeg konvertiert einen Winkel vom Bogen- in das Gradmaß

RadToGrad konvertiert Winkel vom Bogenmaß in das Neugradmaß

RandG generiert anhand der Gaußschen Normalverteilung eine Zufallszahl

Random erzeugt eine Zufallszahl innerhalb eines bestimmten Bereichs

Randomize initialisiert den Zufallszahlengenerator mit einem zufälligen Wert

Sin gibt den Sinus des mit X angegebenen Winkels im Bogenmaß (Rad) zurück

SinCos gibt Sinus und Cosinus eines Winkels zurück. SinCos ist doppelt so schnell wie der getrennteAufruf von Sin und Cos für denselben Winkel

Sinh berechnet den hyperbolischen Sinus eines Winkels

Sqr gibt das Quadrat eines Wertes zurück

Sqrt gibt die Quadratwurzel eines Werts zurück

StdDev gibt die Standardabweichung der Elemente eines Arrays zurück

Sum... Funktionen zur Berechnung von Summenausdrücken

Tan berechnet den Tangens

Tanh berechnet den hyperbolischen Tangens

Variance berechnet die statistische Varianz der Werte eines Arrays

��!��

BlockRead liest einen oder mehrere Datenblöcke aus einer geöffneten Datei in eine Variable ein

BlockWrite schreibt ein oder mehrere Datensätze aus einer Variablen in eine geöffnete Datei

ChangeFileExt ändert die Namenserweiterung einer Datei.

ChDir wechselt das aktuelle Verzeichnis.

CreateDir legt ein neues Verzeichnis an.

DeleteFile löscht eine Datei und gibt im Fehlerfall False zurück.

DirectoryExists ermittelt, ob ein bestimmtes Verzeichnis existiert.

36

DiskFree gibt die Anzahl der freien Bytes auf einem Laufwerk zurück.

DiskSize gibt die Größe eines Laufwerks in Byte zurück.

Eof prüft, ob das Dateiende erreicht ist.

Eoln prüft, ob das Zeilenende erreicht ist.

ExtractFileDir extrahiert Laufwerks- und Verzeichnisinformationen aus dem angegebenen Dateinamen.

ExtractFileDrive extrahiert die Laufwerksangabe aus dem angegebenen Dateinamen.

ExtractFileExt extrahiert die Namenserweiterung aus dem angegebenen Dateinamen.

ExtractFileName extrahiert den Namen und die Erweiterung aus dem angegebenen Dateinamen.

ExtractFilePath extrahiert Laufwerk- und Verzeichnisinformationen aus dem angegebenen Dateinamen.

File... Mit dem Schlüsselwort FILE beginnen eine ganze Reihe an Dateifunktionen

GetCurrentDir gibt den Namen des aktuellen Verzeichnisses zurück.

GetDir ermittelt das aktuelle Verzeichnis eines bestimmten Laufwerks.

MkDir legt ein neues Unterverzeichnis an.

PasswordDialog zeigt ein Dialogfeld an, in dem der Benutzer zur Eingabe eines Kennworts für den Zugriff aufeine lokale, kennwortgeschützte Tabelle aufgefordert wird.

RemoveDir löscht ein vorhandenes leeres Verzeichnis.

Rename ändert den Namen einer externen Datei.

Reset öffnet eine vorhandene Datei.

Rewrite erstellt eine neue Datei und öffnet sie anschließend.

SelectDirectory zeigt ein Dialogfeld an, in dem der Benutzer einen Verzeichnisnamen eingeben kann.

SetCurrentDir legt das aktuelle Verzeichnis fest und liefert nach erfolgreicher Ausführung True zurück.

��!��.��

Date ermittelt das aktuelle Datum

DateTimeToStr konvertiert einen TDateTime-Wert in einen String.

DateToStr konvertiert eine Variable des Typs TDateTime in einen formatierten String.

DayOfWeek gibt für ein bestimmtes Datum den Wochentag zurück.

DecodeDate zerlegt einen TDateTime-Wert in Jahr, Monat und Tag.

DecodeTime zerlegt einen TDateTime-Wert in Stunden, Minuten, Sekunden und Millisekunden.

EncodeDate setzt aus den angegebenen Jahres-, Monats- und Tageswerten einen Wert des Typs TDate-Time zusammen.

EncodeTime setzt aus den angegebenen Stunden-, Minuten-, Sekunden- und Millisekundenwerten einenWert des Typs TDateTime zusammen.

FormatDateTime formatiert einen Datums-/Zeitwert.

IsLeapYear gibt an, ob es sich bei einem bestimmten Jahr um ein Schaltjahr handelt.

Time gibt die aktuelle Uhrzeit zurück.

TimeToStr konvertiert einen TDateTime-Wert in einen String.

��!��

MessageDlg zeigt in der Mitte des Bildschirms ein Dialogfeld mit einer Meldung an.

MessageDlgPos blendet ein Meldungsdialogfeld an den angegebenen Bildschirmkoordinaten ein.

ShowMessage zeigt ein Meldungsfenster mit dem angegebenen Text der Schaltfläche OK an.

ShowMessageFmt zeigt ein Dialogfeld mit einer formatierten Meldung und der Schaltfläche OK an.

37

�� (��$��

CurrToStr konvertiert einen Währungswert in einen String.

CurrToStrF konvertiert einen Währungswert in einen String mit dem angegebenen Format.

FloatToDecimal konvertiert eine Gleitkommazahl in den entsprechenden Dezimalwert.

FloatToStr konvertiert eine Gleitkommazahl in den entsprechenden String-Wert.

FloatToStrF konvertiert eine Gleitkommazahl in einen String-Wert mit dem angegebenen Format, der Ge-nauigkeit und den Stellen.

FloatToText konvertiert einen Gleitkommawert in die entsprechende Dezimaldarstellung mit dem angegebe-nen Format, der Genauigkeit und den Stellen.

FloatToTextFmt konvertiert eine Gleitkommazahl in eine Dezimaldarstellung mit dem angegebenen Format.

Format gibt einen formatierten String zurück, der sich aus einem Pascal-Format-String und einer Reihevon Array-Argumenten ergibt.

FormatFloat formatiert einen Gleitkommawert.

IntToHex gibt einen String in hexadezimaler Darstellung des angegebenen Integer-Wertes zurück.

IntToStr konvertiert einen Integer-Wert in einen String.

Round rundet den Gleitkomma-Wert von X auf den nächsten Integer-Wert.

Trunc konvertiert eine Gleitkommazahl in einen Integer-Wert.

��,�)%� ��

AllocMem weist einen Speicherblock zu und initialisiert jedes Byte mit Null.

Dispose gibt den für eine dynamische Variable reservierten Speicher frei.

FreeMem gibt eine dynamische Variable von einer bestimmten Größe aus dem Speicher frei.

GetMem erzeugt eine dynamische Variable und einen Zeiger auf ihre Speicheradresse.

Move kopiert eine bestimmte Anzahl Bytes von der Quelle Source in das Ziel Dest.

New erzeugt eine neue dynamische Variable und einen Zeiger P, der auf diese Variable zeigt. Mit derStandardprozedur Dispose kann die Variable wieder freigegeben werden.

Im Gegensatz zu 'GetMem' ist der Speicherbedarf bei 'New' bekannt. Der Vorteil der Funktion ge-genüber einem Array besteht in alten 16-Bit-Systemen darin, daß eine mit 'New' deklarierte Variablewesentlich weniger Speicherplatz auf dem (auf 64k-Byte begrenzten) lokalen Heap benötigt.

��+�)��%��Bei den zur Verfügung stehenden Stringoperationen ist immer darauf zu achten, ob es sich umPascal-Strings oder Nullterminierte Strings handelt. Zur Unterscheidung werden die Funktionen,die Nullterminierte Strings behandeln, mit dem Schlüsselwort 'Ansi' eingeleitet.

Ansi... Mit dem einführenden Wort ‚Ansi...‘ bietet Delphi eine ganze Palette an Stringfunktionen zurBehandlung Nullterminierter Strings vom Typ Pchar an. Unter dem Menupunkt "Hilfe / Sucheüber Schlüsselwort..." braucht also lediglich das Stichwort 'ansi' eingegeben zu werden, um dieListe die zur Verfügung stehenden Funktionen einsehen zu können.

AppendStr fügt einen String an einen vorhandenen String an.

CompareStr vergleicht Strings unter Berücksichtigung der Groß-/Kleinschreibung.

CompareText vergleicht zwei Strings ohne Berücksichtigung der Groß-/Kleinschreibung.

Concat verknüpft zwei oder mehr Strings zu einem einzigen String.

Copy gibt einer Stringvariablen einen Teil-String eines Strings zurück.

Delete entfernt einen Teilstring aus einem String.

Length gibt die Anzahl der Zeichen eines Strings zurück.

Pos gibt den Indexwert (Position) des ersten Zeichens innerhalb des angegebenen Teil-Stringszurück, der in einem String vorkommt.

38

SetLength legt die dynamische Länge einer String-Variablen fest.

Str konvertiert einen numerischen Wert in einen formatierten String.

StrAlloc reserviert Speicher für einen nullterminierten String und gibt einen Zeiger auf die Adresse desersten Zeichens zurück. Ist der Speicherbedarf bereits vor der Compilierung bekannt, kann derSpeicher über die Deklaration auch als 'array [..] of Char' reserviert werden.

StrCat hängt eine Kopie von Source an das Ende von Dest an und gibt den zusammengefügten Stringzurück. Zur Längenprüfung verwenden Sie die Funktion StrLCat.

StrComp vergleicht die beiden Strings Str1 und Str2. Verwenden Sie bei der Arbeit mit internationalenZeichen statt dessen AnsiStrComp.

StrCopy kopiert den Inhalt von Source nach Dest und gibt einen Zeiger auf Dest zurück. Soll beim Kopie-ren die Länge überprüft werden, verwenden Sie statt dessen die Funktion StrLCopy.

StrDispose ist nur aus Gründen der Abwärtskompatibilität vorhanden und entfernt einen String vom Heap,der zuvor mit StrAlloc oder StrNew zugewiesen wurde.

StrLen gibt die Anzahl der Zeichen in einem String zurück.

StrMove kopiert eine bestimmte Anzahl Zeichen in einen String.

StrPas konvertiert einen nullterminierten String in einen Pascal-String.

StrPCopy kopiert einen Pascal-String in einen nullterminierten String.

StrPos durchsucht einen String nach einem bestimmten Teilstring.

StrScan sucht nach dem ersten Vorkommen eines bestimmten Zeichens in einem String.

StrToDate konvertiert einen String in einen Datumswert.

StrToDateTime konvertiert einen String in einen TDateTime-Wert.

StrToFloat konvertiert einen String in einen Gleitkommawert.

StrToInt konvertiert einen String in einen Integer-Wert.

StrToTime konvertiert einen String in einen Zeitwert.

Str... sonstige Funktionen zur Behandlung von Stringketten

TextToFloat konvertiert einen nullterminierten String in einen Gleitkommawert.

Trim entfernt alle am Anfang und Ende eines Strings vorhandenen Leer- und Steuerzeichen.

UpperCase konvertiert einen String in Großbuchstaben.

Val konvertiert einen String in einen numerischen Wert.

��&�.��6�"��)��

Addr ... gibt die Adresse eines beliebigen Variablen-, Prozedur- oder Funktionsbezeichners zurück.

Ptr konvertiert eine Adresse in einen Zeiger.

Beep generiert einen Standard-Signalton, der über den Computer-Lautsprecher ausgegeben wird

Chr gibt das Zeichen zurück, das dem entsprechenden ASCII-Wert entspricht. Chr(64) wäre also der Buch-stabe 'A'.

Printer gibt eine globale Instanz von TPrinter zurück, mit der der Drucker verwaltet und als Komponente ange-sprochen werden kann. Unter globaler Instanz kann man in diesem Zusammenhang eine variable Kom-ponente bezeichnen, die den Zugriff auf den Drucker in der Form erlaubt, als handele es sich bei ihm umeine Canvas-Eigenschaft.

Screen gibt eine globale Instanz von TScreen zur Bearbeitung des Bildschirms und der zur Verfügung stehen-den Parameter zurück, wie z.B. die Bildschirmauflösung.

SizeOf gibt die Anzahl der von einer beliebigen Variablen belegten Bytes zurück. Die Funktion ist besonderswertvoll zur dynamischen Ermittlung der Größe von Records.

39

�' � ��

Methoden sind Funktionen und Prozeduren, die in einer Klasse mit einer Komponente zusam-mengefaßt sind. Diese Eigenschaft stellt die wesentliche Erweiterung gegenüber den artver-wandten Records dar und bildet die Grundlage der objektorientierten Programmierung.

��7�#��Das Erstellen von Grafiken und Zeichnungen erfolgt mit Hilfe der Komponenteneigenschaft„Canvas (Leinwand)“, die für verschiedene Komponenten (z.B. Formular, PaintBox, Image, ...)zur Verfügung steht.

-�� #��K��

Pixels Setzt oder liest die Farbe der Pixel innerhalb des aktuellen Clipping-Rechtecks. Alle vorgefertigtenZeichenmethoden bauen auf dieser Eigenschaft auf.

Pen legt fest, welchen Stift die Zeichenfläche zum Zeichnen von Linien und Umrissen verwendet. Farbe,Strichstärke und Strichart können mit dieser Eigenschaft definiert werden. Für alle Parameter sindKonstante vordefiniert, die durch Drücken der F1-Taste auf dem Wort 'Pen' im Quelltext eingesehenwerden können.

Brush Legt fest, welche Farbe und welches Muster die Zeichenfläche zum Füllen von graphischen Formenund Hintergründen verwendet.

Font Legt fest, welche Schriftart bei der Ausgabe von Text im Bildbereich verwendet wird.

PenPos gibt die gegenwärtige Position des Stifts als x- und y-Koordinate wieder.

'��

Arc Zeichnet einen Bogen entlang der Peripherie einer Ellipse, die von dem angegebenen Rechteckumgeben wird.

Chord Zeichnet einen geschlossenen Umriß, der von einer Linie und einer Ellipse begrenzt wird.

Ellipse Zeichnet auf der Zeichenfläche eine Ellipse, die durch ein umgebendes Rechteck definiert ist.

LineTo Zeichnet ausgehend von der aktuellen Stiftposition (PenPos) eine Linie zum Punkt (X,Y) und setztPenPos anschließend auf (X, Y).

MoveTo Macht den Punkt (X,Y) zur aktuellen Zeichenposition (PenPos).

Pie Zeichnet einen Abschnitt der Ellipse, die durch das Rechteck (X1, Y1) und (X2, Y2) begrenzt ist.

Polygon Zeichnet eine Reihe von Linien auf der Zeichenfläche, die die als Parameter übergebenen Punkteder Reihe nach verbinden. Eine Linie vom letzten zum ersten Punkt schließt den Umriß.

Polyline Zeichnet mit dem aktuellen Stift eine Reihe von Linien, indem die im Parameter Points übergebe-nen Punkte miteinander verbunden werden.

Rectangle Zeichnet ein Rechteck mit der linken oberen Ecke am Punkt (X1, Y1) und der rechten unterenEcke am Punkt (X2, Y2).

TextOut Gibt beginnend am Punkt (X,Y) einen String auf der Zeichenfläche aus und setzt die EigenschaftPenPos auf das Ende des Strings. Der Punkt x,y kennzeichnet die obere linke Ecke des Textfen-sters.

TextRect gibt einen String innerhalb eines Clipping-Rechtecks aus.

TextHeight Gibt die Höhe eines Strings, der in der aktuellen Schriftart ausgegeben wird, in der Einheit Pixelzurück.

TextWidth gibt die Breite eines Strings, der in der aktuellen Schriftart ausgegeben wird, in der Einheit Pixelzurück.

TextHeight und TextWidth ermöglichen damit die dynamische Anpassung von Beschriftungsfel-dern an die aktuell verwendete Zeichengröße oder Bildschirmauflösung.

40

��!��Um unter Delphi mit einer Datenbank arbeiten zu können, sind die Komponenten TTable undTDataSource erforderlich.

Mit Hilfe von >>�� können Sie über die Borland Database Engine (BDE) auf Daten in einerDatenbanktabelle zugreifen. TTable bietet direkten Zugriff auf jeden Datensatz und jedes Feldder zugrundeliegenden Datenbanktabelle. Dabei kann es sich um eine Paradox-, dBASE-,Access-, FoxPro-, eine ODBC-konforme oder eine SQL-Datenbank auf einem Remote-Serverhandeln (wie InterBase, Oracle, Sybase, MS SQL Server, Informix oder DB2).

Mit >!��)�� können Sie eine Verbindung zwischen einer Datenmenge und den datensen-sitiven Steuerelementen herstellen, mit denen die der Datenmenge zugrundeliegenden Datenangezeigt und bearbeitet werden können.

Die rein visuelle Darstellung erfolgt über die Komponenten der Gruppe „Datensteuerung“, wiez.B. das Tabellengitter !47��. Um sich in den Zeilen und Spalten einer Tabelle zu bewegen,sowie Datensätze bearbeiten zu können, stellt die Komponente >!4<�� ein einfach zubedienendes Hilfsmittel dar. Die beiden letzt genannten sind zur Bearbeitung einer Tabelle abernicht unbedingt erforderlich.

Um den Signalfluß von TTable über TDataSource nach TDBGrid und TDBNavigator zu ermögli-chen, müssen folgende Eigenschaften im Objektinspektor definiert werden:

$��%�� -�� #� (��

DatabaseName Pfad der Datenbanktabelle

TableName Name der Datei, die die Tabelle enthält

TTable

Active Öffnen oder Schließen der Datei

TDataSource DataSet Name der TTable-Komponente, deren Datenbankdatei ver-waltet und angesteuert werden soll

TDBGrid DataSource Name der DataSource, die dargestellt werden soll

TDBNavigator DataSource Name der DataSource, die angesteuert werden soll

Die grundlegende Tabellenbearbeitung erfolgt über die Eigenschaften und Methoden vonTTable.

-�� #��

Active True: Tabelle ist geöffnet (entspricht der Methode OPEN)

False: Tabelle ist geschlossen (entspricht der Methode CLOSE)

EOF Mit EOF (End Of File) können Sie feststellen, ob sich der Cursor auf einem Datensatz einerDatenmenge befindet. Hat EOF den Wert True, befindet sich der Cursor hinter der letzten Da-tenzeile der Datenmenge.

FieldCount Gibt die Anzahl der Feldkomponenten in einer Datenmenge an und entspricht damit der Anzahlder Spalten in einer matrixförmigen Tabelle..

Fields Mit Fields können Sie auf die Feldkomponenten einer Datenmenge über deren Indexnummernzugreifen. Z.B.: Wert := Table1.Fields[0].Value

FieldValues Ermöglicht den Zugriff auf alle Feldwerte im aktuellen Datensatz der Datenmenge.

ReadOnly Gibt an, ob eine Tabelle in dieser Anwendung bearbeitet werden kann. Mit der Eigenschaft'ReadOnly' läßt sich ein sehr flexibel zu definierender Schreibschutz aufbauen.

41

RecNo Gibt den aktuellen Datensatz der Datenmenge an. Mit einer Vorgabe an ’RecNo’ kann der Cur-sor auch auf einen Datensatz positioniert werden.

RecordCount gibt die Gesamtzahl der Datensätze in einer Datenmenge an.

'��

Append Append fügt einen neuen leeren Datensatz am Ende der Datenmenge hinzu. Zum Anhängeneines Datensatzes an das Ende der Tabelle wird der Tabellencursor auf die erste freie Zeile amEnde der Tabelle gesetzt. Die Tabelle befindet sich damit automatisch im Editiermodus

AppendRecord fügt einen neuen Datensatz mit Daten für alle Feldelemente eines Records am Ende der Da-tenmenge hinzu und trägt ihn in die Datenbank ein.

Close Durch einen Aufruf der Methode Close wird die Eigenschaft Active einer Datenmenge auf Falsegesetzt. Die Datenmenge wird daraufhin geschlossen und kann nicht mehr für den Zugriff aufdie zugrundeliegende Datenbank verwendet werden (identisch zu Active := False)

Create Mit dem Aufruf von Create kann eine in einer Anwendung deklarierte Tabelle instantiiert wer-den, d.h. es wird eine neue Tabelle angelegt, deren Struktur von einer bereits vorhandenenTabelle abkopiert wird, und die natürlich vorhanden und zugänglich sein muß.

DatabaseName Laufwerk und Pfad, in dem die Tabelle sich befindet. Delphi bietet für diese Eigenschaft auchsogenannte 'Aliase' an, über die einem kompletten Pfad eine prägnante Kurzbezeichnung zu-gewiesen werden kann.

Delete löscht den aktuellen Datensatz und setzt den Cursor auf die nächste Zeile.

DeleteTable löscht und entfernt eine vorhandene Datenbanktabelle

DisableControls Mit DisableControls können Sie die Datenanzeige in den datensensitiven Steuerelementendeaktivieren, bevor Sie eine große Anzahl von Datensätzen in einer Schleife verarbeiten. Aufdiese Weise können Sie den ständigen Bildaufbau in den Steuerelementen während der Iterati-on verhindern und die Verarbeitung beschleunigen, da die Anzeige nicht laufend aktualisiertwerden muß.

Edit Mit Edit können Sie das Bearbeiten des aktuellen Datensatzes einer Datentabelle ermöglichen.

EmptyTable Die Methode EmptyTable löscht sämtliche Datensätze aus der Datenbanktabelle, die mit denEigenschaften DatabaseName und TableName angegeben wird. Im Gegensatz zu 'Deletetable'bleibt die leere Datenbank aber bestehen.

Find... Suchfunktionen in einer Datenrabelle

First Der Tabellenzeiger wird auf das erste Datenrecord plaziert

GetFieldNames ruft eine Liste mit den Namen der Felder in einer Datenmenge ab.

Insert fügt einen neuen leeren Datensatz in eine Datenmenge ein.

Last setzt den Cursor auf den letzten Datensatz einer Datenmenge.

LockTable sperrt eine Paradox- oder dBASE-Tabelle zum Lesen und/oder Schreiben.

MoveBy positioniert den Cursor in einer Datenmenge um eine bestimmte Anzahl Datensätze vor oderzurück.

Next Der Tabellenzeiger wird um ein Record weiterbewegt

Open öffnet eine Datenmenge (identisch zu Active := True).

Post schreibt einen geänderten Datensatz in die Datenbank. Das Editieren eines Datensatzes wirddamit beendet

Prior setzt den Cursor auf den vorhergehenden Datensatz einer Datenmenge.

RecNo gibt die Nummer des aktuellen Datensatzes der Datenmenge an.

Refresh aktualisiert eine Datenmenge durch erneutes Abrufen der Daten aus der Datenbank.

RenameTable benennt die Paradox- oder dBASE-Tabelle um, die mit dieser Tabellenkomponente verknüpftist.

TableName Name der Tabelle

UnlockTable entfernt eine vorher zugewiesene Sperre von einer Paradox- oder dBASE-Tabelle.

42

��"��#��Unter einer ereignisorientierten Programmieroberfläche werden Prozeduren durch ein beliebi-ges Ereignis angestoßen und laufen anschließend bis zu ihrer Terminierung, d.h. dem Errei-chen der letzten end-Anweisung, ab. Weitere Aktionen anderer Prozeduren können demzufolgeerst erfolgen, wenn die vorherige Prozedur abgearbeitet worden ist. Für die in einer Endlos-schleife laufende Steuerungs-Funktion bedeutet das aber, daß sie alle anderen Aktivitätenblockiert und das Programm z.B. nicht mehr auf eine neue Aktion reagieren kann.

Das sich hier einstellende Problem ist an und für sich die grundlegende Problematik der paral-lelen Abarbeitung unterschiedlicher Prozeduren, und da Windows kein Echtzeit-Betriebssystemist, erfordert das Parallel-Tasking einen recht beträchtlichen Aufwand, was das Message-Routing innerhalb der eigenen Anwendung angeht. Dieser Aufwand läßt sich für viele Anwen-dungen aber umgehen, wenn man die von Delphi zur Verfügung gestellte Timer-Komponenteverwendet.

Timer-Komponente

Eigenschaften der Timer-Komponente

Durch den Timer aufgerufeneProzedur

Die Steuerung eines kontinuierlich ablaufenden Prozesses, der aber auch zu jedem Zeitpunktüber den Anwender beeinflußbar bleiben soll, erfolgt zu diesem Zweck über die Timer-Komponente aus der Gruppe „System“, die eine Prozedur in einem frei definierbaren Zeitrasterregelmäßig aufruft und abarbeitet. Das Aufrufintervall kann allerdings nicht beliebig klein ge-wählt werden, da der Timer in die Taskliste des Betriebssystems eingereiht und von diesemverwaltet wird. Für die kleinste Zeitscheibe muß man sich unter WindowsNT daher mit 10 Milli-sekunden begnügen. Für größere Geschwindigkeitsansprüche muß weiterhin auf die nicht ganzunproblematische Interrupt-Programmierung zurückgegriffen werden.

Der abzuarbeitende Gesamt-Prozeß wird zu diesem Zweck in kleine Teilprozesses aufgeteilt,die im Zeitscheibenverfahren zyklisch abgearbeitet werden. Während des Wechsels von einemTeilprozeß zum nächsten besteht dann für das Programm die Möglichkeit, auf extern anliegen-de Ereignisse, wie z.B. einen Mausklick, zu reagieren.

Das grundlegende Schema eines 'zerlegten' Prozesses ist im Prinzip eine case Anweisung, inder während der zyklischen Abarbeitung immer die Funktion ausgeführt wird, die durch denAblauf-Selektor bestimmt ist. Die 'Schalterstellung' des Selektors erfolgt dabei während der Ab-arbeitung der einzelnen Unterprogramme. Für kompliziertere Steuerungen können durchausmehrere Timer eingesetzt werden, die ein zeitscheiben-orientiertes Paralleltasking erlauben.

Die Verwendung des Timers soll am Beispiel einer kamerabasierten Stopfen-Erkennungsanlagefür Automobilfelgen demonstriert werden. Die Aufgabe der Prüfeinrichtung besteht darin, Kunst-stoffhülsen zu erkennen, die nicht aus den Anschraublöchern der aus der Lackiererei kommen-den Felgen entfernt worden sind.

Im Grunde genommen handelt es sich um eine Steuerung, die über den zentralen Sensor 'Ka-mera' realisiert worden ist. Typisch für eine derartige Steuerung ist das Einlesen der Eingangs-signale vor dem case-Block und das Setzen der Ausgangssignale nach der Abarbeitung descase-Blocks.

43

Kamera-Messzelle

Messrechnermit

Monitor

Schiebe-Weiche

Auslauf fürNIO-Teile

Auslauf fürIO-Teile

Transport-Rollgangaus der

Lackiererei PneumatischerZylinderstopper

Kamera

Lichtschranke

{-------------------------------------------------------------------------------------------------------------------------}{ *** Ablauf-Steuerung für eine Stopfenerkennungsanlage*** }{-------------------------------------------------------------------------------------------------------------------------}%� �� TFBV.AblaufTimerTimer (Sender: TObject);begin 0��!��; case Ablauf of ��$��: AufStartEreignisWarten;��%��&��: KamerabildAufnehmen;��%��'��: CalculateStopfenLoch; ��: begin DigOut [ARollgang] := False; { Rollgang stoppen } DigOut [ABetrieb] := False; { Ablaufbetrieb stoppen } if FehlerAnzRadIO then HandleAnzRadIO; if FehlerTimeOut then HandleTimeOut; if FehlerRadOhneResult then HandleRadOhneResult; end; end;K� �-�� ;K� �>��(��;K�� !��;)��)=��)��;1��!��;end;

44

, � >��

,��!��Zur Analyse von Programmfehlern bietet Delphi einen sehr leistungsfähigen Debugger an, dereine schrittweise Ausführung des Programmes erlaubt, während der die Inhalte der einzelnenVariablen eingesehen und für Testzwecke auch editiert werden können.

Zum Debuggen eines Programmes erfolgt vor dessen Start das Setzen eines @��%��durch Anklicken der grauen Leiste am linken Rand des Unit-Fensters. Die Zeile mit dem Halte-punkt erscheint rot hinterlegt (je nach Farbdefinition im Menupunkt "Tools / Umgebungsoptionen.. / Farben") und erhält am linken Rand einen roten Markierungspunkt. Das Programm wirdspäter bei seiner Ausführung an dieser Position stoppen (der Textcursor blinkt in dieser Zeile),und die interessierenden Variablen können in der Liste der A�� "��A � darge-stellt werden. Geöffnet wird die Liste mit dem Menu-Befehl "Ansicht / Überwachte Ausdrücke".

a0:37,455b0:37,672c0:108,334d0:92,449fi0:0,528

fi0: 0,528

Um eine neue Variable in die Liste aufzunehmen, klickt man mit der Maus in das Fenster unddrückt die Taste L-��#�L; eine andere Möglichkeit ist, den Textcursor im Quelltext auf die Varia-ble zu positionieren und L)��( L zu drücken. Das Positionieren des Textcursors auf die Varia-ble vor dem Drücken der Funktionstaste erspart es, den Variablennamen im Editierfenster extraeinippen zu müssen, da die Variable beim Cursor automatisch im Editor angeboten wird. ZumEntfernen eines Variablenwertes aus der Liste, klickt man diesen mit der Maus an und drücktanschließend die Taste L-��#L.

Nach dem Stop des Programms am Haltepunkt hat man die Möglichkeit, das Programm mit (/normal weiterlaufen zu lassen, oder kann es schrittweise weiter abarbeiten. Die � ��"�� erfolgt mit den Funktionstasten (+ oder (&. Der Unterschied zwischen den beidenFunktionen kommt nur zum Tragen, wenn der Debugger auf einer Quelltextzeile steht, die wie-derum eine Funktion oder Prozedur aufruft. Mit F8 wird die Funktion oder Prozedur mit einemSchritt als Block abgearbeitet, mit F7 springt der Debugger in die Funktion oder Prozedur hineinund arbeitet hier schrittweise weiter.

Mehrere Befehle auf einmal lassen sich abarbeiten, indem man den Cursor auf die Quell-textzeile positioniert, an der das Programm wieder stoppen soll und anschließend die Funkti-onstaste (� drückt. Diese Verfahrensweise ist besonders vorteilhaft, wenn Schleifen überprüftwerden sollen.

45

Die einfachste Art und Weise, den Inhalt einer Variablen vorübergehend darzustellen bestehtdarin, den Mauscursor auf die Variable zu bewegen und dort einfach für ca. 2 Sekunden stehenzu lassen. Der Inhalt der Variablen wird in einem gelben Fenster dargestellt; das verschwindet,sobald man die Maus wieder bewegt. Bei Arrays und Record-Variablen kann man unterschiedli-che Darstellungen erreichen, je nachdem wo man den Mauszeiger im Variablennamen positio-niert.

Ein Variableninhalt läßt sich für Testzwecke im Debugger-Modus auch ändern, indem der Me-nupunkt "Start / Auswerten/Ändern ..." oder 'Strg F7'

,��!��#�8 �Wie man mit einer Datenbank-Tabelle arbeitet, ist in den grundlegenden Zügen in Abschnitt 5.2angerissen worden. Allerdings gehen die dort aufgeführten Operationen davon aus, daß miteiner bereits bestehenden Dantenbank-Tabelle gearbeitet werden kann.

Das Erstellen einer eigenen Datenbank geht am einfachsten mit der 4��!��#�8 �, die über den Menupunkt "Tools / Datenbankoberfläche" aufgerufen werden kann.

Der nächste Schritt zur Erstellung einer Datenbank erfolgt dann bereits auf dem Formular derDatenbankoberfläche mit dem Menupunkt "Datei / Neu / Tabelle ...". In einem Fenster kann auseiner Liste der >��=% selektiert werden, der als Gerüst für die Datenbanktabelle verwen-det werden soll. Nach der Typvorgabe erscheint das eigentliche Eingabefenster, um die (�� der Tabelle entsprechend den Erfordernissen definieren zu können. In einer zweidi-mensionalen Tabelle könnte man die Felddefinitionen mit den Spalteninhalten der Tabelle iden-tifizieren.

Mit dem Schalter 'Speichern unter ...' kann die nun angelegte Tabelle ��%� �� und in derDelphi-Anwendung verwendet werden, indem die Eigenschaften 'DataBaseName' und 'Ta-bleName' mit dem Pfad und dem Namen der Tabelle belegt und die Eigenschaft 'Active' aufTrue gesetzt wird.

,��4��Eine grafische Bedienoberfläche lebt von aussagekräftigen Grafikelementen, wie sie z.B. alsSymbole für Schaltflächen eingesetzt werden. Das Einfügen eines Grafikelements in die An-wendung erfolgt über die Eigenschaft der Komponente, die das Grafikelement verwaltet. Beieinem Image wäre das die Eigenschaft L�� L, beim SpeedButton die Eigenschaft L7�=%�L.Nach dem Anklicken dieser Eigenschaft läßt sich eine vorbereitete Grafik über ein dialogge-führtes Menufenster in die Komponente einfügen. Das Grafikelement ist von nun an Bestandteilder Komponente. Der einzige Nachteil dieser Methode ist, daß man die Grafik, so wie sie ange-boten wird, akzeptieren muß.

Relativ häufig kommt es vor, daß man eine bereits bestehende Grafik nur ein klein wenig än-dern möchte, und an dieser Stelle bietet der Bildeditor seine Dienste an. Er ist ein pixelorien-tiertes Malprogramm und entspricht in vielen Zügen dem weit verbreiteten 'PaintBrush'. DieGrafik, die als Vorlage verwendet werden soll, wird in den Bildeditor geladen und kann hiernach eigenen Wünschen geändert und unter einem anderen Namen gespeichert werden. Diegeänderte Grafik wird dann über die bildverwaltende Eigenschaft in die Komponente eingebun-den.

Etwas mehr Aufwand bereitet es, wenn keine adäquate Vorgabe vorhanden ist. In diesem Fallmuß die Größe für eine neue Grafik im Bildeditor vorgegeben werden, und in das vom Bildeditorangebotene leere Fenster eine komplett neue Bitmap gemäß den eigenen Vorstellungen ge-zeichnet werden. Auch diese Grafik wird unter einem eigenen Namen gespeichert und kannanschließend in die Komponente eingeladen werden.

46

? � � � � �

Programmieren lernen in Borland Delphi 3Walter Doberenz / Thomas Kowalski, Carl-Hanser-Verlag, 1998, ISBN 3-446-19219-0

Das große Buch zu DelphiData Becker, Arthur Burda, Günther Färber, Wiener Verlag, ISBN 3-8158-1107-4

Borland Delphi – Das BuchTewi Verlag, 1995, ISBN 3-89362-408-2

Documents

Objektorientiertes Programmieren - uni-wuppertal.de · Project1.opt Die für das Projekt eingestellten Optionen (Compiler, Verzeichnispfade, Editor) Unit1.dcu Die compilierte und