Grafische Programmierung mit dem Borland C++-Builder

Transkript

1 Grafische Programmierung mit dem Borland C++-Builder 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 Grafische Programmierung mit dem Borland C++-Builder 1

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 Programming 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. Grafische Programmierung mit dem Borland C++-Builder 2

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. Grafische Programmierung mit dem Borland C++-Builder 3

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 Grafische Programmierung mit dem Borland C++-Builder 4

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 Komponentenpalette, 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 Grafische Programmierung mit dem Borland C++-Builder 5

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. Grafische Programmierung mit dem Borland C++-Builder 6

7 5 Das Programmieren mit GUI 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 Grafische Programmierung mit dem Borland C++-Builder 7

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 Eigenschaften 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 Grafische Programmierung mit dem Borland C++-Builder 8

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). Grafische Programmierung mit dem Borland C++-Builder 9

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). Grafische Programmierung mit dem Borland C++-Builder 10

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). Grafische Programmierung mit dem Borland C++-Builder 11

12 Abbildung: 7. Das Dialogfeld Kompilieren Abbildung: 8. Das Programm Test1 in der Ausführung Grafische Programmierung mit dem Borland C++-Builder 12

13 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). Grafische Programmierung mit dem Borland C++-Builder 13

14 Abbildung: 10 Auf dem Objektinspektor wird Ihnen die Eigenschaft Name ins Auge fallen, mit dem Titel PaintBox1 (Abb. 11). Grafische Programmierung mit dem Borland C++-Builder 14

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. Grafische Programmierung mit dem Borland C++-Builder 15

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 Konsolenanwendungen gewohnt sind, geschrieben. Der Unterschied zu den konsolenorientierten Programmierung liegt darin, dass keine (selbstverfasste) main- Funktion sondern ereignisgesteuerte Objektmethoden vorliegen Grafische Programmierung mit dem Borland C++-Builder 16

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, intx2, inty2); Abbildung: 13 Grafische Programmierung mit dem Borland C++-Builder 17

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. Grafische Programmierung mit dem Borland C++-Builder 18

19 Abbildung: 14 Aufgrund der Achsenparameter ist unsere Ellipse ein Kreis (Abb. 14). Grafische Programmierung mit dem Borland C++-Builder 19

20 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). Grafische Programmierung mit dem Borland C++-Builder 20

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). Grafische Programmierung mit dem Borland C++-Builder 21

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. Grafische Programmierung mit dem Borland C++-Builder 22

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). Grafische Programmierung mit dem Borland C++-Builder 23

24 Abbildung: 19 Grafische Programmierung mit dem Borland C++-Builder 24

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. Grafische Programmierung mit dem Borland C++-Builder 25

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 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. Grafische Programmierung mit dem Borland C++-Builder 26

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 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 Die Komponentenklassen Diese Gruppe umfasst einen weiten Bereich von Klassen, der in verschiedene Kategorien unterteilt wird. Grafische Programmierung mit dem Borland C++-Builder 27

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 Mauspalettenschalter (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 Grafische Programmierung mit dem Borland C++-Builder 28

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 eingesenkt (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 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 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- Grafische Programmierung mit dem Borland C++-Builder 29

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 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. Grafische Programmierung mit dem Borland C++-Builder 30

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 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 Grafische Programmierung mit dem Borland C++-Builder 31

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. Grafische Programmierung mit dem Borland C++-Builder 32

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. Grafische Programmierung mit dem Borland C++-Builder 33

34 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). Grafische Programmierung mit dem Borland C++-Builder 34

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). Grafische Programmierung mit dem Borland C++-Builder 35

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. Grafische Programmierung mit dem Borland C++-Builder 36

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 Grafische Programmierung mit dem Borland C++-Builder 37

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. Grafische Programmierung mit dem Borland C++-Builder 38

39 Abbildung: 23 Grafische Programmierung mit dem Borland C++-Builder 39

40 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 Grafische Programmierung mit dem Borland C++-Builder 40

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). Grafische Programmierung mit dem Borland C++-Builder 41

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). Grafische Programmierung mit dem Borland C++-Builder 42

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. Grafische Programmierung mit dem Borland C++-Builder 43

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 Konsolenanwendung 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). Grafische Programmierung mit dem Borland C++-Builder 44

45 Abbildung: 29 Hier wird jetzt der Quellcode für das Addieren, also für unser Button den wir mit + bezeichnet haben, eingefügt. Grafische Programmierung mit dem Borland C++-Builder 45

46 Der Quellcode zum Addieren sieht folgendermaßen aus: String s1, s2; float r1, r2, erg; DecimalSeparator = '.'; // stellt Komma auf Punkt um // 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). Grafische Programmierung mit dem Borland C++-Builder 46

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). Grafische Programmierung mit dem Borland C++-Builder 47

48 Abbildung: 31 Fertig ist der Taschenrechner. Jetzt muss nur noch kompiliert werden. Grafische Programmierung mit dem Borland C++-Builder 48

49 Schritt: Überlagerung zweier Sinus-Funktionen 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 Komponentenpalette. 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. Grafische Programmierung mit dem Borland C++-Builder 49

50 Die Beschriftung: Label1 = Frequenz1 (Hz) Edit1 = 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. Grafische Programmierung mit dem Borland C++-Builder 50

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. Grafische Programmierung mit dem Borland C++-Builder 51

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. Grafische Programmierung mit dem Borland C++-Builder 52

53 In diesen Quelltexteditor geben Sie folgenden Quellcode ein: const double PI = ; 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 * sin (freq2 * x); xi = w * x / xmax; // Umrechnung in Pixel yi = h/2 - (h/2) * y / ymax; // Punkt setzen: Form1->PaintBox1->Canvas->MoveTo (xi, yi); Form1->PaintBox1->Canvas->Pen->Color = clred; Grafische Programmierung mit dem Borland C++-Builder 53

54 for (x = step; x < xmax + step; x += step) { // nächsten Punkt berechnen: y = amp1 * sin (freq1 * (x - shift)) + amp2 * sin (freq2 * x); xi = w * x / xmax; // Umrechnung in Pixel 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. Grafische Programmierung mit dem Borland C++-Builder 54

55 Abbildung: 34 Wenn Sie das Programm kompilieren und starten, sehen Sie eine verrauschte Sinus-Funktionen (Abb. 35). Grafische Programmierung mit dem Borland C++-Builder 55

56 Abbildung: 35 Grafische Programmierung mit dem Borland C++-Builder 56

57 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 = 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. Grafische Programmierung mit dem Borland C++-Builder 57

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; Grafische Programmierung mit dem Borland C++-Builder 58

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 = ; 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); xi = w * x / xmax; // Umrechnung in Pixel yi = h/2 - (h/2) * y / ymax; // Punkt setzen: Form1->PaintBox1->Canvas->MoveTo (xi, yi); Form1->PaintBox1->Canvas->Pen->Color = clred; Grafische Programmierung mit dem Borland C++-Builder 59

60 for (x = step; x < xmax + step; x += step) { // nächsten Punkt berechnen: y = amp1 * sin (freq1 * (x-shift)) + amp2 * sin (freq2 * x); y = y * exp (-0.5 * x); xi = w * x / xmax; // Umrechnung in Pixel yi = h/2 - (h/2) * y / ymax; // Linie ziehen: Form1->PaintBox1->Canvas->LineTo (xi, yi); Form1->PaintBox1->Canvas->Pen->Color = clred; } 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). Grafische Programmierung mit dem Borland C++-Builder 60

61 Abbildung: 37 Grafische Programmierung mit dem Borland C++-Builder 61