die MFC
Die MFC oder Microsoft Foundation Classes sind ein Konzept, das es einem ermöglicht
schneller fertige laufende Windows - Anwendungen zu erstellen, als dies nur mit der
Win32 API möglich wäre. Man arbeitet daher mit einem Baukasten aus vorgefertigten
Quellcodeteilen, die selbst, da sie vor der Auslieferung getestet wurden, nicht
fehlerbehaftet sind.
Grundsätzlich geben die MFC jedem Programm, das mit ihnen erstellt wurde, ein Windows
"Look and Feel". Der Anwendungsassistent legt gleich die für den Anfang nötigen
von der MFC abgeleiteten Klassen an, in denen sich die WinMain - Funktion bereits
implizit befindet.
Aus welchen Klassen bestehen die MFC?
CObject ist die Basisklasse fast aller MFC - Klassen.
Die Applikationsklasse und das Anwendungsgerüst
C"ProjektName"App(Name zu Beginn frei wählbar) wird abgeleitet von CWinApp - von dieser Klasse darf es nur eine Instanz geben,
da ein Objekt einer von CWinApp abgeleiteten Klasse die laufende Applikation bildet. Diese von
CWinApp abgeleitete Klasse ist sehr wichtig, da der gesamte Rahmen des Programmablaufes in ihren
Methoden steckt! Die Methoden laufen nun auf dem einen global angelegten Objekt der Klasse.
Diesen Rahmen nennt man auch Anwendungsgerüst oder Application Framework.
Der Programmstart beginnt mit WinMain(Hauptfunktion), diese ruft AfxWinMain(Startfunktion für die MFC) auf, die ihrerseits
1. InitInstance(Erzeugen eines Fensters) und 2. die Methode Run(Nachrichtenschleife) aufruft.
Am Ende des Programms verzweigt Run nach ExitInstance(Schließen des Fensters), sonst, wenn keine neuen Nachrichten
vorliegen nach OnIdle(Leerlaufmethode). ExitInstance gibt auch zuvor reservierten
Speicher wieder frei.
Der Programmierer muss den Ablauf selbst wieder von OnIdle zu Run zurückbringen.
Sämtliche hier erwähnten Methoden des Anwendungsgerüstes werden von CWinApp geerbt.
Das Anwendungsgerüst besteht aus Klassen, Methoden und Strukturen, die Regeln zum Erstellen einer
Windows - Applikation enthalten. Ohne das Anwendungsgerüst hat man keinen Überblick über die Arbeit
mit MFC. An ein bestehendes MFC - Anwendungsgerüst kann man auch Funktionen mit der Win32 API
dranstricken.
Es ist wichtig, darauf zu achten möglichst keine Initialisierungen im Konstruktor vorzunehmen, da
dieser oft erst nach Erzeugung eines entsprechenden Fensters aufgerufen wird und die zu initialisierenden
Objekte daher noch gar nicht sichtbar sein können. Hierfür eignet sich eher die Methode InitInstance.
Andere Klassen
CMainFrame wird vom Anwendungsassistenten erstellt und von CFrameWnd abgeleitet,
CChildView entsteht auf die gleiche Weise aus CView.
Je nach ausgewählten Optionen stellt der Anwendungsassistent unterschiedliche Klassen für den
Anfang eines Programms zusammen.
Die MFC haben über 200 Klassen, die teilweise von einander abgeleitet sind, so wie
CCmdTarget von CObject, CWnd von CCmdTarget, CFrameWnd, CDialog und CView von CWnd.
Erstellung von Programmen
Um unter Verwendung der Microsoft Foundation Classes ein Programm zu erstellen,
verwendet man den Anwendungsassistenten für eine .exe - Datei.
Beim Auswählen der Optionen im Anwendungsassistenten sollte man sorgfältig überlegen,
welche Features das zu erstellende Programm haben soll. So sollte man die Dokument - Anwendungs -
Architektur, nur für größere Projekte verwenden, da wo es Sinn macht, die
Daten wirklich so strikt von den Komponenten mit Funktionalität
des Programms zu trennen, wie es dieses Feature tut. Die Dokument - Ansichts - Architektur
ist selbst ein Teil des Anwendungsgerüstes (Application Framework, abgekürzt afx "Application Frameworx").
Die Datenbankanbindung sollte man ebenfalls wirklich nur dann verwenden, wenn man auch eine
Datenbank einbinden will. Auch auf die ActiveX Steuerelemente kann man meistens verzichten.
Am besten kompiliert man erstmal nach der Erstellung, um zu sehen, ob alles fehlerfrei ist,
danach kompiliert man nach jeder Änderung, um Fehler dann zu bemerken, wenn sie auftreten.
Um nach Beendung des Anwendungsassistenten, weitere Funktionen, Klassen, oder Membervariablen
der Klassen hinzuzufügen, nimmt man den Klassenassistenten, den man mit Rechtsklick aufruft.
Außerdem gilt es noch, die Resourcen den individuellen Bedürfnissen anzupassen. Dafür geht man in den
Resourcenbereich und sieht sich an, was man schon hat:
Meistens ein Hauptmenü, namens IDR_MAINFRAME mit den Einträgen Datei, Bearbeiten, Ansicht und '?',
sowie eine Dialogbox mit dem Titel IDC_ABOUT, auf der "Programmname, version 1" zu lesen ist.
Man geht nun also hin, erstellt eigene Menüeinträge und Dialogboxen, die man immer mit dem
Menüeintrag "Layout" der Entwicklungsumgebung anpassen sollte, damit die einzelnen Elementfenster
der Dialogbox nicht schief zueinander stehen. Unter "layout" lässt sich auch eine Vorschau anzeigen.
Links im Fenster "Arbeitsbereich" werden die einzelnen Ressourcen angezeigt.
Nach Rechtsklick auf den Hauptordner erhält man die Möglichkeit, sich die IDs
der Resourcensymbole anzeigen zu lassen, also deren ganzzahlige, vorzeichenlose Nummern.
Mit dem Klassenassistenten lassen sich die Dialogboxen nun einbinden.
Mit Rechtsklick auf die selbst erstellte Dialogbox(oder auch irgendeine Quellcode - Datei) wird der
Klassenassistent aufgerufen. Hier sollte man nun eine neue von CDialog abgeleitete Klasse erstellen.
Sie ist per Voreinstellung der neu erstellten Dialogbox zugeordnet.
Für Ein- und Ausgabefelder der Dialogbox, wie z.B. Textfelder, sollte man im Klassenassistenten
Membervariablen anlegen, damit man sie später im Quellcode ein- und auslesen kann.
Um nun den Elementen der Dialogbox Funktionalität zu unterlegen, braucht man Funktionen, die z.B.
hinter den Mausklick auf einen Button gelegt werden.
Nach ihrer Erstellung mit dem Klassenassistenten wählt man die Option "Code bearbeiten".
Der Befehl für die Anzeige einer modalen Dialogbox(d.h. das Programm geht erst weiter, wenn die Dialogbox
beendet wird) lautet "DoModal( )". Er wird als Methode der von CDialog abgeleiteten Dialogklasse
nach Erstellung einer Instanz mit dem Punktoperator aufgerufen.
Modularität
Um ein MFC - Programm auf einer anderen MS - VC++6 Entwicklungsumgebung oder auf einem anderen
Rechner laufen zu lassen, erstellt man ein leeres Win32 - Projekt und fügt dann alle .cpp, .h
und .rc - Dateien ein, außerdem alle Resourcen.
Grundsätzlich kann man auch einzelne Komponenten wieder verwenden, doch muss man hier äußerst
vorsichtig sein, keine Fehler zu verursachen. Sofern man nicht genau weiß, was man tut, sollte
man den grau unterlegten Quelltext des Klassenassistenten auch nicht verändern, ebensowenig, wie
diese bestimmten Kommentare, die der Klassenassistent als Markierungen verwendet, z.B . :
//{{AFX_MESSAGE_MAP...
Die Verwendung des Debuggers empfiehlt sich überall, wo logische Fehler entstehen, die der
Compiler nicht gemeldet hat.
MFC und Datenbanken
Zunächst sollte man eine Datenbank anlegen. Wenn die Datenbank nicht zu groß werden soll,
empfiehlt es sich sofern man Windows benutzt, Access zu verwenden. Access Datenbank Treiber
können über ODBC(Open Database Connectivity), oder DAO angebunden werden.
Andere Datenbanken können nur über ODBC eingebunden werden.
Die ODBC - Schnittstelle gehört zum Betriebssystem und findet sich unter START - SYSTEMSTEUERUNG
- ODBC, oder START - SYSTEMSTEUERUNG - VERWALTUNG - ODBC,
je nachdem ob man unter Win9x oder NT arbeitet. Nun geht man vor, wie folgt:
1) Art der Datenquelle, z.B. "MS - Access - Datenbank" wählen.
2) Hinzufügen
3) Einen Namen für die Treiberanbindung der DB geben
4) Die konkrete DB auswählen und so verbinden.
SQL - Befehle für Access
Einbinden der DB in ein MFC - Programm
1) Eine Klasse von CRecordset ableiten. Diese Klasse darf nur auf eine einzige Tabelle der Datenbank
zugreifen, da sonst ein Durcheinander entsteht. Der abgeleitete Recordset, z.B.: CMyRecordset1
(für die erste Tabelle) enthält dann von vorn herein schon Membervariablen, die jedem Datenfeld
der gewählten Tabelle der Datenbank entsprechen. Kombinierte Abfragen über mehrere Tabellen
sind mit dem DB-Zugriff über mehrere Recordsets möglich.
2) Die Membervariablen des Recordsets müssen nun Membervariablen der Dialogklasse zugewiesen werden
und umgekehrt. Dafür müssen die Membervariablen der Dialogklasse
selbst im Klassenassistenten hinzugefügt werden. Sie entsprechen je einem Ein- oder
Ausgabefeld in der Dialogbox.
3) Um nun die Sache ans Laufen zu bringen, muss man den Inhalt der Membervariablen einer
Instanz der Dialogfensterklasse an die Membervariablen einer Instanz der Recordsetklasse
zuweisen - für die Eingabe in die Datenbank über unser MFC - Programm.
Für die Ausgabe ist es umgekehrt:
Man weist die Inhalte der Variablen der Recordsetklasse über ein Objekt den Membervariablen
der Dialogfensterklasse zu, um sie im Dialogfenster anzeigen zu können.
Weiter mit Java
Objektorientierte Modellierung