QMetaObject Struct

Documentation des fonctions membres

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

Renvoie true si les arguments signal et method sont compatibles ; sinon, renvoie false.

On s'attend à ce que signal et method soient normalisés.

Voir aussi normalizedSignature().

[static] bool QMetaObject::checkConnectArgs(const QMetaMethod &signal, const QMetaMethod &method)

Renvoie true si les arguments signal et method sont compatibles ; sinon, renvoie false.

QMetaClassInfo QMetaObject::classInfo(int index) const

Renvoie les métadonnées de l'élément d'information de classe dont l'adresse est index.

Exemple :

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

public:
    //...
};

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

int QMetaObject::classInfoCount() const

Renvoie le nombre d'éléments d'information sur la classe dans cette classe.

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

int QMetaObject::classInfoOffset() const

Renvoie le décalage des informations de classe pour cette classe, c'est-à-dire la position de l'index du premier élément d'information de classe de cette classe.

Si la classe n'a pas de superclasses avec des informations de classe, le décalage est 0. Sinon, le décalage est la somme de tous les éléments d'information de classe dans les superclasses de la classe.

Voir également classInfo(), classInfoCount() et indexOfClassInfo().

const char *QMetaObject::className() const

Renvoie le nom de la classe.

Voir aussi superClass().

[static, since 6.10] template <typename Functor> QMetaObject::Connection QMetaObject::connect(const QObject *sender, const QMetaMethod &signal, const QObject *context, Functor functor, Qt::ConnectionType type = Qt::AutoConnection)

Crée une connexion d'un type donné à partir de signal dans l'objet sender vers functor pour être placée dans une boucle d'événement spécifique de context. Renvoie une poignée à la connexion qui peut être utilisée pour la déconnecter plus tard. Cela peut être utile pour connecter un signal récupéré à partir de l'introspection d'un méta-objet à une lambda capturant des variables locales.

La fonction slot peut être n'importe quelle fonction ou foncteur avec un nombre d'arguments égal ou inférieur à celui du signal. Il doit y avoir une correspondance exacte entre les arguments correspondants du signal et du slot, les conversions implicites et la vérification de type ne sont pas gérées par cette fonction. Les foncteurs surchargés doivent être explicitement résolus à l'aide de qOverload. signal doit être la méta-méthode d'un signal, sinon une connexion invalide sera renvoyée.

La connexion se déconnecte automatiquement si l'émetteur ou le contexte est détruit. Cependant, vous devez veiller à ce que les objets utilisés dans le foncteur soient toujours vivants lorsque le signal est émis.

Note : Cette fonction est à l'épreuve des threads.

Cette fonction a été introduite dans Qt 6.10.

Voir aussi QObject::connect() et QObject::disconnect().

[static, since 6.10] template <typename PointerToMemberFunction> QMetaObject::Connection QMetaObject::connect(const QObject *sender, const QMetaMethod &signal, const QObject *receiver, PointerToMemberFunction method, Qt::ConnectionType type = Qt::AutoConnection)

Crée une connexion du type type à partir de signal dans l'objet sender jusqu'à method dans l'objet receiver. Renvoie un identifiant de la connexion qui peut être utilisé pour la déconnecter ultérieurement.

L'identifiant de la connexion sera invalide s'il n'est pas possible de créer la connexion, par exemple si les paramètres ne sont pas valides. Vous pouvez vérifier si l'objet QMetaObject::Connection est valide en le transformant en bool. Passez le handle retourné à QObject::disconnect() pour déconnecter la connexion.

Un slot peut être connecté à un signal donné si le signal a au moins autant d'arguments que le slot. Il doit y avoir une correspondance exacte entre le signal correspondant et les arguments du slot, les conversions implicites et la vérification du type ne sont pas gérées par cette fonction. Les slots surchargés doivent être explicitement résolus à l'aide de qOverload. signal doit être la méta-méthode d'un signal, sinon une connexion invalide sera renvoyée.

Note : Cette fonction est à l'épreuve des threads.

Cette fonction a été introduite dans Qt 6.10.

Voir aussi QObject::connect() et QObject::disconnect().

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

Recherche récursivement tous les objets enfants de l'objet donné object, et connecte les signaux correspondants de ces objets aux slots de object qui suivent la forme suivante :

void on_<object name>_<signal name>(<signal parameters>);

Supposons que notre objet ait un objet enfant de type QPushButton avec object name button1 . L'emplacement pour capter le signal du bouton clicked() serait :

void on_button1_clicked();

Si object a lui-même un nom d'objet correctement défini, ses propres signaux sont également connectés à leurs emplacements respectifs.

Voir aussi QObject::setObjectName().

QMetaMethod QMetaObject::constructor(int index) const

Renvoie les méta-données du constructeur avec l'adresse index.

Voir aussi constructorCount() et newInstance().

int QMetaObject::constructorCount() const

Renvoie le nombre de constructeurs de cette classe.

Voir aussi constructor() et indexOfConstructor().

QMetaEnum QMetaObject::enumerator(int index) const

Renvoie les métadonnées de l'énumérateur dont l'adresse est index.

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

int QMetaObject::enumeratorCount() const

Renvoie le nombre d'énumérateurs dans cette classe.

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

int QMetaObject::enumeratorOffset() const

Renvoie le décalage de l'énumérateur pour cette classe, c'est-à-dire la position de l'index du premier énumérateur de cette classe.

Si la classe n'a pas de superclasses avec des énumérateurs, l'offset est 0. Sinon, l'offset est la somme de tous les énumérateurs dans les superclasses de la classe.

Voir également enumerator(), enumeratorCount() et indexOfEnumerator().

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

Trouve l'élément d'information de classe name et renvoie son index ; sinon, renvoie -1.

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

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

Trouve constructor et renvoie son index ; sinon, renvoie -1.

Notez que constructor doit être sous forme normalisée, comme le renvoie normalizedSignature().

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

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

Trouve l'énumérateur name et renvoie son index ; sinon, renvoie -1.

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

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

Trouve method et renvoie son index ; sinon, renvoie -1.

Notez que method doit être sous forme normalisée, comme le renvoie normalizedSignature().

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

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

Trouve la propriété name et renvoie son index ; sinon, renvoie -1.

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

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

Trouve signal et renvoie son index ; sinon, renvoie -1.

C'est la même chose que indexOfMethod(), sauf qu'il renvoie -1 si la méthode existe mais n'est pas un signal.

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

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

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

Trouve slot et renvoie son index ; sinon, renvoie -1.

C'est la même chose que indexOfMethod(), sauf qu'il renvoie -1 si la méthode existe mais n'est pas un slot.

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

[noexcept] bool QMetaObject::inherits(const QMetaObject *metaObject) const

Renvoie true si la classe décrite par ce QMetaObject hérite du type décrit par metaObject; sinon, renvoie false.

Un type est considéré comme héritant de lui-même.

Invoque la fonction function dans la boucle événementielle de context. function peut être un foncteur ou un pointeur vers une fonction membre. Retourne true si la fonction a pu être invoquée. Retourne false si cette fonction n'existe pas ou si les paramètres ne correspondent pas. La valeur de retour de l'appel de fonction est placée dans ret.

Si type est défini, la fonction est invoquée en utilisant ce type de connexion. Sinon, Qt::AutoConnection sera utilisé.

Remarque : cette fonction est à l'épreuve des threads.

Invoque function avec arguments dans la boucle d'événements de context. function peut être un foncteur ou un pointeur vers une fonction membre. Retourne true si la fonction a pu être invoquée. La valeur de retour de l'appel de fonction est placée dans ret. L'objet utilisé pour l'argument ret doit être obtenu en passant votre objet à qReturnArg(). Par exemple :

MyClass *obj = ...;
int result = 0;
QMetaObject::invokeMethod(obj, &MyClass::myMethod, qReturnArg(result), parameter);

Si type est défini, la fonction est invoquée en utilisant ce type de connexion. Sinon, c'est Qt::AutoConnection qui sera utilisé.

Remarque : cette fonction est à l'épreuve des threads.

Ces fonctions ont été introduites dans Qt 6.7.

Invoque le member (un signal ou un nom de slot) sur l'objet obj. Renvoie true si le membre a pu être invoqué. Retourne false s'il n'existe pas de membre de ce type ou si les paramètres ne correspondent pas.

Pour les surcharges avec un paramètre QTemplatedMetaMethodReturnArgument, la valeur de retour de l'appel de fonction member est placée dans ret. Pour les surcharges sans ce type de membre, la valeur de retour de la fonction appelée (s'il y en a une) sera rejetée. QTemplatedMetaMethodReturnArgument est un type interne que vous ne devez pas utiliser directement. Utilisez plutôt la fonction qReturnArg().

Les surcharges avec un paramètre Qt::ConnectionType type permettent de choisir explicitement si l'invocation sera synchrone ou non :

• Si type est Qt::DirectConnection, le membre sera invoqué immédiatement dans le thread courant.
• 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 dans le thread dans lequel le obj a été créé ou a été déplacé.
• Si type est Qt::BlockingQueuedConnection, la méthode sera invoquée de la même manière que pour Qt::QueuedConnection, sauf que le thread en cours sera bloqué jusqu'à ce que l'événement soit délivré. L'utilisation de ce type de connexion pour communiquer entre des objets dans le même thread conduira à des blocages.
• Si type est Qt::AutoConnection, le membre est invoqué de manière synchrone si obj vit dans le même thread que l'appelant ; sinon, il invoquera le membre de manière asynchrone. C'est le comportement des surcharges qui n'ont pas le paramètre type.

Vous ne devez transmettre à cette fonction que le nom du signal ou du slot, et non la signature complète. Par exemple, pour invoquer de manière asynchrone le slot quit() sur un QThread, utilisez le code suivant :

QMetaObject::invokeMethod(thread, "quit", Qt::QueuedConnection);

Avec les invocations de méthodes asynchrones, les paramètres doivent être des types copiables, car Qt a besoin de copier les arguments pour les stocker dans un événement en coulisses. Depuis Qt 6.5, cette fonction enregistre automatiquement les types utilisés ; cependant, il n'est pas possible d'effectuer des appels à l'aide de types qui ne sont déclarés que par anticipation. En outre, il n'est pas non plus possible d'effectuer des appels asynchrones utilisant comme paramètres des références à des types non qualifiés par des conventions.

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

QString retVal;
QMetaObject::invokeMethod(obj, "compute", Qt::DirectConnection,
                          qReturnArg(retVal),
                          QString("sqrt"), 42, 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. Notez qu'il était nécessaire d'être explicite sur le type de QString, car le littéral de caractère n'est pas exactement le bon type pour correspondre. Si la méthode prenait plutôt un QStringView, un qsizetype, et un float, l'appel devrait être écrit comme suit :

QString retVal;
QMetaObject::invokeMethod(obj, "compute", Qt::DirectConnection,
                          qReturnArg(retVal),
                          QStringView(u"sqrt"), qsizetype(42), 9.7f);

Le même appel peut être exécuté en utilisant les macros Q_ARG() et Q_RETURN_ARG(), comme dans :

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

Les macros sont conservées pour des raisons de compatibilité avec Qt 6.4 et les versions antérieures, et peuvent être librement mélangées avec des paramètres qui n'utilisent pas la macro. Elles peuvent être nécessaires dans de rares situations lors de l'appel d'une méthode qui a utilisé un typedef à un type déclaré comme paramètre ou comme type de retour.

Note : Cette fonction est à l'épreuve des threads.

Ces fonctions ont été introduites dans Qt 6.5.

Voir aussi Q_ARG(), Q_RETURN_ARG() et QMetaMethod::invoke().

[since 6.2] QMetaType QMetaObject::metaType() const

Renvoie le métatype correspondant à ce métaobjet. Si le métaobjet provient d'un espace de noms, un métatype invalide est renvoyé.

Cette fonction a été introduite dans Qt 6.2.

QMetaMethod QMetaObject::method(int index) const

Renvoie les méta-données de la méthode avec l'adresse index.

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

int QMetaObject::methodCount() const

Renvoie le nombre de méthodes de cette classe, y compris le nombre de méthodes fournies par chaque classe de base. Celles-ci comprennent les signaux et les slots ainsi que les fonctions normales des membres.

Utilisez le code suivant pour obtenir une page QStringList contenant les méthodes spécifiques à une 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).methodSignature());

Voir également method(), methodOffset() et indexOfMethod().

int QMetaObject::methodOffset() const

Renvoie l'offset de la méthode de cette classe, c'est-à-dire la position de l'index de la première fonction membre de cette classe.

Le décalage est la somme de toutes les méthodes des superclasses de la classe (qui est toujours positive puisque QObject a le slot deleteLater() et un signal destroyed()).

Voir également method(), methodCount() et indexOfMethod().

[since 6.5] template <typename... Args> QObject *QMetaObject::newInstance(Args &&... arguments) const

Construit une nouvelle instance de cette classe et renvoie le nouvel objet, ou nullptr si aucun constructeur approprié n'est disponible. Les types des arguments arguments seront utilisés pour trouver un constructeur correspondant, puis lui seront transmis de la même manière que les connexions par fente de signal.

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

Cette fonction a été introduite dans Qt 6.5.

Voir aussi constructor().

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

Normalise la signature de l'adresse method.

Qt utilise les signatures normalisées pour décider si deux signaux et slots donnés sont compatibles. La normalisation réduit les espaces blancs au minimum, déplace "const" vers l'avant lorsque cela est approprié, supprime "const" des types de valeur et remplace les références const par des valeurs.

Voir également checkConnectArgs() et normalizedType().

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

Normalise un type.

Voir QMetaObject::normalizedSignature() pour une description de la façon dont Qt XML normalise.

Exemple :

QByteArray normType = QMetaObject::normalizedType(" int    const  *");
// normType is now "const int*"

Voir aussi normalizedSignature().

QMetaProperty QMetaObject::property(int index) const

Renvoie les métadonnées de la propriété dont le nom est index. Si aucune propriété de ce type n'existe, une valeur null QMetaProperty est renvoyée.

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

int QMetaObject::propertyCount() const

Renvoie le nombre de propriétés de cette classe, y compris le nombre de propriétés fournies par chaque classe de base.

Utilisez le code suivant pour obtenir une page QStringList contenant les propriétés spécifiques d'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 également property(), propertyOffset() et indexOfProperty().

int QMetaObject::propertyOffset() const

Renvoie l'offset de la propriété de cette classe, c'est-à-dire la position de l'index de la première propriété de cette classe.

Le décalage est la somme de toutes les propriétés des superclasses de la classe (qui est toujours positive puisque QObject possède la propriété objectName ).

Voir également property(), propertyCount() et indexOfProperty().

const QMetaObject *QMetaObject::superClass() const

Renvoie le méta-objet de la superclasse, ou nullptr s'il n'existe pas d'objet de ce type.

Voir aussi className().

QMetaProperty QMetaObject::userProperty() const

Renvoie la propriété pour laquelle l'indicateur USER a la valeur true.

Voir aussi QMetaProperty::isUser().