Die Softwareindustrie hat in den vergangenen Jahren eine Revolution erlebt. Die Art und Weise, wie man Software erstellt und im Paket zusammenschnürt, hat sich von einem Modell, bei dem alle Anwendungen große, monolithische Stücke von ausführbarem Code waren, zu einem Modell entwickelt, bei dem die meisten Anwendungen aus kleinen Bausteinen bestehen. Diese kleinen Bausteine - oftmals als Komponenten bezeichnet - lassen sich mit den unterschiedlichsten Sprachen erstellen und können die verschiedensten Formen annehmen. Eine der bekanntesten Komponenten ist das ActiveX-Steuerelement. Wenn Sie wissen, wie man eigene ActiveX-Steuerelemente erstellt, können Sie eigene Komponenten erzeugen und anderen Programmierern zur Verfügung stellen. Heute lernen Sie, wie man ...
Ein ActiveX-Steuerelement ist eine funktionelle Einheit, die in einem COM- (Component Object Model) Objekt verpackt ist. Dieses COM-Objekt ist selbständig, obwohl es nicht die Fähigkeit besitzt, eigenständig zu laufen. Ein ActiveX-Steuerelement läßt sich nur innerhalb eines ActiveX-Containers ausführen, beispielsweise in einer Visual C++- oder Visual Basic-Anwendung.
Wie Sie am Tag 9 gelernt haben, stellen ActiveX-Steuerelemente eine Reihe von Schnittstellen bereit, auf die die Container-Anwendung zurückgreift, um die verschiedenen funktionellen Einheiten, die das Steuerelement bietet, auszulösen. Viele dieser Schnittstellen dienen dazu, Ereignisse im Steuerelement oder in der Container-Anwendung auszulösen. Andere Schnittstellen sind dafür vorgesehen, die Eigenschaftsseite des Steuerelements zu spezifizieren oder um mitzuteilen, ob das Steuerelement aktiviert wurde. Alles in allem sind in den meisten ActiveX-Steuerelementen derartig viele Schnittstellen eingebaut, daß man eine ganze Zeit brauchen würde, um die Funktionalität für jede dieser Schnittstellen selbst zu codieren. Glücklicherweise fügen der Anwendungs-Assistent und der Klassen-Assistent von Visual C++ den größten Teil dieser Funktionalität automatisch hinzu und gestatten Ihnen damit, daß Sie sich auf die spezifische Funktionalität, die man vom Steuerelement erwartet, konzentrieren können.
Für das zu erstellende Steuerelement müssen Sie trotzdem selbst festlegen, welche Eigenschaften, Methoden und Ereignisse Sie für das Steuerelement freilegen möchten. Diese Elemente können Sie dem Steuerelement über den Klassen-Assistenten hinzufügen. Wenn aber irgendwelche Eigenschaften oder Ereignisse speziellen Code von Ihrer Seite erfordern, müssen Sie ihn auch selbst hinzufügen. Wie bei allen Methoden, die Sie Ihren Steuerelementen hinzufügen, müssen Sie den gesamten Code bereitstellen. Der Klassen-Assistent baut automatisch die umgebende Struktur und den Code auf, um der Container-Anwendung zu erlauben, die Methode zu sehen und aufzurufen - genauso wie der Klassen-Assistent Ihrer Anwendung den erforderlichen Code hinzufügt, um beliebige Behandlungsroutinen aufzurufen.
Eigenschaften sind die Attribute von Steuerelementen, die für die Container-Anwendung sichtbar sind und sich oftmals auch durch diese modifizieren lassen. Die vier grundlegenden Typen der Eigenschaften sind ambient, erweitert, vordefiniert und benutzerdefiniert. Ambient-Eigenschaften - wie etwa Hintergrundfarbe oder Standardschrift - stellt die Container-Anwendung dem Steuerelement bereit, so daß das Steuerelement wie ein Teil der Container-Anwendung aussieht. Erweiterte Eigenschaften sind eigentlich keine Eigenschaften des Steuerelements, sondern werden von der Container-Anwendung bereitgestellt und implementiert, beispielsweise die Tabulator-Reihenfolge. Das Steuerelement kann diese Eigenschaften bis zu einem gewissen Grad erweitern. Wenn zum Beispiel das Steuerelement zwei oder mehr Standardsteuerelemente enthält, kann es die Tabulator-Reihenfolge im Steuerelement als Ganzes festlegen und die Kontrolle der Tabulator-Reihenfolge an die Anwendung zurückgeben, nachdem das Steuerelement die interne Tabulator-Reihenfolge durchlaufen hat. Vordefinierte Eigenschaften werden durch das ActiveX-Entwicklungskit implementiert, beispielsweise die Schrift oder die Hintergrundfarbe des Steuerelements. Mit dem letzten Typ, den benutzerdefinierten Eigenschaften, haben Sie am meisten zu tun, da diese Eigenschaften für Ihr Steuerelement spezifisch sind und sich direkt auf die Funktionalität des Steuerelements beziehen.
Über die Registerkarte Automatisierung können Sie alle Eigenschaften festlegen, die Sie in Ihrem Steuerelement brauchen. Wenn Sie eine neue Eigenschaft über den Klassen-Assistenten in das Steuerelement aufnehmen, spezifizieren Sie mehrere Aspekte der Eigenschaft.
Der erste Aspekt ist der externe Eigenschaftsname. Unter diesem Namen spricht auch die Container-Anwendung die Eigenschaft an. Ein weiterer Aspekt ist der, daß man den internen Variablennamen festlegen kann, den man selbst im Code verwendet, aber nur, wenn die Eigenschaft als Member-Variable implementiert ist. Weiterhin legen Sie den Variablentyp für die Eigenschaft fest.
Wenn Sie angeben, die Eigenschaft als Member-Variable zu implementieren (die
Eigenschaft ist eine Member-Variable der Steuerelementklasse), dann können Sie den
Namen der Benachrichtigungsfunktion spezifizieren, die aufzurufen ist, wenn die
Eigenschaft durch die Container-Anwendung geändert wird. Ist die Eigenschaft keine
Member-Variable der Steuerelementklasse, müssen Sie festlegen, daß sie über die
Methoden Get und Set abgerufen und geändert wird, wobei die Container-Anwendung
eine Get-Methode aufruft, um den aktuellen Wert der Eigenschaft zu holen, und
mit einer Set-Methode den Wert der Eigenschaft ändert. Wenn die Eigenschaft über
Get- und Set-Methoden verwaltet wird, können Sie die Namen dieser beiden Methoden
festlegen.
Für alle diese Aspekte einer Eigenschaft schlägt das Dialogfeld Eigenschaft hinzufügen
einen passenden Namen vor, nachdem Sie den externen Namen für die Eigenschaft
eingegeben haben. Wenn Sie die Standardnamen übernehmen möchten, müssen
Sie nur folgende Dinge festlegen: den externen Namen, den Typ und ob die
Variable eine Member-Variable ist oder die Methoden Get und Set zu verwenden sind.
Wenn Sie eine vordefinierte Eigenschaft aus der Liste der Standardeigenschaften auswählen,
werden die übrigen Elemente automatisch spezifiziert. Nachdem Sie alle Informationen
angegeben haben, fügt der Klassen-Assistent den gesamten erforderlichen
Code und die Variablen in Ihr Steuerelementprojekt ein.
Methoden sind Funktionen im Steuerelement, die sich durch die Container-Anwendung
aufrufen lassen. Die Funktionen werden über die (am Tag 9 behandelte) IDispatch
-Schnittstelle anderen Anwendungen verfügbar gemacht. Aufgrund der Arbeitsweise
von IDispatch beim Aufruf der Methoden in einem Steuerelement sind die an
die Methode zu übergebenden Variablen in einer Struktur zu verpacken, die an das
Steuerelement übergeben wird. Diese Struktur ist maschinenunabhängig, so daß es
keine Rolle spielt, ob das Steuerelement unter Windows 95/98 auf einem Intel Pentium
II oder unter Windows NT mit einem MIPS oder Alpha-Prozessor läuft. Die Struktur
ist immer die gleiche. Jede Seite des Funktionsaufrufs ist selbst dafür verantwortlich,
die Parameter nach Bedarf zu konvertieren, um sie korrekt in die Struktur
einzutragen oder sie daraus zu extrahieren. Diese Verpackung der Methodenparameter
bezeichnet man als Marshaling.
Wenn Sie Ihrem Steuerelement eine neue Methode über den Klassen-Assistenten auf
der Registerkarte Automatisierung hinzufügen, fügt der Klassen-Assistent sowohl
den gesamten erforderlichen Code ein, um das Marshaling der Parameter zu realisieren,
als auch andere unterstützende Funktionalität, wozu auch der Aufbau der IDispatch
-Schnittstelle und der Tabelle gehört.
Der Klassen-Assistent fordert Sie auf, den externen Namen für die Methode anzugeben, die durch die Container-Anwendung aufgerufen wird. Die Methode erhält einen vorgegebenen internen Namen, den Sie mit einem selbst gewählten internen Namen überschreiben können. Andere Aspekte Ihrer Steuerelementmethoden, die Sie festlegen müssen, sind der Rückgabetyp und die Parameter der Methode. Nachdem Sie diese Informationen eingegeben haben, fügt der Klassen-Assistent den gesamten erforderlichen Code automatisch ein.
Ereignisse sind Benachrichtigungen, die vom Steuerelement an die Container-Anwendung gesendet werden. Sie sind dafür vorgesehen, die Anwendung zu informieren, daß ein bestimmtes Ereignis eingetreten ist, und die Anwendung kann bei Bedarf eine Aktion unternehmen. Es lassen sich zwei Ereignisarten vom Steuerelement auslösen: vordefinierte und benutzerdefinierte Ereignisse. Vordefinierte Ereignisse werden vom ActiveX-Steuerelement-Entwicklungskit implementiert und sind als Funktionsaufrufe innerhalb des Steuerelements verfügbar. Über diese vordefinierten Ereignisse können Sie in der Container-Anwendung Ereignisse für Maus und Tastatur, Fehler oder Zustandsänderungen auslösen.
Neben den vordefinierten Ereignissen kann man eigene benutzerdefinierte Ereignisse hinzufügen, die in der Container-Anwendung ausgelöst werden. Diese Ereignisse sollten sich auf die spezifische Funktionalität Ihres Steuerelements beziehen. Man kann zusammen mit dem Ereignis an die Container-Anwendung Argumente übergeben, so daß die Anwendung die Daten erhält, die sie für die Reaktion auf die Nachricht benötigt.
Wenn Sie diese Ereignisse auslösen müssen, rufen Sie einfach die interne Ereignisfunktion auf, die das Ereignis initiiert, und übergeben alle erforderlichen Parameter an die Funktion. Der Klassen-Assistent fügt auch den gesamten Code hinzu, damit sich die Nachricht vom internen Funktionsaufruf auslösen läßt.
Ereignisse gehören zu den drei Elementen, die Sie für Ihr Steuerelement nicht auf der Registerkarte Automatisierung im Klassen-Assistenten festlegen, sondern über die Registerkarte ActiveX-Ereignisse des Klassen-Assistenten.
Im heutigen Beispiel erstellen Sie ein ActiveX-Steuerelement für Freihandzeichnungen, das Ihnen bereits aus Lektion 16 als Bibliotheksmodul bzw. Lektion 17 als DLL bekannt ist. Dieses Modul wandeln Sie nun in ein ActiveX-Steuerelement um. Dabei legen Sie als Eigenschaften des Steuerelements die Anzahl der vom Steuerelement zu zeichnenden Squiggles und auch die maximale Länge der Squiggles frei. Diese Eigenschaften kann die Container-Anwendung setzen. Das Steuerelement ist so programmiert, daß es beim Anklicken eine neue Squiggle-Zeichnung erzeugt. Außerdem fügen Sie eine Methode hinzu, um eine Squiggle-Zeichnung in das Steuerelement zu laden, die mit den vorherigen Versionen des Squiggle-Moduls erstellt wurde. Schließlich lassen Sie das Steuerelement ein Ereignis auslösen, um der Container-Anwendung mitzuteilen, daß das Steuerelement die Zeichnung geladen hat.
Sicherlich haben Sie mittlerweile bemerkt, daß im Dialogfeld Neu auf der Registerkarte Projekte die Option MFC ActiveX-Steuerelement-Assistent vorhanden ist. Es handelt sich um einen weiteren Projektassistenten analog zum Anwendungs-Assistenten, der Anwendungs- und DLL-Projekte erzeugt. Mit dem ActiveX-Steuerelement-Assistenten können Sie ein Gerüst für beliebige ActiveX-Steuerelemente erstellen. Der Assistent legt die erforderlichen Dateien an und konfiguriert das Projekt, so daß der Compiler ein ActiveX-Steuerelement erstellen kann.
Der Steuerelement-Assistent stellt im ersten Schritt ein paar Fragen über das Steuerelementprojekt, beispielsweise wie viele Steuerelemente das Projekt umfassen soll und ob die Steuerelemente mit Laufzeitlizenzen auszustatten sind.
Das zweite Dialogfeld des Steuerelement-Assistenten stellt etwas tiefergehende Fragen,
die aber dennoch leicht zu beantworten sind. In diesem Schritt können Sie auf
die Schaltfläche Namen bearbeiten klicken, um dem Steuerelement einen aussagekräftigen
Namen zu geben, mit dem der Benutzer etwas anfangen kann. Das Kombinationsfeld
im unteren Teil des Assistenten listet eine Reihe von Fensterklassen auf,
die von diesem Steuerelement als untergeordnete Klasse definiert werden können.
Wenn Sie ein spezielles Eingabefeld erstellen möchten, das bestimmte Editorfunktionen
für die Benutzereingaben erlaubt, wählen Sie EDIT aus der Liste der Fensterklassen
im Dropdown-Teil des Kombinationsfelds. Über die Schaltfläche Erweitert gelangen
Sie zu einem Dialogfeld, bei dem die Beantwortung der Fragen ein
tiefergehendes Verständnis der ActiveX-Steuerelemente erfordert.
Legen Sie für das heutige Beispiel eines Steuerelements ein neues Projekt an, indem
Sie im Dialogfeld Neu auf der Registerkarte Projekte die Option MFC ActiveX-
Steuerelement-Assistent wählen und dem Projekt einen passenden Namen wie
etwa Squiggle geben (siehe Abbildung 19.1).
Abbildung 19.1:
Das Projekt eines ActiveX-Steuerelements beginnen
Im ersten Schritt des MFC ActiveX-Steuerelement-Assistenten übernehmen Sie die Standardeinstellungen, da Sie heute nur ein einzelnes Steuerelement erstellen und auch keine Laufzeitlizenz einbinden. Im zweiten Dialogfeld des Steuerelement- Assistenten klicken Sie auf die Schaltfläche Namen bearbeiten. Stellen Sie sicher, daß der Typ-Name das Steuerelement ausreichend charakterisiert. Klicken Sie auf OK, um die Namen zu akzeptieren und zum zweiten Dialogfeld des ActiveX-Steuerelement-Assistenten zurückzukehren. Wenn Sie im ersten Schritt festgelegt haben, daß Sie mehrere Steuerelemente erzeugen, können Sie im Dropdown-Listenfeld neben der Schaltfläche Namen bearbeiten die einzelnen Steuerelemente auswählen und jeweils die Namen für das Projekt festlegen. Für die übrigen Optionen des Steuerelement-Assistenten können Sie im Beispielprojekt die Standardeinstellungen übernehmen.
Nachdem Sie das Gerüst des Steuerelements erstellt haben, kopieren Sie die Dateien
Line und ModArt aus dem Projektverzeichnis des am Tag 16 angelegten Bibliotheksprojekts.
Laden Sie alle vier Dateien in das Steuerelementprojekt, und fügen Sie dem
Projekt die Klassen CLine und CModArt hinzu.
Die Änderungen, die Sie an der Klasse CModArt für Ihr Steuerelement vornehmen
müssen, betrifft die Variablen für die Maximalzahl und die Länge der Squiggels, die als
Eigenschaften des Steuerelements freigelegt werden können. Zu diesem Zweck fügen
Sie der Klasse CModArt zwei Member-Variablen hinzu. Mit der einen Variablen steuern
Sie die Länge der Squiggles, mit der anderen die Anzahl. Fügen Sie diese beiden Variablen
der Klasse CModArt gemäß Tabelle 19.1 hinzu.
Es ist nun eine Möglichkeit zu schaffen, um die Variablen über die freigelegten Eigenschaften
abrufen und aktualisieren zu können. Das bedeutet, daß Sie für beide Werte
Funktionen brauchen, um den aktuellen Wert zu holen und den neuen Wert einzustellen.
Für die Variable m_iLength nehmen Sie zu diesem Zweck eine Member-Funktion
in die Klasse CModArt auf. Legen Sie den Funktionstyp als int, die Deklaration als
GetLength und den Zugriff als Public fest. In die Funktion schreiben Sie den Code aus
Listing 19.1.
Listing 19.1: Die Funktion GetLength der Klasse CModArt
1: int CModArt::GetLength()
2: {
3: // Aktuellen Wert für Variable m_iLength zurückgeben
4: return m_iLength;
5: }
Als nächstes fügen Sie eine weitere Member-Funktion in die Klasse CModArt ein. Legen
Sie den Funktionstyp als void, die Deklaration mit SetLength(int iLength) und
den Zugriff als Public fest. In die Funktion übernehmen Sie den Code aus Listing
19.2.
Listing 19.2: Die Funktion SetLength der Klasse CModArt
1: void CModArt::SetLength(int iLength)
2: {
3: // Aktuellen Wert für Variable m_iLength setzen
4: m_iLength = iLength;
5: }
Analoge Funktionen fügen Sie für die Variable m_iSegments hinzu, so daß sich diese
Variable ebenfalls als Eigenschaft des Steuerelements freilegen läßt.
Nachdem Sie die beiden Eigenschaften für das Steuerelement verfügbar gemacht haben,
stellen Sie sicher, daß sie auf vernünftige Werte initialisiert werden, bevor das
Steuerelement zum Einsatz kommt. Um die Werte zu initialisieren, modifizieren Sie
den Konstruktor von CModArt gemäß Listing 19.3.
Listing 19.3: Der modifizierte Konstruktor der Klasse CModArt
1: CModArt::CModArt()
2: {
3: // Zufallszahlengenerator initialisieren
4: srand((unsigned)time(NULL));
5: // Eigenschaftsvariablen initialisieren
6: m_iLength = 200;
7: m_iSegments = 50;
8: }
Schließlich modifizieren Sie die beiden Funktionen, die die Squiggle-Zeichnungen erstellen,
so daß sie die Variablen anstelle der momentan fest kodierten Werte verwenden.
Um die Funktion NewDrawing zu modifizieren, ersetzen Sie die Maximalzahl der
Squiggles entsprechend Zeile 7 von Listing 19.4 durch die Variable m_iSegments.
Listing 19.4: Die modifizierte Funktion NewDrawing der Klasse CModArt
1: void CModArt::NewDrawing()
2: {
3: int lNumLines;
4: int lCurLine;
5:
6: // Anzahl der zu erzeugenden Linien bestimmen
7: lNumLines = rand() % m_iSegments;
8: // Sind Linien zu erzeugen?
9: if (lNumLines > 0)
10: {
11: // Schleife durch Anzahl der Linien
12: for (lCurLine = 0; lCurLine < lNumLines; lCurLine++)
13: {
14: // Die neue Linie erzeugen
15: NewLine();
16: }
17: }
18: }
Schließlich ersetzen Sie die Maximallänge der Squiggles in der Funktion NewLine gemäß
Zeile 20 von Listing 19.5 durch die Variable m_iLength.
Listing 19.5: Die modifizierte Funktion NewLine der Klasse CModArt
1: void CModArt::NewLine()
2: {
3: int lNumLines;
.
.
.
18:
19: // Anzahl der Teile dieses Squiggles bestimmen
20: lNumLines = rand() % m_iLength;
21: // Umfaßt das Squiggle mindestens ein Teil?
.
.
.
67: }
An den Klassen CModArt und CLine haben Sie nun alle erforderlichen Änderungen für
Ihr ActiveX-Steuerelement vorgenommen. Jetzt müssen Sie eine Instanz der Klasse
CModArt in die Steuerelementklasse als Member-Variable hinzufügen. Nehmen Sie
eine neue Member-Variable in die Steuerelementklasse CSquiggleCtrl auf. Legen Sie
den Variablentyp als CModArt, den Namen als m_maDrawing und den Zugriff als Privat
fest. Weiterhin müssen Sie die Header-Datei für die Klasse CModArt in die Quellcodedatei
der Steuerelementklasse aufnehmen. Öffnen Sie dazu die Datei, gehen Sie an
den Beginn der Datei, und fügen Sie eine Include-Anweisung für die Datei ModArt.h
gemäß Listing 19.6 hinzu.
Listing 19.6: Die Include-Anweisungen von CSquiggleCtrl
1: // SquiggleCtl.cpp: Implementierung der CSquiggleCtrl-ActiveX-
ÂSteuerelementklasse.
2:
3: #include "stdafx.h"
4: #include "Squiggle.h"
5: #include "SquiggleCtl.h"
6: #include "SquigglePpg.h"
7: #include "ModArt.h"
Da die beiden Variablen, die Sie in die Klasse CModArt aufgenommen haben, keine
Variablen der Steuerelementklasse (CSquiggleCtrl) sind, sieht man normalerweise
Get- und Set-Methoden vor, um den Eigenschaftswert abzurufen bzw. zu setzen. Wären
diese Variablen Elemente der Steuerelementklasse, könnten Sie sie über den Klassen-Assistenten
als Member-Variablen hinzufügen. Sie wüßten dann immer darüber
Bescheid, wann und ob sich die Variablen geändert haben, da in der Steuerelementklasse
auch eine Benachrichtigungsmethode enthalten wäre, wie bei Änderung des
Eigenschaftswerts aufgerufen wird. Weil aber nun die Variablen Elemente einer internen
Klasse sind, braucht man etwas mehr Kontrolle über deren Werte.
Um diese Eigenschaften Ihrem Steuerelement hinzuzufügen, öffnen Sie den Klassen-
Assistenten und gehen auf die Registerkarte Automatisierung, wie es Abbildung
19.2 zeigt. Klicken Sie auf die Schaltfläche Eigenschaft hinzufügen, um die erste
Eigenschaft aufzunehmen. Im Dialogfeld Eigenschaft hinzufügen geben Sie den externen
Namen ein, den die Eigenschaft haben soll, beispielsweise SquiggleLength,
und legen den Typ als short fest (der Typ int ist nicht verfügbar, nur short und
long). Klicken Sie auf das Optionsfeld Get/Set-Methoden. Daraufhin erscheinen im
Dialogfeld die Namen für die beiden Methoden, wie es Abbildung 19.3 zeigt. Klicken
Sie auf OK, um die Eigenschaft hinzuzufügen.
Abbildung 19.2:
Die Registerkarte Automatisierung des Klassen-Assistenten
Abbildung 19.3:
Das Dialogfeld Eigenschaften hinzufügen
Klicken Sie auf die Schaltfläche Code bearbeiten, um den Code für die Get- und Set-
Methoden, die Sie der Klasse CModArt hinzugefügt haben, um den Zugriff auf die Längenvariable
zu steuern, einzugeben. Schreiben Sie den Code aus Listing 19.7 in die
beiden Methoden.
Listing 19.7: Die Funktionen Get/SetSquiggleLength
1: short CSquiggleCtrl::GetSquiggleLength()
2: {
3: // ZU ERLEDIGEN: Fügen Sie hier Ihre Behandlungsroutine für Eigenschaften
Âhinzu
4: // Ergebnis der Funktion GetLength zurückgeben
5: return m_maDrawing.GetLength();
6: }
7:
8: void CSquiggleCtrl::SetSquiggleLength(short nNewValue)
9: {
10: // ZU ERLEDIGEN: Fügen Sie hier Ihre Behandlungsroutine für Eigenschaften
Âhinzu
11: // Neue Länge setzen
12: m_maDrawing.SetLength(nNewValue);
13: SetModifiedFlag();
14: }
Sehen Sie eine weitere Eigenschaft für die Anzahl der Squiggles in der Zeichnung vor,
indem Sie die gleichen Schritte ausführen, dabei aber einen entsprechenden Eigenschaftsnamen
wie etwa NumberSquiggles verwenden.
Als letzte Eigenschaft soll das Steuerelement eine boolesche Eigenschaft erhalten,
über die die Container-Anwendung Einfluß auf das Erzeugen neuer Zeichnungen und
die Sichtbarkeit der aktuellen Zeichnung hat. Nehmen Sie eine neue Eigenschaft über
den Klassen-Assistenten auf, vergeben Sie einen geeigneten Namen wie etwa KeepCurrentDrawing
, und legen Sie den Typ als BOOL fest. Übernehmen Sie die vorgeschlagene
Implementierung als Member-Variable, und klicken Sie auf OK. Der Klassen-Assistent
nimmt die Variable automatisch in die Steuerelementklasse auf und
schreibt auch den erforderlichen Code, um die Variable zu verwalten.
Für das Steuerelement ist eine Eigenschaftsseite bereitzustellen, auf die Entwickler zugreifen können, wenn sie mit Ihrem Steuerelement arbeiten. Diese Eigenschaftsseite liefert den Benutzern ein Mittel, um die Eigenschaften des Steuerelements zu setzen, selbst wenn ihre eigenen Entwicklungswerkzeuge keine Einrichtung bieten, um die Eigenschaften in einer anderen Form als per Code zugänglich zu machen.
Eine Eigenschaftsseite läßt sich dem Steuerelement in einfacher Weise hinzufügen.
Wenn Sie die Registerkarte Ressourcen im Arbeitsbereich wählen und den Ordner
Dialog erweitern, finden Sie hier bereits ein Dialogfeld für die Eigenschaften des Steuerelements
(IDD_PROPPAGE_SQUIGGLE). Es handelt sich um ein normales Dialogfeld, das
Sie mit den Standardsteuerelementen des Dialog-Editors entwerfen können. Um die
Eigenschaftsseite für das Steuerelement des Beispiels zu gestalten, nehmen Sie den
Entwurf des Dialogfelds wie in Abbildung 19.4 und mit den Eigenschaftseinstellungen
gemäß Tabelle 19.2 vor.
Abbildung 19.4:
Das Layout der Eigenschaftsseite für das Steuerelement
Nachdem Sie alle Steuerelemente plaziert und die Eigenschaften festgelegt haben, öffnen Sie den Klassen-Assistenten, um den Steuerelementen Variablen zuzuordnen. Wenn Sie einem der Steuerelemente im Dialogfeld Eigenschaften eine Variable hinzufügen, erscheint ein zusätzliches Kombinationsfeld im Dialogfeld Member-Variable hinzufügen. Dieses Kombinationsfeld ist für den externen Namen der Eigenschaft vorgesehen, an die die Variable im Steuerelement gebunden werden soll. Die Dropdown- Liste in diesem Kombinationsfeld enthält alle Standardeigenschaften, die Sie mit der Eigenschaftsseite des Steuerelements verbinden können. Wenn Sie aber das Steuerelement mit einer benutzerdefinierten Eigenschaft verbinden möchten, müssen Sie den Eigenschaftsnamen selbst eingeben, wie es Abbildung 19.5 zeigt.
Abbildung 19.5:
Das Dialogfeld Member-Variable hinzufügen
Fügen Sie Variablen für die Steuerelemente auf der Eigenschaftsseite Ihres Steuerelements hinzu, und binden Sie sie an die Eigenschaften des Steuerelements, wie es Tabelle 19.3 angibt.
Klicken Sie auf OK, um alle Variablen in die Klasse der Eigenschaftsseite für das Steuerelement aufzunehmen.
Als grundlegende Funktionalität soll Ihr Steuerelement auf Mausklicks hin eine neue
Zeichnung generieren. Um dieses Verhalten zu steuern, nehmen Sie eine zweite boolesche
Variable in die Steuerelementklasse auf, damit die Funktion OnDraw weiß, daß
ein Mausklick ausgelöst wurde. Am einfachsten läßt sich der Zeichenbereich in der
Funktion OnDraw ermitteln, so daß hier auch die Zeichnungen generiert werden. Soll
nun das Steuerelement jedesmal eine neue Zeichnung hervorbringen, wenn der Benutzer
die Anwendung mit Ihrem Steuerelement vor eine andere Anwendung verschiebt?
Wahrscheinlich nicht. Höchstwahrscheinlich wollen Sie mehr Einfluß auf das
Verhalten des Steuerelements ausüben, so daß sich diese zweite boolesche Variable
anbietet. Nehmen Sie eine Member-Variable in die Steuerelementklasse (CSquiggleCtrl
) auf. Legen Sie den Variablentyp als BOOL, den Variablennamen mit
m_bGenNewDrawing und den Zugriff als Privat fest.
Bevor Sie den Code eingeben, der die verschiedenen Aufgaben realisiert, müssen Sie
zunächst alle Member-Variablen in der Steuerelementklasse initialisieren. Dazu gehört
die als Eigenschaft festgelegte Member-Variable m_keepCurrentDrawing und die Member-Variable,
die Sie gerade hinzugefügt haben, m_bGenNewDrawing. Das Steuerelement
soll eine neue Zeichnung aufs Geratewohl generieren, und Sie wollen sicherlich
nicht irgendwelche Zeichnungen verwalten, außer wenn die Container-Anwendung
explizit festlegt, daß eine Zeichnung zu verwalten ist. Die beiden Variablen setzen Sie
entsprechend im Konstruktor der Steuerelementklasse, wie es Listing 19.8 zeigt.
Listing 19.8: Der Konstruktor der Klasse CSquiggleCtrl
1: CSquiggleCtrl::CSquiggleCtrl()
2: {
3: InitializeIIDs(&IID_DSquiggle, &IID_DSquiggleEvents);
4:
5: // ZU ERLEDIGEN: Daten der Steuerelementinstanz hier initialisieren.
6: // Variablen initialisieren
7: m_bGenNewDrawing = TRUE;
8: m_keepCurrentDrawing = FALSE;
9: }
Als nächstes fügen Sie den Code hinzu, um die Squiggle-Zeichnungen zu generieren
und anzuzeigen. Für diese Funktionalität bietet sich die Funktion OnDraw in der Steuerelementklasse
an. Die Funktion wird immer dann aufgerufen, wenn sich das Steuerelement
selbst neu zeichnen muß, ob es nun verborgen war oder ein anderes Ereignis
über die Funktion Invalidate das Neuzeichnen des Steuerelements ausgelöst hat. In
der Funktion OnDraw können Sie auch gleich ermitteln, ob eine neue Zeichnung zu generieren
oder einfach die vorhandene Zeichnung neu darzustellen ist. Man sollte auch
daran denken, daß man für das Zeichnen des gesamten Bereichs, den das Steuerelement
einnimmt, verantwortlich ist. Das bedeutet, daß Sie den Hintergrund der
Squiggle-Zeichnung erstellen müssen, da sonst die Squiggles auf dem erscheinen, was
gerade in diesem Anzeigebereich vorhanden ist. (Wer weiß? Vielleicht ist es gerade
der Effekt, den Sie erzielen wollen.) Um diese Funktionalität in Ihrem Steuerelement
zu realisieren, bearbeiten Sie die Funktion OnDraw in der Steuerelementklasse und fügen
den Code aus Listing 19.9 hinzu.
Listing 19.9: Die Funktion OnDraw der Klasse CSquiggleCtrl
1: void CSquiggleCtrl::OnDraw(
2: CDC* pdc, const CRect& rcBounds, const CRect& rcInvalid)
3: {
4: // ZU ERLEDIGEN: Folgenden Code durch eigene Zeichenfunktion ersetzen.
5: //pdc->FillRect(rcBounds,
ÂCBrush::FromHandle((HBRUSH)GetStockObject(WHITE_BRUSH)));
6: //pdc->Ellipse(rcBounds);
7: // Muß neue Zeichnung generiert werden?
8: if (m_bGenNewDrawing)
9: {
10: // Zeichenbereich für neue Zeichnung festlegen
11: m_maDrawing.SetRect(rcBounds);
12: // Alte Zeichnung löschen
13: m_maDrawing.ClearDrawing();
14: // Neue Zeichnung generieren
15: m_maDrawing.NewDrawing();
16: // Steuerflag zurücksetzen
17: m_bGenNewDrawing = FALSE;
18: }
19: // Hintergrund füllen
20: pdc->FillRect(rcBounds,
21: CBrush::FromHandle((HBRUSH)GetStockObject(WHITE_BRUSH)));
22: // Squiggle-Zeichnung ausgeben
23: m_maDrawing.Draw(pdc);
24: }
Schließlich lösen Sie das Steuerelement aus, um eine neue Zeichnung zu generieren,
sobald der Benutzer auf das Steuerelement klickt. Dafür ist eine Behandlungsroutine
für das Ereignis OnClick des Steuerelements erforderlich. Zuerst nehmen Sie aber
eine vordefinierte Methode in das Steuerelement auf, um sicherzustellen, daß es die
Nachricht OnClick erhält. Öffnen Sie dazu den Klassen-Assistenten, und gehen Sie
auf die Registerkarte Automatisierung. Nehmen Sie in die Steuerelementklasse eine
neue Methode auf. Wählen Sie dafür die Methode DoClick aus der Dropdown-Liste
der vordefinierten Methoden aus, wie es Abbildung 19.6 zeigt. Klicken Sie auf OK,
um die Methode in Ihr Steuerelement aufzunehmen, und gehen Sie dann im Klassen-
Assistenten auf die Registerkarte Nachrichtenzuordnungstabellen. Markieren Sie
die Nachricht OnClick in der Liste der verfügbaren Nachrichten, und fügen Sie für diese
Nachricht eine Behandlungsroutine hinzu. In die OnClick-Behandlungsroutine
übernehmen Sie den Code aus Listing 19.10.
Abbildung 19.6:
Das Dialogfeld Methode hinzufügen
Listing 19.10: Die Funktion OnClick der Klasse CSquiggleCtrl
1: void CSquiggleCtrl::OnClick(USHORT iButton)
2: {
3: // TODO: Speziellen Code hier einfügen und/oder Basisklasse aufrufen
4: // Kann eine neue Zeichnung generiert werden?
5: if (!m_keepCurrentDrawing)
6: {
7: // Flag setzen, so daß neue Zeichnung generiert wird
8: m_bGenNewDrawing = TRUE;
9: // Steuerelement ungültig machen, um Funktion OnDraw auszulösen
10: Invalidate();
11: }
12: COleControl::OnClick(iButton);
13: }
Die Funktion OnClick prüft zuerst, ob eine neue Zeichnung zu generieren oder die aktuelle
Zeichnung zu verwalten ist. Beim Generieren einer neuen Zeichnung wird das
Flag m_bGenNewDrawing auf TRUE gesetzt und das Steuerelement mit der Funktion
Invalidate ungültig gemacht. Das löst den Aufruf der Funktion OnDraw aus.
Denken Sie noch einmal an die Funktionalität, die das Steuerelement erhalten soll: Eine der Funktionen lädt eine Squiggle-Zeichnung, die mit dem Squiggle-Modul in der Version von Tag 16 erstellt wurde. Zu diesem Zweck nehmen Sie eine Methode in das Steuerelement auf, die die Container-Anwendung aufrufen kann, um den Namen einer zu ladenden Datei zu übergeben. Der Anwendung haben Sie bereits eine Methode hinzugefügt, und zwar eine vordefinierte Methode. Eine benutzerdefinierte Methode läßt sich fast in der gleichen Weise hinzufügen, man muß aber ein paar mehr Angaben im Dialogfeld Methode hinzufügen ausfüllen.
In der Methode zum Laden einer vorhandenen Zeichnung erzeugen Sie ein CFile-Objekt
für den als Parameter übergebenen Dateinamen. Der Konstruktor von CFile
übernimmt den Dateinamen und das Flag CFile::modeRead, um dem Objekt mitzuteilen,
daß die Datei schreibgeschützt zu öffnen ist. Nachdem Sie das CFile-Objekt erstellt
haben, erzeugen Sie ein CArchive-Objekt, um die Datei zu lesen. Der Konstruktor
von CArchive übernimmt das CFile-Objekt, das Sie gerade erzeugt haben, und das
Flag CArchive::load, um dem Objekt mitzuteilen, daß die Datei zu laden ist. Jetzt
können Sie das CArchive-Objekt an die Funktion Serialize des Zeichenobjekts übergeben
und die Zeichnung lesen und laden lassen. Nachdem die Zeichnung geladen ist,
zeigen Sie sie an, indem Sie das Steuerelement ungültig machen. Vorher setzen Sie
noch das Flag m_bGenNewDrawing auf FALSE, damit die eben geladene Zeichnung nicht
überschrieben wird.
Öffnen Sie den Klassen-Assistenten, und gehen Sie auf die Registerkarte Automatisierung
. Klicken Sie auf die Schaltfläche Methode hinzufügen, um eine benutzerdefinierte
Methode aufzunehmen. Geben Sie den externen Namen der Methode in das
erste Kombinationsfeld ein, im Beispiel LoadDrawing. Der interne Name wird automatisch
auf der Basis des eingegebenen externen Namens erzeugt. Legen Sie dann den
Rückgabetyp als BOOL fest, um die Container-Anwendung darüber informieren zu können,
ob das Steuerelement die Zeichnung laden konnte. Schließlich fügen Sie noch einen
Parameter in die Parameterliste ein. Legen Sie den Namen als sFileName und
den Typ als LPCTSTR fest (der Typ CString ist nicht verfügbar, aber der Typ LPCTSTR
ist kompatibel), wie es Abbildung 19.7 zeigt. Klicken Sie auf OK, um die Methode in
Ihr Steuerelement aufzunehmen. Anschließend klicken Sie auf die Schaltfläche Code
bearbeiten, um den Code gemäß Listing 19.11 in die Methode zu übernehmen.
Abbildung 19.7:
Das Dialogfeld Methode hinzufügen für eine benutzerdefinierte Methode
Listing 19.11: Die Funktion LoadDrawing der Klasse CSquiggleCtrl
1: BOOL CSquiggleCtrl::LoadDrawing(LPCTSTR sFileName)
2: {
3: // ZU ERLEDIGEN: Fügen Sie hier den Code für Ihre Dispatch-
ÂBehandlungsroutine ein
4: try
5: {
6: // Ein CFile-Objekt erzeugen
7: CFile lFile(sFileName, CFile::modeRead);
8: // Ein CArchive-Objekt erzeugen, um die Datei zu laden
9: CArchive lArchive(&lFile, CArchive::load);
10: // Datei laden
11: m_maDrawing.Serialize(lArchive);
12: // Sicherstellen, daß geladene Datei nicht überschrieben wird
13: m_bGenNewDrawing = FALSE;
14: // Geladene Zeichnung anzeigen
15: Invalidate();
16: }
17: catch (CFileException err)
18: {
19: return FALSE;
20: }
21: return TRUE;
22: }
Als letzten Schritt beim Erstellen des Steuerelements fügen Sie die Ereignisse hinzu, die das Steuerelement in der Container-Anwendung auslöst. Beim Einsatz des Steuerelements kann der Entwickler Code vorsehen, der bei diesen Ereignissen ausgelöst wird. Die Ereignisse nehmen Sie über die Registerkarte ActiveX-Ereignisse des Klassen-Assistenten auf. Wenn Ihr Steuerelement ein vordefiniertes Ereignis auslösen soll, klicken Sie einfach auf die Schaltfläche Ereignis hinzufügen und wählen ein vordefiniertes Ereignis aus der Dropdown-Liste der Ereignisse aus. Soll Ihr Steuerelement ein benutzerdefiniertes Ereignis erhalten, wählen Sie im Dialogfeld Ereignis hinzufügen kein vordefiniertes Ereignis aus, sondern geben den Namen Ihres benutzerdefinierten Ereignisses ein. In die Parameterliste im unteren Teil des Dialogfelds Ereignis hinzufügen tragen Sie die Parameter ein, die Sie mit dem Ereignis von Ihrem Steuerelement an die Container-Anwendung übergeben möchten.
Für das Steuerelement im heutigen Beispiel fügen Sie ein Ereignis hinzu, und zwar ein
benutzerdefiniertes Ereignis, um die Anwendung darüber zu informieren, daß die angegebene
Datei mit der Zeichnung geladen wurde. Öffnen Sie dazu den Klassen-Assistenten.
Gehen Sie auf die Registerkarte ActiveX-Ereignisse (siehe Abbildung 19.8),
und klicken Sie auf die Schaltfläche Ereignis hinzufügen. Geben Sie den Namen
FileLoaded für das benutzerdefinierte Ereignis ein. Das Dialogfeld Ereignis hinzufügen
erzeugt automatisch einen internen Namen für das Ereignis, im Beispiel FireFileLoaded
(siehe Abbildung 19.9). Dieser interne Name ist der Name der Funktion,
die Sie in Ihrem Code aufrufen müssen, wenn Sie das Ereignis auslösen möchten.
Klicken Sie auf OK, um das Ereignis hinzuzufügen. Um ein vordefiniertes Ereignis hinzuzufügen,
markieren Sie das Ereignis in der Dropdown-Liste der vordefinierten Ereignisse
und klicken auf OK, um dieses zweite Ereignis hinzuzufügen.
Abbildung 19.8:
Die Registerkarte ActiveX-Ereignisse des Klassen-Assistenten
Abbildung 19.9:
Das Dialogfeld Ereignis hinzufügen
Nachdem Sie nun das Ereignis in das Steuerelement eingefügt haben, passen Sie
noch den Code an, um das Ereignis an den geeigneten Stellen auszulösen. Das Ereignis
lösen Sie am Ende der Funktion LoadDrawing aus, vorausgesetzt, daß die Zeichnung
korrekt geladen wurde. Bauen Sie die zusätzliche Funktionalität gemäß Zeile 17
von Listing 19.12 in die Funktion LoadDrawing ein.
Listing 19.12: Die modifizierte Funktion LoadDrawing der Klasse CSquiggleCtrl
1: BOOL CSquiggleCtrl::LoadDrawing(LPCTSTR sFileName)
2: {
3: // ZU ERLEDIGEN: Fügen Sie hier den Code für Ihre Dispatch-
ÂBehandlungsroutine ein
4: try
5: {
6: // Ein CFile-Objekt erzeugen
7: CFile lFile(sFileName, CFile::modeRead);
8: // Ein CArchive-Objekt erzeugen, um die Datei zu laden
9: CArchive lArchive(&lFile, CArchive::load);
10: // Datei laden
11: m_maDrawing.Serialize(lArchive);
12: // Sicherstellen, daß geladene Datei nicht überschrieben wird
13: m_bGenNewDrawing = FALSE;
14: // Geladene Zeichnung anzeigen
15: Invalidate();
16: // Das Ereignis FileLoaded auslösen
17: FireFileLoaded();
18: }
19: catch (CFileException err)
20: {
21: return FALSE;
22: }
23: return TRUE;
24: }
Damit sind alle Vorbereitungen abgeschlossen. Sie können nun das Steuerelement kompilieren und testen. Sie brauchen aber nun nicht in den nächsten Computerladen rennen, um sich Visual Basic zuzulegen, sondern verfügen bereits über ein Werkzeug zum Testen von ActiveX-Steuerelementen. Im Menü Extras finden Sie den Befehl Testcontainer für ActiveX-Steuerelemente. Es handelt sich hierbei um ein Hilfsprogramm, das speziell dafür vorgesehen ist, selbst erstellte ActiveX-Steuerelemente auszuprobieren. Nachdem Sie das Steuerelement kompiliert haben, starten Sie den Testcontainer für ActiveX-Steuerelemente, um das Steuerelement auf Herz und Nieren zu prüfen.
Beim Start des Testcontainers sehen Sie einen leeren Bereich, in dem Ihr Steuerelement erscheinen wird. Um das Steuerelement in diesen Bereich einzufügen, wählen Sie Bearbeiten / Neues Steuerelement einfügen aus dem Menü des Testcontainers. Daraufhin öffnet sich das Dialogfeld Steuerelement einfügen (siehe Abbildung 19.10). Markieren Sie das Steuerelement in der Liste der verfügbaren Steuerelemente, und klicken Sie auf OK, um das Steuerelement in den Containerbereich einzufügen, wie es Abbildung 19.11 zeigt.
Abbildung 19.10:
Das Dialogfeld ActiveX-Steuerelement einfügen
Abbildung 19.11:
Das Squiggle-Steuerelement im Testcontainer
Nachdem Sie nun das Steuerelement in den Testcontainer geladen haben, können Sie es ausprobieren, in der Größe ändern, darauf klicken und prüfen, wann es eine neue Zeichnung generiert und wann es lediglich die vorhandene Zeichnung neu darstellt. Wenn Sie irgendwelche Ereignisse für das Steuerelement auslösen, sehen Sie das vom Steuerelement ausgelöste Ereignis im unteren Fensterbereich des Testcontainers, so daß Sie alle ausgelösten Ereignisse, die Sie für das Steuerelement vorgesehen haben, verfolgen können.
Wenn Sie bei markiertem Steuerelement den Befehl Bearbeiten / Eigenschaften wählen, erscheint die Eigenschaftsseite, die Sie für Ihr Steuerelement erstellt haben. Hier können Sie die verschiedenen Eigenschaften des Steuerelements modifizieren, um sich davon zu überzeugen, daß sie korrekt arbeiten (siehe Abbildung 19.12).
Abbildung 19.12:
Die Eigenschaftsseite des Squiggle-Steuerelements
Um schließlich die in das Steuerelement hinzugefügten Methoden zu testen, wählen Sie Steuerelement / Methoden aufrufen. Daraufhin erscheint das Dialogfeld Methoden aufrufen, wie in Abbildung 19.13 zu sehen. Hier können Sie aus der Liste der für Ihr Steuerelement verfügbaren Methoden auswählen, die erforderlichen Parameter für die betreffende Methode eingeben und dann auf die Schaltfläche Aufrufen klicken, um die betreffende Methode zu starten. Dabei können Sie den Aufruf der Methode und die Reaktion des Steuerelements überwachen.
Abbildung 19.13:
Das Dialogfeld Aufrufen der Steuerelementmethode
Heute haben Sie gelernt, wie man die Werkzeuge und Assistenten von Visual C++ einsetzt, um ActiveX-Steuerelemente mit geringem Aufwand von Ihrer Seite zu erstellen. Es wurde gezeigt, wie man das Gerüst des Steuerelementprojekts mit dem MFC- ActiveX-Steuerelement-Assistenten erstellt. Weiterhin haben Sie gesehen, wie man mit dem Klassen-Assistenten Eigenschaften, Methoden und Ereignisse in das Steuerelement aufnimmt. Sie haben eine Eigenschaftsseite für das Steuerelement angelegt und erfahren, wie man mit dem Klassen-Assistenten die Steuerelemente auf diesem Dialogfeld mit den Eigenschaften für das Steuerelement verbindet, ohne daß man dazu Code schreiben müßte. Schließlich haben Sie das Steuerelement im Testcontainer für ActiveX-Steuerelemente ausprobiert und mit den Werkzeugen dieses Programms die gesamte Funktionalität ausgelöst.
Frage:
Wie ändere ich das Symbol, das in der Toolbox für mein Steuerelement erscheint?
Antwort:
Öffnen Sie über die Registerkarte Ressourcen des Arbeitsbereichs den Ordner
Bitmap, der ein einzelnes Bitmap enthalten sollte. Dieses Bild wird in der
Toolbox für Ihr Steuerelement angezeigt, wenn Sie es in ein Visual-C++- oder
Visual-Basic-Projekt einbinden. Dieses Bitmap können Sie bearbeiten, so daß
es Ihr Steuerelement in gewünschter Weise repräsentiert.
Frage:
Warum weist mein Steuerelement ein Dialogfeld Info auf?
Antwort:
Wenn Sie ActiveX-Steuerelemente erstellen, die für andere Entwickler vorgesehen
sind, möchten Sie sicherlich irgendwo einen Hinweis anbringen, daß
Sie das Steuerelement geschrieben haben und Sie oder Ihr Brötchengeber das
Copyright besitzen. Damit haben Sie eine rechtliche Kennzeichnung des Steuerelements
geschaffen, so daß niemand Ihr Steuerelement ohne Ihre Zustimmung
als seine eigene Kreation verkaufen darf.
1. Welche drei Aspekte eines Steuerelements sind für die Container-Anwendung sichtbar?
2. Warum müssen Sie eine Eigenschaftsseite für Ihr Steuerelement entwerfen?
3. Welche vier Arten von Eigenschaften kann ein Steuerelement besitzen?
4. Was passiert mit den Parametern, die an die Methoden eines Steuerelements übergeben werden?
5. Mit welchem Hilfsprogramm können Sie Ihre Steuerelemente testen?
1. Nehmen Sie in Ihr Steuerelement eine Methode auf, um der Container-Anwendung zu ermöglichen, das Generieren einer neuen Squiggle-Zeichnung auszulösen.
2. Nehmen Sie in Ihr Steuerelement eine Methode auf, um eine Squiggle-Zeichnung
zu speichern. Verwenden Sie die Flags CFile::modeWrite und CArchive::store,
wenn Sie die Objekte CFile und CArchive erstellen.
