Creación de servidores ActiveX en Qt
El módulo « QAxServer » forma parte del marco ActiveQt. Consta de tres clases:
- QAxFactory define una fábrica para la creación de objetos COM.
- QAxBindable proporciona una interfaz entre el widget de Qt Widgets y el objeto COM.
- QAxAggregated puede subclasificarse para implementar interfaces COM adicionales.
Se proporcionan algunos ejemplos de implementación de controles ActiveX y objetos COM.
Uso de la biblioteca
Para convertir una aplicación Qt estándar en un servidor COM utilizando la biblioteca QAxServer, debes añadir axserver a la variable QT en tu archivo .pro.
A partir de un archivo ` .pro ` como este se genera un servidor ejecutable fuera de proceso:
TEMPLATE = app
QT += axserver
RC_FILE = qaxserver.rc
...Para compilar un servidor en proceso, utiliza un archivo ` .pro ` como este:
TEMPLATE = lib
QT += axserver
CONFIG += dll
DEF_FILE = qaxserver.def
RC_FILE = qaxserver.rc
...Los archivos qaxserver.rc y qaxserver.def forman parte del marco de trabajo y pueden utilizarse desde su ubicación habitual (especifica una ruta en el archivo .pro ) o copiarse en el directorio del proyecto. Puedes modificar estos archivos siempre que incluyan cualquier archivo como entrada de la biblioteca de tipos; es decir, puedes añadir información de versión o especificar un icono de caja de herramientas diferente.
El uso del módulo axserver hará que la herramienta qmake añada los pasos de compilación necesarios al sistema de compilación:
- Enlaza el binario con
qaxserver.liben lugar deqtmain.lib - Llamar a la herramienta idc para generar un archivo IDL para el servidor COM
- Compilar el IDL en una biblioteca de tipos utilizando la herramienta MIDL (parte de la instalación del compilador)
- Adjuntar la biblioteca de tipos resultante como recurso binario al binario del servidor (de nuevo utilizando la herramienta idc )
- Registrar el servidor. Este paso puede requerir privilegios de administrador y se puede omitir configurando la opción «
qaxserver_no_register».
Para omitir el paso de posprocesamiento, configura también la opción « qaxserver_no_postlink ».
Además, puede especificar un número de versión mediante la variable « VERSION », por ejemplo:
TEMPLATE = lib
VERSION = 2.5
...El número de versión especificado se utilizará como versión de la biblioteca de tipos y del servidor al realizar el registro.
Fuera del proceso frente a dentro del proceso
El hecho de que tu servidor COM se ejecute como un ejecutable independiente o como una biblioteca compartida en el proceso del cliente depende principalmente del tipo de objetos COM que desees proporcionar en el servidor.
Un servidor ejecutable tiene la ventaja de poder ejecutarse como una aplicación independiente, pero añade una sobrecarga considerable a la comunicación entre el cliente COM y el objeto COM. Si el control tiene un error de programación, solo se bloqueará el proceso del servidor que ejecuta el control, y es probable que la aplicación cliente siga ejecutándose. No todos los clientes COM admiten servidores ejecutables.
Un servidor en proceso suele ser más pequeño y tiene un tiempo de inicio más rápido. La comunicación entre el cliente y el servidor se realiza directamente a través de llamadas a funciones virtuales y no introduce la sobrecarga que requieren las llamadas a procedimientos remotos. Sin embargo, si el servidor se bloquea, es probable que la aplicación cliente también se bloquee, y no todas las funcionalidades están disponibles para los servidores en proceso (por ejemplo, el registro en la tabla de objetos en ejecución de COM).
Ambos tipos de servidor pueden utilizar Qt, ya sea como biblioteca compartida o enlazado estáticamente en el binario del servidor.
Errores habituales durante los pasos posteriores a la compilación
Para que funcionen los pasos de posprocesamiento específicos de ActiveQt, el servidor debe cumplir una serie de requisitos:
- Todos los controles expuestos deben poder crearse con nada más que una instancia de ` QApplication ` presente
- La vinculación inicial del servidor incluye un recurso de biblioteca de tipos temporal.
- Todas las dependencias necesarias para ejecutar el servidor se encuentran en la ruta del sistema (o en la ruta utilizada por el entorno de llamada; ten en cuenta que Visual Studio tiene su propio conjunto de variables de entorno, que se enumeran en el cuadro de diálogo Herramientas | Opciones | Directorios).
Si no se cumplen estos requisitos, es probable que se produzca uno o varios de los siguientes errores:
El ejecutable del servidor se bloquea
Para generar el IDL, es necesario instanciar los widgets expuestos como controles ActiveX (se invoca el constructor). En este momento, no existe nada más que un objeto ` QApplication `. El constructor de tu widget no debe depender de que se creen otros objetos; por ejemplo, debe comprobar si hay punteros nulos.
Para depurar el servidor, ejecútalo con la opción -dumpidl archivo_de_salida y comprueba dónde se bloquea.
Ten en cuenta que no se invoca ninguna función del control.
El ejecutable del servidor no es una aplicación Win32 válida
Al adjuntar la biblioteca de tipos se ha dañado el binario del servidor. Se trata de un error de Windows y solo ocurre con las compilaciones de versión final.
El primer paso de enlace debe vincular una biblioteca de tipos ficticia al ejecutable, que posteriormente podrá ser sustituida por idc. Añade un archivo de recursos con una biblioteca de tipos a tu proyecto, tal y como se muestra en los ejemplos.
«No se puede localizar la DLL»
El sistema de compilación necesita ejecutar el ejecutable del servidor para generar la definición de la interfaz y para registrar el servidor. Si una biblioteca de enlace dinámico a la que se vincula el servidor no se encuentra en la ruta, esto podría fallar (por ejemplo, Visual Studio llama al servidor utilizando la configuración del entorno especificada en la opción «Directorios»). Asegúrate de que todas las DLL y los complementos que requiere tu servidor se encuentren en un directorio incluido en la ruta tal y como aparece en el cuadro de mensaje de error (véase también La herramienta de implementación de Windows).
«No se puede abrir el archivo...»
El servidor ActiveX no pudo cerrarse correctamente cuando el último cliente dejó de utilizarlo. Normalmente, la aplicación tarda unos dos segundos en cerrarse, pero es posible que tengas que utilizar el Administrador de tareas para forzar el cierre del proceso (por ejemplo, cuando un cliente no libera los controles correctamente).
No se puede instanciar el control
En este caso, puede ser útil registrar el servidor como administrador.
Implementación de controles
Para implementar un objeto COM con Qt, crea una subclase de ` QObject ` o de cualquier subclase existente de ` QObject `. Si la clase es una subclase de ` QWidget`, el objeto COM será un control ActiveX.
#include <QWidget>
class MyActiveX : public QWidget
{
Q_OBJECTLa macro ` Q_OBJECT ` es necesaria para proporcionar al marco ActiveQt la información del metaobjeto sobre el widget.
Q_CLASSINFO("ClassID", "{1D9928BD-4453-4bdd-903D-E525ED17FDE5}")
Q_CLASSINFO("InterfaceID", "{99F6860E-2C5A-42ec-87F2-43396F4BE389}")
Q_CLASSINFO("EventsID", "{0A3E9F27-E4F1-45bb-9E47-63099BCCD0E3}")Utilice la macro Q_CLASSINFO() para especificar los identificadores COM del objeto COM. Son obligatorios ClassID y InterfaceID, mientras que EventsID solo es necesario cuando el objeto tiene señales. Para generar estos identificadores, utilice herramientas del sistema como uuidgen o guidgen.
Puede especificar atributos adicionales para cada una de sus clases; consulte «Información y ajuste de clases» para obtener más detalles.
Q_PROPERTY(int value READ value WRITE setValue)Utiliza la macro « Q_PROPERTY()» para declarar propiedades para el control ActiveX.
Declare un constructor estándar que tome un objeto padre, así como funciones, señales y ranuras, al igual que en cualquier subclase de QObject.
public:
MyActiveX(QWidget *parent = 0)
...
int value() const;
public slots:
void setValue(int v);
...
signals:
void valueChange(int v);
...
};El marco ActiveQt expondrá las propiedades y las ranuras públicas como propiedades y métodos de ActiveX, y las señales como eventos de ActiveX, y realizará la conversión entre los tipos de datos de Qt y los tipos de datos COM equivalentes.
Tipos de datos
Los tipos de datos de Qt compatibles con las propiedades son:
| Tipo de datos de Qt | Propiedad COM |
|---|---|
| bool | VARIANT_BOOL |
| QString | BSTR |
| int | int |
| uint | int sin signo |
| doble | double |
| qlonglong | CY |
| qulonglong | CY |
| QColor | OLE_COLOR |
| QDate | FECHA |
| QDateTime | FECHA |
| QTime | FECHA |
| QFont | IFontDisp* |
| QPixmap | IPictureDisp* |
| QVariant | VARIANTE |
| QVariantList (igual que QList<QVariant>) | SAFEARRAY(VARIANT) |
| QStringList | SAFEARRAY(BSTR) |
| QByteArray | SAFEARRAY(BYTE) |
| QRect | Tipo definido por el usuario |
| QSize | Tipo definido por el usuario |
| QPoint | Tipo definido por el usuario |
Los tipos de datos de Qt compatibles con los parámetros de señales y ranuras son:
| Tipo de datos de Qt | Parámetro COM |
|---|---|
| bool | [in] VARIANT_BOOL |
| bool& | [entrada, salida] VARIANT_BOOL* |
| QString, const QString& | [entrada] BSTR |
| QString& | [in, out] BSTR* |
| QString& | [in, out] BSTR* |
| int | [entrada] int |
| int& | [entrada, salida] int |
| uint | [in] unsigned int |
| uint& | [in, out] *entero sin signo |
| double | [in] double |
| double& | [in, out] double* |
| QColor, const QColor& | [in] OLE_COLOR |
| QColor& | [in, out] OLE_COLOR* |
| QDate, const QDate& | [in] DATE |
| QDate& | [entrada, salida] DATE* |
| QDateTime, const QDateTime& | [in] DATE |
| QDateTime& | [entrada, salida] DATE* |
| QFont, const QFont& | [in] IFontDisp* |
| QFont& | [entrada, salida] IFontDisp** |
| QPixmap, const QPixmap& | [in] IPictureDisp* |
| QPixmap& | [entrada, salida] IPictureDisp** |
| QList<QVariant>, const QList<QVariant>& | [in] SAFEARRAY(VARIANT) |
| QList<QVariant>& | [entrada, salida] SAFEARRAY(VARIANT)* |
| QStringList, const QStringList& | [in] SAFEARRAY(BSTR) |
| QStringList& | [entrada, salida] SAFEARRAY(BSTR)* |
| QByteArray, const QByteArray& | [in] SAFEARRAY(BYTE) |
| QByteArray& | [entrada, salida] SAFEARRAY(BYTE)* |
| QObject* | [in] IDispatch* |
| QRect& | [entrada, salida] struct QRect (definido por el usuario) |
| QSize& | [in, out] struct QSize (definida por el usuario) |
| QPoint& | [in, out] struct QPoint (definida por el usuario) |
También se admiten enumeraciones y indicadores exportados (véase Q_ENUM() y Q_FLAG()). Los tipos de los parámetros de entrada también se admiten como valores de retorno.
El marco ActiveQt ignora las propiedades y las señales/ranuras que tengan parámetros que utilicen cualquier otro tipo de datos.
Subobjetos
Los objetos COM pueden tener múltiples subobjetos que representan un subelemento del objeto COM. Un objeto COM que represente una aplicación de hoja de cálculo con varios documentos puede, por ejemplo, proporcionar un subobjeto para cada hoja de cálculo.
Cualquier subclase de ` QObject ` puede utilizarse como tipo para un subobjeto en ActiveX, siempre que sea conocida por ` QAxFactory`. A continuación, el tipo puede utilizarse en propiedades, o como tipo de retorno o parámetro de una ranura.
Notificación de propiedades
Para que las propiedades sean vinculables para el cliente ActiveX, utiliza la herencia múltiple de la clase ` QAxBindable `:
#include <QAxBindable>
#include <QWidget>
class MyActiveX : public QWidget, public QAxBindable
{
Q_OBJECTAl implementar las funciones de escritura de propiedades, utilice las funciones requestPropertyChange() y propertyChanged() de la clase QAxBindable para permitir que los clientes ActiveX se vinculen a las propiedades del control.
Puesta a disposición de controles
Para que un servidor COM esté disponible para el sistema COM, debe registrarse en el registro del sistema utilizando cinco identificadores únicos. Estos identificadores los proporcionan herramientas como guidgen o uuidgen. La información de registro permite a COM localizar el binario que proporciona un control ActiveX solicitado, gestionar las llamadas a procedimientos remotos al control y leer la información de tipos sobre los métodos y propiedades expuestos por el control.
Para crear el objeto COM cuando el cliente lo solicite, el servidor debe exportar una implementación de QAxFactory. La forma más sencilla de hacerlo es utilizar un conjunto de macros:
QAXFACTORY_BEGIN("{ad90301a-849e-4e8b-9a91-0a6dc5f6461f}",
"{a8f21901-7ff7-4f6a-b939-789620c03d83}")
QAXCLASS(MyWidget)
QAXCLASS(MyWidget2)
QAXTYPE(MySubType)
QAXFACTORY_END()Esto exportará ` MyWidget ` y ` MyWidget2 ` como objetos COM que pueden ser creados por clientes COM, y registrará ` MySubType ` como un tipo que puede utilizarse en las propiedades y parámetros de ` MyWidget ` y ` MyWidget2`.
La página QAxFactory class documentation explica cómo utilizar esta macro, así como cómo implementar y utilizar fábricas personalizadas.
Para servidores ejecutables fuera de proceso, puedes implementar una función main() para instanciar un objeto QApplication y entrar en el bucle de eventos igual que en cualquier aplicación Qt normal. Por defecto, la aplicación se iniciará como una aplicación Qt estándar, pero si se pasa « -activex » en la línea de comandos, se iniciará como un servidor ActiveX. Utilice « QAxFactory::isServer()» para crear y ejecutar una interfaz de aplicación estándar, o para impedir una ejecución independiente:
#include <QApplication>
#include <QAxFactory>
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
if (!QAxFactory::isServer()) {
// create and show main window
}
return app.exec();
}Sin embargo, esto no es necesario, ya que ActiveQt proporciona una implementación por defecto de la función main. La implementación por defecto llama a QAxFactory::startServer(), crea una instancia de QApplication y llama a exec().
Para compilar el ejecutable del servidor ActiveX, ejecuta qmake para generar el archivo makefile y utiliza la herramienta make de tu compilador como harías con cualquier otra aplicación Qt. El proceso de compilación también registrará los controles en el registro del sistema llamando al ejecutable resultante con la opción de línea de comandos -regserver.
Si el servidor ActiveX es un ejecutable, se admiten las siguientes opciones de línea de comandos:
| Opción | Resultado |
|---|---|
-regserver | Registra el servidor en el registro del sistema |
-regserverperuser | Registra el servidor en el registro del sistema para el usuario actual (desde la versión 5.14) |
-unregserver | Da de baja el servidor del registro del sistema |
-unregserverperuser | Elimina el registro del servidor del Registro del sistema para el usuario actual (desde la versión 5.14) |
-activex | Inicia la aplicación como servidor ActiveX |
-dumpidl <file> -version x.y | Escribe el IDL del servidor en el archivo especificado. La biblioteca de tipos tendrá la versión x.y |
Los servidores en proceso se pueden registrar mediante la herramienta « regsvr32 », disponible en todos los sistemas Windows.
Problemas habituales en tiempo de compilación
Los errores del compilador/enlazador que se enumeran a continuación se basan en los generados por el compilador Microsoft Visual C++ 6.0.
«Ninguna función sobrecargada admite 2 parámetros»
Cuando el error se produce en código que utiliza la macro QAXCLASS() o QAXFACTORY_DEFAULT(), la clase de widget no tenía ningún constructor que pudiera utilizar la fábrica predeterminada. Añade un constructor de widget estándar o implementa una fábrica personalizada que no lo requiera.
Cuando el error se produce en código que utiliza la macro QAXFACTORY_EXPORT(), la subclase de QAxFactory no tenía un constructor adecuado. Proporciona un constructor de clase público como
para su clase de fábrica.
«Error de sintaxis: sufijo incorrecto en un número»
Los identificadores únicos no se han pasado como cadenas a la macro QAXFACTORY_EXPORT(), QAXFACTORY_BEGIN() o QAXFACTORY_DEFAULT().
«Símbolo externo no resuelto _ucm_instantiate»
El servidor no exporta una implementación de QAxFactory. Utiliza la macro QAXFACTORY_EXPORT() en uno de los archivos de implementación del proyecto para instanciar y exportar una fábrica, o utiliza la macro QAXCLASS() o QAXFACTORY_DEFAULT() para utilizar la fábrica predeterminada.
«_ucm_initialize ya está definido en...»
El servidor exporta más de una implementación de un QAxFactory, o exporta la misma implementación dos veces. Si utiliza la fábrica predeterminada, la macro QAXFACTORY_BEGIN() o QAXFACTORY_DEFAULT() solo debe utilizarse una vez en el proyecto. Utilice una implementación personalizada de QAxFactory y la macro QAXFACTORY_EXPORT(), si el servidor proporciona varios controles ActiveX.
Distribución de los binarios de QAxServer
Los servidores ActiveX escritos con Qt pueden utilizar Qt como biblioteca compartida o tener Qt enlazado estáticamente en el binario. Ambas opciones dan lugar a paquetes bastante grandes (o bien el propio binario del servidor ocupa mucho espacio, o bien hay que incluir la DLL de Qt).
Instalación de servidores independientes
Cuando su servidor ActiveX también pueda ejecutarse como una aplicación independiente, ejecute el ejecutable del servidor con el parámetro de línea de comandos ` -regserver ` tras instalar el ejecutable en el sistema de destino. A partir de ese momento, los controles proporcionados por el servidor estarán disponibles para los clientes ActiveX.
Instalación de servidores en proceso
Cuando tu servidor ActiveX forme parte de un paquete de instalación, utiliza la herramienta « regsvr32 » proporcionada por Microsoft para registrar los controles en el sistema de destino. Si esta herramienta no está presente, carga la DLL en el proceso de instalación, resuelve el símbolo « DllRegisterServer » y llama a la función:
HMODULE dll = LoadLibrary("myserver.dll");
typedef HRESULT(__stdcall *DllRegisterServerProc)();
DllRegisterServerProc DllRegisterServer =
(DllRegisterServerProc)GetProcAddress(dll, "DllRegisterServer");
HRESULT res = E_FAIL;
if (DllRegisterServer)
res = DllRegisterServer();
if (res != S_OK)
// error handlingDistribución de servidores a través de Internet
Si deseas utilizar controles de tu servidor en páginas web, debes hacer que el servidor esté disponible para el navegador utilizado para visualizar tu página, y debes especificar la ubicación del paquete del servidor en tu página.
Para especificar la ubicación de un servidor, utiliza el atributo CODEBASE en la etiqueta OBJECT de tu sitio web. El valor puede apuntar al propio archivo del servidor, a un archivo INF que enumere otros archivos que el servidor requiera (por ejemplo, la DLL de Qt) o a un archivo CAB comprimido.
Los archivos INF y CAB se describen en casi todos los libros disponibles sobre programación ActiveX y COM, así como en la biblioteca MSDN y en otros recursos en línea. Los ejemplos incluyen archivos INF que se pueden utilizar para crear archivos CAB:
[version]
signature="$CHICAGO$"
AdvancedINF=2.0
[Add.Code]
simpleax.exe=simpleax.exe
[simpleax.exe]
file-win32-x86=thiscab
clsid={DF16845C-92CD-4AAB-A982-EB9840E74669}
RegisterServer=yesLa herramienta CABARC de Microsoft permite generar fácilmente archivos CAB:
cabarc N simpleax.cab simpleax.exe simple.infLos archivos INF asumen una compilación estática de Qt, por lo que no se incluyen dependencias de otras DLL en los archivos INF. Para distribuir un servidor ActiveX que dependa de DLL, debes añadir las dependencias y proporcionar los archivos de biblioteca junto con el archivo comprimido.
Uso de los controles
Para utilizar los controles ActiveX, por ejemplo, para incrustarlos en una página web, utiliza la etiqueta HTML ` <object> `.
<object ID="MyActiveX1" CLASSID="CLSID:ad90301a-849e-4e8b-9a91-0a6dc5f6461f">
...
<\object>Para inicializar las propiedades del control, utilice
<object ID=...>
<param name="name" value="value">
<\object>Si el navegador web admite scripts, utiliza JavaScript, VBScript y formularios para programar el control. Los ejemplos de ActiveQt incluyen páginas HTML de demostración para los controles de ejemplo.
Clientes ActiveX compatibles e incompatibles
Lo que sigue se basa en gran medida en nuestras propias experiencias con controles ActiveX y aplicaciones cliente, y no es en absoluto exhaustivo.
Clientes compatibles
Estas aplicaciones estándar funcionan con controles ActiveX desarrollados con ActiveQt. Ten en cuenta que algunos clientes solo admiten controles «in-process».
- Internet Explorer
- Contenedor de pruebas de controles ActiveX de Microsoft
- Microsoft Visual Studio 6.0
- Microsoft Visual Studio.NET/2003
- Microsoft Visual Basic 6.0
- Contenedores basados en MFC y ATL
- Sybase PowerBuilder
- Contenedores basados en ActiveQt
Las aplicaciones de Microsoft Office son compatibles, pero es necesario registrar los controles como objetos «Insertable». Reimplementa ` QAxFactory::registerClass ` para añadir este atributo a la clase COM, o establece la información de clase «Insertable» de tu clase en «sí» utilizando la macro ` Q_CLASSINFO `.
Clientes no compatibles
No hemos conseguido que los objetos COM basados en ActiveQt funcionen con las siguientes aplicaciones cliente.
- Borland C++ Builder (versiones 5 y 6)
- Borland Delphi
Errores típicos de tiempo de ejecución
El servidor no responde
Si el sistema no puede iniciar el servidor (comprueba en el gestor de tareas si el servidor ejecuta algún proceso), asegúrate de que no falte en la ruta del sistema ninguna DLL de la que dependa el servidor (¡por ejemplo, la DLL de Qt!). Utiliza un analizador de dependencias para ver todas las dependencias del binario del servidor.
Si el servidor se ejecuta (por ejemplo, si el gestor de tareas muestra un proceso), consulta la siguiente sección para obtener información sobre cómo depurar el servidor.
No se puede crear el objeto
Si el servidor se ha podido compilar y registrar correctamente durante el proceso de compilación, pero no se puede inicializar el objeto (por ejemplo, mediante la aplicación OLE/COM Object Viewer), asegúrate de que no falte en la ruta del sistema ninguna DLL de la que dependa el servidor (por ejemplo, la DLL de Qt). Utilice una herramienta de análisis de dependencias para ver todas las dependencias del binario del servidor.
Si el servidor se ejecuta, consulta la siguiente sección para obtener información sobre cómo depurar tu servidor.
Fallos al descargar y volver a cargar servidores COM
Si los servidores COM de Active Qt utilizan módulos de Qt que no se encuentran en Qt Base, es necesario activar el servidor COM como un servidor COM fuera de proceso. Intentar activar un servidor COM en proceso que incluya módulos como Qt Quick puede provocar un fallo tras descargar el servidor COM.
Bloqueo o comportamiento inesperado durante las llamadas COM salientes
Tenga en cuenta que un servidor COM fuera de proceso procesará su cola de mensajes mientras realiza una llamada saliente al cliente. Esto puede provocar un comportamiento inesperado o un fallo si el cliente está llamando al servidor al mismo tiempo. En esta situación, la llamada entrante se ejecutará en el servidor antes de que la llamada saliente devuelva un resultado. En concreto, si el cliente cierra un control ActiveX mientras este está realizando una llamada de retorno al cliente, esto puede provocar un fallo del sistema. Estos problemas de reentrada pueden mitigarse utilizando filtros de mensajes (IMessageFilter y CoRegisterMessageFilter).
Depuración de errores de tiempo de ejecución
Para depurar un servidor en proceso en Visual Studio, establece el proyecto del servidor como proyecto activo y especifica un «ejecutable para la sesión de depuración» del cliente en la configuración del proyecto (por ejemplo, utiliza el ActiveX Test Container). Puede establecer puntos de interrupción en su código y también examinar el código de ActiveQt y Qt si ha instalado la versión de depuración.
Para depurar un servidor ejecutable, ejecute la aplicación en un depurador e iníciela con el parámetro de línea de comandos ` -activex`. A continuación, inicie su cliente y cree una instancia de su control ActiveX. COM utilizará el proceso existente para el siguiente cliente que intente crear un control ActiveX.
Información sobre clases y ajuste
Para proporcionar atributos a cada clase COM, utiliza la macro ` Q_CLASSINFO `, que forma parte del sistema de metobjetos de Qt.
| Clave | Significado del valor |
|---|---|
| Versión | La versión de la clase (1.0 es la predeterminada) |
| Descripción | Una cadena que describe la clase. |
| ClassID | El identificador de la clase. Si no se especifica, debes reimplementar ` QAxFactory::classID `. |
| InterfaceID | El ID de la interfaz. Si no se especifica, debes reimplementar ` QAxFactory::interfaceID `. |
| EventsID | El ID de la interfaz de eventos. Si no se especifica, no se expondrán señales como eventos COM. |
| DefaultProperty | La propiedad especificada representa la propiedad por defecto de esta clase. Es decir, la propiedad por defecto de un botón sería «text». |
| Señal predeterminada | La señal especificada representa la señal por defecto de esta clase. Por ejemplo, la señal por defecto de un botón sería «clicked». |
| LicenseKey | La creación de objetos requiere la clave de licencia especificada. La clave puede dejarse vacía para exigir un equipo con licencia. Por defecto, las clases no tienen licencia. Véase también la siguiente sección. |
| StockEvents | Los objetos exponen eventos de acciones si el valor es «yes». Véase QAxFactory::hasStockEvents() |
| ToSuperClass | Los objetos exponen la funcionalidad de todas las superclases hasta la clase cuyo nombre figura en el valor, incluida esta. Véase QAxFactory::exposeToSuperClass() |
| Insertable | Si el valor es «sí», la clase se registra como «Insertable» y aparecerá en los contenedores OLE 2 (por ejemplo, Microsoft Office). Este atributo no está activado de forma predeterminada. |
| Aggregatable | Si el valor es «no», la clase no admite la agregación. Por defecto, la agregación está habilitada. |
| Creable | Si el valor es «no», el cliente no puede crear la clase, y solo está disponible a través de la API de otra clase (es decir, la clase es un subtipo). |
| RegisterObject | Si el valor es «sí», los objetos de esta clase se registran en OLE y son accesibles desde la tabla de objetos en ejecución (es decir, los clientes pueden conectarse a una instancia de esta clase que ya esté en ejecución). Este atributo solo es compatible con servidores fuera de proceso. |
| MIME | El objeto puede gestionar datos y archivos del formato especificado en el valor. El valor tiene el formato mime:extensión:descripción. Los formatos múltiples se separan mediante un punto y coma. |
| CoClassAlias | El nombre de clase utilizado en el IDL generado y en el registro. Esto resulta especialmente útil para clases de C++ que se encuentran en un espacio de nombres; por defecto, ActiveQt simplemente elimina «::» para que el IDL se compile. |
| Categorías implementadas | Lista de UUID de identificadores de categoría (CATID) separados por comas. Mecanismo genérico para especificar capacidades adicionales del contenedor, además de «control», «insertable», etc. Entre los CATID típicos se incluyen CATID_InternetAware («{0DE86A58-2BAA-11CF-A229-00AA003D7352}»), CATID_SafeForScripting («{7DD95801-9882-11CF-9FA9-00AA006C42C4}»), así como valores CATID definidos por el usuario. |
Ten en cuenta que tanto las claves como los valores distinguen entre mayúsculas y minúsculas.
A continuación se declara la versión 2.0 de una clase que expone únicamente su propia API y que está disponible en el cuadro de diálogo «Insertar objetos» de las aplicaciones de Microsoft Office.
class MyActiveX : public QWidget
{
Q_OBJECT
Q_CLASSINFO("Version", "2.0")
Q_CLASSINFO("ClassID", "{7a4cffd8-cbcd-4ae9-ae7e-343e1e5710df}")
Q_CLASSINFO("InterfaceID", "{6fb035bf-8019-48d8-be51-ef05427d8994}")
Q_CLASSINFO("EventsID", "{c42fffdf-6557-47c9-817a-2da2228bc29c}")
Q_CLASSINFO("Insertable", "yes")
Q_CLASSINFO("ToSuperClass", "MyActiveX")
Q_PROPERTY(...)
public:
MyActiveX(QWidget *parent = 0);
...
};Desarrollo de componentes con licencia
Si desarrollas componentes, es posible que quieras controlar quién puede instanciarlos. Dado que el binario del servidor puede enviarse y registrarse en cualquier equipo cliente, es posible que cualquiera utilice esos componentes en su propio software.
La concesión de licencias a los componentes puede realizarse mediante diversas técnicas; por ejemplo, el código que crea el control puede proporcionar una clave de licencia, o bien es necesario que el equipo en el que se supone que se ejecutará el control cuente con una licencia.
Para marcar una clase de Qt como con licencia, especifica una «LicenseKey» mediante la macro Q_CLASSINFO().
class MyLicensedControl : public QWidget
{
Q_OBJECT
Q_CLASSINFO("LicenseKey", "<key string>")
...
};La clave es necesaria para poder crear una instancia de MyLicensedControl en un equipo que no cuente con licencia propia. El desarrollador con licencia puede ahora redistribuir el binario del servidor junto con su aplicación, la cual crea el control utilizando el valor de «LicenseKey», mientras que los usuarios de la aplicación no pueden crear el control sin la clave de licencia.
Si una única clave de licencia para el control no es suficiente (es decir, si se desea que distintos desarrolladores reciban claves de licencia diferentes), se puede especificar una clave vacía para indicar que el control requiere una licencia y reimplementar QAxFactory::validateLicenseKey() para verificar que existe una licencia en el sistema (por ejemplo, a través de un archivo de licencia).
Más interfaces
Los controles ActiveX proporcionados por los servidores de ActiveQt admiten un conjunto mínimo de interfaces COM para implementar las especificaciones OLE. Cuando la clase ActiveX hereda de la clase ` QAxBindable `, también puede implementar interfaces COM adicionales.
Crea una nueva subclase de ` QAxAggregated ` y utiliza la herencia múltiple para crear subclases de otras clases de interfaz COM.
class AxImpl : public QAxAggregated, public ISomeCOMInterface
{
public:
AxImpl() {}
long queryInterface(const QUuid &iid, void **iface);
// IUnknown
QAXAGG_IUNKNOWN
// ISomeCOMInterface
...
}Reimplementa la función ` QAxAggregated::queryInterface()` para admitir las interfaces COM adicionales.
long AxImpl::queryInterface(const QUuid &iid, void **iface)
{
*iface = 0;
if (iid == IID_ISomeCOMInterface)
*iface = (ISomeCOMInterface *)this;
else
return E_NOINTERFACE;
AddRef();
return S_OK;
}Dado que ` ISomeCOMInterface ` es una subclase de ` IUnknown `, tendrás que implementar las funciones ` QueryInterface()`, ` AddRef()` y ` Release() `. Utiliza la macro `QAXAGG_IUNKNOWN` en la definición de tu clase para hacerlo. Si implementas las funciones ` IUnknown ` manualmente, delega las llamadas al puntero de interfaz devuelto por la función ` QAxAggregated::controllingUnknown()`, p. ej.:
HRESULT AxImpl::QueryInterface(REFIID iid, void **iface)
{
return controllingUnknown()->QueryInterface(iid, iface);
}No implementes la propia interfaz IUnknown en tu implementación de queryInterface().
Implementa los métodos de las interfaces COM y utiliza QAxAggregated::object() si necesitas realizar llamadas a la subclase QObject que implementa el control.
En su subclase de ` QAxBindable `, implemente ` QAxBindable::createAggregate()` para devolver un nuevo objeto de la subclase ` QAxAggregated `.
class MyActiveX : public QWidget, public QAxBindable
{
Q_OBJECT
public:
MyActiveX(QWidget *parent);
QAxAggregated *createAggregate()
{
return new AxImpl();
}
};Véase también ActiveQt Framework.
© 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.