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 aussi clear().

QVariant QAxBase::asVariant() const

Renvoie une adresse QVariant qui englobe l'objet COM. La variante peut alors être utilisée comme paramètre, par exemple dans dynamicCall().

ulong QAxBase::classContext() const

Renvoie le contexte dans lequel le contrôle ActiveX sera exécuté (par défaut CLSCTX_SERVER).

Voir aussi 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 pour 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 sur la classe du contrôle ActiveX, utilisez cette fonction pour accélérer la génération du méta-objet.

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 puits d'événements pour ce conteneur ActiveX. Si vous n'avez pas l'intention d'écouter les événements du contrôle ActiveX, utilisez cette fonction pour accélérer la génération des méta-objets.

Certains contrôles ActiveX peuvent être instables lorsqu'ils sont connectés à un récepteur d'événements. Pour obtenir des événements OLE, vous devez utiliser les méthodes COM standard pour enregistrer votre propre puits d'événements. Utilisez 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 des informations sur les événements et les classes. Si vous n'avez pas l'intention d'utiliser l'implémentation de l'objet méta de 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 être 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 construction 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 de l'objet COM function, en passant les paramètres var1, var1, var2, var3, var4, var5, var6, var7 et var8, et renvoie la valeur renvoyée par la méthode, ou un QVariant invalide si la méthode ne renvoie pas de valeur ou si l'appel de la 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 tel qu'il serait écrit dans un appel à QObject::connect().

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

Il est également possible d'appeler une fonction en passant les paramètres intégrés dans la chaîne de caractères, par exemple la fonction ci-dessus peut également être appelée en utilisant

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 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 être le nom de la propriété. L'outil de définition de la propriété est appelé lorsque var1 est un QVariant valide, sinon l'outil d'acquisition est appelé.

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

Notez qu'il est plus rapide d'obtenir et de définir des propriétés en utilisant QObject::property() et QObject::setProperty().

dynamicCall() peut également être utilisé pour appeler des objets avec un wrapper disabled metaobject, ce qui peut améliorer considérablement les performances, en particulier lors de l'appel de nombreux objets de types différents au cours d'un processus d'automatisation. ActiveQt ne validera cependant pas les paramètres.

Il n'est possible d'appeler des fonctions via dynamicCall() que si les paramètres ou les valeurs de retour sont des types de données pris en charge par QVariant. Voir la documentation de la classe QAxBase pour une liste des types de données supportés et non supportés. Si vous souhaitez appeler des fonctions dont la liste des paramètres contient des types de données non pris en charge, utilisez queryInterface() pour récupérer l'interface COM appropriée et utilisez 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 de l'objet COM function, en passant les paramètres 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 invalide.

Les objets QVariant dans vars sont mis à jour lorsque la méthode a des paramètres externes.

QString QAxBase::generateDocumentation()

Renvoie une chaîne de texte riche contenant la documentation de l'objet COM enveloppé. Déchargez la 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 ; sinon, elle renvoie false.

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

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

L'interface renvoyée dans ptr doit être référencée exactement une fois lorsque cette fonction est renvoyée. L'interface fournie par exemple par CoCreateInstance 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 en cours d'exécution sur la machine actuelle et renvoie l'interface IUnknown à l'objet en cours d'exécution à l'adresse 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 qui gère le nom de fichier dans la propriété control et renvoie l'interface IUnknown à 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 est le 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 à l'objet dans ptr. Cette fonction renvoie la valeur "true" en cas de succès, sinon elle renvoie la valeur "false".

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

Voir aussi initialize().

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

Crée l'instance sur un serveur distant et renvoie l'interface IUnknown à 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 la sous-chaîne.

Voir aussi initialize().

bool QAxBase::isNull() const

Retourne true s'il n'y a pas d'objet COM chargé par ce wrapper, sinon retourne false.

Voir aussi control().

QAxBase::PropertyBag QAxBase::propertyBag() const

Renvoie une carte nom/valeur de toutes les propriétés exposées par l'objet COM.

Cette méthode est plus efficace que l'obtention de plusieurs propriétés individuellement si l'objet COM prend en charge les sacs de propriétés.

Voir aussi setPropertyBag().

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

Retourne true si la propriété prop est accessible en écriture, sinon retourne false. Par défaut, toutes les propriétés sont accessibles en écriture.

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 valeur iface à l'interface fournie, ou à 0 si l'interface demandée n'a pas pu être fournie.

Renvoie le résultat de l'implémentation de 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 un QAxObject enveloppant l'objet COM fourni par la méthode ou la propriété name, en passant 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 être le nom de la propriété, et var1, ... var8 sont ignorés.

L'objet retourné QAxObject est un enfant de cet objet (qui est soit du type QAxObject, soit du type QAxWidget) et est supprimé lorsque cet objet est supprimé. Il est toutefois possible de supprimer soi-même l'objet retourné, ce que vous devriez faire lorsque vous itérez sur 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 distribution. Utilisez cette méthode pour naviguer dans 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 dans vars sont mis à jour lorsque la méthode a des paramètres de sortie.

void QAxBase::setClassContext(ulong classContext)

Définit le contexte dans lequel le contrôle ActiveX sera exécuté classContext

Affecte l'argument "dwClsContext" lors de l'appel à CoCreateInstance. Ceci peut être utilisé pour contrôler le démarrage in-proc ou out-of-proc pour les contrôles supportant les deux alternatives. Elle peut également être utilisée pour modifier/réduire les autorisations de contrôle 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 avoir un effet.

Voir aussi classContext().

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

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

Voir aussi propertyBag().

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

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

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 IOleObject ou ne supporte aucun verbe, cette fonction renvoie une liste de chaînes vide.

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