QAxBase Class

Documentation des fonctions membres

[protected] QAxBase::QAxBase()

Crée un objet QAxBase.

[virtual noexcept] QAxBase::~QAxBase()

Ferme l'objet COM et détruit l'objet QAxBase.

Voir également clear().

QVariant QAxBase::asVariant() const

Renvoie un objet de type « QVariant » qui encapsule l'objet COM. Ce variant peut ensuite être utilisé comme paramètre, par exemple dans la fonction ` dynamicCall()`.

ulong QAxBase::classContext() const

Renvoie le contexte dans lequel le contrôle ActiveX s'exécutera (par défaut : CLSCTX_SERVER).

Voir également setClassContext().

void QAxBase::clear()

Déconnecte et détruit l'objet COM.

Si vous réimplémentez cette fonction, vous devez également réimplémenter le destructeur afin d'appeler clear(), et appeler cette implémentation à la fin de votre fonction clear().

QString QAxBase::control() const

Renvoie le contrôle ActiveX.

void QAxBase::disableClassInfo()

Désactive la génération d'informations de classe pour ce conteneur ActiveX. Si vous n'avez pas besoin d'informations de classe concernant le contrôle ActiveX, utilisez cette fonction pour accélérer la génération des méta-objets.

Notez que cette fonction doit être appelée immédiatement après la construction de l'objet

void QAxBase::disableEventSink()

Désactive l'implémentation du récepteur d'événements pour ce conteneur ActiveX. Si vous ne comptez pas écouter les événements du contrôle ActiveX, utilisez cette fonction pour accélérer la génération du méta-objet.

Certains contrôles ActiveX peuvent présenter un comportement instable lorsqu’ils sont connectés à un récepteur d’événements. Pour recevoir des événements OLE, vous devez utiliser les méthodes COM standard afin d’enregistrer votre propre récepteur d’événements. Utilisez la fonction queryInterface() pour accéder à l’objet COM brut.

Notez que cette fonction doit être appelée immédiatement après la construction de l’objet.

void QAxBase::disableMetaObject()

Désactive la génération de méta-objets pour ce conteneur ActiveX. Cela désactive également la génération du récepteur d'événements et des informations de classe. Si vous ne comptez pas utiliser l'implémentation des méta-objets Qt, appelez cette fonction pour accélérer l'instanciation du contrôle. Vous pourrez toujours appeler l’objet via ` dynamicCall()`, mais les signaux, les slots et les propriétés ne seront pas disponibles avec les API ` QObject `.

Certains contrôles ActiveX peuvent s’avérer instables lorsqu’ils sont utilisés avec l’automatisation OLE. Utilisez les méthodes COM standard pour utiliser ces contrôles via les interfaces COM fournies par ` queryInterface()`.

Notez que cette fonction doit être appelée immédiatement après la création de l’objet.

QVariant QAxBase::dynamicCall(const char *function, const QVariant &var1 = QVariant(), const QVariant &var2 = QVariant(), const QVariant &var3 = QVariant(), const QVariant &var4 = QVariant(), const QVariant &var5 = QVariant(), const QVariant &var6 = QVariant(), const QVariant &var7 = QVariant(), const QVariant &var8 = QVariant())

Appelle la méthode « function » de l'objet COM en lui transmettant les paramètres « var1 », « var1 », « var2 », « var3 », « var4 », « var5 », « var6 », « var7 » et « var8 », puis renvoie la valeur retournée par la méthode, ou un « QVariant » invalide si la méthode ne renvoie pas de valeur ou si l'appel de fonction a échoué.

Si ` function ` est une méthode de l’objet, la chaîne doit être fournie sous la forme du prototype complet, par exemple telle qu’elle serait écrite dans un appel ` QObject::connect()`.

activeX->dynamicCall("Navigate(const QString&)", "www.qt-project.org");

Il est également possible d’appeler une fonction en lui passant les paramètres intégrés dans la chaîne de caractères ; par exemple, la fonction ci-dessus peut également être invoquée à l’aide de

activeX->dynamicCall("Navigate(\"www.qt-project.org\")");

Tous les paramètres sont transmis sous forme de chaînes de caractères ; leur interprétation correcte dépend du contrôle, et cette méthode est plus lente que l’utilisation du prototype avec des paramètres correctement typés.

Si ` function ` est une propriété, la chaîne doit correspondre au nom de cette propriété. Le setter de la propriété est appelé lorsque ` var1 ` est une valeur valide de type ` QVariant` ; dans le cas contraire, c’est le getter qui est appelé.

activeX->dynamicCall("Value", 5);
QString text = activeX->dynamicCall("Text").toString();

Notez qu’il est plus rapide d’accéder aux propriétés et de les définir à l’aide de ` QObject::property()` et ` QObject::setProperty()`.

La méthode `dynamicCall()` peut également être utilisée pour appeler des objets via un wrapper ` disabled metaobject `, ce qui peut améliorer considérablement les performances, notamment lors de l'appel de nombreux objets de types différents au cours d'un processus d'automatisation. ActiveQt ne validera toutefois pas les paramètres dans ce cas.

Il n’est possible d’appeler via `dynamicCall()` que des fonctions dont les paramètres ou les valeurs de retour sont de types pris en charge par ` QVariant`. Consultez la documentation de la classe ` QAxBase ` pour obtenir la liste des types de données pris en charge et non pris en charge. Si vous souhaitez appeler des fonctions dont la liste de paramètres contient des types de données non pris en charge, utilisez ` queryInterface()` pour récupérer l'interface COM appropriée, puis appelez la fonction directement.

IWebBrowser2 *webBrowser = 0;
activeX->queryInterface(IID_IWebBrowser2, (void **)&webBrowser);
if (webBrowser) {
    webBrowser->Navigate2(pvarURL);
    webBrowser->Release();
}

Cette méthode est également plus efficace.

QVariant QAxBase::dynamicCall(const char *function, QList<QVariant> &vars)

Appelle la méthode function de l'objet COM, en lui transmettant les paramètres contenus dans vars, et renvoie la valeur renvoyée par la méthode. Si la méthode ne renvoie pas de valeur ou si l'appel de fonction a échoué, cette fonction renvoie un objet QVariant non valide.

Les objets ` QVariant ` de ` vars ` sont mis à jour lorsque la méthode comporte des paramètres de sortie.

QString QAxBase::generateDocumentation()

Renvoie une chaîne de texte enrichi contenant la documentation relative à l'objet COM encapsulé. Enregistrez cette chaîne dans un fichier HTML ou utilisez-la, par exemple, dans un widget « QTextBrowser ».

[virtual protected] bool QAxBase::initialize(IUnknown **ptr)

Cette fonction virtuelle est appelée par `setControl()` et crée l'objet COM demandé. ` ptr ` est défini sur l'implémentation `IUnknown` de l'objet. La fonction renvoie `true` si l'initialisation de l'objet a réussi ; dans le cas contraire, elle renvoie `false`.

L’implémentation par défaut interprète la chaîne renvoyée par control(), puis appelle initializeRemote(), initializeLicensed() ou initializeActive() si la chaîne correspond aux modèles respectifs. Si control() correspond au nom d’un fichier existant, initializeFromFile() est appelée. Si aucun modèle ne correspond, ou si l’initialisation à distance ou sous licence échoue, CoCreateInstance est utilisée directement pour créer l’objet.

Consultez la documentation relative à la propriété QAxBaseWidget::control pour plus de détails sur les modèles pris en charge.

L’interface renvoyée par ptr doit être référencée exactement une fois lorsque cette fonction renvoie une valeur. L’interface fournie par CoCreateInstance, par exemple, est déjà référencée, et il n’est pas nécessaire de la référencer à nouveau.

[protected] bool QAxBase::initializeActive(IUnknown **ptr)

Se connecte à une instance active s'exécutant sur la machine actuelle et renvoie l'interface IUnknown de l'objet en cours d'exécution dans ptr. Cette fonction renvoie « true » en cas de succès, sinon elle renvoie « false ».

Cette fonction est appelée par ` initialize()` si la chaîne de contrôle contient la sous-chaîne « }& ».

Voir également initialize().

[protected] bool QAxBase::initializeFromFile(IUnknown **ptr)

Crée l'objet COM gérant le nom de fichier indiqué dans la propriété « control » et renvoie l'interface IUnknown vers cet objet via la méthode ptr. Cette fonction renvoie « true » en cas de succès, sinon elle renvoie « false ».

Cette fonction est appelée par initialize() si la chaîne du contrôle correspond au nom d'un fichier existant.

Voir également initialize().

[protected] bool QAxBase::initializeLicensed(IUnknown **ptr)

Crée une instance d'un contrôle sous licence et renvoie l'interface IUnknown de l'objet dans ` ptr`. Cette fonction renvoie `true` en cas de réussite, sinon elle renvoie `false`.

Cette fonction est appelée par initialize() si la chaîne du contrôle contient la sous-chaîne « }: ». La clé de licence doit suivre cette sous-chaîne.

Voir également initialize().

[protected] bool QAxBase::initializeRemote(IUnknown **ptr)

Crée l'instance sur un serveur distant et renvoie l'interface IUnknown de l'objet dans ptr. Cette fonction renvoie « true » en cas de succès, sinon elle renvoie « false ».

Cette fonction est appelée par initialize() si la chaîne de contrôle contient la sous-chaîne « /{ ». Les informations relatives à la machine distante doivent être fournies avant cette sous-chaîne.

Voir également initialize().

bool QAxBase::isNull() const

Renvoie « true » s'il n'y a aucun objet COM chargé par ce wrapper ; sinon, renvoie « false ».

Voir aussi control().

QAxBase::PropertyBag QAxBase::propertyBag() const

Renvoie un tableau « nom:valeur » contenant toutes les propriétés exposées par l'objet COM.

Cette méthode est plus efficace que de récupérer plusieurs propriétés individuellement si l'objet COM prend en charge les « property bags ».

Voir également setPropertyBag().

[virtual] bool QAxBase::propertyWritable(const char *prop) const

Renvoie « true » si la propriété prop est modifiable ; sinon, renvoie « false ». Par défaut, toutes les propriétés sont modifiables.

Voir également setPropertyWritable(), QAxBaseWidget::propertyChanged() et QAxBaseObject::propertyChanged().

long QAxBase::queryInterface(const QUuid &uuid, void **iface) const

Demande l'interface uuid à l'objet COM et attribue à la variable iface la valeur de l'interface fournie, ou la valeur 0 si l'interface demandée n'a pas pu être fournie.

Renvoie le résultat de l'implémentation de la méthode QueryInterface de l'objet COM.

Voir aussi control().

QAxObject *QAxBase::querySubObject(const char *name, const QVariant &var1 = QVariant(), const QVariant &var2 = QVariant(), const QVariant &var3 = QVariant(), const QVariant &var4 = QVariant(), const QVariant &var5 = QVariant(), const QVariant &var6 = QVariant(), const QVariant &var7 = QVariant(), const QVariant &var8 = QVariant())

Renvoie un pointeur vers une instance de ` QAxObject ` encapsulant l'objet COM fourni par la méthode ou la propriété ` name`, en transmettant les paramètres ` var1`, ` var1`, ` var2`, ` var3`, ` var4`, ` var5`, ` var6`, ` var7 ` et ` var8`.

Si name est fourni par une méthode, la chaîne doit inclure le prototype complet de la fonction.

Si ` name ` est une propriété, la chaîne doit correspondre au nom de la propriété ; les éléments ` var1`, … ` var8 ` sont ignorés.

L’ QAxObject renvoyée est un enfant de cet objet (qui est soit de type QAxObject soit de type QAxWidget), et est supprimée lorsque cet objet est supprimé. Vous pouvez toutefois supprimer vous-même l’objet renvoyé en toute sécurité, et vous devriez le faire lorsque vous parcourez des listes de sous-objets.

Les applications compatibles COM disposent généralement d’un modèle d’objet publiant certains éléments de l’application sous forme d’interfaces de répartition. Utilisez cette méthode pour parcourir la hiérarchie du modèle d’objet, par exemple :

QAxWidget outlook("Outlook.Application");
QAxObject *session = outlook.querySubObject("Session");
if (session) {
    QAxObject *defFolder = session->querySubObject(
                            "GetDefaultFolder(OlDefaultFolders)",
                            "olFolderContacts");
    //...
}

QAxObject *QAxBase::querySubObject(const char *name, QList<QVariant> &vars)

Les objets « QVariant » de vars sont mis à jour lorsque la méthode comporte des paramètres de sortie.

void QAxBase::setClassContext(ulong classContext)

Définit le contexte dans lequel le contrôle ActiveX s'exécutera classContext

Influence l’argument « dwClsContext » lors de l’appel de CoCreateInstance. Cela permet de contrôler le démarrage en mode « in-proc » ou « out-of-proc » pour les contrôles prenant en charge ces deux modes. Elle peut également servir à modifier ou à restreindre les autorisations des contrôles lorsqu’elle est utilisée avec CLSCTX_ENABLE_CLOAKING et un jeton d’usurpation d’identité.

Notez que cette fonction doit être appelée avant setControl() pour produire un effet.

Voir également classContext().

void QAxBase::setPropertyBag(const QAxBase::PropertyBag &bag)

Définit les propriétés de l'objet COM sur les valeurs correspondantes de bag.

Voir également propertyBag().

[virtual] void QAxBase::setPropertyWritable(const char *prop, bool ok)

Définit la propriété prop comme modifiable si ok est vrai ; sinon, définit prop comme étant en lecture seule. Par défaut, toutes les propriétés sont modifiables.

Voir également propertyWritable(), QAxBaseWidget::propertyChanged() et QAxBaseObject::propertyChanged().

QStringList QAxBase::verbs() const

Renvoie la liste des verbes que l'objet COM peut exécuter. Si l'objet n'implémente pas l'interface IOleObject ou ne prend en charge aucun verbe, cette fonction renvoie une liste de chaînes vide.

Notez que les verbes OLE par défaut (OLEIVERB_SHOW, etc.) ne figurent pas dans la liste.