QAxFactory Class

Die Klasse QAxFactory definiert eine Fabrik für die Erstellung von COM-Komponenten. Mehr...

Kopfzeile: #include <QAxFactory>
CMake: find_package(Qt6 REQUIRED COMPONENTS AxServer)
target_link_libraries(mytarget PRIVATE Qt6::AxServer)
qmake: QT += axserver
Vererbungen: QObject

Öffentliche Typen

enum ServerType { SingleInstance, MultipleInstances }

Öffentliche Funktionen

QAxFactory(const QUuid &libid, const QUuid &appid)
virtual ~QAxFactory() override
virtual QUuid appID() const
virtual QUuid classID(const QString &key) const
virtual QObject *createObject(const QString &key) = 0
virtual bool createObjectWrapper(QObject *object, IDispatch **wrapper)
virtual QUuid eventsID(const QString &key) const
virtual QString exposeToSuperClass(const QString &key) const
virtual QStringList featureList() const = 0
virtual bool hasStockEvents(const QString &key) const
virtual QUuid interfaceID(const QString &key) const
virtual bool isService() const
virtual const QMetaObject *metaObject(const QString &key) const = 0
virtual void registerClass(const QString &key, QSettings *settings) const
virtual bool stayTopLevel(const QString &key) const
virtual QUuid typeLibID() const
virtual void unregisterClass(const QString &key, QSettings *settings) const
virtual bool validateLicenseKey(const QString &key, const QString &licenseKey) const

Statische öffentliche Mitglieder

bool isServer()
bool registerActiveObject(QObject *object)
QString serverDirPath()
QString serverFilePath()
bool startServer(QAxFactory::ServerType type = MultipleInstances)
bool stopServer()

Makros

QAXCLASS(Class)
QAXFACTORY_BEGIN(IDTypeLib, IDApp)
QAXFACTORY_END
QAXFACTORY_EXPORT(Class, LibID, AppID)
QAXTYPE(Class)

Ausführliche Beschreibung

Implementieren Sie diese Fabrik einmal in Ihrem COM-Server, um Informationen über die Komponenten bereitzustellen, die der Server erstellen kann. Unterklassifizieren Sie QAxFactory und implementieren Sie die rein virtuellen Funktionen in einer beliebigen Implementierungsdatei (z. B. main.cpp) und exportieren Sie die Fabrik mit dem Makro QAXFACTORY_EXPORT().

QStringList ActiveQtFactory::featureList() const
{
    QStringList list;
    list << "ActiveX1";
    list << "ActiveX2";
    return list;
}

QObject *ActiveQtFactory::createObject(const QString &key)
{
    if (key == "ActiveX1")
        return new ActiveX1(parent);
    if (key == "ActiveX2")
        return new ActiveX2(parent);
    return 0;
}

const QMetaObject *ActiveQtFactory::metaObject(const QString &key) const
{
    if (key == "ActiveX1")
        return &ActiveX1::staticMetaObject;
    if (key == "ActiveX2")
        return &ActiveX2::staticMetaObject;
}

QUuid ActiveQtFactory::classID(const QString &key) const
{
    if (key == "ActiveX1")
        return "{01234567-89AB-CDEF-0123-456789ABCDEF}";
    ...
    return QUuid();
}

QUuid ActiveQtFactory::interfaceID(const QString &key) const
{
    if (key == "ActiveX1")
        return "{01234567-89AB-CDEF-0123-456789ABCDEF}";
    ...
    return QUuid();
}

QUuid ActiveQtFactory::eventsID(const QString &key) const
{
    if (key == "ActiveX1")
        return "{01234567-89AB-CDEF-0123-456789ABCDEF}";
    ...
    return QUuid();
}

QAXFACTORY_EXPORT(
    ActiveQtFactory,                          // factory class
    "{01234567-89AB-CDEF-0123-456789ABCDEF}", // type library ID
    "{01234567-89AB-CDEF-0123-456789ABCDEF}"  // application ID
)

Wenn Sie das Makro Q_CLASSINFO() verwenden, um die eindeutigen Bezeichner oder andere Attribute für Ihre Klasse bereitzustellen, können Sie die Makros QAXFACTORY_BEGIN(), QAXCLASS() und QAXFACTORY_END() verwenden, um eine oder mehrere Klassen als COM-Objekte darzustellen.

QAXFACTORY_BEGIN(
    "{01234567-89AB-CDEF-0123-456789ABCDEF}", // type library ID
    "{01234567-89AB-CDEF-0123-456789ABCDEF}"  // application ID
)
    QAXCLASS(Class1)
    QAXCLASS(Class2)
QAXFACTORY_END()

Nur eine QAxFactory-Implementierung darf von einer ActiveX-Serveranwendung instanziiert und exportiert werden. Diese Instanz ist über die globale Funktion qAxFactory() zugänglich.

Eine Factory kann auch die Funktionen registerClass() und unregisterClass() reimplementieren, um zusätzliche Flags für ein ActiveX-Steuerelement in der Registry zu setzen. Um die Anzahl der Methoden oder Eigenschaften zu begrenzen, die eine Widget-Klasse von ihren übergeordneten Klassen preisgibt, reimplementieren Sie exposeToSuperClass().

Siehe auch QAxAggregated, QAxBindable, und ActiveQt Framework.

Dokumentation der Mitgliedstypen

enum QAxFactory::ServerType

Diese Aufzählung gibt die verschiedenen Typen von Servern an, die mit startServer gestartet werden können.

KonstanteWertBeschreibung
QAxFactory::SingleInstance0Der Serverprozess kann von jeder exportierten Klasse nur eine Instanz erzeugen. COM startet für jede Anfrage einen neuen Prozess. Dies wird typischerweise in Servern verwendet, die nur eine erstellbare Klasse exportieren.
QAxFactory::MultipleInstances1Der Server kann mehrere Instanzen jeder exportierten Klasse erstellen. Dies ist die Standardeinstellung. Alle Instanzen leben im selben Thread und teilen sich statische Ressourcen.

Dokumentation der Mitgliedsfunktionen

QAxFactory::QAxFactory(const QUuid &libid, const QUuid &appid)

Konstruiert ein QAxFactory-Objekt, das libid und appid in der Implementierung der jeweiligen Schnittstellenfunktionen zurückgibt.

[override virtual noexcept] QAxFactory::~QAxFactory()

Zerstört das Objekt QAxFactory.

[virtual] QUuid QAxFactory::appID() const

Reimplementieren Sie diese Funktion, um die Anwendungskennung des ActiveX-Servers zurückzugeben.

[virtual] QUuid QAxFactory::classID(const QString &key) const

Reimplementieren Sie diese Funktion, um den Klassenidentifikator für jedes key zurückzugeben, das von der featureList()-Implementierung zurückgegeben wird, oder ein leeres QUuid, wenn diese Fabrik den Wert von key nicht unterstützt.

Die Standardimplementierung interpretiert key als den Klassennamen und gibt den Wert des Q_CLASSINFO()-Eintrags "ClassID" zurück.

[pure virtual] QObject *QAxFactory::createObject(const QString &key)

Reimplementieren Sie diese Funktion, um ein neues Objekt für key zurückzugeben, oder 0, wenn diese Fabrik den Wert von key nicht unterstützt.

Wenn das zurückgegebene Objekt ein QWidget ist, wird es als ActiveX-Steuerelement dargestellt, andernfalls wird das zurückgegebene Objekt als einfaches COM-Objekt dargestellt.

[virtual] bool QAxFactory::createObjectWrapper(QObject *object, IDispatch **wrapper)

Reimplementieren Sie diese Funktion, um das COM-Objekt für object in wrapper bereitzustellen. Geben Sie true zurück, wenn die Funktion erfolgreich war; andernfalls geben Sie false zurück.

Die Standardimplementierung erstellt einen generischen Automations-Wrapper auf der Grundlage der Meta-Objektinformationen von object.

[virtual] QUuid QAxFactory::eventsID(const QString &key) const

Reimplementieren Sie diese Funktion, um den Bezeichner der Ereignisschnittstelle für jedes key zurückzugeben, das von der featureList()-Implementierung zurückgegeben wird, oder ein leeres QUuid, wenn diese Fabrik den Wert von key nicht unterstützt.

Die Standardimplementierung interpretiert key als den Klassennamen und gibt den Wert des Q_CLASSINFO()-Eintrags "EventsID" zurück.

[virtual] QString QAxFactory::exposeToSuperClass(const QString &key) const

Reimplementieren Sie diese Funktion, um den Namen der Superklasse von key zurückzugeben, bis zu der Methoden und Eigenschaften durch das ActiveX-Steuerelement ausgesetzt werden sollen.

Die Standardimplementierung interpretiert key als den Klassennamen und gibt den Wert des Q_CLASSINFO() Eintrags "ToSuperClass" zurück. Wenn kein solcher Wert gesetzt ist, wird der Null-String zurückgegeben und die Funktionen und Eigenschaften aller Superklassen, einschließlich QWidget, werden angezeigt.

Um nur die Funktionen und Eigenschaften der Klasse selbst freizulegen, implementieren Sie diese Funktion neu und geben Sie key zurück.

[pure virtual] QStringList QAxFactory::featureList() const

Reimplementieren Sie diese Funktion, um eine Liste der Widgets (Klassennamen) zurückzugeben, die von dieser Fabrik unterstützt werden.

[virtual] bool QAxFactory::hasStockEvents(const QString &key) const

Implementieren Sie diese Funktion neu, um true zurückzugeben, wenn das ActiveX-Steuerelement key die Standard-ActiveX-Ereignisse unterstützen soll

  • Klick
  • DblClick
  • KeyDown
  • Tastendruck
  • KeyUp
  • MausAb
  • MausAuf
  • MausBewegung

Die Standardimplementierung interpretiert key als den Klassennamen und gibt true zurück, wenn der Wert des Q_CLASSINFO() Eintrags "StockEvents" "yes" ist. Andernfalls gibt diese Funktion false zurück.

[virtual] QUuid QAxFactory::interfaceID(const QString &key) const

Reimplementieren Sie diese Funktion, um die Schnittstellenkennung für jede key zurückzugeben, die von der featureList()-Implementierung zurückgegeben wird, oder eine leere QUuid, wenn diese Fabrik den Wert von key nicht unterstützt.

Die Standardimplementierung interpretiert key als den Klassennamen und gibt den Wert des Q_CLASSINFO()-Eintrags "InterfaceID" zurück.

[static] bool QAxFactory::isServer()

Gibt true zurück, wenn die Anwendung (von COM) als ActiveX-Server gestartet wurde, andernfalls wird false zurückgegeben.

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    if (!QAxFactory::isServer()) {
        // initialize for stand-alone execution
    }
    return app.exec();
}

[virtual] bool QAxFactory::isService() const

Reimplementieren Sie diese Funktion, um true zurückzugeben, wenn der Server als dauerhafter Dienst (z.B. ein NT-Dienst) läuft und nicht beendet werden soll, auch wenn alle bereitgestellten Objekte freigegeben wurden.

Die Standardimplementierung gibt false zurück.

[pure virtual] const QMetaObject *QAxFactory::metaObject(const QString &key) const

Reimplementieren Sie diese Funktion, um den QMetaObject entsprechend key zurückzugeben, oder 0, wenn diese Fabrik den Wert von key nicht unterstützt.

[static] bool QAxFactory::registerActiveObject(QObject *object)

Registriert das Objekt QObject object bei COM als laufendes Objekt und gibt true zurück, wenn die Registrierung erfolgreich war, andernfalls false. Das Objekt wird automatisch deregistriert, wenn es zerstört wird.

Diese Funktion sollte nur aufgerufen werden, wenn die Anwendung vom Benutzer gestartet wurde (d.h. nicht von COM, um auf eine Anforderung zu reagieren), und nur für ein Objekt, normalerweise das oberste Objekt der Objekthierarchie der Anwendung.

Diese Funktion tut nichts und gibt false zurück, wenn die Klasseninfo des Objekts für "RegisterObject" nicht auf "yes" gesetzt ist oder wenn der Server ein prozessinterner Server ist.

[virtual] void QAxFactory::registerClass(const QString &key, QSettings *settings) const

Registriert zusätzliche Werte für die Klasse key in der Systemregistrierung unter Verwendung des settings Objekts. Die Standardwerte sind bereits vom Framework registriert worden, aber zusätzliche Werte, z. B. implementierte Kategorien, können in einer Implementierung dieser Funktion hinzugefügt werden.

settings->setValue("/CLSID/" + classID(key)
                   + "/Implemented Categories/"
                   + "/{00000000-0000-0000-000000000000}/.",
                   QString());

Wenn Sie diese Funktion neu implementieren, müssen Sie auch unregisterClass() neu implementieren, um die zusätzlichen Registry-Werte zu entfernen.

Siehe auch QSettings.

[static] QString QAxFactory::serverDirPath()

Gibt das Verzeichnis zurück, das die Server-Binärdatei enthält.

Bei Out-of-Process-Servern ist dies dasselbe wie QCoreApplication::applicationDirPath(). Bei prozessinternen Servern gibt diese Funktion das Verzeichnis zurück, das die Host-Anwendung enthält.

[static] QString QAxFactory::serverFilePath()

Gibt den Dateipfad der Server-Binärdatei zurück.

Bei Out-of-Process-Servern ist dies dasselbe wie QCoreApplication::applicationFilePath(). Bei prozessinternen Servern gibt diese Funktion den Dateipfad der Hostanwendung zurück.

[static] bool QAxFactory::startServer(QAxFactory::ServerType type = MultipleInstances)

Startet den COM-Server mit type und gibt bei Erfolg true zurück, andernfalls false.

Der Aufruf dieser Funktion, wenn der Server bereits läuft (oder bei einem prozessinternen Server), bewirkt nichts und gibt true zurück.

Der Server wird automatisch mit type gestartet, das auf MultipleInstances gesetzt ist, wenn die ausführbare Serverdatei mit dem Befehlszeilenparameter -activex gestartet wurde. Um zu SingleInstance zu wechseln, rufen Sie

if (QAxFactory::isServer()) {
    QAxFactory::stopServer();
    QAxFactory::startServer(QAxFactory::SingleInstance);
}

in Ihrer eigenen main()-Einstiegspunkt-Funktion auf.

[virtual] bool QAxFactory::stayTopLevel(const QString &key) const

Implementieren Sie diese Funktion neu, um true zurückzugeben, wenn das ActiveX-Steuerelement key ein Fenster der obersten Ebene sein soll, z. B. ein Dialog. Die Standardimplementierung gibt false zurück.

[static] bool QAxFactory::stopServer()

Stoppt den COM-Server und gibt bei Erfolg true zurück, andernfalls false.

Der Aufruf dieser Funktion, wenn der Server nicht läuft (oder bei einem prozessinternen Server), bewirkt nichts und gibt true zurück.

Durch das Anhalten des Servers werden vorhandene Objekte nicht ungültig, aber es können keine neuen Objekte vom vorhandenen Serverprozess erstellt werden. Normalerweise wird COM einen neuen Serverprozess starten, wenn zusätzliche Objekte angefordert werden.

Der Server wird automatisch gestoppt, wenn die Funktion main() zurückkehrt.

[virtual] QUuid QAxFactory::typeLibID() const

Reimplementieren Sie diese Funktion, um die Kennung der Typbibliothek des ActiveX-Servers zurückzugeben.

[virtual] void QAxFactory::unregisterClass(const QString &key, QSettings *settings) const

Deregistriert alle zusätzlichen Werte für die Klasse key aus der Systemregistrierung über das Objekt settings.

settings->remove("/CLSID/" + classID(key)
                 + "/Implemented Categories"
                 + "/{00000000-0000-0000-000000000000}/.");

Siehe auch registerClass() und QSettings.

[virtual] bool QAxFactory::validateLicenseKey(const QString &key, const QString &licenseKey) const

Reimplementieren Sie diese Funktion so, dass sie true zurückgibt, wenn licenseKey eine gültige Lizenz für die Klasse key ist, oder wenn der aktuelle Rechner lizenziert ist.

Die Standardimplementierung gibt true zurück, wenn die Klasse key nicht lizenziert ist (d.h. kein Q_CLASSINFO() -Attribut "LicenseKey"), oder wenn licenseKey mit dem Wert des Attributs "LicenseKey" übereinstimmt, oder wenn der Rechner über eine .LIC-Datei mit demselben Dateinamen wie dieser COM-Server lizenziert ist.

Makro-Dokumentation

QAXCLASS(Class)

Dieses Makro fügt der mit dem Makro QAXFACTORY_BEGIN() deklarierten QAxFactory eine erzeugbare COM-Klasse Class hinzu.

Siehe auch QAXFACTORY_BEGIN(), QAXTYPE(), QAXFACTORY_END(), und Q_CLASSINFO().

QAXFACTORY_BEGIN(IDTypeLib, IDApp)

Dieses Makro kann verwendet werden, um mehrere QObject Klassen durch eine implizit deklarierte QAxFactory Implementierung zu exportieren. Alle QObject Klassen müssen die ClassID, InterfaceID und EventsID (falls zutreffend) über das Makro Q_CLASSINFO() deklarieren. Alle Deklarationen befinden sich in einer Typbibliothek mit der ID IDTypeLib, und wenn der Server ein ausführbarer Server ist, hat er die Anwendungs-ID IDApp.

Dieses Makro muss zusammen mit den Makros QAXCLASS(), QAXTYPE() und QAXFACTORY_END() verwendet werden.

QAXFACTORY_BEGIN(
    "{01234567-89AB-CDEF-0123-456789ABCDEF}", // type library ID
    "{01234567-89AB-CDEF-0123-456789ABCDEF}"  // application ID
)
    QAXCLASS(Class1)
    QAXCLASS(Class2)
QAXFACTORY_END()

QAXFACTORY_END

Schließt die mit dem Makro QAXFACTORY_BEGIN() begonnene Deklaration QAxFactory ab.

Siehe auch QAXFACTORY_BEGIN(), QAXCLASS(), und QAXTYPE().

QAXFACTORY_EXPORT(Class, LibID, AppID)

Dieses Makro kann verwendet werden, um eine Implementierung QAxFactory Class von einem COM-Server zu exportieren. Alle Deklarationen befinden sich in einer Typbibliothek mit der ID LibID, und wenn der Server ein ausführbarer Server ist, hat er die Anwendungs-ID AppID.

QAXFACTORY_EXPORT(
    MyFactory,                                // factory class
    "{01234567-89AB-CDEF-0123-456789ABCDEF}", // type library ID
    "{01234567-89AB-CDEF-0123-456789ABCDEF}"  // application ID
)

Siehe auch QAXFACTORY_BEGIN().

QAXTYPE(Class)

Dieses Makro fügt eine nicht-erstellbare COM-Klasse Class zu der mit QAXFACTORY_BEGIN() deklarierten QAxFactory hinzu. Die Klasse Class kann in APIs anderer COM-Klassen verwendet werden, die über QAXTYPE() oder QAXCLASS() exportiert werden.

Instanzen des Typs Class können nur über APIs von bereits instanziierten Objekten abgerufen werden.

Siehe auch QAXFACTORY_BEGIN(), QAXCLASS(), QAXFACTORY_END(), und Q_CLASSINFO().

© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.