En esta página

QAxFactory Class

La clase QAxFactory define una fábrica para la creación de componentes COM. Más información...

Encabezado: #include <qaxfactory.h>
CMake: find_package(Qt6 REQUIRED COMPONENTS AxServer)
target_link_libraries(mytarget PRIVATE Qt6::AxServer)
qmake: QT += axserver
Heredado de: QObject

Tipos públicos

enum ServerType { SingleInstance, MultipleInstances }

Funciones públicas

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

Miembros públicos estáticos

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

Macros

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

Descripción detallada

Implementa esta fábrica una vez en tu servidor COM para proporcionar información sobre los componentes que el servidor puede crear. Crea una subclase de QAxFactory e implementa las funciones virtuales puras en cualquier archivo de implementación (por ejemplo, main.cpp), y exporta la fábrica utilizando la macro 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
)

Si utiliza la macro « Q_CLASSINFO() » para proporcionar los identificadores únicos u otros atributos de su clase, puede utilizar las macros « QAXFACTORY_BEGIN() », « QAXCLASS() » y « QAXFACTORY_END() » para exponer una o más clases como objetos COM.

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

Una aplicación de servidor ActiveX solo puede instanciar y exportar una implementación de QAxFactory. Se puede acceder a esta instancia a través de la función global qAxFactory().

Una fábrica también puede reimplementar las funciones registerClass() y unregisterClass() para establecer indicadores adicionales para un control ActiveX en el registro. Para limitar el número de métodos o propiedades que una clase de widget expone de sus clases padre, reimplemente exposeToSuperClass().

Véase también QAxAggregated, QAxBindable y ActiveQt Framework.

Documentación sobre tipos de miembros

enum QAxFactory::ServerType

Esta enumeración especifica los diferentes tipos de servidores que se pueden iniciar con ` startServer`.

ConstanteValorDescripción
QAxFactory::SingleInstance0El proceso del servidor solo puede crear una instancia de cada clase exportada. COM inicia un nuevo proceso para cada solicitud. Esto se utiliza normalmente en servidores que exportan solo una clase creable.
QAxFactory::MultipleInstances1El servidor puede crear varias instancias de cada clase exportada. Este es el valor predeterminado. Todas las instancias se ejecutarán en el mismo hilo y compartirán recursos estáticos.

Documentación de funciones de miembro

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

Crea un objeto QAxFactory que devuelve « libid » y « appid » en la implementación de las funciones respectivas de la interfaz.

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

Elimina el objeto « QAxFactory ».

[virtual] QUuid QAxFactory::appID() const

Reimplementa esta función para que devuelva el identificador de aplicación del servidor ActiveX.

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

Reimplementa esta función para que devuelva el identificador de clase de cada key devuelto por la implementación de featureList(), o un QUuid vacío si esta fábrica no admite el valor de key.

La implementación por defecto interpreta key como el nombre de la clase y devuelve el valor de la entrada «ClassID» de Q_CLASSINFO().

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

Reimplementa esta función para que devuelva un nuevo objeto de tipo ` key`, o 0 si esta fábrica no admite el valor de ` key`.

Si el objeto devuelto es un ` QWidget `, se expondrá como un control ActiveX; de lo contrario, el objeto devuelto se expondrá como un objeto COM simple.

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

Reimplementa esta función para proporcionar el objeto COM de object en wrapper. Devuelve «true» si la función se ha ejecutado correctamente; en caso contrario, devuelve «false».

La implementación predeterminada crea un contenedor de automatización genérico basado en la información del metaobjeto de object.

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

Reimplementa esta función para que devuelva el identificador de la interfaz de eventos correspondiente a cada key devuelto por la implementación de featureList(), o un QUuid vacío si esta fábrica no admite el valor de key.

La implementación por defecto interpreta key como el nombre de la clase y devuelve el valor de la entrada «EventsID» de Q_CLASSINFO().

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

Reimplementa esta función para que devuelva el nombre de la superclase de key hasta la cual el control ActiveX debe exponer métodos y propiedades.

La implementación predeterminada interpreta key como el nombre de la clase y devuelve el valor de la entrada «ToSuperClass» de Q_CLASSINFO(). Si no se ha establecido dicho valor, se devuelve la cadena nula y se expondrán las funciones y propiedades de todas las superclases, incluida QWidget.

Para exponer únicamente las funciones y propiedades de la propia clase, reimplementa esta función para que devuelva key.

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

Reimplementa esta función para que devuelva una lista de los widgets (nombres de clase) compatibles con esta fábrica.

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

Reimplementa esta función para que devuelva «true» si el control ActiveX key debe admitir los eventos estándar de ActiveX

  • Click
  • DblClick
  • KeyDown
  • KeyPress
  • KeyUp
  • Pulsación del ratón
  • MouseUp
  • MouseMove

La implementación predeterminada interpreta « key » como el nombre de la clase y devuelve «true» si el valor de la entrada «StockEvents» del registro « Q_CLASSINFO() » es «yes». En caso contrario, esta función devuelve «false».

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

Reimplementa esta función para que devuelva el identificador de interfaz correspondiente a cada key devuelto por la implementación de featureList(), o un QUuid vacío si esta fábrica no admite el valor de key.

La implementación por defecto interpreta key como el nombre de la clase y devuelve el valor de la entrada «InterfaceID» de Q_CLASSINFO().

[static] bool QAxFactory::isServer()

Devuelve «true» si la aplicación se ha iniciado (mediante COM) como servidor ActiveX; en caso contrario, devuelve «false».

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

Reimplementa esta función para que devuelva «true» si el servidor se está ejecutando como un servicio persistente (por ejemplo, un servicio NT) y no debe cerrarse aunque se hayan liberado todos los objetos proporcionados.

La implementación predeterminada devuelve «false».

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

Reimplementa esta función para que devuelva el objeto ` QMetaObject ` correspondiente a ` key`, o 0 si esta fábrica no admite el valor de ` key`.

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

Registra el objeto QObject object en COM como un objeto en ejecución y devuelve «true» si el registro se ha realizado correctamente; en caso contrario, devuelve «false». El objeto se da de baja automáticamente cuando se destruye.

Esta función solo debe invocarse si la aplicación ha sido iniciada por el usuario (es decir, no por COM en respuesta a una solicitud), y solo para un objeto, normalmente el objeto de nivel superior de la jerarquía de objetos de la aplicación.

Esta función no realiza ninguna acción y devuelve «false» si la información de clase del objeto para «RegisterObject» no está establecida en «yes», o si el servidor es un servidor en proceso.

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

Registra valores adicionales para la clase « key » en el registro del sistema mediante el objeto « settings ». Los valores estándar ya han sido registrados por el marco de trabajo, pero se pueden añadir valores adicionales —por ejemplo, categorías implementadas— en una implementación de esta función.

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

Si reimplementas esta función, también debes reimplementar unregisterClass() para eliminar los valores adicionales del registro.

Véase también QSettings.

[static] QString QAxFactory::serverDirPath()

Devuelve el directorio que contiene el binario del servidor.

En el caso de los servidores fuera de proceso, es lo mismo que « QCoreApplication::applicationDirPath()». En el caso de los servidores en proceso, esta función devuelve el directorio que contiene la aplicación de alojamiento.

[static] QString QAxFactory::serverFilePath()

Devuelve la ruta del archivo del binario del servidor.

En el caso de los servidores fuera de proceso, esto equivale a ` QCoreApplication::applicationFilePath()`. En el caso de los servidores dentro de proceso, esta función devuelve la ruta de archivo de la aplicación anfitriona.

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

Inicia el servidor COM con type y devuelve «true» si se realiza correctamente; en caso contrario, devuelve «false».

Si se llama a esta función cuando el servidor ya está en ejecución (o en el caso de un servidor en proceso), no realiza ninguna acción y devuelve «true».

El servidor se inicia automáticamente con type establecido en MultipleInstances si el ejecutable del servidor se ha iniciado con el parámetro de línea de comandos -activex. Para cambiar a SingleInstance, llama a

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

en su propia función de punto de entrada `main()`.

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

Reimplementa esta función para que devuelva «true» si el control ActiveX key debe ser una ventana de nivel superior, por ejemplo, un cuadro de diálogo. La implementación por defecto devuelve «false».

[static] bool QAxFactory::stopServer()

Detiene el servidor COM y devuelve «true» si se realiza correctamente; en caso contrario, devuelve «false».

Si se llama a esta función cuando el servidor no está en ejecución (o en el caso de un servidor en proceso), no se realiza ninguna acción y devuelve «true».

Detener el servidor no invalidará los objetos existentes, pero no se podrán crear nuevos objetos desde el proceso del servidor existente. Normalmente, COM iniciará un nuevo proceso de servidor si se solicitan objetos adicionales.

El servidor se detiene automáticamente cuando la función main() devuelve un valor.

[virtual] QUuid QAxFactory::typeLibID() const

Reimplementa esta función para que devuelva el identificador de la biblioteca de tipos del servidor ActiveX.

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

Da de baja cualquier valor adicional de la clase « key » del registro del sistema mediante el objeto « settings ».

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

Véase también registerClass() y QSettings.

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

Reimplementa esta función para que devuelva «true» si licenseKey es una licencia válida para la clase key, o si el equipo actual dispone de licencia.

La implementación predeterminada devuelve «true» si la clase key no dispone de licencia (es decir, no tiene el atributo «LicenseKey» de Q_CLASSINFO() ), o si licenseKey coincide con el valor del atributo «LicenseKey», o si el equipo dispone de licencia a través de un archivo .LIC con el mismo nombre que este servidor COM.

Documentación de macros

QAXCLASS(Class)

Esta macro añade una clase COM creable, « Class », a la clase « QAxFactory » declarada con la macro « QAXFACTORY_BEGIN()».

Véanse también QAXFACTORY_BEGIN(), QAXTYPE(), QAXFACTORY_END() y Q_CLASSINFO().

QAXFACTORY_BEGIN(IDTypeLib, IDApp)

Esta macro se puede utilizar para exportar varias clases de tipo « QObject » a través de una implementación de « QAxFactory » declarada de forma implícita. Todas las clases de tipo « QObject » deben declarar el ClassID, el InterfaceID y el EventsID (si procede) mediante la macro « Q_CLASSINFO()». Todas las declaraciones se incluirán en una biblioteca de tipos con el identificador « IDTypeLib », y si el servidor es un servidor ejecutable, tendrá el identificador de aplicación « IDApp ».

Esta macro debe utilizarse junto con las macros QAXCLASS(), QAXTYPE() y QAXFACTORY_END().

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()

Completa la declaración « QAxFactory » iniciada con la macro « QAXFACTORY_BEGIN()».

Véase también QAXFACTORY_BEGIN(), QAXCLASS() y QAXTYPE().

QAXFACTORY_EXPORT(Class, LibID, AppID)

Esta macro se puede utilizar para exportar una implementación de QAxFactory Class desde un servidor COM. Todas las declaraciones se incluirán en una biblioteca de tipos con el identificador LibID, y si el servidor es un servidor ejecutable, tendrá el identificador de aplicación AppID.

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

Véase también QAXFACTORY_BEGIN().

QAXTYPE(Class)

Esta macro añade una clase COM no creable, ` Class `, al ` QAxFactory ` declarado mediante ` QAXFACTORY_BEGIN()`. La clase ` Class ` puede utilizarse en las API de otras clases COM exportadas a través de `QAXTYPE()` o ` QAXCLASS()`.

Las instancias de tipo Class solo pueden recuperarse mediante las API de objetos ya instanciados.

Véase también QAXFACTORY_BEGIN(), QAXCLASS(), QAXFACTORY_END() y Q_CLASSINFO().

© 2026 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.