Grafische Programmierung mit dem Borland C++

Transcription

Fachhochschule Wiesbaden
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
1
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.
2
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.
3
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
4
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
5
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.
6
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
7
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
8
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 LabelKomponente 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).
9
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).
10
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).
11
Abbildung: 7. Das Dialogfeld Kompilieren
Abbildung: 8. Das Programm Test1 in der Ausführung
12
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).
13
Abbildung: 10
Auf dem Objektinspektor wird Ihnen die Eigenschaft Name ins Auge fallen,
mit dem Titel PaintBox1 (Abb. 11)
.
14
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.
15
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) mainFunktion sondern ereignisgesteuerte Objektmethoden vorliegen
16
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
17
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.
18
Abbildung: 14
Aufgrund der Achsenparameter ist unsere „Ellipse“ ein Kreis (Abb. 14).
19
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).
20
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).
21
Abbildung: 17
Wenn Sie jetzt einen Doppelklick auf die Schaltfläche Beenden im FormularDesigner 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.
22
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).
23
Abbildung: 19
24
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.
25
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.
26
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.
27
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
28
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.
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 TableGrafische Programmierung mit dem Borland C++-Builder
29
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.
30
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
31
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 WindowsGerä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 ZeichenstiftFarbe 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.
32
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.
33
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).
34
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).
35
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.
36
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
37
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 QuelltextEditor. 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 QuelltextEditor 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.
38
Abbildung: 23
39
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
40
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).
41
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).
42
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.
43
Abbildung: 28
Nun beginnt die eigentliche Arbeit, denn jetzt kommt die Funktion der ButtonFelder 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).
44
Abbildung: 29
Hier wird jetzt der Quellcode für das Addieren, also für unser Button den wir
mit „+“ bezeichnet haben, eingefügt.
45
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).
46
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).
47
Abbildung: 31
Fertig ist der Taschenrechner. Jetzt muss nur noch kompiliert werden.
48
5.7 6. 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 STANDARDSeite,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 DefaultNamen (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.
49
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.
50
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.
51
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 EreignisseRegisterkarte 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.
52
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 * 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;
53
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;
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 FormularDesigner müsste jetzt wie in der folgenden Abb.:34 erscheinen.
54
Abbildung: 34
Wenn Sie das Programm kompilieren und starten, sehen Sie eine
„verrauschte“ Sinus-Funktionen (Abb. 35).
55
Abbildung: 35
56
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 EditEingabefelder, einen Timer, ein Button-Feld, eine PaintBox und einen BevelRahmen.
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.
57
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;
58
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);
xi = w * x / xmax;
yi = h/2 - (h/2) * y / ymax;
// Punkt setzen:
Form1->PaintBox1->Canvas->MoveTo (xi, yi);
59
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;
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).
60
Abbildung: 37
61

Grafische Programmierung mit dem Borland C++

Transcription

Similar documents

Applikations- entwicklung mit Delphi

Taxpool-Buchhalter Hilfe

Lazarus

Delphi 6 für Profis

CATIA V5 Programmierung Möglichkeiten und Grenzen von

Stichworte zur Vorlesung 2004 - Prof. Dr.

Anpassung der IDE von Lazarus unter dem

BMI-Rechner