Previous Page TOC Index Next Page See Page

1

Erstellen Sie Ihre erste Anwendung

Visual C++ kann Code nicht nur kompilieren, sondern auch generieren. Sie können innerhalb von Minuten eine Windows-Anwendung erstellen, indem Sie den Anwendungs-Assistenten aufrufen, damit er eine »Startanwendung« mit der gewünschten Windows-Codegrundstruktur für Sie erstellt. Der Anwendungs-Assistent ist ein leistungsstarkes Tool. Er kopiert den Code, den fast alle Windows-Anwendungen benötigen, in Ihre Anwendung. Schließlich sind Sie nicht der erste Programmierer, der eine Anwendung benötigt, die über Merkmale wie die Schaltflächen Minimieren und Maximieren und das Menü Datei mit den Befehlen Öffnen, Schließen, Seite einrichten, Drucken und Beenden, verfügt.. n

Erstellen einer Windows-Anwendung

Der Anwendungs-Assistent kann erstellen im Ueberblick Windows-Anwendungenerstellen im Ueberblick viele unterschiedliche Anwendungen erstellen. Häufig braucht man ein ausführbares Programm (.EXE). Meist soll der Anwendungs-Assistent auch die Codegrundstruktur aufbauen: die Klassen, Objekte und Funktionen, die jedes Programm benötigt. Um ein solches Programm zu erstellen, wählen Sie im Menü Datei den Befehl Neu und klicken im Dialogfeld Neu auf das Register Projekte (siehe Abbildung 1.1)

Abbildung 1.1: Im Register Projekte des Dialogfelds Neu können Sie festlegen, welcher Anwendungstyp erstellt werden soll.

siehe Abbildung

.

Markieren Sie im linken Listenfeld die Option MFC-Anwendungs-Assistent (exe), geben Sie einen Projektnamen ein, und aktivieren Sie die Schaltfläche OK. Der Anwendungs-Assistent durchläuft dann mehrere Schritte. Bei jedem Schritt müssen Sie entscheiden, welche Eigenschaften Ihre Anwendung haben soll, und betätigen abschließend die Schaltfläche Weiter. Sie haben auch die Möglichkeit zu einem der vorherigen Schritte zurückzukehren, indem Sie die Schaltfläche Zurück anklicken, oder Sie können die Schaltfläche Abbrechen aktivieren, um den Vorgang abzubrechen. Aktivieren Sie die Schaltflächen Hilfe, um Details zu erfahren bzw. Fertigstellen, um die Anwendung sofort zu erstellen, ohne die übrigen Schritte zu durchlaufen und weitere Fragen zu beantworten. In den folgenden Abschnitten wird jeder dieser Schritte beschrieben.

Schritt 1 û Wie viele Dokumente soll die Anwendung unterstützen?

Als erstes müssen Sie dem Anwendungs-Assistenten mitteilen, ob Sie eine MDI- oder SDI-Anwendung Unterstuetzungsoptionen fuer Anwendungen Unterstuetzungsoptionen fuer Dokumenteerstellen wollen, oder ob die Anwendung dialogfeldbasierend aufgebaut sein soll. Der Anwendungs-Assistent generiert für jeden dieser Anwendungstypen einen anderen Code und andere Klassen.

Sie können zwischen folgenden drei Arten von Anwendungen wählen:

Abbildung 1.2: Als ersten Schritt beim Erstellen einer typischen Anwendung mit dem Anwendungs-Assistenten bestimmen Sie den Typ der Benutzerschnittstelle.

siehe Abbildung

Abbildung 1.3: Die Zeichentabelle ist eine dialogfeldbasierte Anwendung.

siehe Abbildung


Dialogfeldbasierte Anwendungen unterscheiden sich grundlegend von MDI- und SDI-Anwendungen. Zum Erstellen von dialogfeldbasierten Anwendungen verfügt der Anwendungs-Assistent über eigene Dialogfelder. Sie werden weiter unten im Abschnitt 1.2 »Erstellen einer dialogfeldbasierten Anwendung« beschrieben.

Weiter unten im Dialogfeld finden Sie ein Dropdownfeld, in dem Sie festlegen können, in welcher Sprache Ihre Ressourcen erstellt werden sollen. Achten Sie beim Wählen der Sprache darauf (z.B. German [Standard]), daß Sie Ihre Systemsprache entsprechend festlegen. Andernfalls kann es zu unerwarteten Reaktionen beim Klassen-Assistenten kommen. Wenn Sie Ihre Wahl getroffen haben, klicken Sie auf die Schaltfläche Weiter.

Schritt 2 û Datenbanken

Im zweiten Schritt beim Erstellen eines ausführbaren Windows-Programms mit dem Anwendungs-Assistenten legen Sie fest, welche Form der Datenbankunterstützung verwendet werden soll Datenbankunterstuetzung bei Anwendungen(siehe Abbildung 1.4).

Folgende Optionen stehen Ihnen zur Verfügung:

Abbildung 1.4: Im zweiten Schritt beim Erstellen einer typischen Anwendung mit dem Anwendungs-Assistenten legen Sie fest, welche Form der Datenbankunterstützung Sie verwenden wollen.

siehe Abbildung

In Kapitel 22 »Zugriff auf Datenbanken« werden diese Optionen näher erklärt und die Programmierung von Datenbanken mit den MFC aufgezeigt. Haben Sie eine Datenbankansicht gewählt, müssen Sie nun eine Datenquelle angeben. Klicken Sie auf die Schaltfläche Datenquelle, um weitere Angaben zu machen.

Schritt 3 û Unterstützung für Verbunddokumente

Der dritte Schritt des Anwendungs-Assistenten zum Erstellen eines ausführbaren Windows-Programms betrifft die Option, welche Unterstützung für Verbunddokumente eingebunden werden soll Unterstuetzung fuer Verbunddokumente fuer Verbunddokumente in Anwendungen Unterstuetzung in Anwendungen (siehe Abbildung 1.5). OLE (Object Linking and Embedding) heißt nun offiziell ActiveX, um die jüngsten technologischen Neuerungen zu verdeutlichen, die durch die MFC-Klassen größtenteils gekapselt werden. Kapitel 13 »Grundlagen von ActiveX« beschreibt diese Technologie im Detail.

Abbildung 1.5: Im dritten Schritt beim Erstellen einer typischen Anwendung mit dem Anwendungs-Assistenten legen Sie die Unterstützung für Verbunddokumente fest.

siehe Abbildung

Für die Unterstützung von Verbunddokumenten stehen Ihnen fünf Optionen zur Verfügung:

Wenn Sie sich dafür entscheiden, Verbunddokumente zu unterstützen, können Sie auch Verbunddateien unterstützen. Verbunddateien enthalten ein oder mehrere ActiveX-Objekte und werden auf besondere Art gespeichert, so daß eines der Objekte geändert werden kann, ohne daß die gesamte Datei neu erstellt werden muß. Das kann viel Zeit sparen. Verwenden Sie die Optionsfelder in der Mitte des Dialogfeldes in Schritt 3, und wählen Sie die Option Ja, bitte bzw. Nein, danke, um festzulegen, ob Sie die Unterstützung von Verbunddateien wünschen.

Sollen andere Anwendung durch Automatisierung die Steuerung Ihrer Anwendung übernehmen können, aktivieren Sie das Kontrollkästchen Automatisierung. (Die Automatisierung ist auch das Thema von Kapitel 16 »Erstellen eines Automatisierungs-Servers«.) Wenn Ihre Anwendung ActiveX-Steuerelemente verwenden soll, aktivieren Sie das Kontrollkästchen ActiveX-Steuerelemente.


Soll Ihre Anwendung ein ActiveX-Steuerelement sein, so erstellen Sie keine typische Anwendung, wie sie in diesem Abschnitt beschrieben wird. Das Erstellen von ActiveX-Steuerelementen mit dem ActiveX-Steuerelement-Assistenten wird in Kapitel 17 »Erstellen eines ActiveX-Steuerelements« beschrieben.

Schritt 4 û Anzeige und andere Optionen

Im vierten Schritt des Anwendungs-Assistenten zum Erstellen eines ausführbaren Windows-Programms (siehe Abbildung 1.6) können Sie Oberflächenanzeigeoptionen Oberflaechenanzeigeoptionenfuer Anwendungen für Ihre Anwendung festlegen. Das Dialogfeld Schritt 4 enthält eine Reihe voneinander unabhängiger Kontrollkästchen; aktivieren Sie die Merkmale, die eingebunden werden sollen.

Abbildung 1.6: Im vierten Schritt beim Erstellen einer typischen Anwendung mit dem Anwendungs-Assistenten legen Sie bestimmte Oberflächen-Merkmale fest.

siehe Abbildung

Folgende Optionen verändern die Oberflächenanzeige:

Sie können für die Anwendung auch festlegen, wie viele Dateien in der Liste der zuletzt verwendeten Dateien stehen sollen. Standardmäßig werden vier Dateien angezeigt. Ändern Sie die Einstellung nur, wenn Sie guten Grund dazu haben.

Aktivieren Sie in Schritt 4 im unteren Bereich des Dialogfeldes die Schaltfläche Weitere Optionen, wird das Dialogfeld Weitere Optionen angezeigt. Es hat zwei Register: das Register Zeichenfolgen für Dokumentvorlage sehen Sie in Abbildung 1.7. Der Anwendungs-Assistent erstellt viele Namen und Eingabeaufforderungen aus dem Namen der Anwendung, mitunter muß der Name der Anwendung abgekürzt werden. Solange Sie mit den Namen, die der Anwendungs-Assistent erstellt, noch nicht vertraut sind, sollten Sie diese im Dialogfeld Zeichenfolgen für Dokumentvorlage prüfen und wenn nötig ändern. Sie können auch die Beschriftung des Hauptfensters, die in der Titelleiste der Anwendung erscheint, ändern. Wählen Sie die Option der Dateierweiterung, so gilt Sie für Dateinamen, die von Ihrer Anwendung gespeichert werden, und begrenzt die Anzahl der Dateien, die angezeigt werden, wenn der Anwender im Menü Datei den Befehl Öffnen wählt.

Abbildung 1.7: Im Dialogfeld Weitere Optionen können Sie im Register Zeichenfolgen für Dokumentvorlage die Abkürzung von Namen festlegen.

siehe Abbildung

Das Register Fensterstile ist in Abbildung 1.8 dargestellt. Hier können Sie die Anzeige Ihrer Anwendung grundlegend verändern. Das erste Kontrollkästchen Geteiltes Fenster verwenden fügt sämtlichen Code hinzu, der für die Implementierung von geteilten Fenstern (wie z.B. die Fenster im Code-Editor des Developer Studios) benötigt wird. In den übrigen Optionen des Dialogfelds Fensterstile können Sie die Anzeige Stile des Hauptrahmens und für MDI-Anwendungen die Anzeige Stile der untergeordneten MDI-Rahmen festlegen. Mit Rahmen sind hier die Ränder der Fenster gemeint. Das Systemmenü, die Titelleiste, die Schaltflächen Minimieren und Maximieren und die Fensterränder gehören alle zu den Rahmeneigenschaften. Der Hauptrahmen enthält Ihre ganze Anwendung. Eine MDI-Anwendung hat eine Reihe von untergeordneten MDI-Rahmen: einen für jedes Dokumentfenster innerhalb des Hauptrahmens.

Abbildung 1.8: Im Dialogfeld Weitere Optionen können Sie im Register Fensterstile die Anzeige der Fenster festlegen.

siehe Abbildung

Sie können folgende Eigenschaften für Rahmen festlegen:

Haben Sie die gewünschten Optionen aktiviert, klicken Sie auf die Schaltfläche Schließen, um zu Schritt 4 zurückzukehren. Dann aktivieren Sie die Schaltfläche Weiter, um zum nächsten Schritt überzugehen.

Schritt 5 û Weitere Optionen

Im fünften Schritt des Anwendungs-Assistenten beim Erstellen eines ausführbaren Windows-Programms (siehe Abbildung 1.9) können Sie alle übrigen Optionen festlegen, die nichts mit Menüs, OLE, Zugriff auf Datenbanken oder Anzeige zu tun haben.

Sollen Kommentare in Quellcodedateien erzeugt werden? Sicherlich wollen Sie das, und somit läßt sich diese Frage leicht beantworten.

Der nächste Punkt ist vielleicht nicht so einfach. Soll die MFC-Bibliothek als gemeinsam genutzte DLLs oder als statisch verknüpfte Bibliothek verwendet werden? Eine DLL (Dynamic Link Library) ist eine Sammlung von Funktionen, die von vielen verschiedenen Anwendungen verwendet werden. Die Verwendung von DLLs reduziert die Größe Ihrer Programmdatei, macht die Installation jedoch etwas komplexer. Haben Sie ein ausführbares Programm schon einmal auf einen anderen Rechner kopiert und mußten dann feststellen, daß es aufgrund der nun fehlenden DLLs nicht mehr läuft? Wenn Sie die MFC-Bibliothek mit Ihrer Anwendung statisch verknüpfen, ist die Anwendung größer, dafür aber leichter zu bewegen und zu kopieren.

Sind die Anwender Ihrer Anwendung ebenfalls Entwickler und besitzen wenigstens eine andere Anwendung, die die MFC-DLLs verwendet, oder es macht ihnen nichts aus, neben dem Programm selbst auch die DLLs zu installieren, wählen Sie die Option der gemeinsam genutzten DLLs. Die kleinere ausführbare EXE-Datei ist für alle angenehmer. Sind die Benutzer Ihrer Anwendung keine Entwickler (was der häufigere Fall sein wird), wählen Sie die statisch verknüpfte Option. Damit reduzieren Sie die Anfragen für technische Unterstützung von seiten unerfahrener Anwender. Wenn Sie ein gutes Installationsprogramm schreiben, können Sie bzgl. der Verwendung gemeinsam genutzter DLLs zuversichtlich sein.

Abbildung 1.9: Im fünften Schritt beim Erstellen einer Anwendung mit dem Anwendungs-Assistenten legen Sie die Optionen für Kommentare und die MFC-Bibliothek fest.

siehe Abbildung

Schritt 6 û Datei- und Klassennamen

Im letzten Schritt des Anwendungs-Assistenten beim Erstellen eines ausführbaren Windows-Programms können Sie die Klassen- und Dateinamen, die der Anwendungs-Assistent für Sie erstellt hat, bestätigen (siehe Abbildung 1.10). Der Anwendungs-Assistent verwendet den Namen des Projekts (in diesem Beispiel FirstSDI) zum Erstellen der Klassen- und Dateinamen. Es ist selten nötig, die Namen zu ändern. Enthält Ihre Anwendung eine Ansichtsklasse, können Sie die Klasse, von der sie abgeleitet ist, ändern. Standardmäßig werden Ansichtsklassen von der Klasse CView abgeleitet, aber viele Entwickler bevorzugen die Klassen CScrollView oder CEditView. Näheres über die acht verfügbaren Ansichtsklassen können Sie in Kapitel 5 »Dokumente und Sichten« nachlesen. Wenn Sie die Optionen in Schritt 6 festgelegt haben, aktivieren Sie die Schaltfläche Fertigstellen.

Abbildung 1.10: Im letzten Schritt beim Erstellen einer typischen Anwendung mit dem Anwendungs-Assistenten bestätigen Sie die Datei- und Klassennamen.

siehe Abbildung

Erstellen der Anwendung

Nachdem Sie die Schaltfläche Fertigstellen aktiviert haben, zeigt der Anwendungs-Assistent im Dialogfeld Neue Projektinformationen (siehe Abbildung 1.11) die Angaben der zu erstellende Projektstruktur an. Sind Sie mit bestimmten Einstellungen nicht zufrieden, aktivieren Sie die Schaltfläche Abbrechen und kehren über die Schaltfläche Zurück zu dem Schritt im Anwendungs-Assistenten zurück, an dem Sie Änderungen vornehmen wollen. Dann aktivieren Sie wiederum die Schaltflächen Weiter und Fertigstellen, prüfen dieses Dialogfeld erneut und aktivieren anschließend die Schaltfläche OK, um die Anwendung wirklich zu erstellen.

Abbildung 1.11: Wenn der Anwendungs-Assistent bereit ist, Ihre Anwendung zu erstellen, haben Sie noch einmal die Möglichkeit, alle Entscheidungen zu bestätigen.

siehe Abbildung

Probieren Sie selbst

Haben Sie es nicht bereits getan, rufen Sie nun das Developer Studio auf. Wenn Sie das Developer Studio zum ersten Mal verwenden, sind Sie mit der Oberfläche noch nicht vertraut und fühlen sich vielleicht etwas unsicher. In Anhang B »Das Developer Studio« werden Symbolleisten, Menüs und sonstige Elemente des Developer Studios genau erklärt.

Rufen Sie den Anwendungs-Assistenten auf, indem Sie im Menü Datei den Befehl Neu wählen Menue Datei NeuNeu und das Register Projekte anklicken. Im Register Projekte geben Sie den Pfad an, in dem Ihre Anwendung gespeichert werden soll: Der Anwendungs-Assistent erstellt für jedes Projekt einen neuen Ordner. Geben Sie als Projektnamen FirstSDI ein, und durchlaufen Sie anschließend die sechs Schritte des Anwendungs-Assistenten. Aktivieren Sie in Schritt 1 die Option Einzelnes Dokument. Bei allen anderen Schritten behalten Sie die Standardeinstellungen bei und aktivieren jeweils die Schaltfläche Weiter. Wenn der Anwendungs-Assistent das Projekt erstellt hat, wählen Sie im Menü des Developer Studios die Option Erstellen, um den Code zu kompilieren und zu verknüpfen.

Wenn das Projekt fertig erstellt ist, wählen Sie im Menü Erstellen den Befehl Ausführen von FirstSDI.exe. Menue ErstellenMenue ErstellenAusfuehrenAusfuehren Sie verfügen nun über eine funktionsfähige und betriebsbereite Windows-Anwendung (siehe Abbildung 1.12). Sie können mit ihr experimentieren: ihre Größe ändern, minimieren und maximieren.

Machen Sie einen Versuch mit dem Menü Datei, und wählen Sie im Menü Datei DateienMenue DateiOeffnenOeffnen den Befehl Öffnen. Das vertraute Windows-Dialogfeld Datei öffnen wird angezeigt (allerdings passiert nichts weiter, ganz gleich, welche Datei Sie öffnen). Anschließend wählen Sie im Menü Datei den Befehl Beenden, um die Anwendung zu schließen. Menue DateiBeendenBeenden Gehen Sie mit dem Mauszeiger zu einer der Schaltflächen an der Symbolleiste, und halten Sie einen Moment inne: ein Quick-Info mit der Beschreibung dieser Schaltfläche wird angezeigt. Klicken Sie auf die Schaltfläche Öffnen, um festzustellen, ob die Schaltfläche mit dem früher gewählten Befehl Öffnen im Menü Datei verknüpft ist. Wählen Sie im Menü Ansicht den Befehl Symbolleiste, um die Symbolleiste auszublenden. Anschließend wählen Sie im Menü Ansicht den Befehl Symbolleiste erneut, um die Symbolleiste wieder einzublenden. Versuchen Sie das gleiche mit der Statusleiste. Wählen Sie im Menü Hilfe den Befehl Info über. Sie werden feststellen, daß das Dialogfeld Info über, wie bei anderen Windows-Anwendungen auch, den Namen, die Version und das Jahr des Copyrights enthält (siehe Abbildung 1.13.).

Wiederholen Sie diese Schritte, um eine MDI-Anwendung mit Namen FirstMDI zu erstellen. Der Erstellungsvorgang unterscheidet sich nur in Schritt 0, in dem Sie den Projektnamen angeben müssen, und in Schritt 1, in dem Sie die Option Mehrere Dokumente wählen. Übernehmen Sie die Standardeinstellungen für alle weiteren Schritte, lassen Sie die Anwendung erstellen, rufen Sie dann zuerst den Befehl Erstellen und anschließend den Befehl Ausführen auf. Das Ergebnis wird eine MDI-Anwendung mit einem einzigen geöffneten Dokument (siehe Abbildung 1.14) sein. Machen Sie die gleichen Versuche wie bei der Anwendung FirstSDI.

Abbildung 1.12: Ihre erste Anwendung hat alle Merkmale einer vollwertigen Windows-Anwendung.

siehe Abbildung

Abbildung 1.13: Diese Start-Anwendung enthält sogar das Dialogfeld Info über.

siehe Abbildung

Nun wählen Sie im Menü Datei den Befehl Neu und das zweite Fenster FirstM2 wird angezeigt. Versuchen Sie diese Fenster zu minimieren, zu maximieren und dann wiederherzustellen. Wechseln Sie mit den Befehlen im Menü Fenster zwischen den Fenstern. All diese Funktionen erhalten Sie vom Anwendungs-Assistenten, ohne auch nur eine Codezeile zu schreiben.

Abbildung 1.14: Eine MDI-Anwendung kann mehrere Dokumente gleichzeitig anzeigen.

siehe Abbildung

Erstellen einer dialogfeldbasierten Anwendung

Eine dialogfeldbasierte Anwendung enthält neben dem Systemmenü keine weiteren Menübefehle und kann Dateien weder speichern noch öffnen. Sie eignet sich für einfache Dienstprogramme wie die Windows-Zeichentabelle. Bei dialogfeldbasierten Anwendungen geht der Anwendungs-Assistent etwas anders vor, und zwar in erster Linie, weil diese Anwendungen nicht über Dokumente verfügen und somit weder den Zugriff auf Datenbanken noch auf Verbunddokumente unterstützen. Um eine dialogfeldbasierte Anwendung zu erstellen, rufen Sie den Anwendungs-Assistenten wie für die oben erstellten Anwendungen SDI und MDI auf. In Schritt 1 wählen Sie diesmal jedoch eine dialogfeldbasierte Anwendung (siehe Abbildung 1.15).

Abbildung 1.15: Um eine dialogfeldbasierte Anwendung zu erstellen, geben Sie in Schritt 1 des Anwendungs-Assistenten Ihre Präferenz an.

siehe Abbildung

Wählen Sie die Option Dialogfeldbasierend, und klicken Sie anschließend auf die Schaltfläche Weiter, um zu Schritt 2 zu gelangen (siehe Abbildung 1.16).

Soll die Anwendung ein Dialogfeld Info im Systemmenü enthalten, aktivieren Sie die entsprechende Option. Damit der Anwendungs-Assistent das Grundgerüst für Hilfe erstellt, wählen Sie die Option Kontextabhängige Hilfedialogfeldbasierende Anwendungendialogfeldbasierendkontextabhaengige Hilfe kontextabhaengige Hilfe . Das dritte Kontrollkästchen 3D-Steuerelemente sollte für Windows 95- und Windows NT-Anwendungen in der Regel aktiviert sein. Wenn Ihre Anwendung, wie in Kapitel 16 »Erstellen eines Automatisierungs-Servers« beschrieben, durch Automatisierung die Unterstützung anderer Anwendungen einbinden soll, aktivieren Sie das Kontrollkästchen Automatisierung. Soll Ihre Anwendung über ActiveX-Steuerelemente verfügen, aktivieren Sie das Kontrollkästchen ActiveX-Steuerelemente. Wollen Sie, daß Ihre Anwendung mit Sockets über das Internet läuft, aktivieren Sie das Kontrollkästchen Windows-Sockets. Klicken Sie die Schaltfläche Weiter, um zu Schritt 3 des Anwendungs-Assistenten zu gelangen (siehe Abbildung 1.17).

Abbildung 1.16: In Schritt 2 des Anwendungs-Assistenten beim Erstellen einer dialogfeldbasierten Anwendung legen Sie die Einstellungen für Hilfe, Automatisierung, ActiveX und Sockets fest.

siehe Abbildung

Abbildung 1.17: In Schritt 3 des Anwendungs-Assistenten beim Erstellen einer dialogfeldbasierten Anwendung legen Sie die Optionen für Kommentare und die MFC-Bibliothek fest.

siehe Abbildung

Wie bei den bereits erstellten SDI- und MDI-Anwendungen sollen Kommentare in Quellcodedateien erzeugt werden. Bei der Entscheidung, ob die MFC-Bibliothek als gemeinsam genutzte DLL oder als statisch verknüpfte Bibliothek genutzt werden soll, gelten wieder die Kriterien, die auch für die SDI- bzw. MDI-Anwendung galten.

Sind die Benutzer Ihrer Anwendung vermutlich bereits im Besitz der MFC-DLLS (weil sie ebenfalls Entwickler sind oder weil sie eine andere Anwendung haben, die MFC-DLLs verwendet), oder es macht Ihnen nichts aus, die DLLs zusätzlich zu Ihrem Programm zu installieren, wählen Sie die Option der gemeinsam genutzten DLL. Andernfalls wählen Sie die Option für die statische Einbindung. Aktivieren Sie die Schaltfläche Weiter, um zum letzten Schritt zu gelangen (siehe Abbildung 1.18).

In diesem Schritt können Sie die Namen ändern, die der Anwendungs-Assistent für die Dateien und Klassen erstellt hat. Eine Änderung der Namen ist jedoch nicht immer zu empfehlen, da es Anwender, die mit Ihrem Code arbeiten, eher verwirrt, wenn die Dateinamen sich nicht logisch von den Klassennamen ableiten lassen und umgekehrt. Wenn Sie in diesem Dialogfeld feststellen, daß Sie mit der Wahl des Projektnamens nicht einverstanden sind, gehen Sie über die Schaltflächen Zurück zum Dialogfeld Neu zurück, ändern dort den Namen und aktivieren anschließend die Schaltfläche OK. Dann kehren Sie durch Klicken der Schaltflächen Weiter zum aktuellen Dialogfeld zurück. Aktivieren Sie die Schaltfläche Fertigstellen, um eine Zusammenfassung der Dateien und Klassen zu sehen, die erstellt werden sollen (siehe Abbildung 1.19).

Abbildung 1.18: In Schritt 4 des Anwendungs-Assistenten beim Erstellen einer dialogfeldbasierten Anwendung können Sie die Datei- und Klassennamen ändern.

siehe Abbildung

Abbildung 1.19: Der Anwendungs-Assistent bestätigt die Dateien und Klassen, bevor er sie erstellt.

siehe Abbildung

Sind Sie mit bestimmten Einstellungen nicht zufrieden, aktivieren Sie die Schaltfläche Abbrechen, oder kehren Sie über die Schaltfläche Zurück zu dem Schritt im Anwendungs-Assistenten zurück, wo Sie Änderungen vornehmen wollen. Dann aktivieren Sie wiederum die Schaltflächen Weiter und Fertigstellen, prüfen dieses Dialogfeld erneut und aktivieren anschließend die Schaltfläche OK, um die Anwendung wirklich zu erstellen.

Probieren Sie selbst

Erstellen Sie selbst eine leere dialogfeldbasierte Anwendung, und geben Sie ihr den Namen FirstDialog. Übernehmen Sie die Standardeinstellungen für jeden Schritt des Anwendungs-Assistenten. Ist die Anwendung vollständig, wählen Sie im Menü Erstellen die Option Erstellen, um die Anwendung zu kompilieren und zu verknüpfen. Wählen Sie im Menü Erstellen die Option Ausführen, um die Anwendung in Aktion zu sehen. Abbildung 1.20 zeigt die leere dialogfeldbasierte Anwendung bei der Ausführung.

Klicken Sie auf die Schaltfläche OK oder Abbrechen oder auf die Schaltfläche Schließen in der Ecke rechts oben, wird das Dialogfeld ausgeblendet. Klicken Sie auf das Systemmenü in der Ecke oben links, können Sie zwischen den Befehlen Verschieben, Schließen und Info über wählen. Abbildung 1.21 zeigt das vom Anwendungs-Assistenten erstellte Dialogfeld Info über.

Abbildung 1.20: Eine Start-Dialoganwendung enthält ein Erinnerungsfeld mit den Aufgaben, die noch zu erledigen sind.

siehe Abbildung

Abbildung 1.21: Für SDI-, MDI- und dialogfelbasierende Anwendungen wird das gleiche Dialogfeld Info über generiert.

siehe Abbildung

Erstellen von DLLs, Konsolenanwendungen und vieles mehr

Obwohl der Anwendungs-Assistent meistens zum Erstellen eine ausführbaren Programms verwendet wird, kann er auch andere Projekte erstellen. Wählen Sie, wie am Anfang des Kapitels erwähnt, im Menü Datei den Befehl Neu und anschließend das Register Projekte. Diesmal wählen Sie im Dialogfeld Neu aus der links angezeigten Liste (siehe Abbildung 1.1) jedoch einen anderen Assistenten. Unter den Projekten, die der Anwendungs-Assistent ebenfalls erstellen kann, sind folgende (bezogen auf die Professional Edition):

Diese Projekte werden in den folgenden Abschnitten näher erklärt.

Der ATL-COM-Anwendungs-Assistent

Der ATL-COM-Anwendungs-Assistent ist die Active Template Library und wird verwendet, um kleine (hinsichtlich der Dateigröße) ActiveX-Steuerelemente zu schreiben. Sie wird im allgemeinen von Entwicklern verwendet, die bereits Erfahrung mit dem Schreiben von ActiveX-Steuerelementen haben. Kapitel 17 »Erstellen eines ActiveX-Steuerelements« gibt eine Einführung in wichtigen Grundlagen für Steuerelemente und zeigt, wie ein MFC-Steuerelement erstellt wird. In Kapitel 21»Die Active Template Library« erfahren Sie alles über die ATL.

Benutzerdefinierte Anwendungs-Assistenten

Vielleicht arbeiten Sie in einer Firma, die auf das Programmieren von Anwendungen spezialisiert ist und daher viele Anwendungen erstellt. Obwohl Sie mit den Anwendungs-Assistenten eine Menge Zeit sparen können, verbringen Ihre Programmierer am Anfang jedes Projekts mitunter ein oder zwei Tage damit, Ihre eigene Codegrundstruktur, d.h. das Material, das Sie für jedes Ihrer Projekte übernehmen, einzufügen. Es mag sich unter Umständen für Sie lohnen, einen benutzerdefinierten Anwendungs-Assistenten zu erstellen, d.h. Ihren eigenen Anwendungs-Assistenten, der Ihre Codegrundstruktur sowie das Standard MFC-Material einfügt. Anschließend wird Ihr Anwendungstyp dem Listenfeld links im Register Projekte im Dialogfeld Neu hinzugefügt (siehe Abbildung 1.1). Näheres über das Erstellen und Verwenden von benutzerdefinierten Anwendungs-Assistenten finden Sie in Kapitel 25 »Wiederverwendung mit Gallery und eigenen Anwendungs-Assistenten«.

Datenbankenprojekt

Wenn Sie die Enterprise Edition von Visual C++ installiert haben, können Sie ein Datenbankenprojekt*** erstellen. Näheres dazu finden Sie im Kapitel 23 »Die Enterprise Edition«.

DevStudio Add-In-Assistent

Add-Ins sind ähnlich den Makros, die das Developer Studio automatisieren, aber sie werden in C++ oder einer anderen Programmiersprache geschrieben; für Makros wird dagegen die Sprache VBScript verwendet. Sie verwenden ActiveX-Automatisierung, um das Developer Studio zu steuern.

ISAPI-Erweiterungs-Assistent

ISAPI ist die Abkürzung für Internet Server API und bezieht sich auf Funktionen, die aufgerufen werden können, um mit dem Microsoft Internet Information Server (einem World-Wide-Web-Server-Programm) zu interagieren, der gerade ausgeführt wird. Sie können dieses API verwenden, um DLLs für Programme zu schreiben, die weit über das Suchen im Web und die Automatisierung von Informationen hinausgehen. Näheres über diesen Vorgang finden Sie in Kapitel 18 »Windows-Socket, MAPI und das Internet«.

Makefile

Wollen Sie ein Projekt erstellen, das andere Befehle wie Programme und Stapeldateien ausführt, wählen Sie diesen Assistenten aus dem linken Listenfeld im Register Projekte des Dialogfelds Neu. Es wird kein Code generiert.

Der MFC ActiveX-Steuerelement-Assistent

ActiveX-Steuerelemente sind Steuerelemente, die Sie selbst schreiben und die für-Visual C++-Dialogfelder, Visual-Basic-Formulare und sogar Web-Seiten verwendet werden können. Diese Steuerelemente sind der 32-Bit-Ersatz für die VBX-Steuerelemente, die viele Entwickler verwendeten, um intuitive Oberflächen zu gestalten oder Bedien- und Funktionselemente wiederzuverwenden. In Kapitel 17 »Erstellen eines ActiveX-Steuerelements« erfahren Sie genau, wie Sie mit diesem Assistenten Steuerelemente erstellen können.

MFC AppWizard (DLL)

Wählen Sie diesen Assistenten, wenn Sie mehrere Funktionen in einer DLL sammeln und MFC-Klassen verwenden wollen. (Verwendet die DLL keine MFC-Klassen, wählen Sie die Win32 Dynamic-Link Library, auf die weiter unten in diesem Kapitel eingegangen wird.) Näheres über das Erstellen einer DLL finden Sie in Kapitel 28 »Future Explorations«. Der Anwendungs-Assistent generiert den Code für Sie, bevor Sie selbst anfangen.

New Database Wizard

Dieser Assistent ist für diejenigen gedacht, die das Programm Visual InterDev installiert haben. Er vereinfacht den Vorgang, eine Web-Seite mit einer SQL-Datenbank zu verbinden.

Win32 Application

Mitunter wollen Sie mit Visual C++ eine Anwendung erstellen, die keine MFC-Klassen verwendet und nicht mit der vom Anwendungs-Assistenten generierten Codegrundstruktur beginnt. Um eine solche Anwendung zu erstellen, wählen Sie den AssistentenWin32 Application aus dem linken Listenfeld im Register Projekte, geben den Namen und das Verzeichnis für das Projekt ein und aktivieren Schaltfläche OK. Der Anwendungs-Assistent stellt keine weiteren Fragen, sondern erstellt die Projektdatei und öffnet diese. Sie müssen den gesamten Code komplett erstellen und die Dateien in das Projekt einfügen.

Win32 Console Application

Eine Konsolenanwendung ist einer DOS-Anwendung sehr ähnlich, wird jedoch in einem Fenster ausgeführt, das in der Größe angepaßt werden kann. Sie besitzt eine Oberfläche, die ganz auf Zeichen ausgerichtet ist, die Cursorbewegung erfolgt über die Tastatur und nicht über die Maus. Für den Dialog mit dem Anwender werden die Konsolen-API und zeichenabhängige E/A-Funktionen wie printf und scanf verwendet. Es wird keine Codegrundstruktur generiert, sondern nur ein leeres Projekt. In Kapitel 28 » Future Explorations« finden Sie Näheres über das Erstellen und Verwenden von Konsolenanwendungen.

Win32 Dynamic-Link Library

Wollen Sie eine DLL erstellen, die keine MFC-Klassen verwendet und keine Codegrundstruktur benötigt, wählen Sie vorzugsweise diese Option anstelle der Option MFC-Anwendungs-Assistent (dll). Ohne weitere Fragen wird umgehend ein leeres Projekt erstellt.

Win32 Static Library

Obwohl der Großteil des Codes, den Sie wiederverwenden, in einer DLL zusammengetragen wird, verwenden Sie vielleicht lieber eine statisch verknüpfte Bibliothek. Damit umgehen Sie, die DLL mit Ihrer Anwendung auszuliefern. Wählen Sie diesen Assistenten aus dem linken Listenfeld im Register Projekte im Dialogfeld Neu, um eine Projektdatei für eine statische Bibliothek zu erstellen.

Die Entscheidungen des Anwendungs-Assistenten ändern

Das Ausführen des Anwendungs-Assistenteneinfuegen (Anwendungs-Assistent)einfuegen(Anwendungs-Assistent) Code einfuegenist eine einmalige Angelegenheit. Zum Erstellen einer typischen Anwendung wählen Sie im Menü Datei den Befehl Neu, klicken auf das Register Projekte, geben einen Namen und ein Verzeichnis ein, wählen die Option MFC-Anwendungs-Assistent (exe), durchlaufen die sechs Schritte des Assistenten, erstellen die Startdateien der Anwendung und kommen danach mit dem Anwendungs-Assistenten nicht mehr in Berührung. Was machen Sie aber, wenn Sie beim Erstellen der Anwendung keine Online-Hilfe gewählt haben und erst später feststellen, daß Ihre Anwendung diese Option enthalten sollte?

Der Anwendungs-Assistent mag zwar wie ein Zauberkünstler erscheinen, ist aber in Wirklichkeit keiner. Er fügt die benötigten Code-Elemente und Bestandteile ein, die Sie aber genauso gut auch selbst erstellen könnten. In den folgenden Abschnitten erfahren Sie, wie Sie herausfinden, was Sie einfügen müssen.

Zuerst erstellen Sie ein Projekt mit den gleichen Optionen, die Sie beim Erstellen des Projektes verwendet haben, dessen Einstellungen Sie nun verändern wollen, und fügen dem keinen weiteren Code hinzu. Als zweiten Schritt erstellen Sie in einem anderen Verzeichnis ein Projekt mit gleichem Namen und übernehmen die Einstellungen des zuerst erstellten Projektes mit Ausnahme des Elements, das verändert werden soll (in diesem Beispiel für die kontextabhängige Hilfe). Nun vergleichen Sie die Dateien mit dem Programm WinDiff, das mit Visual C++ geliefert wird. Nun wissen Sie, welche Elemente Sie Ihrem Projekt hinzufügen müssen, um das Merkmal zu implementieren, das Sie dem Anwendungs-Assistenten mitzuteilen vergaßen.

Ist ihnen der Fehler früh genug aufgefallen, betrachten einige Entwickler es als schnellere Methode, ein neues Projekt mit den gewünschten Merkmalen zu erstellen und dann die eigenen Funktionen und Ressourcen aus dem teilweise erstellten Projekt in das neue leere Projekt einzufügen. Welche Methode man anwendet, ist Geschmackssache, aber wenn Sie diesen Vorgang erst einmal hinter sich haben, werden Sie die Dialogfelder des Anwendungs-Assistenten sicherlich langsamer durcharbeiten.

Den Code des Anwendungs-Assistenten verstehen

Der vom Anwendungs-AssistentErklaerung und UebersichtAnwendungs-AssistentErklaerung und UebersichtAnwendungs-Assistent generierte Code mag Ihnen anfangs, vor allem, wenn Sie bisher noch kein C++-Programm geschrieben haben, wenig verständlich erscheinen. Den Code zu verstehen, ist jedoch kein Muß, um selbst einfache Anwendungen zu erstellen. Ihre Programme werden allerdings ausgereifter sein, wenn Sie wissen, was der Code bedeutet. Darum wollen wir einen genaueren Blick auf die Codegrundstruktur des Anwendungs-Assistenten werfen. In den folgenden Abschnitten werden Sie das Innenleben einer SDI-Anwendung, einer MDI-Anwendung und einer dialogfeldbasierten Anwendung kennenlernen.

Haben Sie die Startanwendungen FirstSDI, FirstMDI und FirstDialog nicht erstellt, können Sie diese aus der mitgelieferten CD öffnen. Haben Sie die Anwendungen bereits erstellt, öffnen Sie diese Fassungen. Sind Sie mit der Oberfläche des Developer Studios noch nicht vertraut, werfen Sie einen Blick in Anhang B »Die Developer Studio-Benutzeroberfläche«***, um Näheres über das Bearbeiten von Codes und die Betrachtung von Klassen zu erfahren.

Die SDI-Anwendung

Eine Single-Document-Interface (SDI)-Anwendung enthält Menübefehle, die der Anwender verwendet, um jeweils ein Dokument zu öffnen und es zu bearbeiten. In diesem Abschnitt finden Sie den Code, der beim Erstellen einer SDI-Anwendung generiert wird, die weder Datenbanken noch Verbunddokumente unterstützt, über eine Symbolleiste, eine Statusleiste, Hilfe, 3D-Steuerelemente, Quelltextkommentare verfügt und die MFC-Bibliothek als gemeinsam genutzte DLL verwendet. Für diese Anwendung werden mit anderen Worten nach Schritt 1 alle Standardeinstellungen übernommen.

Es werden fünf Klassen erstellt. Für die Anwendung FirstSDI lauten diese folgendermaßen:

Näheres über Dialogfeldklassen erfahren Sie in Kapitel 2 »Dialogfelder und Steuerelemente«. Näheres über Dokument-, Ansicht- und Rahmenklassen erfahren Sie in Kapitel 5 »Dokumente und Ansichten«. Die Header-Datei für die Klasse CFirstSDIApp sehen Sie in Listing 1.1.

Listing 1.1: Haupt-Header-Datei für die Anwendung FirstSDI

// FirstSDI.h : Haupt-Header-Datei für die 
// Anwendung FIRSTSDI 
// 

#if !defined(AFX_FIRSTSDI_H__F40B98A6_D1B9_11D0_96DD_444553540000__INCLUDED_) #define AFX_FIRSTSDI_H__F40B98A6_D1B9_11D0_96DD_444553540000__INCLUDED_
#if _MSC_VER >= 1000 #pragma once #endif // _MSC_VER >= 1000
#ifndef __AFXWIN_H__ #error include 'stdafx.h' before including this file for PCH #endif #include "resource.h" // Hauptsymbole ///////////////////////////////////////////////// // CFirstSDIApp: // Siehe FirstSDI.cpp für die Implementierung // dieser Klasse // class CFirstSDIApp : public CWinApp { public: CFirstSDIApp(); // Überladungen // Vom Klassenassistenten generierte Überladungen virtueller Funktionen //{{AFX_VIRTUAL(CFirstSDIApp) public: virtual BOOL InitInstance(); //}}AFX_VIRTUAL // Implementierung //{{AFX_MSG(CFirstSDIApp) afx_msg void OnAppAbout(); // HINWEIS û An dieser Stelle werden // Member-Funktionen vom Klassen- // Assistenten eingefügt und entfernt. // Innerhalb dieser generierten // Quelltextabschnitte NICHTS VERÄNDERN! //}}AFX_MSG DECLARE_MESSAGE_MAP() }; ///////////////////////////////////////////////// //{{AFX_INSERT_LOCATION}} // Microsoft Developer Studio fügt zusätzliche Deklarationen unmittelbar vor der vorhergehenden Zeile ein. #endif // !defined(AFX_FIRSTSDI_H__F40B98A6_D1B9_11D0_96DD_444553540000__INCLUDED_)

Dieser Code ist am Anfang etwas verwirrend. Das erste #if (!defined), gefolgt von einer langen Zeichenfolge (die bei Ihnen anders aussehen wird) ist die sichere Form Header-Dateien einzubinden, da ein doppeltes Einbinden damit vermieden wird. Vielleicht ist Ihnen folgendes Codeelement schon einmal begegnet:

#ifndef test_h 
#include "test.h" 
#define test_h 
#endif 

Damit wird sichergestellt, daß die Datei test.h nur einmal eingebunden wird. Bei C++ ist ohne weiteres möglich, daß die gleiche Datei mehrmals an verschiedene Stellen eingebunden wird. Nehmen wir an, daß Sie eine Klasse mit den Namen von Angestellten definieren, die eine Klasse mit Namen Geschäftsführer verwendet. Wenn die Header-Dateien für diese beiden Klassen beispielsweise die Datei Firma.h enthalten, erhalten Sie, wenn die Datei zum zweitenmal erstellt wird, vom Compiler Fehlermeldungen mit der Aufforderung, die Symbole in der Datei Firma.h »neu zu definieren«.

Bei der oben verwendeten Methode wird folgendes Problem auftreten: Wenn der Anwender test.h berücksichtigt, aber vergißt test_h festzulegen, wird der Code ein zweites Mal test.h enthalten. Dieses Problem läßt sich lösen, indem der Test und die Definition statt dessen in der Header-Datei erscheinen. test.h sieht dann folgendermaßen aus:

Listing 1.2: Sicheres Einbinden von Header-Dateien

#ifndef test_h 
... die gesamte Header-Datei
#define test_h
#endif

Der Anwendungs-Assistent hat hier lediglich einen etwas komplizierten Variablennamen als test_h generiert (dieser hilft aber Probleme zu vermeiden, wenn Sie mehrere Dateien mit gleichem Namen in verschiedenen Ordnern und Projekten haben) und eine etwas andere Syntax verwendet, um die Variable zu prüfen. Die Compiler-Anweisung #pragma once hilft ebenfalls, Mehrfachdefinitionen zu vermeiden, sollte die Datei zweifach erstellt werden.

Kernstück der Datei ist die Definition der Klasse CFirstSDIApp. Diese Klasse ist von der Klasse CWinApp, einer MFC-Klasse, die die meisten benötigten Funktionen zur Verfügung stellt, abgeleitet. Der Anwendungs-Assistent hat einige Funktionen für diese Klasse generiert, die andere von der Basisklasse abgeleitete Funktionen überladen. Der Codeabschnitt, der mit //Overrides beginnt, betrifft das Überladen virtueller Funktionen. Die Kommentare, die der Anwendungs-Assistent für die Deklaration der Funktion InitInstance generiert hat, dienen dazu, dem Klassen-Assistenten die Aufgabe zu erleichtern, zu einem späteren Zeitpunkt andere notwendige Funktionsprototypen hinzuzufügen. Der darauf folgende Code-Abschnitt ist eine Nachrichtentabelle und deklariert die Funktion OnAppAbout. Sie erfahren alles über Nachrichtentabellen in Kapitel 4 »Nachrichten und Befehle«.

Der Anwendungs-Assistent hat den Code für den Konstruktor CFirstSDIApp, die Funktionen InitInstance und OnAppAbout in der Datei firstsdi.cpp generiert. Im folgenden Listing finden Sie den Code für den Konstruktor, der beim Erstellen ein CFirstSDIApp-Objekt initialisiert:

Listing 1.3: Der Konstruktor der Anwendungsklasse

CFirstSDIApp::CFirstSDIApp() 
{
// ZU ERLEDIGEN: Hier Code zur Konstruktion einfügen
// Alle wichtigen Initialisierungen in InitInstance plazieren}
}

Dies ist ein typischer Microsoft-Konstruktor. Da Konstruktoren keine Werte zurückgeben, ist nicht so einfach anzuzeigen, daß bei der Initialisierung ein Problem aufgetreten ist. Man kann dieses Problem auf verschiedene Art angehen. Die Methode von Microsoft ist eine Ini-tialisierung in zwei Schritten mit einer zusätzlichen Initialisierungsfunktion, so daß der Konstruktor keine Initialisierungsanweisungen enthält. Bei einer Anwendung trägt diese Funktion den Namen InitInstance (siehe Listing 1.4).

Listing 1.4: CFirstSDIApp::InitInstance

BOOL CFirstSDIApp::InitInstance() 
{
AfxEnableControlContainer();

// Standardinitialisierung
// Wenn Sie diese Funktionen nicht nutzen und die Größe Ihrer fertigen
// ausführbaren Datei reduzieren wollen, sollten Sie die nachfolgenden
// spezifischen Initialisierungsroutinen, die Sie nicht benötigen, entfernen.

#ifdef _AFXDLL
Enable3dControls(); // Diese Funktion bei Verwendung von MFC in gemeinsam
// genutzten DLLs aufrufen
#else
Enable3dControlsStatic(); // Diese Funktion bei statischen MFC-Anbindungen aufrufen
#endif

// Ändern des Registrierungsschlüssels, unter dem unsere Einstellungen gespeichert sind.
// Sie sollten dieser Zeichenfolge einen geeigneten Inhalt geben

Listing 1.4: CFirstSDIApp::InitInstance (Forts.)


// wie z.B. den Namen Ihrer Firma oder Organisation. 
SetRegistryKey(_T("Local AppWizard-Generated Applications"));

LoadStdProfileSettings(); // Standard-INI-Dateioptionen einlesen (einschließlich MRU)

// Dokumentvorlagen der Anwendung registrieren. Dokumentvorlagen
// dienen als Verbindung zwischen Dokumenten, Rahmenfenstern und Ansichten.

CSingleDocTemplate* pDocTemplate;
pDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
RUNTIME_CLASS(CFirstSDIDoc),
RUNTIME_CLASS(CMainFrame), // Haupt-SDI-Rahmenfenster
RUNTIME_CLASS(CFirstSDIView));
AddDocTemplate(pDocTemplate);

// Befehlszeile parsen, um zu prüfen auf Standard-Umgebungsbefehle DDE, Datei offen
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);

// Verteilung der in der Befehlszeile angegebenen Befehle
if (!ProcessShellCommand(cmdInfo))
return FALSE;

// Das einzige Fenster ist initialisiert und kann jetzt angezeigt und aktualisiert werden.
m_pMainWnd->ShowWindow(SW_SHOW);
m_pMainWnd->UpdateWindow();

return TRUE;
}

Die Funktion InitInstance nimmt die Initialisierungen für jede Instanz des Programms vor. In diesem Beispiel ermöglicht sie, daß die Anwendung mit einem Aufruf der Funktion Afx-EnableControlContainer ActiveX-Steuerelemente enthalten kann, bevor sie sich den 3D-Steuerelementen zuwendet. Dann erstellt sie den Registrierungsschlüssel, unter dem die Einstellungen der Anwendung gespeichert werden. (Näheres über die Registrierung erfahren Sie in Kapitel 8 »Bestand und Dateiein- und -ausgangsdaten«. Wenn Sie davon bisher noch nichts gehört haben, können Sie im Moment darüber hinwegsehen.)

Im weiteren registriert die Funktion InitInstance die für SDI-Anwendungen typische Dokumentvorlagen. Gerade die Verwendung von CSingleDocTemplate macht die Anwendung zu einer SDI-Anwendung. Näheres über Dokumente, Sichten, Rahmen und Dokumentvorlagen finden Sie in Kapitel 5 »Dokumente und Sichten«.

Nach dem Kommentar über das Parsen (Analysieren und Zerlegen) der Befehlszeile erstellt die Funktion InitInstance ein leeres CCommandLineInfo-Objekt für die Parameter, die eventuell während des Ausführens an die Anwendung weitergeleitet worden sind, und ruft die Funktion ParseCommandLine auf, um das Objekt zu füllen. Schließlich wird die Funktion ProcessShellCommand aufgerufen, um den Anforderungen der Parameter nachzukommen. Das heißt, Ihre Anwendung kann Befehlszeilen-Parameter unterstützen, so daß der Anwender Zeit und Mühe sparen kann, ohne daß Sie sich darum kümmern müssen. Gibt der Anwender in die Befehlszeile z.B. FirstSDI fooble ein, so wird die Anwendung gestartet und die Datei mit Namen fooble geöffnet. Die Funktion ProcessShellCommand unterstützt folgende Befehlszeilen-Parameter:

Tabelle 1.1: Die Befehlszeilen-Parameter

Parameter

Aktion

keine

Anwendung starten und neue Datei öffnen

Dateiname

Anwendung starten und Datei öffnen

/p Dateiname

Anwendung starten und Datei im Standarddrucker drucken

/pt Dateiname Druckertreiberanschluß

Anwendung starten und Datei im angegebenen Drucker drucken

/dde

Anwendung starten und DDE-Befehl abwarten

/Automation

Anwendung als OLE-Automatisierungsserver starten

/Embedding

Anwendung starten, um ein eingebettetes OLE-Objekt zu bearbeiten

Wollen Sie noch weitere Aktionen implementieren, erstellen Sie für die analysierte Befehlszeile eine Klasse, die sich von der Klasse CCommandLineInfo ableitet. Dann übertragen Sie die Funktionen CWinApp::ParseCommandLine und CWinApp::ProcessShellCommand in Ihre eigene Anwendungsklasse.


Vielleicht ist es für Sie nichts Neues, daß Sie viele Windows-Programme von der Windows 95- und Windows-NT-Befehlszeile aufrufen können. Geben Sie z.B. bei einer DOS-Eingabeaufforderung Notepad blah.txt ein, wird blah.txt im Programm Notepad geöffnet. Auch andere Befehlszeilen-Optionen können eingegeben werden. Gibt man z.B. Notepad /p blah.txt in die Befehlszeile ein, wird blah.txt im Programm Notepad geöffnet und gedruckt.

Nun sind wir am Ende des Codes der Funktion InitInstance. Um anzuzeigen, daß die übrige Anwendung nun ausgeführt werden soll, wird der Wert TRUE ausgegeben.

Die Nachrichtentabelle in der Header-Datei gibt an, daß die Funktion OnAppAbout eine Nachricht handhabt. Folgendes ist die Nachrichtentabelle der CPP-Datei:

Listing 1.5: Die Nachrichtentabelle

BEGIN_MESSAGE_MAP(CFirstSDIApp, CWinApp) 
//{{AFX_MSG_MAP(CFirstSDIApp)
ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
// HINWEIS û Hier werden Mapping-Makros vom Klassen-Assistenten eingefügt und entfernt.
// Innerhalb dieser generierten Quelltextabschnitte NICHTS VERÄNDERN!
//}}AFX_MSG_MAP
// Dateibasierte Standard-Dokumentbefehle
ON_COMMAND(ID_FILE_NEW, CWinApp::OnFileNew)
ON_COMMAND(ID_FILE_OPEN, CWinApp::OnFileOpen)
// Standard-Druckbefehl "Seite einrichten"
ON_COMMAND(ID_FILE_PRINT_SETUP, CWinApp::OnFilePrintSetup)
END_MESSAGE_MAP()BEGIN_MESSAGE_MAP(CFirstSDIApp, CWinApp)

Diese Nachrichtentabelle nimmt Befehle aus Menüs entgegen, wie in Kapitel 4 »Nachrichten und Befehle« genauer beschrieben wird. Wählt der Anwender den Befehl Info über, wird die Funktion CFirstSDIApp::OnAppAbout aufgerufen. Wählt der Anwender im Menü Datei den Befehl Neu, Öffnen oder Seitenansicht, werden die Funktionen der Klasse CWinApp diese Aufgaben für Sie erledigen. (Sie können diese Funktionen auch überladen, wenn Sie für diese Menüoptionen etwas Besonderes vorhaben.) Die Funktion OnAppAbout sieht folgendermaßen aus:

void CFirstSDIApp::OnAppAbout() 
{
CAboutDlg aboutDlg;
aboutDlg.DoModal();
}

Dieser Code deklariert ein Objekt, das eine Instanz der Klasse CAboutDlg ist und ruft dessen Funktion DoModal auf, um den Dialog auf dem Bildschirm anzuzeigen. (Näheres über Dialogfeldklassen und die Funktion DoModal finden Sie in Kapitel 2 »Dialogfelder und Steuerelemente«. Die Schaltflächen OK oder Abbrechen benötigen keine spezielle Handhabung, die Funktionalität wird durch die Basismethoden von CDialog bereitgestellt.

Andere Dateien

Haben Sie die Option Kontextabhängige Hilfe aktiviert, generiert der Anwendungs-Assistent eine HPJ-Datei und etliche RTF-Dateien, in denen Sie die Hilfetexte formulieren können. Näheres über diese Dateien finden Sie in Kapitel 11 »Das Windows-Hilfesystem« im Abschnitt »Komponenten des Hilfesystems«.

Der Anwendungs-Assistent generiert auch eine Datei README.TXT, die die anderen Dateien vorstellt und erklärt, welche Klassen erstellt wurden. Lesen Sie diese Datei, wenn die vielen ähnlich klingenden Dateinamen Sie verwirren.

Die MDI-Anwendung

Eine Multiple-Document-Interface-(MDI)-Anwendung enthält ebenfalls Menübefehle, und der Anwender hat die Möglichkeit, mehrere Dokumente gleichzeitig geöffnet zu haben. In diesem Abschnitt finden Sie den Code, der beim Erstellen einer MDI-Anwendung generiert wird, die weder Datenbanken noch Verbunddokumente unterstützt, über eine Symbolleiste, eine Statusleiste, Hilfe, 3D-Steuerelemente, Quelltextkommentare verfügt und die MFC-Bibliothek in DLL-Form verwendet. Wie bei der SDI-Anwendung stimmen diese Einstellungen nach Schritt 1 mit den Standardeinstellungen überein. Dieser Abschnitt geht vor allem auf die Unterschiede ein, die zu einer SDI-Anwendung bestehen, wie sie in Abschnitt 1.5.1 beschrieben wurde.

Es wurden fünf Klassen erstellt. Für die Anwendung FirstMDI lauten sie folgendermaßen:

Die Header-Datei für die Anwendungsklasse sehen Sie in Listing 1.6.

Listing 1.6: Haupt-Header-Datei für die Anwendung FIRSTMDI

// FirstMDI.h : Haupt-Header-Datei für die Anwendung FIRSTMDI 
//

#if !defined(AFX_FIRSTMDI_H__F40B98BA_D1B9_11D0_96DD_444553540000__INCLUDED_)
#define AFX_FIRSTMDI_H__F40B98BA_D1B9_11D0_96DD_444553540000__INCLUDED_

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

#ifndef __AFXWIN_H__
#error include 'stdafx.h' before including this file for PCH
#endif

#include "resource.h" // Hauptsymbole

/////////////////////////////////////////////////////////////////////////////
// CFirstMDIApp:
// Siehe FirstMDI.cpp für die Implementierung dieser Klasse
//

class CFirstMDIApp : public CWinApp
{
public:

Listing 1.6: Haupt-Header-Datei für die Anwendung FIRSTMDI (Forts.)

CFirstMDIApp(); 

// Überladungen
// Vom Klassenassistenten generierte Überladungen virtueller Funktionen
//{{AFX_VIRTUAL(CFirstMDIApp)
public:
virtual BOOL InitInstance();
//}}AFX_VIRTUAL

// Implementierung

//{{AFX_MSG(CFirstMDIApp)
afx_msg void OnAppAbout();
// HINWEIS û An dieser Stelle werden Member-Funktionen vom Klassen-Assistenten eingefügt und entfernt.
// Innerhalb dieser generierten Quelltextabschnitte NICHTS VERÄNDERN!
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};


/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio fügt zusätzliche Deklarationen unmittelbar vor der vorhergehenden Zeile ein.

#endif // !defined(AFX_FIRSTMDI_H__F40B98BA_D1B9_11D0_96DD_444553540000__INCLUDED_)

Wie unterscheidet sich dieser Code von FirstSDI.h? Nur die Klassennamen sind unterschiedlich. Der Konstruktor ist ebenfalls der gleiche wie vorher. Und die Funktion OnApp-About ist genauso wie in der SDI-Version. Wie sieht die Funktion InitInstance aus? Sie finden sie in Listing 1.7.

Listing 1.7: CFirstMDIApp::InitInstance()

BOOL CFirstMDIApp::InitInstance() 
{
AfxEnableControlContainer();

// Standardinitialisierung
// Wenn Sie diese Funktionen nicht nutzen und die Größe Ihrer fertigen
// ausführbaren Datei reduzieren wollen, sollten Sie die nachfolgenden
// spezifischen Initialisierungsroutinen, die Sie nicht benötigen, entfernen.

#ifdef _AFXDLL
Enable3dControls(); // Diese Funktion bei Verwendung von MFC in gemeinsam
genutzten DLLs aufrufen

Listing 1.7: CFirstMDIApp::InitInstance() (Forts.)

#else 
Enable3dControlsStatic(); // Diese Funktion bei statischen MFC-Anbindungen
aufrufen
#endif

// Ändern des Registrierungsschlüssels, unter dem unsere Einstellungen gespeichert sind.
// Sie sollten dieser Zeichenfolge einen geeigneten Inhalt geben
// wie z.B. den Namen Ihrer Firma oder Organisation.
SetRegistryKey(_T("Local AppWizard-Generated Applications"));

LoadStdProfileSettings(); // Standard-INI-Dateioptionen einlesen (einschließlich MRU)

// Dokumentvorlagen der Anwendung registrieren. Dokumentvorlagen
// dienen als Verbindung zwischen Dokumenten, Rahmenfenstern und Ansichten.

CMultiDocTemplate* pDocTemplate;
pDocTemplate = new CMultiDocTemplate(
IDR_FIRSTMTYPE,
RUNTIME_CLASS(CFirstMDIDoc),
RUNTIME_CLASS(CChildFrame), // Benutzerspezifischer MDI-Child-Rahmen
RUNTIME_CLASS(CFirstMDIView));
AddDocTemplate(pDocTemplate);

// Haupt-MDI-Rahmenfenster erzeugen
CMainFrame* pMainFrame = new CMainFrame;
if (!pMainFrame->LoadFrame(IDR_MAINFRAME))
return FALSE;
m_pMainWnd = pMainFrame;

// Befehlszeile parsen, um zu prüfen auf Standard-Umgebungsbefehle DDE, Datei offen
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);

// Verteilung der in der Befehlszeile angegebenen Befehle
if (!ProcessShellCommand(cmdInfo))
return FALSE;

// Das Hauptfenster ist initialisiert und kann jetzt angezeigt und aktualisiert werden.
pMainFrame->ShowWindow(m_nCmdShow);
pMainFrame->UpdateWindow();

return TRUE;
}

Was ist hier anders? Dies herauszufinden, kann Sie WinDiff unterstützen. WinDiff ist ein Tool, das mit Visual C++ geliefert wird und vom Menü Extras aus aufgerufen werden kann. (Ist WinDiff nicht in Ihrem Menü Extras, schlagen Sie im Abschnitt »Tools« in Anhang B »Das Developer Studio« nach. Verwenden Sie WinDiff, um die für FirstSDI bzw. FirstMDI generierten Versionen der Funktion InitInstance zu vergleichen, und Sie werden feststellen, daß neben den unterschiedlichen Klassennamen folgende Unterschiede bestehen:

Die dialogfeldbasierte Anwendung

Dialogfeld-Anwendungen sind meist viel einfacher als SDI- und MDI-Anwendungen aufgebaut.

Erstellen Sie eine Anwendung mit Namen FirstDialog, mit einem Feld Info über, ohne Hilfe, mit 3D-Steuerelementen, ohne Automatisierung, mit Unterstützung von ActiveX-Steuerelementen, ohne Sokkets und mit Quelltextkommentaren, die die MFC-Bibliothek als DLLs verwenden. Für diese Anwendung werden mit anderen Worten alle Standardeinstellungen übernommen.

Für die Anwendung FirstDialog wurden drei Klassen erstellt. Sie lauten folgendermaßen:

Näheres über Dialogfeldklassen erfahren Sie in Kapitel 2 »Dialogfelder und Steuerelemente«. Die Header-Datei für die Klasse CFirstDialogApp sehen Sie in Listing 1.8.

Listing 1.8: FirstDialog.h : Haupt-Header-Datei

// FirstDialog.h : Haupt-Header-Datei für die Anwendung FIRSTDIALOG 
//

#if !defined(AFX_FIRSTDIALOG_H__F40B98D0_D1B9_11D0_96DD_444553540000__INCLUDED_)
#define AFX_FIRSTDIALOG_H__F40B98D0_D1B9_11D0_96DD_444553540000__INCLUDED_

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

#ifndef __AFXWIN_H__
#error include 'stdafx.h' before including this file for PCH
#endif

#include "resource.h" // Hauptsymbole

Listing 1.8: FirstDialog.h : Haupt-Header-Datei (Forts.)


///////////////////////////////////////////////////////////////////////////// 
// CFirstDialogApp:
// Siehe FirstDialog.cpp für die Implementierung dieser Klasse
//

class CFirstDialogApp : public CWinApp
{
public:
CFirstDialogApp();

// Überladungen
// Vom Klassenassistenten generierte Überladungen virtueller Funktionen
//{{AFX_VIRTUAL(CFirstDialogApp)
public:
virtual BOOL InitInstance();
//}}AFX_VIRTUAL

// Implementierung

//{{AFX_MSG(CFirstDialogApp)
// HINWEIS û An dieser Stelle werden Member-Funktionen vom Klassen-Assistenten eingefügt und entfernt.
// Innerhalb dieser generierten Quelltextabschnitte NICHTS VERÄNDERN!
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};


/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio fügt zusätzliche Deklarationen unmittelbar vor der vorhergehenden Zeile ein.

#endif // !defined(AFX_FIRSTDIALOG_H__F40B98D0_D1B9_11D0_96DD_444553540000__INCLUDED_)

Die Klasse CFirstDialogApp ist von der Klasse CWinApp abgeleitet, die die meisten Funktionen zur Verfügung stellt. Die Klasse CWinApp hat einen Konstruktor, der wie die Konstruktoren der Anwendungen SDI und MDI weiter oben in diesem Kapitel keine Initialisierung vornimmt und die virtuelle Funktion InitInstance überlädt (siehe Listing 1.9).

Listing 1.9: CFirstDialogApp::InitInstance()

BOOL CFirstDialogApp::InitInstance()
{
AfxEnableControlContainer();

// Standardinitialisierung
// Wenn Sie diese Funktionen nicht nutzen und die Größe Ihrer fertigen

Listing 1.9: CFirstDialogApp::InitInstance( (Forts.)


// ausführbaren Datei reduzieren wollen, sollten Sie die nachfolgenden 
// spezifischen Initialisierungsroutinen, die Sie nicht benötigen, entfernen.

#ifdef _AFXDLL
Enable3dControls(); // Diese Funktion bei Verwendung von MFC in
gemeinsam genutzten DLLs aufrufen
#else
Enable3dControlsStatic(); // Diese Funktion bei statischen MFC-Anbindungen
aufrufen
#endif

CFirstDialogDlg dlg;
m_pMainWnd = &dlg;
int nResponse = dlg.DoModal();
if (nResponse == IDOK)
{
// ZU ERLEDIGEN: Fügen Sie hier Code ein, um ein Schließen des
// Dialogfelds über OK zu steuern
}
else if (nResponse == IDCANCEL)
{
// ZU ERLEDIGEN: Fügen Sie hier Code ein, um ein Schließen des
// Dialogfelds über "Abbrechen" zu steuern
}

// Da das Dialogfeld geschlossen wurde, FALSE zurückliefern, so dass wir die
// Anwendung verlassen, anstatt das Nachrichtensystem der Anwendung zu starten.
return FALSE;
}

Damit werden 3D-Steuerelemente ermöglicht, die Sie als Option gewählt haben, und das Dialogfeld erstellt, das die gesamte Anwendung ausmacht. Hierfür deklariert die Funktion eine Instanz der Klasse CFirstDialogDlg, dlg und ruft anschließend die Funktion DoModal des Dialogs auf, die das Dialogfeld auf dem Bildschirm anzeigt und IDOK ausgibt, wenn der Anwender die Schaltfläche OK aktiviert bzw. IDCANCEL, wenn der Anwender die Schaltfläche Abbrechen aktiviert. (Näheres über diesen Vorgang erfahren Sie in Kapitel 2 »Dialogfelder und Steuerelemente«.) Es ist Ihre Aufgabe, das Dialogfeld dazu zu bringen, etwas auf die Beine zu stellen. Am Schluß gibt die Funktion InitInstance den Wert FALSE aus, weil es sich um eine dialogfeldbasierte Anwendung handelt, die mit dem Schließen des Dialogfeldes beendet ist. Wie Sie bei den Anwendungen SDI und MDI gesehen haben, gibt die Funktion InitInstance normalerweise die Werte TRUE (das bedeutet »alles ist in Ordnung, die übrige Anwendung soll ausgeführt werden«) oder FALSE aus (das bedeutet »bei der Initialisierung ist etwas falsch gelaufen«). Weil die Anwendung nach dem Schließen des Dialogfeldes nichts mehr tut, gibt die Funktion InitInstance für dialogfeldbasierte Anwendungen immer den Wert FALSE aus.

Die Optionen des Anwendungs-Assistenten und dieses Buches û ein Überblick

Der Anwendungs-Assistent stellt sehr viele Fragen und nimmt viele Aufgaben auf einmal wahr. Dieses Kapitel geht näher auf die Funktion InitInstance ein und wie sich die erste Entscheidung im Anwendungs-Assistenten, die Wahl der Option für eine dialogfeldbasierte, SDI- oder MDI-Anwendung, auf bestimmte Code-Elemente auswirkt. Die meisten anderen Entscheidungen des Anwendungs-Assistenten betreffen Themen, denen jeweils ein ganzes Kapitel gewidmet ist. Folgende Tabelle faßt diese Optionen zusammen und verweist Sie auf das jeweilige Kapitel, in dem Sie mehr über das betreffende Thema erfahren.

Tabelle 1.2: Die Schritte des Anwendungs-Assistenten mit Kapitelverweisen. (Forts.)

Schritt

Entscheidung

Kapitel

Dialog?

0

MFC-DLL oder nicht MFC-DLL

28 »Weiterführende Themen «


0

ActiveX-Steuerelement

17 »Ein ActiveX-Steuerelement erstellen«


0

Konsolenanwendung

28 »Weiterführende Themen«


0

Benutzerdefinierter Anwendungs-Assistent***

25 »Die Komponentensammlung und eigene Anwendungs-Assistenten«


0

ISAPI-Erweiterungs-Assistent

18 »Socket, MAPI und das Internet«


1

Sprache

28 »Weiterführende Themen«

Ja

2

Einbinden von Datenbanken

22 »Datenbank-Zugriff«***


3

Containerunterstüzung für Verbunddokumente

14 »Eine ActiveX-Container-Anwendung«


3

Mini-Server-Unterstüzung für Verbunddokumente

15 »Eine ActiveX-Server-Anwendung«


3

Voll-Server-Unterstüzung für Verbunddokumente

15 »Eine ActiveX-Server-Anwendung«


3

Verbunddateien

14 »Eine ActiveX-Container-Anwendung«


3

Automatisierung

16 »Einen Automatisierungs-Server entwickeln«

Ja

3

Verwenden von ActiveX-Steuerelementen

17 » Ein ActiveX-Steuerelement erstellen«

Ja

4

Andockbare Symbolleiste

10 »Statuszeilen und Symbolleisten«***


4

Statusleiste zu Beginn

10 »Status- und Symbolleisten«***


4

Drucken und Seitenansicht

7 »Drucken und Seitenansicht«***


4

Kontextabhängige Hilfe

11 »Das Windows-Hilfesystem«

Ja

4

3D-Steuerelemente

--

Ja

4

MAPI (Messaging API)

18 »Sockets, MAPI und das Internet«


4

Windows-Socket

18 »Sockets, MAPI und das Internet«

Ja

4

Dateien in Liste zuletzt verwendeter Dateien

---


5

Kommentare in Quellcodedateien

--

Ja

5

MFC-Bibliothek

--

Ja

6

Basisklasse für die Klasse View

5 »Dokumente und Ansichten«***


Nicht alle Optionen gelten auch für dialogfeldbasierende Anwendungen. In der Spalte Dialog? finden Sie daher ein Ja, wenn diese Entscheidung auch für dialogfeldbasierte Anwendungen verfügbar ist. Der Eintrag û in der Spalte Kapitel bedeutet, daß diese Entscheidung keiner näheren Ausführung bedarf. Diese Themen finden nur kurze Erwähnung in dem einen oder anderen Kapitel.

Wie geht's weiter?

Nun wissen Sie, wie man Anwendungen erstellt, die noch nicht viel bewegen. Um aktiv werden zu können, brauchen Sie Menüs und Dialogfeld-Steuerelemente, die Befehle weiterleiten, und andere Dialogfeld-Steuerelemente zum Sammeln weiterer Informationen. Das ist Thema des folgenden Kapitels »Dialogfelder und Steuerelemente«.

Wenn Sie dann wissen, was eine Anwendung braucht, um aktiv zu werden, finden Sie in diesem Buch Näheres über das Hinzufügen von weiteren Merkmalen:


© 1997 Que
Ein Imprint des Markt&Technik Buch- und Software- Verlag GmbH
Elektronische Fassung des Titels: Special Edition Visual C++ 5.0, ISBN: 3-8272-1019-4

Previous Page Page Top TOC Index Next Page See Page