Grafische Programmierung mit dem Borland C++-Builder · erstellen, sowohl Win32-Konsolenanwendungen als auch Win32-Programme mit graphischer Benutzeroberläche (GUI = Graphical User

Fachhochschule Wiesbaden

Grafische Programmierung mit dem Borland C++-Builder

1

Grafische Programmierung mit dem Borland C++-Builde r 1 Vorwort Die Programmiersprache C++ ist von großer praktischer Bedeutung.

In den Anfänger-Vorlesungen wird C++ fast ausschließlich als

Konsolenanwendung gelehrt. Da man mit C++ auch grafische Animationen,

Webseiten, Textverarbeitung, kleine Internet-Appletts,

Bildverarbeitungsprogramme, grafische Benutzeroberflächen und vieles

mehr erstellen kann, besteht der Bedarf für eine entsprechende

Kurzeinführung.

Diese Kurzeinführung richtet sich nicht nur an fortgeschrittene

Programmierer, sondern auch an (relative) Anfänger. Entsprechend wurden

einfache Beispiele zur Veranschaulichung gewählt.

Dursun Gür



2

2 Einleitung

Es soll nun ein kleiner Einblick in die graphische Anwendung mit dem

Borland C++Builder für die Windows-Plattform vermittelt werden. Hierbei soll

mit Hilfe des C++Builders Übungssoftware erstellt werden, an der sich der

interessierte Anwender bei graphischer Softwareentwicklung orientieren

kann.

Mit dem C++Builder kann man schnell und einfach Windows-Anwendungen

erstellen, sowohl Win32-Konsolenanwendungen als auch Win32-Programme

mit graphischer Benutzeroberläche (GUI = Graphical User Interface). Mit

relativ wenigen Code-Zeilen, lassen sich graphische Anwendungen für die

Windows-Plattform entwickeln.

Die wichtigsten Elemente zur einfachen Bedienung sind schon im C++Builder

vorgefertigt mitgeliefert. Mit ein paar Mausklicks muss man sie nur noch

zusammenfügen.

3 Der bisherige Weg

Um eine Windows-Anwendung zu erstellen, musste man früher viel Aufwand

treiben, denn zunächst gab es nur das Windows API (Application Program-

ming Interface), d.h. eine Schnittstelle zur Anwendungsprogrammierung. Die

Windows API enthält viele Funktionen, die mit der Programmiersprache C

angesprochen werden können. Zum Beispiel musste man für einen kurzen

Text, den man in einem Fenster ausgeben wollte viele Programmzeilen

schreiben. Je größer und umfangreicher das Programm, desto mehr

Programmzeilen oder Programmseiten waren erforderlich.



3

Die Vorteile des objektorientierten Zugangs zu Windows API liegen klar auf

der Hand. Fenster, Dialoge, Schaltflächen und Menüs sind vorgefertigte

Objekte mit Eigenschaften wie Größe oder Farben und Methoden zum

Verschieben oder Schließen.

Zum besseren Überblick über die vielen notwendigen Parametervorgaben für

die Bedienelemente, helfen deren Konstruktoren.

Mit der RAD-Entwicklungsumgebung (RAD = Rapid Application Development), kann die Benutzeroberfläche von Programmen (zur Benutzeroberfläche gehören Menüs, Dialogfelder, Hauptfenster usw.) mit der Hilfe von Drag&Drop-Technik ausgesprochen schnell entwickelt werden. Der Entwickler kann auch mit den OCX-Steuerelementen (OCX = Auf COM basierendes Komponentensystem von Microsoft, implementiert als OLE-Klassen; programmiert unter C++ mit den MFC. Vorläufer von ActiveX) , die er in die Formulare aufnehmen kann, in relativ kurzer Zeit spezielle Programme, wie z.B. einen Web-Browser erstellen.



4

4 Die IDE des C++Builder

Abbildung: 1

Die IDE (IDE = integrierte Entwicklungsumgebung) des C++Builder besteht

aus drei unterschiedlichen Teilen. Das oberste Fenster kann man als

Hauptfenster betrachten. Auf der linken Seite ist die Mauspalette und auf der

rechten Seite die Komponentenpalette (Komponenten = selbständige

Software-Bausteine, die eine bestimmte, vordefinierte Aufgabe erfüllen, z.B.

Textfelder, Editierfelder oder Listenfelder). Mit Hilfe der Mauspalette hat man

einen einfachen Zugriff auf die Operationen, wie das Öffnen mit einem

Mausklick, Speichern und Kompilieren von Projekten. Auf der

Komponentenpalette gibt es eine Reihe von Komponenten, die man in die



5

Formulare mit aufnehmen kann (Textfelder, Eingabefelder, Listenfelder,

Schaltflächen, usw.). Um die Übersicht zu wahren, sind die Komponenten in

Gruppen zusammengefasst. Zum Aufnehmen einer Komponente in das

Formularfeld, muss lediglich auf der Komponentenpalette die Schaltfläche

der gewünschten Komponente angeklickt werden, anschließend die Position

im Formular, an der die Komponente erscheinen soll.

Auf der linken Seite, unterhalb der Mauspalette und der Komponenten-

palette, befindet sich der Objektinspektor. Über den Objektinspektor kann

man auf die Eigenschaften und Ereignisse einer Komponente Einfluss

nehmen. Wer mit dem C++Builder arbeitet, wird den Objektinspektor ständig

im Einsatz haben. Je nach Komponenten, zeigt der Objektinspektor ein oder

zwei Registerkarten an. Die Registerkarte mit der Überschrift

EIGENSCHAFTEN ist immer vorhanden. Mit den Eigenschaften einer

Komponente kann man das Erscheinungsbild der Komponente festlegen.

Ändert man beispielsweise die Eigenschaft Color, so ändert sich die

Hintergrundfarbe der Komponente. Eigenschaften sind von Komponente zu

Komponente unterschiedlich, allerdings gibt es auch einige gemeinsame

Elemente wie z.B. die Breite (Width) und die Höhe (Height).

Der Objektinspektor weist zusätzlich zur Registerkarte EIGENSCHAFTEN

auch die Registerkarte EREIGNISSE auf. Ereignisse können beispielsweise

dann auftreten, wenn der Anwender mit einer Komponente interagiert. Wird

z.B. eine Komponente angeklickt, so wird ein Ereignis ausgelöst, welches

Windows eine entsprechende Mitteilung macht. Man kann dazu einen Code

schreiben, der auf dieses Ereignis reagiert und als Antwort Aktionen ausführt.

So wie die Eigenschaften sind auch die Ereignisse von verschiedenen

Komponenten unterschiedlich.

Das dritte Fenster, welches sich rechts des Objektinspektors befindet, ist der

Arbeitsbereich des C++Builder. Zum Anfang wird im Arbeitsbereich der

Formular-Designer angezeigt. Im C++Builder wird unter einem Formular ein



6

Fenster im Programm verstanden. Es kann sich hierbei um das Hauptfenster,

ein Dialogfeld oder ein anderes Fenster handeln. Der Formular-Designer

dient dazu, die entsprechenden Formulare zu erstellen, die Komponenten

darauf zu platzieren, diese zu verschieben oder ihre Größe zu verändern.

Der Quelltexteditor liegt, als zunächst unsichtbares viertes Fenster, direkt

hinter dem Formular-Designer. In diesen kann man seinen Quellcode

eingeben, um einen Algorithmus zu erstellen. Quelltexteditor,

Komponentenpalette, Formular-Designer und Objektinspektor arbeiten bei

der Erstellung von Anwendungen als eine Einheit zusammen.



7

5 Das Programmieren mit GUI

5.1 1. Schritt: Die Label Erstellung

Wenn der C++Builder aufgerufen ist, sollte man auf ein leeres Formular (wie

Abb. 1) sehen können. Das Formular wird standardmäßig Form1 bezeichnet

(der Formularname hat im C++Builder eine sehr wichtige Rolle, worauf wir

später zurückkommen werden). Der Objektinspektor (links des Formulars)

zeigt die Eigenschaften des Formulars an.

Abbilldung: 2



8

Wenn auf die Titelleiste des Objektinspektors geklickt wird, wird die

Eigenschaft Caption (Abb. 2) hervorgehoben, worauf man seine Eingabe

tätigen kann. Falls die Eigenschaft Caption nicht sofort zu sehen ist, muss

man unter Umständen das Objektinspektor-Fenster scrollen. Die Eigen-

schaften werden alphabetisch aufgelistet. Hier kann man den Namen des

Formulars ändern. Wenn jetzt Test1 eingegeben wird, ändert sich auch die

Überschrift des Formulars (wie Abb. 3).

Abbildung: 3

Um einen Text in die Mitte des Formulars zu schreiben, muss man zunächst

ein Textfeld (Label) in das Formular einfügen. Das Textfeld (Label) befindet

sich in der Komponentenpalette. Wenn man auf die Seite Standard klickt, ist



9

es der vierte Button von links mit dem großen Buchstaben „A“ als Symbol

(siehe Abb. 4).

Abbildung 4

Fährt man die Maus auf die Schaltfläche, erscheint eine Kurzinformation mit

dem Hinweis: Label. Wenn jetzt auf diese Schaltfläche geklickt wird und

danach auf eine beliebige Stelle im Formular, erscheint eine Label-

Komponente mit dem vorgegebenen Titel Label1 im Formular. Auf dem

Objektinspektor kann man nun die Eigenschaft für Label1 ersehen (zuvor war

die Eigenschaft von Form1 zu sehen). Die Eigenschaft Caption ist wieder

hervorgehoben. Klickt man auf die Titelleiste des Objektinspektors oder auf

die Eigenschaft Caption kann man den Text ändern. Sie können jetzt den

Text „FH – Wiesbaden“ eingeben. Gleichzeitig wird in dem Label auf dem

Formular ihre Eingabe angezeigt (Abb. 5).



10

Abbildung: 5

Nun können wir z.B. die Schriftgröße des Textes im Textfeld ändern. Es folgt

ein Doppelklick auf die Eigenschaft Font, die daraufhin expandiert wird, um

weitere Attribute für Schriftart, Farbe und Schriftschnitt zur Auswahl

bereitzustellen. Für die Auswahl der Schriftgröße gehen Sie auf Font zu der

Eigenschaft Size oder Größe und verändern diese von gegenwärtig 8 auf

z.B. 24. Sobald die Eingabetaste gedrückt wird oder das Formular angeklickt

wird, erscheint die Beschriftung in der neuen Größe (Abb. 6).



11

Abbildung: 6

Falls das Textfeld im Formular nicht zentriert ist, kann man das Textfeld

verschieben. Hierfür muss man lediglich das Textfeld anklicken und an die

gewünschte neue Position ziehen. Befindet sich das Textfeld an seiner

neuen Position, können Sie das Programm kompilieren und starten (Abb. 7).



12

Abbildung: 7. Das Dialogfeld Kompilieren

Abbildung: 8. Das Programm Test1 in der Ausführung



13

5. 2 2. Schritt: Erstellung von Figuren

Falls noch eine Anwendung im aktuellen Fenster aktiv ist, können Sie diese

direkt schließen, oder Sie gehen auf dem Hauptfenster auf das Menü DATEI

und klicken auf den Button NEUE ANWENDUNG. Sie werden dann

aufgefordert, die Änderung in Projekt1 zu speichern, diese Option bleibt

ihnen überlassen. Danach müsste die IDE wie in Abbildung 1 auf ihrem

Bildschirm erscheinen.

Für unser folgendes Beispiel, Zeichnen eines Kreises, gehen Sie mit der

Maus auf die Komponentenpalette und klicken Sie die Seite System (Abb. 9)

an. Auf der System-Seite klicken Sie dann auf den zweiten Button von links.

Abbildung: 9

Wenn Sie die Maus auf die Schaltfläche halten, erscheint die Kurzinformation

PaintBox. Klicken Sie auf eine Stelle im Formular. Auf dem Formular müsste

eine Komponente mit einem quadratischen Rahmen erscheinen. Diesen

Rahmen können Sie, wenn Sie den Rand des Rahmens anklicken, in der

Größe verändern, so dass er beispielsweise bis an den Rand des

Formularfensters reicht (Abb. 10).



14

Abbildung: 10

Auf dem Objektinspektor wird Ihnen die Eigenschaft Name ins Auge fallen,

mit dem Titel PaintBox1 (Abb. 11)

.



15

Abbildung: 11

Klicken Sie auf dem Objektinspektor auf die Registerkarte mit der Überschrift

Ereignisse, hier das Ereignis OnPaint . Gleichzeitig wird die graue Fläche an

dem Ereignisfeld OnPaint weiß hervorgehoben. Sobald Sie die weiße Fläche

mit der Maus doppelt anklicken, wird darin die Schrift PaintBox1Paint zu

sehen sein (Abb. 12), gleichzeitig wird der Quelltexteditor, welcher hinter

dem Formular liegt, geöffnet.



16

Abbildung: 12

In dem Quelltexteditor erscheint eine vorgefertigter PaintBox1Paint-Routine

(Funktion). Hier muss nur noch der gewünschte Code hinzugefügt werden.

Bis hierher wurde noch kein Quellcode, wie wir es bei Konsolenanwend-

ungen gewohnt sind, geschrieben. Der Unterschied zu den konsolen-

orientierten Programmierung liegt darin, dass keine (selbstverfasste) main-

Funktion sondern ereignisgesteuerte Objektmethoden vorliegen



17

5.2.1 Zur Erklärung der Routine

Diese Funktion ist eine Elementfunktion der Klasse. Die einzige Besonderheit

besteht darin, dass die C++Builder-Funktionen das Schlüsselwort __fastcall

als Aufrufkonvention verwendet. Die Funktion heißt PaintBox1Paint und ist

ein Element von TFORM1, hat keinen Rückgabewert (void) und besitzt einen

Zeiger auf ein Tobject als Parameter. Der Sender ist ein Zeiger auf diejenige

Komponente, die die Botschaft verschickt. In anderen Fällen ermöglicht der

Sender -Parameter für mehrere Komponenten, ein und dieselbe Funktion zur

Ereignisbearbeitung zu verwenden.

Nun können wir den Code hinzufügen um einen Kreis darzustellen. Der Code

für den Kreis lautet (Abb. 13):

Form1->PaintBox1->Canvas->Ellipse(intX1, intY1, int X2, intY2);

Abbildung: 13



18

5.2.2 Erläuterung

Form1: Eine Form1- Komponente erlaubt die Anzeige auf einem

Formular-Designer.

PaintBox1: Diese Komponente stellt eine „Leinwand“ für die Eigenschaft

Canvas bereit.

Canvas: Diese Eigenschaft ist eine Instanz der Klasse Tcanvas In einer

C++Builder- Anwendung zeichnet man mit dieser Klasse.

Ellipse: Zeichnet mit dem aktuellen Stift eine Ellipse auf die Leinwand.

Diesen Code beenden wir wie gewohnt mit einem Semikolon und können mit

der Kompilierung beginnen.



19

Abbildung: 14

Aufgrund der Achsenparameter ist unsere „Ellipse“ ein Kreis (Abb. 14).



20

5.3 3. Schritt: Die Button Schaltfläche

Für dieses Bespiel beginnen Sie ebenfalls mit einer neuen Anwendung.

Holen Sie drei Button-Komponenten aus der STANDARD-Seite der

Komponentenpalette (es ist die siebte Schaltfläche von links) und platzieren

Sie diese, ohne Rücksicht auf die Ränder zu nehmen, im Formular-Designer.

Abbildung: 15

Zunächst sollten Sie die Schaltflächen zentrieren, weil das professioneller

wirkt. Zum Zentrieren dieser drei Schaltflächen müssen Sie diese markieren.

Dieses geschieht, indem Sie einen rechteckigen Rahmen mit der Maus um

die Schaltflächen ziehen. Es genügt schon, wenn der Rand der Schaltfläche

berührt wird (Abb. 15).

Wählen Sie jetzt im Menü die Schaltfläche ANSICHT und den Befehl

AUSRICHTUNGSPALETTE (Abb. 16).



21

Abbildung: 16

In der Ausrichtungspalette klicken Sie auf die Schaltfläche VERTIKAL

ZENTRIERT (unten links die Zweite) und auf GLEICHER ABSTAND

HORIZONTAL (oben rechts die Zweite), somit ist die Zentrierung

abgeschlossen.

Suchen Sie sich eine Button-Schaltfläche aus. Am besten, sie nehmen die

die erste von links (anklicken). Gehen Sie mit der Maus zum Objektinspektor

auf die Eigenschaft Caption und ändern den Namen von Button1 auf

Beenden um (Abb. 17).



22

Abbildung: 17

Wenn Sie jetzt einen Doppelklick auf die Schaltfläche Beenden im Formular-

Designer tätigen, öffnet sich der Quelltexteditor, in dem eine vorgefertigte

Button1Click-Routine zum Vorschein kommt. In diese vorgefertigte Routine

geben Sie ihren Code ein (Abb. 18). Der Code für die Schaltfläche Beenden

lautet:

Close();

Mit dem Zeilen-Code Close() wird das Beenden (Schließen) der Anwendung

erreicht.



23

Abbildung: 18

Nach dem Kompilieren müssten die Schaltflächen Button2 und Button3 als

funktionslose Schaltfläche auf dem Formular-Designer zu sehen sein. Man

kann diese beiden Schaltflächen anklicken und es geschieht nichts. Falls Sie

die Schaltfläche Beenden betätigen, schließen Sie die Funktion bzw.

beenden das Programm (Abb. 19).



24

Abbildung: 19



25

5.4 Einblick in die VCL

Die VCL (Visual-Component-Library) ist ein strukturiert aufgebautes

Rahmenwerk. Wie alle anderen Klassenbibliotheken nutzt die VCL auch die

Möglichkeiten der Vererbung. Im Großen und Ganzen besteht die VCL aus

Klassen, welche die Komponenten repräsentieren. Die Klassenhierarchie der

VCL ist zwar verwirrend, aber zum Glück nicht völlig undurchschaubar.

TObjekt

TPersistent

nicht sichtbare

Komponenten

TComponent sichtbare Komponenten

TTimer, u.s.w.

TControl

TGraphicsControl TWinControl

TSpeedButton TPanel, u.s.w.



26

Oben in der VCL Klassenhierarchie befindet sich TObject, sie ist die Basis

der Klassen. Die nächste Stufe bildet TPersistent, diese Klasse befähigt die

Komponenten, für sich selbst Dateien oder den Speicher zu sichern. Danach

folgt in der Klassenhierarchie die Basisklasse Tcomponent. Diese liefert das

Fundament als grundlegende Funktion einer Komponente. Die daraus

folgenden, nicht sichtbaren Komponenten werden von TComponent

abgeleitet. Die sichtbaren Komponenten hingegen werden von der Klasse

TControl abgeleitet, welche wiederum von TComponent abgeleitet ist. Die

sichtbaren Komponenten werden zusätzlich von TControl mit weiteren

Funktionen ausgestattet, woraus sich schließlich die Komponenten

TGraphicControl oder TWinControl abgeleiten.

Wenn Sie eine Komponente in ein Formular aufnehmen, erzeugt der

C++Builder in der Klassendeklaration des Formulars einen Zeiger auf diese

Komponente, so dass Sie auf die Komponente in ihrem Code zugreifen

können. Der C++Builder benutzt die Name-Eigenschaft für den

Klassennamen und für die Zeigervariable. Als wir weiter oben einen Schalter

installierten, legte der C++Builder eine TButton* Variable zur Repräsentation

des Schalters an. Bevor dies geschah, hatte der C++Builder allerdings schon

eine Klasse von TForm abgeleitet und eine Instanz dieser Klasse gebildet,

stellvertretend für das Formular.

5.4.1 Formular- und Anwendungsklassen

Formular- und Anwendungsklassen repräsentieren Formulare und das

TApplication – Objekt der VCL. Diese Klassen sind alle von TComponent

abgeleitet und sind selbst Komponenten. Sie werden hier getrennt

aufgeführt, um sie von den Steuerelementen, die in die Formulare

aufgenommen werden, zu unterscheiden.



27

5.4.2 TApplication

Die Klasse TApplication kapselt die grundlegenden Operationen eines

Windows-Programms. Sie bearbeitet das Anwendungssymbol, die

Kontexthilfe und die grundlegende Botschaftsverarbeitung. In jeder

C++Builder –Anwendung ist der Zeiger Application definiert, der auf das

TApplication – Objekt weist. Diese Klasse wird vor allem benutzt, um

Meldungsfenster aufzurufen, um die Kontexthilfe zu verwalten und um

Hinweise für Schaltflächen und Text in die Statuszeile zu schreiben.

TApplication hat eine Besonderheit: Einige ihrer Eigenschaften (TITEL,

HILFEDATEI und SYMBOL) können auf der Seite ANWENDUNG der

Projektoptionen eingestellt werden.

5.4.3 TForm

Die Klasse TForm kapselt Formulare für das Hauptfenster, Dialogfenster,

untergeordnete Fenster und jeden anderen Fenstertyp. TForm kennt ca. 60

Eigenschaften, 45 Methoden und etwa 20 Ereignisse.

5.4.4 Die Komponentenklassen

Diese Gruppe umfasst einen weiten Bereich von Klassen, der in

verschiedene Kategorien unterteilt wird.



28

5.4.5 Die Klassen der Standardkomponenten

Zu den Standardkomponenten gehören die Klassen: TButton, TEdit,

TListBox, TMemo, TMainMenu, TPopupMenu, TCheckBox, TRadioButton,

TRadioGroup, TGroupBox und Tpanel. Die meisten dieser Klassen kapseln

Windows-Steuerelemente; die Klasse TmainMenu verwaltet das Hauptmenü

einer Anwendung. Zur „Echtzeit“ gelangt man durch einen Doppelklick auf

das Symbol der MainMenu–Komponente zum Menü-Designer. Mit Hilfe der

Eigenschaften von TmainMenu (bzw. TmenuItem) können Sie steuern, ob

ein Menüeintrag deaktiviert ist ( Enabled = false), ob vor dem Menüeintrag

ein Häkchen angezeigt werden soll (Checked = true), wie der Hinweistext

lautet und anderes mehr. Ein Menüeintrag kennt nur ein einziges Ereignis,

OnClick, mit dem Sie einen ausgewählten Menüeintrag mit einer Funktion

verbinden können.

Wollen Sie z.B. für eine Anwendung eine Mauspalette erstellen, fangen Sie

mit einem Bedienfeld an und setzen dann die einzelnen Mauspaletten-

schalter (speed buttons) in das Bedienfeld. Wenn Sie das Bedienfeld

verschieben, bewegen sich die Schalter mit. Bedienfelder können für eine

Vielzahl von Aufgaben eingesetzt werden, wie auch zur Einrichtung von

Statuszeilen. Panels besitzen gleich mehrere Eigenschaften, über die Sie die

Ränder und das Erscheinungsbild des Panels anpassen können (flach,

erhöht, abgesenkt). Durch Kombination dieser Eigenschaften können Sie

eine Menge unterschiedlicher 3-D-Bedienelemente kreieren.

Der C++Builder definiert eine weitere Gruppe von Komponenten Diese sind

auf der Seite ZUSÄTZLICH der Komponentenpalette zu finden. Zu dieser

Gruppe gehören die Klassen TBitBtn, TSpeedButton, TMaskEdit,

TStringGrid, TDrawGrid, TImage, TShape, TBevel und TScrollBox. Die

Klasse TBitBtn repräsentiert einen Schalter, der ein Bild in seinem Feld

anzeigt. TSpeedButton ist ebenfalls ein Schalter mit Bild, doch ist diese

Komponente für den Einsatz in Bedienfeldern gedacht. Eigentlich ist es kein



29

echter Schalter, sondern vielmehr eine bildliche Darstellung eines Schalters.

Auf diese Weise können Sie eine große Anzahl von Mauspalettenschalter

verwenden, ohne für jeden einzelnen von ihnen Windows-Ressourcen zu

verbrauchen. Die Image-Komponente ermöglicht es Ihnen, ein Bild aus einer

Datei in ein Formular aufzunehmen. Die Bevel-Komponente wird benutzt, um

Flächen und Linien zu zeichnen, die hervorgehoben (Raised) oder einge-

senkt (Lowered) sind. Mit ihrer Hilfe können Formulare visuell unterteilt und

ansprechend gestaltet werden. Die Klassen TSringGrid und TDrawGrid

dienen der tabellarischen Darstellung von Informationen.

5.4.6 Klassen der Win32-Steuerelemente

Die VCL enthält Klassen für viele der 32-Bit-Steuerelemente von Windows.

Zu diesen Klassen gehören TListView, TTreeView, TProgressBar,

TTabControl, TPageControl, TRichEdit, TImageList, TStatusBar, TAnimate,

TToolbar, TCoolBar und einige andere. Manche dieser Steuerelemente sind

kompliziert, und somit auch die zugehörigen VCL-Klassen. Insgesamt leistet

die VCL einen großen Beitrag, um die Arbeit mit den Steuerelementen zu

erleichtern.

5.4.7 Klassen der Datenbankkomponenten

Die VCL besitzt ein Heer von Datenbankkomponenten, das sowohl sichtbare

als auch nicht sichtbare Komponenten umfasst. DataSource, DataBase,

Table und Query gehören zu den letzteren. Sie kapseln im Hintergrund

ablaufende Datenbankoperationen.

Mit den sichtbaren Komponenten kann der Benutzer interagieren. Zum

Beispiel wird die DBGrid-Komponente verwendet, um dem Benutzer Zugriff

auf eine Datenbanktabelle zu ermöglichen, die durch eine Table-



30

Komponente repräsentiert wird. In diesem Sinne bildet DBGrid die

Schnittstelle zwischen dem Anwender und der Table-Komponente. Mit

DBGrid können Tabellen betrachtet und editiert werden.

Die DBNavigator-Komponente besitzt Schalter, mit denen Sie sich durch eine

Tabelle bewegen können. Es gibt Schalter, um zum nächsten,

vorhergehenden, ersten und letzten Datensatz zu springen, sowie zum

Abbrechen, Übernehmen und Rückgängigmachen einer Änderung.

Andere Datenzugriffskomponenten verbinden Standard-Steuerelemente von

Windows mit Datenbankfeldern. Dazu gehören unter anderem TDBText,

TDBEdit, TDBListBox und TDBImage.

5.4.8 Klassen der Standard-Dialogfelder

Windows stellt für bestimmte Aktionen wie das Öffnen einer Datei, Speichern

einer Datei, Auswählen einer Schriftart oder Farbe Standard-Dialogfelder

bereit. Die VCL kapselt die Standard-Dialogfelder in den Klassen

TOpenDialog, TSaveDialog, TOpenPictureDialog, TSavePictureDialog,

TFontDialog, TColorDialog, TPrintDialog und TPrinterSetupDialog.

Darüber hinaus gehören zu dieser Gruppe noch die Klassen TFindDialog und

TReplaceDialog. All diese Komponenten sind nicht sichtbar, haben also zur

Entwurfszeit keine Schnittstelle, die man sehen kann. Zur Laufzeit können

die Dialogfenster natürlich angezeigt werden.



31

5.4.9 Klassen der Systemkomponenten

Die Seite SYSTEM der Komponentenpalette enthält eine Mischung

sichtbarer und nicht sichtbarer Komponenten. Mit TTimer managen Sie den

Windows System-Zeitgeber. Das einzige Ereignis dieser Komponente ist

OnTimer, das jedes Mal nach Ablauf einer bestimmten Zeitspanne ausgelöst

wird. Diese Zeitspanne wird durch den Wert der Interval-Eigenschaft

festgelegt. TTimer ist eine nicht sichtbare Komponente.

In dieser Gruppe befindet sich auch die Klasse TMediaPlayer. Mit Hilfe

dieser Klasse können Sie Multimedia-Dateien abspielen, beispielsweise

Wave-Dateien, AVI-Videos und MIDI-Dateien. Das Medium kann abgespielt,

angehalten oder vorgespult werden, u.s.w.. Diese Klasse besitzt viele

Eigenschaften und Ereignisse, welche die komplexe Multimedia-Schnittstelle

(MCI) sehr vereinfachen.

Die Komponente TPaintBox richtet eine leere Leinwand ein, auf die Sie alles

Beliebige zeichnen können. Diese Komponente hat somit einen sehr weiten

Anwendungsbereich. Weiterhin gehören Klassen für OLE und den

dynamischen Datenaustausch (DDE) zur SYSTEM-Gruppe.

5.4.10 GDI-Klassen

Die Klassen der GDI (Graphics Device Interface) kommen

charakteristischerweise in GUI-Anwendungen vielfach zum Einsatz. Diese

Klassen kapseln die Benutzung von Bitmaps, Schriftarten, Gerätekontexten

(DC), Pinseln und Zeichenstiften. Diese GDI-Objekte sind es, mit deren Hilfe

Graphiken und Texte in Fenstern angezeigt werden.

Die GDI-Klassen sind nicht mit einer besonderen Komponente verbunden,

aber viele Komponenten enthalten Instanzen dieser Klassen als



32

Eigenschaften. Zum Beispiel hat ein Editierfeld eine Font-Eigenschaft, die

eine Instanz der Klasse TFont ist.

Windows-Programmierern ist der Begriff Gerätekontext (englisch DC =

Device Context) wohl bekannt. Es ist gleichgültig, ob Sie in C programmieren

oder eine der C++-Klassenbibliotheken benutzen. In der VCL allerdings ist

dieser Begriff nicht weit verbreitet. Dies liegt daran, dass die VCL statt von

Gerätekontexten von Leinwänden (Canvas) spricht und die Windows-

Gerätekontexte in der Klasse TCanvas kapselt. Eine Leinwand stellt eine

Fläche zur Verfügung, in die man mit Methoden wie MoveTo(), LineTo() oder

TextOut() zeichnen kann. Bitmaps können mit Draw() oder StretchDraw() auf

die Leinwand projiziert werden.

Die TCanvas-Klasse enthält Instanzen der anderen GDI-Klasen.

Beispielsweise zeichnet die Befehlsfolge MoveTo()/LineTo() eine Linie in der

aktuellen Zeichenstift-Farbe. Die Pen-Eigenschaft bestimmt die Zeichenstift-

Farbe und ist eine Instanz der Klasse TPen. TPen selbst besitzt die

Eigenschaften, die den Linientyp festlegen: die Breite, den Stil

(durchgezogen, gestrichelt, gepunktet, u.s.w.) und den Modus.

Die Klasse TBrush repräsentiert einen Pinsel. Dieser verkörpert seinerseits

ein Füllmuster, das bei Leinwand-Operationen, wie FillRect(), Polygon() oder

Ellipse() benutzt wird. Die Style-Eigenschaft erlaubt es Ihnen, ein

Schraffurmuster für den Pinsel festzulegen. Mit Hilfe der Bitmap-Eigenschaft

können Sie eine Bitmap als Füllmuster auswählen.

TBitmap kapselt Bitmap-Operationen in der VCL. Eigenschaften dieser

Klasse sind etwa Palette, Heigth, Width und TransparentColor. Unter den

Methoden finden Sie LoadFromFile(), LoadFromResourceID() und

SaveToFile(). TBitmap wird von anderen Klassen zusätzlich zu TCanvas

benutzt, beispielsweise von TImage, TBitBtn und TspeedButton. Instanzen

der Klasse TBitmap können auch als Speicher-Bitmaps verwendet werden.



33

Speicher-Bitmaps werden häufig in Anwendungen mit vielen Grafiken

eingesetzt, um das Bildschirmflimmern zu verringern und die

Grafikdarstellung zu beschleunigen.

Die Klasse TFont dient zur Manipulation der Schriftart. Eigenschaften dieser

Klasse sind unter anderem Color, Heigth und Style (fett, kursiv, unterstrichen

und durchgestrichen). Die Klasse TFont wird von allen Komponenten

verwendet, die Text anzeigen.

Außer den hier angeführten GDI-Klassen, gibt es noch weitere, die entweder

als Hilfsklassen fungieren oder eine Basisklasse mit zusätzlicher

Funktionalität ausstatten.



34

5.5 4. Schritt: Anzeigen der Dateien

Als weiteres Beispiel soll ein Programm erstellt werden, das über einen

Dialog Textdateien auswählt und anzeigt. Falls eine Anwendung aktiv ist,

schließen Sie diese und gehen auf DATEI, NEUE ANWENDUNG.

Ändern Sie zunächst den Namen des Formulars, indem Sie im

Objektinspektor die Eigenschaft Caption „Form1“ auf „Datei“ umschreiben.

Gehen Sie nun auf die Komponentenpalette und wählen Sie aus der Seite

STANDARD die Komponente Memo (die sechste von links) aus. Mit einem

Doppelklick bringen Sie diese auf das Formular. Auf dem Objektinspektor

setzen sie die Eigenschaft align von alNone auf alTop. Jetzt müsste sich das

Memo1-Feld auf dem Formular im oberen Drittel und über die gesamte Breite

des Formulars ausgebreitet haben (Abb. 20).



35

Abbildung: 20

Ziehen Sie den unteren Rand des Memo1-Feld soweit nach unten, dass es

etwa drei Viertel des Formulars ausfüllt. Wenn Sie auf dem Objektinspektor

auf die Eigenschaft ScrollBars anklicken und die Eigenschaft von ssNone auf

ssBoth ändern, erscheint dann am unteren und am rechten Rand des

Memo1-Feldes jeweils ein ScrollBar (Abb. 21).



36

Abbildung: 21

Um den Eintrag im Memo1-Feld zu löschen, klicken Sie im Objektinspektor

auf die Eigenschaft Lines und anschließend auf die Schaltfläche mit den drei

Punkten an der rechten Seite. Nun öffnet sich der Stringlisten-Editor , in

dem Sie das Wort „Memo1“ löschen können.

Wenn Sie möchten, können Sie jetzt kompilieren, anschließend in das

Memo1-Feld einen Text hineinschreiben, und dann probieren, ob die

ScrollBars funktionieren.

Auf der Komponentenpalette klicken Sie unter der STANDARD -Seite eine

Button-Komponente (die siebte von links) an und platzieren diese auf dem

Formular unterhalb des Memo1-Feldes. Im Objektinspektor ändern Sie die

Eigenschaft des Namens in Open und die Caption –Eigenschaft in &Öffnen.



37

Ziehen Sie einen zweiten Button und ändern Sie hier die Caption-Eigenschaft

und den Namen in Beenden.

Gehen Sie jetzt auf der Komponentenpalette auf die Seite DIALOGE. Von

dieser wählen Sie gleich die erste Komponente von links. Wenn Sie mit der

Maus auf die Schaltfläche halten, müsste OpenDialog erscheinen. Auf diese

Schaltfläche machen Sie einen Doppelklick und ziehen dann zwischen die

beiden Button-Schaltfläche. Ihr Formular müsste jetzt aussehen wie in der

Abb. 22.

Abbildung: 22



38

Wir müssen noch die Schaltflächen mit dem Quellcode einbinden, damit

etwas geschieht, wenn auf die Schaltfläche gedrückt wird. Wenn Sie einen

Doppelklick auf die Öffnen-Schaltfläche machen, öffnet sich der Quelltext-

Editor. Geben Sie den folgenden Quell-Code ein:

OpenDialog1->FileName = "";

if (OpenDialog1->Execute())

{

if (Memo1->Lines->Count > 0) Memo1->Clear();

Memo1->Lines->LoadFromFile (OpenDialog1->FileName);

}

Wenn Sie anschließend wieder auf das Formular zurück gehen und einen

Doppelklick auf die Beenden-Schaltfläche tätigen, öffnet sich der Quelltext-

Editor für Beenden. Hier geben Sie lediglich ein:

Close();

Das Programm ist nun fertig. Nachdem Sie kompiliert und auf die

Schaltfläche Öffnen geklickt haben, müsste ein ähnliches Bild wie in Abb. 23

erscheinen.



39

Abbildung: 23



40

5.6 5. Schritt: Erstellung eines Rechners

Zunächst sollten Sie eine neue Anwendung erzeugen. Als nächstes werden

die benötigten Graphikobjekte in den Formular-Designer positioniert. Diese

sind Edit als Eingabefeld, Label als Beschriftungsfeld und Button als Schalter

(Knopf zum Drücken). Diese Objekttypen befinden sich alle auf der

STANDARD-Seite der Komponentenpalette.

Für den Taschenrechner positionieren wir drei Eingabefelder (Edit)

untereinander im Formular-Designer und jeweils drei Beschriftungsfelder

(Label), welche über die Eingabefelder positioniert werden. Nach dem wir die

Objekte ausgerichtet haben, müsste der Formular-Designer wie in der Abb.

24 aussehen.

Abbildung: 24



41

Jetzt platzieren wir die Button-Felder, vier davon werden nebeneinander,

zwischen dem Edit1-Eingabefeld und dem Label2-Beschriftungsfeld, und der

fünfte unter dem Edit3-Eingabefeld aufgestellt (Abb. 25).

Abbildung: 25

Der nächste Schritt wäre auf die Edit-Felder zu klicken und im

Objektinspektor die Eigenschaft Text löschen (Abb. 26).



42

Abbildung: 26

Danach gehen wir auf die Label-Felder und ändern die Beschriftung, indem

wir das jeweilige Label auf dem Formular-Designer anklicken und

anschließend auf dem Objektinspektor die Eigenschaft Caption

umbenennen. Label1 wird umbenannt auf 1.Zahl, Label2 auf 2.Zahl und

Label3 wird umbenannt auf Ergebnis (Abb.27).



43

Abbildung: 27

Jetzt nehmen wir uns die Button-Felder vor: Hier verändern wir zunächst

ebenfalls die Namen, wie zuvor bei den Label-Feldern. Button1 wird zu +,

Button2 wird zu – , Button3 wird zu *, Button4 wird zu / und Button5 wird zu

Beenden umbenannt, siehe Abb. 28.



44

Abbildung: 28

Nun beginnt die eigentliche Arbeit, denn jetzt kommt die Funktion der Button-

Felder zur Geltung. Noch wurde kein Quellcode, wie bei einer Konsolen-

anwendung geschrieben. Wie zu Anfang beschrieben, liegt der Unterschied

zur konsolenorientierten Programmierung darin, das keine main-Funktion,

sondern ereignisgesteuerte Objektmethoden, die automatisch aufgerufen

werden, wenn bestimmte Ereignisse (z.B. wenn Button gedrückt wird)

auftreten. Wenn wir jetzt einen Doppelklick auf den Button mit dem „+“-

Zeichen tätigen, öffnet sich der Quelltexteditor (Abb. 29).



45

Abbildung: 29

Hier wird jetzt der Quellcode für das Addieren, also für unser Button den wir

mit „+“ bezeichnet haben, eingefügt.



46

Der Quellcode zum Addieren sieht folgendermaßen aus:

String s1, s2;

float r1, r2, erg;

DecimalSeparator = '.'; // stellt Komma auf Punkt u m

// zum Lesen aus den Editboxen

s1 = Edit1->Text;

s2 = Edit2->Text;

if (s1=="")

s1="0.0";

if (s2=="")

s2="0.0";

r1 = StrToFloat(s1);

r2 = StrToFloat(s2);

erg = r1 + r2;

Edit3->Text = FloatToStrF(erg, ffFixed, 7, 2);

Nachdem der Quellcode eingegeben worden ist, müsste es folgendermaßen

im Quelltexteditor aussehen (Abb. 30).



47

Abbildung: 30

Genauso fahren wir mit den anderen Buttons fort, aber mit dem Unterschied,

dass die „erg“- Zeile entsprechend modifiziert wird:

erg = r1 – r2;

erg = r1 * r2;

erg = r1 / r2;

Zuletzt wird der Button mit der Beschriftung Beenden bedient. Hier wird auch ein Doppelklick auf den Button getätigt und in den sich öffnenden Quelltexteditor wird der Zeilencode: Close(); eingefügt (Abb. 31).



48

Abbildung: 31

Fertig ist der Taschenrechner. Jetzt muss nur noch kompiliert werden.



49

5.7 6. Schritt: Überlagerung zweier Sinus-Funktion en

Bei der Überlagerung der Sinus-Funktionen werden die Frequenzen und die

Amplituden über die Edit-Eingabefelder eingegeben. Die Anzeige der Grafik

erfolgt automatisch.

Für dieses Programm benötigen wir einige Grafikobjekte. Diese sind vier

Edit-Eingabefelder, vier Label-Beschriftungsfelder, ein Button-Feld , eine

PaintBox , einen Bevel-Rahmen und ein Timer.

Die Objekttypen Edit, Label und Button befinden sich in der STANDARD-

Seite,der Bevel-Rahmen befindet sich auf der ZUSÄTZLICH-Seite (der achte

von links), die PaintBox und der Timer in der SYSTEM-Seite der Kompo-

nentenpalette.

Als erstes holen wir die Objekttypen Edit, Label, Button und Timer aus der

Komponentenpalette und stellen diese linksbündig untereinander. Die

PaintBox setzen wir auf die rechte Seite im Formular-Designer. Anschließend

werden das Button- und die Label-Felder beschriftet, die PaintBox auf die

entsprechende Größe gezogen und die Werte für die Frequenzen und

Amplituden in die Edit-Felder eingetragen. Auf den Bevel-Rahmen kommen

wir ganz zum Schluss zurück..

Ganz wichtig ist es jetzt, die Namen der Edit-Felder festzulegen, denn diese

Eigenschaft legt die Namen der Objekte fest. Nur unter diesen Namen

können wir später auf die Objekte zugreifen. Es ist zweckmäßig, die Default-

Namen (Edit1, Edit2, usw.) zu ändern, und dafür eigene Namen (z.B.

Freq1Edit, usw.) auswählt. Die Eigenschaft Text ist wichtig für die

Beschriftungen, bei Buttons und Labels ist es der Text , der in der

Anwendung erscheint, bei Edit ist es der Text, der am Anfang in dem

Textfeld erscheint, aber überschrieben werden kann.



50

Die Beschriftung:

• Label1 = Frequenz1 (Hz)

• Edit1 = 20.00

• Label2 = Amplitude2 (V)

• Edit2 = 5.00

• Label3 = Frequenz2 (Hz)

• Edit3 = 2.00

• Label4 = Amplitude2 (V)

• Edit4 = 5.00

• Button1 = Draw

• Button2 = Beenden

Wir ändern jetzt den Namen Edit1 in der Eigenschaft im Objektinspektor auf

Freq1Edit um, analog dazu auch die anderen Edit-Felder mit den

entsprechenden Namen (Edit2 = Amp1Edit, Edit3 = Freq2Edit, Edit4 =

Amp2Edit), siehe Abb. 32.



51

Abbildung: 32

Da wir ein zusätzlich Rauschen simulieren wollen, geben wir für die

Amplituden den gleichen Wert ein, in unserem Beispiel geben wir für beide

Amplituden 5 V ein. Für die Frequenz1 20 Hz und Frequenz2 geben wir 2 Hz

ein. Das von Ihnen aufgebaute Formular müsste nun wie das in der Abb. 33

gezeigte Bild aussehen.



52

Abbildung: 33

Der nächste Schritt wäre jetzt einen Doppelklick auf den Formular-Designer,

um in den Quelltexteditor zu kommen. Hier müssen wir für die

mathematische Funktion die Headerdatei math.h einbinden (#include

<math.h> ) und die Headerdatei „Unit1.h“ in „Sinus.h“ ändern. Zusätzlich

geben wir als Variablenvereinbarung double shift = 0.0; ein.

Anschließend gehen wir zurück auf den Formular-Designer und klicken nur

einmal auf die PaintBox. Im Objektinspektor klicken wir auf die Ereignisse-

Registerkarte und klicken auf das Feld OnPaint. Auf das sich öffnende Feld

bei OnPaint gehen wir mit einem Doppelklick. Nun müsste die Aufschrift

„PaintBox1Paint“ erscheinen und gleichzeitig sich der entsprechende

Quelltexteditor, der sich im Hintergrund befand, öffnen.



53

In diesen Quelltexteditor geben Sie folgenden Quellcode ein:

const double PI = 3.14159265359;

const double xmax = 2*PI, ymax = 10.0;

double x, y, step, freq1, freq2, amp1, amp2;

int xi, yi, w, h;

step = xmax / 100;

// Breite und Höhe der PaintBox:

w = Form1->PaintBox1->Width;

h = Form1->PaintBox1->Height;

// Lesen der Werte aus den Editboxen:

DecimalSeparator = '.'; //Standard ist Komma!

freq1 = Form1->Freq1Edit->Text.ToDouble ();

freq2 = Form1->Freq2Edit->Text.ToDouble ();

amp1 = Form1->Amp1Edit->Text.ToDouble ();

amp2 = Form1->Amp2Edit->Text.ToDouble ();

// Anfangspunkt für Graphik berechnen:

x = 0.0;

y = amp1 * sin (freq1 * (x - shift)) + amp2 * si n (freq2 * x);

xi = w * x / xmax; // Umrechnung in P ixel

yi = h/2 - (h/2) * y / ymax;

// Punkt setzen:

Form1->PaintBox1->Canvas->MoveTo (xi, yi);

Form1->PaintBox1->Canvas->Pen->Color = clRed;



54

for (x = step; x < xmax + step; x += step)

{

// nächsten Punkt berechnen:

y = amp1 * sin (freq1 * (x - shift)) + amp2 * sin (freq2 * x);


yi = h/2 - (h/2) * y / ymax;

// Linie ziehen:

Form1->PaintBox1->Canvas->LineTo (xi, yi);

}

Zurück zum Formular-Designer: Wenn Sie jetzt einen Doppelklick auf den

Timer tätigen, können Sie mit dem sich hier öffnenden Quelltexteditor

folgendes einfügen:

shift += 0.02; // die Wiederholzeit

Form1->PaintBox1->Repaint (); // Bildwiederholung

Als letztes müssen Sie einen Doppelklick auf den Beenden-Button tätigen

und hier im Quelltexteditor den folgenden Code einfügen:

Close(); Zum Schluss fügen wir noch den Bevel-Rahmen im Formular-Designer ein

und ziehen diesen Rahmen um den Rahmen der PaintBox, so dass die

PaintBox sich innerhalb des Bevel-Rahmens befindet. Das fertige Formular-

Designer müsste jetzt wie in der folgenden Abb.:34 erscheinen.



55

Abbildung: 34

Wenn Sie das Programm kompilieren und starten, sehen Sie eine

„verrauschte“ Sinus-Funktionen (Abb. 35).



56

Abbildung: 35



57

5.8 7. Schritt: Die abklingende Sinus-Welle

Das jetzige Beispiel ist vom Aufbau her nicht viel anders als das

vorangegangene mit der Überlagerung zweier Sinus-Funktionen. Es wird

lediglich die abklingende Sinus-Funktion simuliert.

Für dieses Beispiel benötigen wir zwei Label-Beschriftungsfelder, zwei Edit-

Eingabefelder, einen Timer, ein Button-Feld, eine PaintBox und einen Bevel-

Rahmen.

Die Beschriftung der Label- und Edit-Felder:

• Label1 = Frequenz (Hz)

• Edit1 = 15.00

• Label2 = Amplitude (V)

• Edit2 = 7.00

Die Eigenschaft der Namenseingebung für die Edit-Felder sollte in dem

Objektinspektor wie folgt geändert werden:

• Edit1 = Freq1Edit

• Edit2 = Amp1Edit

Der von Ihnen aufgebaute Formular-Designer sollte nun wie in der Abb. 36

aussehen.



58

Abbildung: 36

Im Quellcodeeditor können wir uns an das obige Beispiel (Überlagerung

zweier Sinus-Funktionen) halten. Auch hier wird die Headerdatei math.h

eingebunden und Unit1.h sollte einen anderen Namen bekommen. In

unserem Beispiel nennen wir die Datei Welle.h .

Auch hier wird eine Variablenvereinbarung vorgenommen:

double shift = 0.0;



59

Als Quellcode für die PaintBox1Paint (im Objektinspektor die Registerkarte

Ereignisse, dann OnPaint-Feld doppelt anklicken) geben Sie folgenden Text

ein:

const double PI = 3.14159265359;

const double xmax = 2*PI, ymax = 10.0;

double x, y, step, freq1, freq2, amp1, amp2;

int xi, yi, w, h;

step = xmax / 300;

// Breite und Höhe der PaintBox:

w = Form1->PaintBox1->Width;

h = Form1->PaintBox1->Height;

// Lesen der Werte aus den Editboxen:

DecimalSeparator = '.'; //Standard ist Komma!

freq1 = Form1->FreqEdit1->Text.ToDouble ();

freq2 = 1; //Form1->Freq2Edit->Text.ToDouble ();

amp1 = Form1->AmpEdit1->Text.ToDouble ();

amp2 = 0; //Form1->Amp2Edit->Text.ToDouble ();

// Anfangspunkt für Graphik berechnen:

x = 0.0;

y = amp1 * sin (freq1 * (x-shift)) + amp2 * sin (freq2 * x);


yi = h/2 - (h/2) * y / ymax;

// Punkt setzen:

Form1->PaintBox1->Canvas->MoveTo (xi, yi);




60

for (x = step; x < xmax + step; x += step)

{

// nächsten Punkt berechnen:

y = amp1 * sin (freq1 * (x-shift)) + amp2 * s in (freq2 * x);

y = y * exp (-0.5 * x);


yi = h/2 - (h/2) * y / ymax;

// Linie ziehen:

Form1->PaintBox1->Canvas->LineTo (xi, yi);


}

Die Quellcodes für den Timer und den Beenden-Button können Sie aus dem

vorherigen Beispiel entnehmen.

Zuletzt den Bevel-Rahmen um den Rahmen des PaintBox ziehen und fertig

ist das Programm.

Nachdem Sie das fertige Programm kompiliert haben, müsste die

abklingende Sinus-Welle auf dem Bildschirm zu sehen sein (Abb. 37).



61

Abbildung: 37

Documents

Grafische Programmierung mit dem Borland C++-Builder · erstellen, sowohl Win32-Konsolenanwendungen als auch Win32-Programme mit graphischer Benutzeroberläche (GUI = Graphical User