Mein Programm soll:
 >> Spektren graphisch darstellen koennen
UND
 >> das Fenster in dem sich die Graphik befindet, soll vergrosser- und verkleinerbar sein!
Das bedeutet, dass die Inhalte des Fensters, also die Zeichnung (und daher auch alle Elemente der Zeichnung) automatisch an die aktuelle Fenstergroesse angepasst werden muessen.
Klingt sehr kompliziert, ist es auch!
Gluecklicherweise bietet der Device Context ein Attribut an, mit welchem sich dieses riesen Problem verhaeltnismaessig einfach loesen laesst, den Mapping Mode. Dieses Attribut wandelt logical coordinates (User-definierte Koordinaten) in device coordinates (Koordinaten in pixels innerhalb eines Fensters) um. Der Umgang mit dem Mapping Mode benoetigt jedoch einiges an Uebung viele ausgiebige Tests.

Grundsaetzlich sind Koordinaten innerhalb eines Fensters (device coordinates) immer relativ zu der linken oberen Ecke des Fensters. Die positive X-Achse zeigt nach rechts waehrend die positive Y-Achse nach unten zeigt. Mit Hilfe des Mapping Modes kann man den Ursprung (der normalerweise in der linken oberen Ecke ist) an jede beliebe Stelle bewegen, die Ausrichtung der Achsen und sogar die Skalierung der Achsen beliebig modifizieren. Der Fantasie des Programmierers sind hier wirklich keine Grenzen gesetzt...

to be continued...

Wenn man etwas in ein Fenster zeichnen moechte - einen Text oder verschiendenste Zeichnungen - so kommen GDI (Graphics Device Interface) und DC (Device Context) zum Einsatz. GDI ist eine Komponente die zischen der Applikation und den Grafik Hardwretreibern steht und mit einfachen Mechanismen dafuer sorgt, dass jedes Programm auf korrekte Art und Weise in ein Fenster zeichnet.
Versucht nun ein Programm in ein Fenster oder fuer einen Drucker zu zeichnen, so schickt es nicht pixel zu diesem Apparat. Statt dessen ist ein so genannter device context das Ziel aller Zeichenoperationen.

Wie ich bereits erwaehnt habe, geschieht saemtliches GUI (Graphical User Interface) Management durch die View, und so auch alle Zeichenvorgaenge (egal ob fuer den Bildschirm oder den Drucker).
OnScreen Darstellungen im Fenster werden grundsaetzlich mit CView's OnDraw Funktion realisiert.
Leitet man nun eine eigene Klasse (z.B: CMyView) von CView ab, so muss man eben diese Methode ueberschreiben, um eigenen Zeichencode hinzufuegen zu koennen.

1      void CMyView::OnDraw( CDC* pDC )
2      {
3           CMyAppDoc* pDoc = (MyAppDoc*) GetDocument( );
4            ASSERT_VALID( pDoc );
5           if ( ! pDoc )
6                 return;
7
8            CBrush brush( RGB(255, 0, 0) );
9            CRect clientRect;
10         GetClientRect( &clientRect );
11         pDC->FillRect( clientRect, &brush );
12    }

Zuerst wird die Funktion definiert (1). Als Parameter bekommt die Methode einen Pointer auf den Device Context. Anschliessend wird eine temporaere Variable vom Typ CMyAppDoc* definiert und ihr wird ein Pointer auf das Document dieser Applikation zugewiesen. Da jedoch CView's GetDocument() eigentlich einen Point auf ein CDocument - und nicht einen Pointer auf ein CMyAppDoc - Objekt zurueckliefert, muss auf dem von der Methode zurueckgelieferten Pointer mittels (MyAppDoc*) ein type cast (Typen Umwandlung) durchgefuehrt werden (3). Danach wird versichert, dass der eben erhaltene Pointer auch gueltig ist (4) und sollte der Pointer NULL sein (5), so wird die Methode beendet (6).
Eigentlich wird in dieser Methode kein Pointer auf das Document benoetigt, doch da in den meisten Faellen sehr wohl Daten von dem Document benoetigt werden, habe ich diesen Code hinzugefuegt.
Anschliessend werden ein roter Pinsel(8), sowie ein Rechteck definiert (9), dann werden diesem Rechteck die Koordinaten der client area des Windows uebergeben (10). Hier ist noch hinzuzufuegen, dass der Methode GetClientRect(LPRECT lpRect) ein Pointer auf ein Rechteck uebergeben werden muss, der dann mit den entsprechenden Daten gefuellt wird. Dies wird mit dem & Operator realisiert.
Zum Schluss wird noch ein rotes gefuelltes Rechteck ueber die gesamte Flaeche des Fensters (genauer gesagt ueber die client area des Fensters) gezeichnet (11).
Selbstverstaendlich koennten noch biliebig viele andere Zeichenoperationen hinzugefuegt werden. Sie alle werden auf dem Pointer auf den device context ausgefuehrt.

Wenn ein Programm lediglich ueber ein Document verfuegt, so spricht man von einem Single Document Interface (SDI). Relativ simple Programme wie MIcrosoft Notepad aber auch ziemlich komplexe Programme wie Microsoft Internet Explorer sind SDI.
Eine typische Charakteristik von SDIs ist, dass solche Programme nur ein Haupfenster, aber keine ChildFrames besitzen. Dies kommt daher, da durch die Tatsache, dass die Anwendung nur ueber ein Document verfuegt, und somit auch nur eine Datei geladen und angezeit werden kann.
Neben diesen SDIs bieten MFC dem Programmierer ausserdem noch die Moeglichkeit, so genannte Multiple Document Interfaces zu verwenden. Sehr komplexe Programme wie das Microsoft Word oder Excell sind MDIs.
Solche Anwendungen verfuegen nicht nur ueber ein Hauptfenster sondern auch ueber beliebig viele ChildFrames, was dem User ermoeglicht mehrere Dateien gleichzeitig zu oeffnen und gegebenen Falls auch zu vergleichen.

Mein Programm soll dem User eben diese Moeglichkeit geben. Es muss also ein MDI sein!

Jedes Mal wenn der User im Menu New waehlt, wird ein neues Document generiert, welches vollkommen unabhaengig von den anderen ist.

Bei der Document/View Architecture handelt es sich um einen von MFC angebotenen Programmierstil, der eine sehr ordentliche und uebersichtliche Strukturierung einer Anwendung zulaesst.
Die Anwendung wird in 5 Grundbausteine Zerlegt:

- die Application Class: Sie ist der Grundbaustein von jeder Anwendung und wird von CWinApp abgeleitet. Diese Klasse kuemmert sich um die Registry entries, kreiert ein so genanntes Document Template (bestehend aus ChildFrame, Document und View) und den MainFrame. Ausserdem schickt sie Nachrichten - so genannte Messages - an das Hauptfenster (Main Frame)

- der MainFrame: Er bildet die physische Arbeitsflaeche einer Applikation auf dem Bildschirm und ist also das Top-lever window. Das Hauptfenster laedt ausserdem das Haupt Menu und jegliche Icons und kreiert sowohl die Toolbar als auch die Statusbar.

- der ChildFrame: Er dient als Container fuer die View und befindet sich "innerhalb" des Hauptfensters. Dieser Frame laedt weiters - falls vorhanden - ein ChildFrame Menu und passt die View in der Groesse an, falls das Frame Window in der Groesse veraendert wird.

- das Document: Es behaelt saemtliche Daten der Applikation und wickelt auch alle Bearbeitungen der Daten selbststaendig ab. Weiters bietet das Document oeffentliche Funktionen (member functions), damit andere Objekte - hauptsaechlich Views - auf seine Daten Zugriff haben. Auch fuer die Serialisierung aller Daten ist das Document verantwortlich.

- die View: Rendert visuelle Repraesentierungen eines Documents auf dem Bildschirm und wandelt den Input (hauptsaechlich mouse oder keybord messages) in Anweisungen um, die mit den Daten des Documents arbeiten.

All diese Bausteine interagieren waehrend der Runtime (Laufzeit) eines Programmes miteinander und verarbeiten so jegliche Ereignisse des Systems.
Durch die strickte Trennung zwischen den Daten einer Applikation und der Schnittstelle zum User Interface bleiben selbst sehr komplexe Applikationen noch ueberschaubar und das User Interface ist relative unabhaengig und kann auch leichter modifiziert werden.

Im Gegensatz zu einigen anderen Programmiersprachen wird in C++ zwischen Pointern auf die Speicherplaetze der einzelnen Variablen und den Werten der Variablen unterschieden.

Wenn man eine einfache int Variable definieren will und ihr den Wert 5 zuweisen moechte, so geschieht dies auf folgenden Weg:

int nVar = 5;

Beim Definieren eines Pointers auf eine int Variable kommt der * Operator zum Einsatz:

int* pnVar;

Um nun von int nach int* zu konvertieren, um also von einem Wert den Pointer zu bekommen, ist der & Operator notwenid:

int nVar = 5;
int* pnVar = &nVar;

Dieser & Operator liefert die Adresse, an der der Wert einer bestimmten Variablen gespeichert ist, zurueck.
Will man hingegen von int* nach int konvertieren, also den Wert einer Variablen, die an einem bestimmten Ort gespeichert ist, erhalten, so benoetigt man den * Operator:

int nWert = *pnVar;

Dieser *Operator liefert im Gegensatz zu dem vorher erwaehnten & Operator den Wert einer Variablen, die an einer bestimmten Adresse gespeichert ist.

Auch beim Aufruf von Methoden eines bestimmten Objekts spielt es eine Rolle ob es sich um einen Pointer handelt oder nicht.
Wenn man beispielsweise einen Pionter auf das Hauptfenster einer Applikation namens pMainFrm hat, wird der Titel dieses Hauptfensters wie folgt ermittelt:

CString strTitle = pMainFrm->GetTitle();

Wenn es sich jedoch nicht um einen Pointer handelt, so muss dieselbe Methode auf folgende Art und Weise aufgerufen werden (die Variable wurde von pMainFrm nun auf mainFrm umbenannt):

CString strTitle = mainFrm.GetTitle();

Um auf jegliche members eines Pointers auf ein Objekt zugreifen zu koennen ist der -> Operator notwendig, waehrend dies bei "normelen" Variablen mit . geschiet.