La classe QMetaObject contient les méta-informations concernant les objets de Qt. Plus d'informations...

#include <QMetaObject>

La classe QMetaObject contient les méta-informations concernant les objets de Qt.

Le système de méta-objets de Qt est responsable du mécanisme de communication inter-objet des signaux et des slots, des informations de type disponibles à l’exécution ainsi que du système de propriétés de Qt. Une unique instance de QMetaObject est créée pour chaque sous-classe de QObject utilisée dans l’application et cette instance stocke toutes les méta-informations de la sous-classe de QObject. Cet objet est utilisable par le biais de QObject::metaObject().

Cette classe n’est normalement pas nécessaire à la programmation d’applications, mais est très utile dans le cas de l’écriture de méta-applications, telles que les moteurs de scripts ou les constructeurs de GUI.

Les fonctions les plus susceptibles d’être considérées comme très utiles sont les suivantes :

• className() retourne le nom de la classe ;
• superClass() retourne le méta-objet de la superclasse ;
• method() et methodCount() fournissent des informations à propos des méta-méthodes d’une classe (signaux, slots et autres fonctions membres pouvant être invoquées) ;
• enumerator() et enumeratorCount() fournissent des informations à propos des énumérateurs d’une classe ;
• propertyCount() et property() fournissent des informations à propos des propriétés d’une classe ;
• constructor() et constructorCount() fournissent des informations à propos des méta-constructeurs d’une classe.

Les fonctions d’index indexOfConstructor(), indexOfMethod(), indexOfEnumerator() et indexOfProperty() font référence aux index dans le méta-objet des noms des constructeurs, des fonctions membres, des énumérateurs et des propriétés. Par exemple, Qt utilise indexOfMethod() quand vous connectez un signal à un slot.

Les classes peuvent aussi avoir une liste de paires nom/valeur d’informations de classes additionnelles, stockées dans des objets de QMetaClassInfo. Le nombre de paires est retourné par classInfoCount(), les paires uniques sont retournées par classInfo et vous pouvez chercher des paires avec indexOfClassInfo().

Voir aussi QMetaClassInfo, QMetaEnum, QMetaMethod, QMetaProperty, QMetaType et Le système de méta-objets.

bool QMetaObject::checkConnectArgs ( const char * signal, const char * methode ) [static]

Retourne true si le signal et la methode sont compatibles ; sinon retourne false.

signal et methode sont supposés être normalisés.

Voir aussi normalizedSignature().

QMetaClassInfo QMetaObject::classInfo ( int index ) const

Retourne la méta-donnée pour l’élément de l’information de classe avec l‘index donné.

Exemple :

 class MyClass
 {
     Q_OBJECT
     Q_CLASSINFO("auteur", "Sabrina Schweinsteiger")
     Q_CLASSINFO("url", "http://doc.moosesoft.co.uk/1.0/")
 
 public:
     ...
 };

Voir aussi classInfoCount(), classInfoOffset() et indexOfClassInfo().

int QMetaObject::classInfoCount () const

Retourne le nombre d’éléments de l’information de classe dans cette classe.

Voir aussi classInfo(), classInfoOffset() et indexOfClassInfo().

int QMetaObject::classInfoOffset () const

Retourne l’offset de l’information de classe de cette classe ; c’est-à-dire la position d’index du premier élément de l’information de classe.

Si la classe n’a pas de superclasse ayant une information de classe, l’offset est 0 ; dans le cas contraire, l’offset est la somme de tous les éléments de l’information de classe des superclasses de la classe.

Voir aussi classInfo(), classInfoCount() et indexOfClassInfo().

const char * QMetaObject::className () const

Retourne le nom de classe.

Voir aussi superClass().

void QMetaObject::connectSlotsByName ( QObject * objet ) [static]

Cherche récursivement tous les objets enfants de l‘objet donné et connecte depuis ceux-ci les signaux identifiés à des slots de l‘objet qui suivent la forme suivante :

void on_<nom de l'objet>_<nom du signal>(<paramètres du signal>);

Supposons que notre objet possède un objet enfant du type de QPushButton avec le nom d'objet bouton1. Le slot permettant la capture du signal clicked() du bouton serait :

void on_bouton1_clicked();

Voir aussi QObject::setObjectName().

QMetaMethod QMetaObject::constructor ( int index ) const

Retourne la méta-donnée pour le constructeur ayant l‘index donné.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi constructorCount() et newInstance().

int QMetaObject::constructorCount () const

Retourne le nombre de constructeurs que contient cette classe.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi constructor() et indexOfConstructor().

QMetaEnum QMetaObject::enumerator ( int index ) const

Retourne la méta-donnée pour l’énumérateur ayant l‘index donné.

Voir aussi enumeratorCount(), enumeratorOffset() et indexOfEnumerator().

int QMetaObject::enumeratorCount () const

Retourne le nombre d’énumérateurs présents dans cette classe.

Voir aussi enumerator(), enumeratorOffset() et indexOfEnumerator().

int QMetaObject::enumeratorOffset () const

Retourne l’offset des énumérateurs de cette classe ; c’est-à-dire la position d’index du premier énumérateur de la classe.

Si la classe n’a pas de superclasse ayant des énumérateurs, l’offset sera 0 ; dans le cas contraire, l’offset sera la somme de tous les énumérateurs des superclasses de la classe.

Voir aussi enumerator(), enumeratorCount() et indexOfEnumerator().

int QMetaObject::indexOfClassInfo ( const char * nom ) const

Trouve le nom de l’élément de l’information de classe et retourne son index ; dans le cas contraire, retourne -1.

Voir aussi classInfo(), classInfoCount() et classInfoOffset().

int QMetaObject::indexOfConstructor ( const char * constructeur ) const

Trouve le constructeur et retourne son index ; dans le cas contraire, retourne -1.

Notez que le constructeur doit être dans une forme normalisée, comme retourné par normalizedSignature().

Cette fonction a été introduite dans Qt 4.5.

Voir aussi constructor(), constructorCount() et normalizedSignature().

int QMetaObject::indexOfEnumerator ( const char * nom ) const

Trouve l’énumérateur nom et retourne son index ; dans le cas contraire, retourne -1.

Voir aussi enumerator(), enumeratorCount() et enumeratorOffset().

int QMetaObject::indexOfMethod ( const char * methode ) const

Trouve le terme methode et retourne son index ; dans le cas contraire, retourne -1.

Notez que la methode doit être dans une forme normalisée, comme retournée par normalizedSignature().

Voir aussi method(), methodCount(), methodOffset() et normalizedSignature().

int QMetaObject::indexOfProperty ( const char * nom ) const

Trouve la propriété nom et retourne son index ; dans le cas contraire, retourne -1.

Voir aussi property(), propertyCount() et propertyOffset().

int QMetaObject::indexOfSignal ( const char * signal ) const

Trouve le signal et retourne son index ; dans le cas contraire, retourne -1.

Cette fonction est identique à indexOfMethod(), mis à part qu’elle retourne -1 si la méthode existe, mais ne correspond pas à un signal.

Notez que le signal doit être dans une forme normalisée, comme retourné par normalizedSignature().

Voir aussi indexOfMethod(), normalizedSignature(), method(), methodCount() et methodOffset().

int QMetaObject::indexOfSlot ( const char * slot ) const

Trouve le slot et retourne son index ; dans le cas contraire, retourne -1.

Cette fonction est identique à indexOfMethod(), mis à part qu’elle retourne -1 si la méthode existe, mais ne correspond pas à un slot.

Voir aussi indexOfMethod(), method(), methodCount() et methodOffset().

bool QMetaObject::invokeMethod ( QObject * obj, const char * membre, Qt::ConnectionType type, QGenericReturnArgument ret, QGenericArgument val0 = QGenericArgument( 0 ), QGenericArgument val1 = QGenericArgument(), QGenericArgument val2 = QGenericArgument(), QGenericArgument val3 = QGenericArgument(), QGenericArgument val4 = QGenericArgument(), QGenericArgument val5 = QGenericArgument(), QGenericArgument val6 = QGenericArgument(), QGenericArgument val7 = QGenericArgument(), QGenericArgument val8 = QGenericArgument(), QGenericArgument val9 = QGenericArgument() ) [static]

Invoque le membre (un nom de signal ou de slot) sur l’objet obj. Retourne true si le membre peut être invoqué. Retourne false s’il n’existe pas de tel membre ou si les paramètres ne correspondent pas.

L’invocation peut être synchrone ou asynchrone, selon le type :

• si type est Qt::DirectConnection, le membre sera invoqué immédiatement ;
• si type est Qt::QueuedConnection, un QEvent sera envoyé et le membre sera invoqué dès que l’application entrera dans la boucle d’évènements principale ;
• si type est Qt::BlockingQueuedConnection, la méthode sera invoquée de la même manière que Qt::QueuedConnection, mis à part le fait que le thread actuel va bloquer jusqu’à ce que l’évènement soit délivré ; l’utilisation de ce type de connexion pour communiquer entre des objets du même thread mènera à des blocages ;
• si type est Qt::AutoConnection, le membre sera invoqué de manière synchrone si obj vit dans le même thread que l’appelant ; dans le cas contraire, il appellera le membre de manière asynchrone.

La valeur de retour de l’appel de la fonction membre est placée dans ret. Si l’invocation est asynchrone, la valeur de retour ne peut pas être évaluée. Vous pouvez passer un maximum de dix arguments (val0, val1, val2, val3, val4, val5, val6, val7, val8 et val9) à la fonction membre.

QGenericArgument et QGenericReturnArgument sont des classes d’assistance internes. Pour la même raison que les signaux et les slots peuvent être invoqués dynamiquement, vous devez joindre les arguments en utilisant les macros Q_ARG() et Q_RETURN_ARG(). Q_ARG() prend un nom de type et une référence constante de ce type ; Q_RETURN_ARG() prend un nom de type et une référence non constante.

Vous devez uniquement passer le nom du signal ou du slot à cette fonction, et non la signature entière. Par exemple, pour invoquer de manière asynchrone le slot QAbstractButton::animateClick() d’un QPushButton, vous pouvez utiliser le code suivant :

 QMetaObject::invokeMethod(pushButton, "animateClick",
                           Qt::QueuedConnection);

Avec des méthodes asynchrones d’invocation, les paramètres doivent être de types connus du système de méta-objets de Qt, car Qt a besoin de copier les arguments pour les stocker dans un évènement derrière les coulisses. Si vous tentez d’utiliser une connexion par file d’attente et que vous récupérez ce message d’erreur :

QMetaObject::invokeMethod: Unable to handle unregistered datatype 'MyType'

Appelez QMetaType::qRegisterMetaType() pour enregistrer les informations de type avant d’appeler invokeMethod().

Pour invoquer de manière synchrone le slot compute(QString, int, double) sur un obj arbitraire pour retourner sa valeur de retour :

 QString retVal;
 QMetaObject::invokeMethod(obj, "compute", Qt::DirectConnection,
                           Q_RETURN_ARG(QString, retVal),
                           Q_ARG(QString, "sqrt"),
                           Q_ARG(int, 42),
                           Q_ARG(double, 9.7));

Si le slot compute ne prend pas exactement un QString, un int et un double dans l’ordre spécifié, l’appel échouera.

Voir aussi Q_ARG(), Q_RETURN_ARG(), qRegisterMetaType() et QMetaMethod#invoke().

bool QMetaObject::invokeMethod ( QObject * obj, const char * membre, QGenericReturnArgument ret, QGenericArgument val0 = QGenericArgument( 0 ), QGenericArgument val1 = QGenericArgument(), QGenericArgument val2 = QGenericArgument(), QGenericArgument val3 = QGenericArgument(), QGenericArgument val4 = QGenericArgument(), QGenericArgument val5 = QGenericArgument(), QGenericArgument val6 = QGenericArgument(), QGenericArgument val7 = QGenericArgument(), QGenericArgument val8 = QGenericArgument(), QGenericArgument val9 = QGenericArgument() ) [static]

Cette fonction surcharge invokeMethod().

Cette surcharge invoque toujours le membre en utilisant le type de connexion Qt::AutoConnection.

bool QMetaObject::invokeMethod ( QObject * obj, const char * membre, Qt::ConnectionType type, QGenericArgument val0 = QGenericArgument( 0 ), QGenericArgument val1 = QGenericArgument(), QGenericArgument val2 = QGenericArgument(), QGenericArgument val3 = QGenericArgument(), QGenericArgument val4 = QGenericArgument(), QGenericArgument val5 = QGenericArgument(), QGenericArgument val6 = QGenericArgument(), QGenericArgument val7 = QGenericArgument(), QGenericArgument val8 = QGenericArgument(), QGenericArgument val9 = QGenericArgument() ) [static]

Cette fonction surcharge invokeMethod().

Cette surcharge peut être utilisée si la valeur de retour n’est d’aucun intérêt.

bool QMetaObject::invokeMethod ( QObject * obj, const char * membre, QGenericArgument val0 = QGenericArgument( 0 ), QGenericArgument val1 = QGenericArgument(), QGenericArgument val2 = QGenericArgument(), QGenericArgument val3 = QGenericArgument(), QGenericArgument val4 = QGenericArgument(), QGenericArgument val5 = QGenericArgument(), QGenericArgument val6 = QGenericArgument(), QGenericArgument val7 = QGenericArgument(), QGenericArgument val8 = QGenericArgument(), QGenericArgument val9 = QGenericArgument() ) [static]

Cette fonction surcharge invokeMethod().

Cette surcharge invoque le membre en utilisant le type de connexion Qt::AutoConnection et ignore les valeurs de retour.

QMetaMethod QMetaObject::method ( int index ) const

Retourne la métadonnée pour la méthode ayant l‘index donné.

Voir aussi methodCount(), methodOffset() et indexOfMethod().

int QMetaObject::methodCount () const

Retourne le nombre de méthodes que possède cette classe, incluant le nombre de propriétés fournies par chaque classe mère. Ils incluent aussi bien les signaux et les slots que les fonctions membres normales.

Utilisez un code tel que le suivant pour obtenir une QStringList contenant les méthodes spécifiques à chaque classe donnée :

 const QMetaObject* metaObject = obj->metaObject();
 QStringList methods;
 for(int i = metaObject->methodOffset(); i < metaObject->methodCount(); ++i)
     methods << QString::fromLatin1(metaObject->method(i).signature());

Voir aussi method(), methodOffset() et indexOfMethod().

int QMetaObject::methodOffset () const

Retourne l’offset des méthodes de cette classe ; c’est-à-dire la position d’index de la première méthode de la classe.

L’offset est la somme de toutes les méthodes des superclasses de la classe (qui est toujours positive depuis que QObject possède le slot deleteLater() et le signal destroyed()).

Voir aussi method(), methodCount() et indexOfMethod().

QObject * QMetaObject::newInstance ( QGenericArgument val0 = QGenericArgument( 0 ), QGenericArgument val1 = QGenericArgument(), QGenericArgument val2 = QGenericArgument(), QGenericArgument val3 = QGenericArgument(), QGenericArgument val4 = QGenericArgument(), QGenericArgument val5 = QGenericArgument(), QGenericArgument val6 = QGenericArgument(), QGenericArgument val7 = QGenericArgument(), QGenericArgument val8 = QGenericArgument(), QGenericArgument val9 = QGenericArgument() ) const

Construit une nouvelle instance de cette classe. Vous pouvez passer un maximum de dix arguments (val0, val1, val2, val3, val4, val5, val6, val7, val8 et val9) au constructeur. Retourne le nouvel objet, ou 0 si aucun constructeur approprié n’est disponible.

Notez que seuls les constructeurs déclarés avec le modificateur Q_INVOKABLE sont rendus disponibles à travers le système de méta-objets.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi Q_ARG() et constructor().

QByteArray QMetaObject::normalizedSignature ( const char * methode ) [static]

Normalise la signature de la methode donnée.

Qt utilise des signatures normalisées pour déterminer si deux signaux et slots donnés sont compatibles. La normalisation réduit les espaces au minimum, déplace les mentions const vers l’avant quand approprié, supprime la mention const des types de valeurs et remplace les références constantes par des valeurs.

Voir aussi checkConnectArgs() et normalizedType().

QByteArray QMetaObject::normalizedType ( const char * type ) [static]

Normalise un type.

Voir QMetaObject::normalizedSignature() pour une description sur la méthode de normalisation de Qt.

Exemple :

 QByteArray normType = QMetaObject::normalizedType(" int    const  *");
 // normType est maintenant "const int*"

Cette fonction a été introduite dans Qt 4.2.

Voir aussi normalizedSignature().

QMetaProperty QMetaObject::property ( int index ) const

Retourne la métadonnée pour la propriété ayant l‘index donné. Si aucune telle propriété n’existe, un QMetaProperty nul est retourné.

Voir aussi propertyCount(), propertyOffset() et indexOfProperty().

int QMetaObject::propertyCount () const

Retourne le nombre de propriétés présentes dans cette classe, incluant le nombre de propriétés fournies par chaque classe parente.

Utilisez un code tel que le suivant pour récupérer une QStringList contenant les propriétés spécifiques à une classe donnée :

 const QMetaObject* metaObject = obj->metaObject();
 QStringList properties;
 for(int i = metaObject->propertyOffset(); i < metaObject->propertyCount(); ++i)
     properties << QString::fromLatin1(metaObject->property(i).name());

Voir aussi property(), propertyOffset() et indexOfProperty().

int QMetaObject::propertyOffset () const

Retourne l’offset des propriétés de cette classe ; c’est-à-dire la position d’index de la première propriété de la classe.

L’offset est la somme de toutes les propriétés des superclasses de la classe (qui est toujours positive depuis que QObject possède la propriété name()).

Voir aussi property(), propertyCount() et indexOfProperty().

const QMetaObject * QMetaObject::superClass () const

Retourne le méta-objet de la superclasse, ou 0 s’il n’existe pas de tel objet.

Voir aussi className().

QMetaProperty QMetaObject::userProperty () const

Retourne la propriété qui détient le flag USER défini à true.

Cette fonction a été introduite dans Qt 4.2.

Voir aussi QMetaProperty::isUser().

QGenericArgument Q_ARG ( Type, const Type & valeur )

Cette macro prend un Type, une valeur de ce type et retourne un objet de QGenericArgument qui peut être passé à QMetaObject::invokeMethod().

Voir aussi Q_RETURN_ARG().

QGenericReturnArgument Q_RETURN_ARG ( Type, Type & valeur )

Cette macro prend un Type et une référence non constante d’une valeur de ce type et retourne un objet de QGenericReturnArgument qui peut être passé à QMetaObject::invokeMethod().

Voir aussi Q_ARG().

Merci à <!zamnell!> pour la traduction et à <!dourouc!>, <!johnlamericain!> ainsi qu’à <!jacques_jean!> pour leur relecture !