|
|
|
|
|
Hier beschreibe ich grundlegende Dinge wie das Einfügen von Variablen, Nachrichtenbehandlungsroutinen, Ressourcen usw. Dabei gehe ich auf die Unterschiede zwischen Visual C++ 6.0, Visual C++.NET 2002 bzw. 2003 und Visual C++ 2005 ein. In Visual C++.NET 2002/2003 und Visual C++ 2005 gibt es z.B keinen Klassen-Assistent wodurch man Variablen für Steuerelemente oder Nachrichtenbehandlungsroutinen etwas anders einfügt. Das Eigenschafts-Fenster unterscheidet sich auch voneinander. In VC++ 6.0 hatte man noch die verschiedenen Einstellmöglichkeiten durch Register getrennt. In VC++.NET 2002/2003 und Visual C++ 2005 wurden die Eigenschaften zusammengefasst. Die Handhabung zwischen der 2002, 2003er und 2005er Version verhält sich gleich.
- Das Eigenschafts-Fenster
- Einfügen von Nachrichtenbehandlungsroutinen
- Einfügen von Variablen für Steuerelemente
- Einfügen von Variablen/Funktionen für Klassen
- Erstellen einer dialogfeldbasierten Anwendung
- Funktionen überschreiben
Ressourcen einfügen/importieren:
- Bitmap einfügen
- Bitmap importieren
- Dialog und zugehörige Klasse einfügen
- Icon einfügen
- Icon importieren
- Menü einfügen
- Toolbar einfügen
In den Eigenschaften eines Steuerelements oder Dialog kann man verschiedene Einstellungen vornehmen. Welche Eigenschaften das sind kommt auf das Steuerelement bzw. Dialog selbst an. Hier wird beschrieben wie man allgemein das Eigenschafts-Fenster für ein Steuerelement bzw. Dialog aufrufen kann.
Visual C++ 6.0
Eigenschaften werden gesetzt, indem man in den jeweiligen Kontrollkästchen einen Haken setzt. Klickt man mit der rechten Maustaste in einen Dialog bzw. auf ein Steuerelement, muss man im erscheinenden Kontexmenü auf Eigenschaften(Properties) klicken. Daraufhin erscheint das Eigenschafts-Fenster. Das sieht für ein Steuerelement dann so aus:
Visual C++.NET 2002/2003 und Visual C++ 2005
Eigenschaften werden gesetzt, indem man die jeweilige Eigenschaft auf TRUE setzt. Sobald man in einen Dialog bzw. auf ein Steuerelement klickt wird das Eigenschafts-Fenster in der Regel links unten am Bildschirm angezeigt. Sollte das nicht der Fall sein, kann man mit der rechten Maustaste auf das gewünschte Steuerelement bzw. Dialog klicken und im aufklappenden Kontexmenü Eigenschaften (Properties) auswählen. Das sieht für ein Steuerelement - hier im Beispiel ein Regler - so aus:
Die beiden Bilder zeigen beide die Einstellungen des gleichen Reglers, nur in verschiedenen Ansichten. Über den Einstellunsmöglichkeiten kann man mit den Buttons eine alphabetische oder eine kategorisierte Auflistung der Einstellungen erzwingen. Über den gelben Blitz ist es übrigens auch möglich Nachrichtenbehandlungsroutinen für Dialoge und Steuerelemente einzufügen.
Wenn ein beliebiges Ereignis eintrifft, z.B das Drücken der linken Maustaste, bekommt die Anwendung eine Nachricht übermittelt. Um auf Nachrichten zu reagieren benötigt man Nachrichtenbehandlungsroutinen(engl. Event-Handler). Eine Nachrichtenbehandlungsroutine ist eine Funktion die auf gesendete Nachrichten reagiert. Diese werden bei Visual C++ 6.0 etwas anders eingefügt wie bei Visual C++.NET 2002/2003 und Visual C++ 2005.
Visual C++ 6.0
Angenommen wir haben einer Anwendung einen Button hinzugefügt und wollen jetzt darauf reagieren, wenn dieser mit der linken Maustaste angeklickt wird. In diesem Fall sendet der Button die Nachricht BN_CLICKED. Nachrichtenbehandlungsroutinen werden bei VC++ 6.0 über den Klassen-Assistenten eingefügt. Es gibt drei Möglichkeiten um ihn aufzurufen:
- Klicke in der Menüleiste von Visual C++ 6.0 auf Ansicht und dann auf Klassen-Assistent
- Drücke auf der Tastaur Ctrl + W
- Klicke mit der rechten Maustaste auf das gewünschte Steuerlement oder den Dialog und wähle im aufklappenden Kontexmenü Klassen-Assistent...
So sieht der Klassen-Assistent aus:
Im Register Nachrichtenzuordnungstabellen kann man Nachrichtenbehandlungsroutinen(Funktionen) einfügen. Ausserdem sieht man auch unter Member-Funktionen welche Funktionen für welche Nachrichten bereits eingefügt sind. Unter Objekt-IDs wählt man ob für die Dialogklasse oder ein Steuerelement eine Funktion eingefügt werden soll. Unter Nachrichten kann man die Nachricht auswählen für die man eine Funktion hinzufügen möchte. In der obigen Abbildung ist schon alles korrekt ausgewählt. Wir wollen eine Nachrichtenbehandlungsroutine für den Button(IDC_BUTTON1) und die Nachricht BN_CLICKED erstellen. Klicke auf Funktion hinzufügen und der Dialog Member-Funktion hinzufügen erscheint:
Hier kann man der Funktion einen Namen geben und man sieht auch nochmal was wir vorher im Klassen-Assistent ausgewählt haben. Um für den Button eine Funktion für die Nachricht BN_CLICKED einzufügen hätte es auch gereicht mit der linken Maustaste doppelt drauf zu klicken. Ich wollte hier aber die allgemeine Vorgehensweise zum einfügen von Nachrichtenbehandlungsroutinen zeigen.
Ein weiteres Beispiel für Visual C++ 6.0
Angenommen wir haben eine Dialogfeldbasierte Anwendung erstellt und wollen nun den Hintergrund einfärben. Dazu benötigen wir eine Nachrichtenbehandlungsroutine für die Nachricht WM_CTLCOLOR. Um die Funktion einzufügen öffne den Klassen-Assistenten und wähle folgende Einstellungen:
Unter Objekt-IDs müssen wir die Dialogklasse anwählen, unter Nachrichten die gewünschte Nachricht für die eine Funktion eingefügt werden soll. Mit einem Klick auf Funktion hinzufügen ist die Funktion eingefügt und kann direkt über den Button Code bearbeiten bearbeitet werden.
Visual C++.NET 2002/2003 und Visual C++ 2005
Angenommen wir haben einer Anwendung einen Button hinzugefügt und wollen jetzt darauf reagieren, wenn dieser mit der linken Maustaste angeklickt wird. In diesem Fall sendet der Button die Nachricht BN_CLICKED. Nachrichtenbehandlungsroutinen für Steuerelemente werden bei Visual C++.NET 2002/2003 bzw. Visual C++ 2005 eingefügt, indem man das gewünschte Steuerelement mit der rechten Maustaste anklickt und im aufklappenden Kontexmenü Ereignishandler wird hinzugefügt... (Add Event Handler) auswählt. Daraufhin erscheint folgender Dialog:
Ganz oben unter Befehlsname (Command name) sehen wir den Namen des gewählten Steurelement (IDC_BUTTON1). Unter Meldungstyp (Message type) sehen wir die verfügbaren Nachrichten für das Steuerelement. Unter Klassenliste (Class list) kann man auswählen für welche Klasse die Funktion eingefügt werden soll. In unserem Beispiel ist die Dialogklasse voreingestellt, was auch korrekt ist. Dann haben wir noch die Möglichkeit den bereits vorgegeben Namen für die Funktion zu ändern oder diesen zu übernehmen. Ganz unten steht dann noch eine Beschreibung der jeweiligen Nachricht. Um für den Button eine Funktion für die Nachricht BN_CLICKED einzufügen hätte es auch gereicht mit der linken Maustaste doppelt drauf zu klicken. Ich wollte hier aber die allgemeine Vorgehensweise zum einfügen von Nachrichtenbehandlungsroutinen zeigen.
Eine weitere Möglichkeit Nachrichtenbehandlungsroutinen einzufügen
Eine weitere Möglichkeit Nachrichtenbehandlungsroutinen einzufügen besteht direkt über das Eigenschafts-Fenster. Sobald man auf ein Steuerelement klickt wird das Eigenschafts-Fenster in der Regel links unten am Bildschirm angezeigt. Sollte das nicht der Fall sein, kann man mit der rechten Maustaste auf das gewünschte Steuerelement bzw. Dialog klicken und im aufklappenden Kontexmenü Eigenschaften(Properties) auswählen. In den Eigenschaften eines Steuerelements sieht man einen gelben Blitz (Steuerelementereignisse / engl. Control-Events) über den es möglich ist Nachrichtenbehandlungsroutinen für verfügbare Nachrichten einzufügen. Am Beispiel des Buttons sieht das so aus:
Noch komfortabler sehen die Eigenschaften eines Dialogs aus. Hier kann man über das Blitz-Symbol (Steuerelementereignisse / engl. Control-Events) Nachrichtenbehandlungsroutinen für alle in dem Dialog enthaltenen Steuerelemente einfügen. Ausserdem sieht man daneben ein weiteres Symbol: Meldungen (Messages) worüber man Nachrichtenbehandlungsroutinen, die den Dialog betreffen, einfügen kann:
Wie in der Abbildung zu sehen wurde zur Demonstration eine Nachrichtenbehandlungsroutine für die Nachricht WM_CTLCOLOR eingefügt.
Hier wird beschrieben wie man Variablen für Steuerelemente einfügen kann. Das funktioniert für VC++ 6.0 etwas anders wie für VC++.NET 2002/2003 bzw. Visual C++ 2005:
Visual C++ 6.0
Variablen für Steuerlemente kann man über den Klassen-Assistenten einfügen. Es gibt drei Möglichkeiten um ihn aufzurufen:
- Klicke in der Menüleiste von Visual C++ 6.0 auf Ansicht und dann auf Klassen-Assistent
- Drücke auf der Tastaur Ctrl + W
- Klicke mit der rechten Maustaste auf das gewünschte Steuerlement oder den Dialog und wähle im aufklappenden Kontexmenü Klassen-Assistent...
So sieht der Klassen-Assistent aus (bereits mit vorgewählten Register Member-Variablen):
Im Register Member-Variablen sieht man alle eingefügten Steuerelemente für die es möglich ist eine Variable einzufügen. In der Abbildung sehen wir an erster Stelle einen Regler. Angenommen wir wollen für diesen Regler (IDC_SLIDER1) eine Variable einfügen, dann klicke auf Variable hinzufügen.... Daraufhin erscheint der Dialog Member-Variablen hinzufügen:
Klicken wir jetzt auf OK fügen wir dem Regler eine Variable der Kategorie: Control, vom Typ: CSliderCtrl mit dem Namen: m_ctlSlider hinzu.
Visual C++.NET 2002/2003 und Visual C++ 2005
Um eine Variable für ein Steuerlement mit dieser Version einzufügen, klicke mit der rechten Maustaste auf das Steuerelement und wähle Variable hinzufügen... (Add Variable... ) Der Dialog Assistent zum Hinzufügen von Membervariablen (Add Member Variable Wizard) öffnet sich:
Der Dialog sieht etwas komplizierter aus, aber bietet im Prinzip die gleichen Möglichkeiten eine Variable anzulegen wie es mit Visual C++ 6.0 der Fall war. Auch hier kann man u.a. den Variablen Namen (Variable name), Kategorie (Category) und Variablentyp (Variable type) angeben. Zusätzlich kann man über Steuerelement ID (Control ID) das Steuerelement auswählen für das man eine Variable hinzufügen möchte.
Da es über diesen Dialog auch möglich ist eine Variable für die Dialogklasse anzulegen, muss der Haken bei Steuerelementvariable (Control Variable) gesetzt sein, wenn man eine Variable für ein Steuerelement hinzufügen will.
Häufig muss man eine Funktion oder eine Variable für eine Klasse einfügen. Ganz egal für welche Klasse man eine Funktion oder Variable einfügen möchte, das Prinzip ist immer gleich. Hier zeige ich wie man mit Visual C++ 6.0, Visual C++.NET 2002/2003 und Visual C++ 2005 Funktionen und Variablen für eine Klasse einfügen kann.
Visual C++ 6.0
Gehe im Arbeitsbereich in das Register Klassen und klicke mit rechter Maustaste auf die Klasse in die eine Funktion oder Variable eingefügt werden soll. Das sieht so aus:
Im aufklappenden Kontextmenü heißen die relevanten Eintrtäge Member-Funktion hinzufügen... und Member-Variable hinzufügen.... Da sich die Dialoge ähneln zeige ich am Beispiel von Member-Funktion hinzufügen... wie das funktioniert. Nachdem wir Member-Funktion hinzufügen ausgewählt haben, erscheint folgender Dialog:
In dem angezeigten Dialog habe ich zur Demonstration eine Funktion eingetragen. Der Dialog ist selbsterklärend
Visual C++.NET 2002/2003 und Visual C++ 2005
Klicke in der Klassen-Ansicht (Class View) mit der rechten Maustaste auf die Klasse für die eine Funktion oder Variable eingefügt werden soll. Sollte die Klassen-Ansicht nicht sichtbar sein, kann man sie über die Menüleiste aufrufen. Gehe dazu im Menü auf Ansicht (View) und dann auf Klassen-Ansicht (Class View) oder drücke Ctrl + Shift + C. Die Klassen-Ansicht sieht so aus:
Um nun eine Funktion für die Klasse einzufügen, klicke mit der rechten Maustaste auf die Klasse und wähle im aufklappenden Kontextmenü Hinzufügn (Add) und dann Funktion hinzufügen... (Add Function...). Der Dialog Assistent zum Hinzufügen von Memberfunktionen (Add Member Function Wizard) öffnet sich:
Auf den ersten Blick sieht das sehr komplex aus, ist aber ganz einfach zu handhaben. Nachdem man den Rückgabetyp und einen Funktionsnamen angegeben hat, kommen die Parameter dran. Wenn die Funktion Parameter haben soll, dann wähle den Parameter Typ und gib den Parameter Namen ein. Drücke dann auf Hinzufügen (Add) und der Parameter wird hinzugefügt. Für weitere Paramater geht man genauso vor. Wie die fertige Funktion bzw. die aktuell angelegte Funktion aussieht, sieht man ganz unten unter Funktionssignatur
Um eine Variable für eine Klasse einzufügen klicke mit der rechten Maustaste auf die jeweilige Klasse und wähle im aufklappenden Kontextmenü Hinzufügen (Add) und dann Variable hinzufügen... (Add Variable...). Der sich öffnende Dialog sieht so aus:
Ganz oben links wird die Zugriffsart (Access) festgelegt, darunter der Variablentyp und ganz unten der Variablenname. Solange man eine Variable für eine Klasse einfügen will, darf kein Haken bei Steuerelementvariable (Control variable) gesetzt sein. Setzt man dort einen Haken, kann man Variablen für Steuerelemente einfügen.
Hier wird beschrieben wie man eine Dialogfeldbasierte Anwendung erstellt. Dies funktioniert bei Visual C++ 6.0 ähnlich wie bei Visual C++.NET 2002/2003 bzw. Visual C++ 2005. Das es aber doch kleine Unterschiede gibt, beschreibe ich es ausführlich für alle Versionen.
Visual C++ 6.0
Klicke in der Menüleiste auf Datei und dann auf Neu oder drücke Ctrl + N. Daraufhin öffnet sich der Dialog Neu:
Um eine Dialogfeldbasierte Anwendung zu erstellen klicke auf MFC-Anwendungs-Assistent(exe) und gib einen Projektnamen ein. Wähle dann noch den Pfad indem das neue Projekt erstellt werden soll und klicke auf OK. Darafhin erscheint das Fenster MFC-Anwendungs-Assistent - Schritt 1:
Wähle hier Dialogfeldbasierend und stelle ggf. die Sprache der Ressourcen um. Klicke auf Weiter und es geht weiter mit MFC-Anwendungs-Assistent - Schritt 2 von 4:
Für die Beispiele reichen die Einstellungen der Abbildung völlig aus. Sollten wir in späteren Beispielen ActiveX benötigen, schreibe ich es dazu. Ich habe in den Beispielen meistens alle Haken entfernt, damit sie klein bleiben. Ganz unten ist es jetzt noch möglich den Titel für das Projekt einzugeben. Klicke auf Weiter und es geht weiter mit MFC-Anwendungs-Assistent - Schritt 3 von 4:
Hier ist es nicht nötig etwas zu ändern, deshalb drücke auf Weiter und es geht weiter mit MFC-Anwendungs-Assistent - Schritt 4 von 4:
Hier braucht man nur noch auf Fertigstellen klicken und die Dialogfeldbasierte Anwendung wird erstellt.
Visual C++.NET 2002/2003 und Visual C++ 2005
Klicke in der Menüleiste auf Datei, dann auf Neu und dann auf Projekt oder drücke Ctrl + Shift + N. Daraufhin öffnet sich der Dialog Neues Projekt:
Wähle Visual C++ Projekte und im rechten Fenster MFC Anwendung. Gib dann noch einen Projektnamen und wähle den Speicherort des Projekts. Klicke auf OK und das Fenster MFC -Anwendungs-Assistent erscheint:
Klicke links auf Anwendungstyp (Application Type), um einen Anwendungstyp auswählen zu können. Wähle jetzt z.B Auf Dialogfeldern basierend (Dialog based) und stelle ggf. Ressource Language auf Deutsch um. Klicke links einmal auf Benutzeroberflächenfeatures (User Interface Features):
Hier kann u.a. festgelegt werden, ob ein Infofeld (About box) eingefügt werden soll, ob ein Systemmenü vorhanden sein soll und welche weiteren Elemente es enthalten soll. Klicke links einmal auf Erweiterte Features (Advanced Features):
Hier kann man u.a. die Unterstützung für ActiveX einfügen oder Allgemeines Steuerelementmanifest (Common Control Manifest). Damit bekommen die Anwendungen einen Windows XP Style. Mit einem Klick auf Fertig stellen wird die neue Dialogfeldbasierte Anwendung erstellt.
Es ist möglich Funktionen zu überschreiben, um eigenen Code einzufügen. Eine oft verwendete Funktion in den Beispielen ist PreTranslateMessage(). Um diese oder andere Funktionen zu überschreiben geht man folgendermaßen vor:
Visual C++ 6.0
Unter VC++ 6.0 wird dies über den Klassen-Assistent erledigt und funktioniert genau so wie unter: Einfügen von Nachrichtenbehandlungsroutinen beschrieben. Angenommen wir wollen die Funktion PreTranslateMessage überschreiben, dann sieht das so aus:
Ein weitere Möglichkeit:
Es geht auch so: Gehe im Arbeitsbereich in das Register Klassen und klicke mit rechter Maustaste auf die Klasse für die eine Funktion überschrieben werden soll. Klicke aufklappenden Kontextmenü auf Virtuelle Funktion hinzufügen.... Der aufgehende Dialog sieht so aus:
Visual C++.NET 2002/2003 und Visual C++ 2005
Markiere in der Klassen-Ansicht die Klasse für die eine Funktion überschrieben werden soll und wähle im aufklappenden Kontextmenü Eigenschaften (Properties). Die Klassen-Ansicht mit einer markierten Klasse sieht so aus:
Das Eigenschafts-Fenster hat in der Toolbar ein neues Element bekommen und zwar dieses Symbol:  (Überschreibungen / engl. Overrides). Klickt man dieses Symbol an, werden alle Funktionen aufgelistet, die sich überschreiben lassen, was so aussieht:
Ressourcen lassen sich bei Visual C++ 6.0, Visual C++.NET 2002/2003 und Visual C++ 2005 relativ gleich einfügen. Jetzt folgen Beschreibungen wie man Bitmaps, Dialoge, Icons, Menüs und Toolbar einfügen kann.
Es gibt zwischen den verschiedenen Versionen nur geringe Unterschiede beim Importieren eines Bitmaps.
Visual C++ 6.0
Füge ein neues Bitmap ein, indem du im Arbeitsbereich auf Ressourcen gehst und dort mit der rechten Maustaste auf Dialog klickst. Wähle im aufgeklappten Kontextmenü Einfügen... und der Dialog Ressource einfügen erscheint. Klicke darin einmal auf Bitmap und dann auf den Button Neu.
Visual C++.NET 2002/2003 und Visual C++ 2005
Füge ein neues Bitmap ein, indem du in der Ressourcenansicht (Ressource View) mit der rechten Maustaste auf Dialog klickst. Wähle im aufgeklappten Kontextmenü Ressource hinzufügen (Add Ressource...) und der Dialog Ressource hinzufügen (Add Ressource) erscheint. Klicke darin einmal auf Bitmap und dann auf den Button Neu.
Es gibt zwischen den verschiedenen Versionen nur geringe Unterschiede beim Importieren eines Bitmaps.
Visual C++ 6.0
Importiere ein Bild im .bmp-Format, indem du im Arbeitsbereich auf Ressourcen gehst und dort mit der rechten Maustaste auf Dialog klickst. Wähle im aufgeklappten Kontextmenü Einfügen... und der Dialog Ressource einfügen erscheint. Klicke darin einmal auf Bitmap und dann auf den Button Importieren. Im aufgeklappten Fenster (Ressource importieren) wähle als Dateityp: Alle Dateien und suche die Datei aus, die importiert werden soll.
Bei Visual C++ 6.0 gibt es noch eine Besonderheit: Wenn das Bitmap mehr als 256 Farben hat, wird man darauf hingewiesen das die Datei richtig importiert wurde, aber nicht angezeigt werden kann. Im Entwurfsmodus ist das Bild dann nicht sichtbar, kompiliert man das Programm sieht man das Bild richtig.
Visual C++.NET 2002/2003 und Visual C++ 2005
Importiere ein Bild im .bmp-Format, indem du in der Ressourcenansicht (Ressource View) mit der rechten Maustaste auf Dialog klickst und wähle im aufklappenden Kontextmenü Ressource hinzufügen... (Add Resource...). Dialog Ressource hinzufügen (Add Ressource) erscheint. Klicke darin einmal auf Bitmap und dann auf den Button Importieren. Im aufklappenden Fenster (Ressource importieren) wähle den Pfad des Bildes aus das importiert werden soll.
Es gibt keinen Unterschied beim Einfügen eines neuen Dialogs zwischen den verschiedenen Versionen, allerdings unterscheidet sich das Einfügen einer neuen Klasse für den eingefügten Dialog etwas.
Visual C++ 6.0
Füge einen neuen Dialog in deine Anwendung ein, indem du im Arbeitsbereich auf Ressourcen gehst und dort mit der rechten Maustaste auf Dialog klickst. Wähle im aufklappenden Kontextmenü Dialog einfügen. Der neue Dialog wird hinzugefügt und kann bearbeitet werden. Um eine Klasse für den eben erstellten Dialog einzufügen, öffne den Klassen-Assistenten über das Menü: Ansicht oder drücke Ctrl + W und der Dialog Hinzufügen einer Klasse erscheint:
Wähle die voreingestellte Option Neue Klasse erstellen und der Dialog Neue Klasse erscheint:
Hier muss man lediglich seinen gewünschten Klassennamen eingeben und mit OK bestätigen. Die Basisklasse belassen wir auf der Voreinstellung (CDialog) ausser wir wollen von einer anderen Klasse ableiten und auch unter Dialogfeld-ID ist schon richtigerweise die ID unseres eingefügten Dialogs vorgegeben.
Visual C++.NET 2002/2003 und Visual C++ 2005
Füge einen neuen Dialog in deine Anwendung ein, indem du in der Ressourcenansicht (Ressource View) mit der rechten Maustaste auf Dialog klickst und wähle im aufklappenden Kontextmenü Dialog einfügen. Der neue Dialog wird hinzugefügt und kann bearbeitet werden. Um eine Klasse für den eben erstellten Dialog einzufügen, klicke mit der rechten Maustaste auf den eben eingefügten Dialog und wähle: Klasse hinzufügen... (Add Class...). Der aufklappende Dialog sieht so aus:
Hier muss man lediglich seinen gewünschten Klassennamen eingeben, die Basisklasse stellen wir auf CDialog, ausser wir wollen von einer anderen Klasse ableiten. Unter Dialogfeld-ID ist schon richtigerweise die ID unseres eingefügten Dialogs vorgegeben.
Es gibt zwischen den verschiedenen Versionen keine Unterschiede beim Einfügen eines Icons.
Visual C++ 6.0
Füge ein neues Icon in deine Anwendung ein, indem du im Arbeitsbereich auf Ressourcen gehst und dort mit der rechten Maustaste auf Icon klickst. Wähle im aufgeklappten Kontextmenü Icon Einfügen... und das Icon wird eingefügt.
Visual C++.NET 2002/2003 und Visual C++ 2005
Füge ein neues Icon in deine Anwendung ein, indem du in der Ressourcenansicht (Ressource View) mit der rechten Maustaste auf Icon klickst. Wähle im aufgeklappten Kontextmenü Icon Einfügen... (Add Icon...) und das Icon wird eingefügt.
Es gibt zwischen den verschiedenen Versionen nur geringe Unterschiede beim Importieren eines Icons.
Visual C++ 6.0
Importiere ein vorhandenes Icon, indem du im Arbeitsbereich auf Ressourcen gehst und dort mit der rechten Maustaste auf Dialog klickst. Wähle im aufgeklappten Kontextmenü Einfügen... und der Dialog Ressource einfügen erscheint. Klicke darin einmal auf Icon und dann auf den Button Importieren (Import). Im aufgeklappten Fenster (Ressource importieren/Import) wähle als Dateityp: Symbole (*.ico) und suche das Icon aus, welches importiert werden soll.
Visual C++.NET 2002/2003 und Visual C++ 2005
Importiere ein vorhandenes Icon, indem du in der Ressourcenansicht (Ressource View) mit der rechten Maustaste auf Dialog klickst. Wähle im aufgeklappten Kontextmenü Ressource hinzufügen (Add Ressource...) und der Dialog Ressource hinzufügen (Add Ressource) erscheint. Klicke darin einmal auf Icon und dann auf den Button Importieren (Import). Im aufgeklappten Fenster (Ressource importieren/Import) wähle als Dateityp: Symbole (*.ico) bzw. Alle Dateien (*.*) und suche das Icon aus, welches importiert werden soll.
Es gibt zwischen den verschiedenen Versionen keine Unterschiede beim Einfügen eines Menüs und nur geringe Unterschiede beim Einfügen von Überschriften und Einträge. Allerdings gibt es große Unterschiede beim Einfügen von Funktionen für erstellte Menüeinträge.
Visual C++ 6.0
Füge ein Menü in deine Anwendung ein, indem du im Arbeitsbereich (Ressource View) auf Ressourcen (Ressource View) gehst und dort mit der rechten Maustaste auf Dialog klickst. Wähle im aufgeklappten Kontextmenü Einfügen... (Add). Im aufklappenden Dialog Ressource einfügen klicke auf Menü und dann auf Neu.
Nachdem Überschriften und Einträge für das Menü eingefügt wurden, öffne den Klassen-Assistent und es erscheint folgender Dialog:
Wähle Vorhandene Klasse auswählen und es erscheint der Dialog Klasse auswählen:
Wähle darin die Dialogklasse. Im Beispiel war der Name der Anwendung: Menue, also ist die Bezeichnung der Dialogklasse: CMenueDlg. Jetzt können Funktionen für die Menüeinträge über den Klassen-Assistent wie gewohnt eingefügt werden:
Jetzt muss das Menü noch dem Dialog zugewiesen werden, in welchem es angezeigt werden soll. Klicke mit der rechten Maustaste auf den Dialog in dem das Menü erscheinen soll und wähle im aufklappenden Kontextmenü Eigenschaften. Wähle im Register Allgemein bei Menü das Menü aus:
Visual C++.NET 2002/2003 und Visual C++ 2005
Füge ein Menü in deine Anwendung ein, indem du in der Ressorcenansicht (Ressource View) mit der rechten Maustaste auf Dialog klickst. Wähle im aufgeklappten Kontextmenü Ressource hinzufügen... (Add Ressource...). Im aufklappenden Dialog Ressource einfügen klicke auf Menü und dann auf Neu.
Nachdem Menüberschriften und Menüeinträge eingefügt wurden, kann man Funktionen für die Menüeinträge einfügen, indem man mit rechter Maustaste auf einen Menüeintrag klickt und dann "Ereignishandler wird hinzugefügt..." wählt.
Jetzt muss das Menü noch dem Dialog zugewiesen werden, in welchem es angezeigt werden soll. Klicke mit der rechten Maustaste auf den Dialog in dem das Menü erscheinen soll und wähle im aufklappenden Kontextmenü Eigenschaften. Unter Misc kann man das Menü einstellen:
Es gibt zwischen den Versionen keinen Unterschied beim Einfügen einer Toolbar.
Visual C++ 6.0
Füge eine neue Toolbar in deine Anwendung ein, indem du im Arbeitsbereich (Ressource View) auf Ressourcen (Ressource View) gehst und dort mit der rechten Maustaste auf Dialog klickst. Wähle im aufgeklappten Kontextmenü Einfügen... (Add). Im aufklappenden Dialog Ressource einfügen klicke auf Toolbar und dann auf Neu.
Visual C++.NET 2002/2003 und Visual C++ 2005
Füge ein neue Toolbar in deine Anwendung ein, indem du in der Ressorcenansicht (Ressource View) mit der rechten Maustaste auf Dialog klickst. Wähle im aufgeklappten Kontextmenü Ressource hinzufügen... (Add Ressource...). Im aufklappenden Dialog Ressource einfügen klicke auf Toolbar und dann auf Neu.
|
Die Vervielfältigung der auf diesen Seiten enthaltenen Informationen und Grafiken ist untersagt, ausgenommen davon ist sämtlicher auf diesen Seiten angezeigter Quellcode. Es wird keinerlei Gewähr für die Richtigkeit und Vollständigkeit der bereitgestellten Informationen übernommen. Haftungsansprüche für Schäden, die durch Nutzung der bereitgestellten Informationen verursacht wurden, sind ausgeschlossen. Für den Inhalt von angegebenen Verweisen wird keine Gewährleistung übernommen.
Copyright © 2005 coding-help.de | |
