QMetaObject Struct

Documentation sur les 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 ».

signal et method doivent tous deux être normalisés.

Voir également 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 de la classe « information » dont l'index est celle indiquée.

Exemple :

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

public:
    //...
};

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

int QMetaObject::classInfoCount() const

Renvoie le nombre d'éléments d'information de classe présents dans cette classe.

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

int QMetaObject::classInfoOffset() const

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

Si la classe ne possède aucune superclasse comportant des informations de classe, le décalage est égal à 0 ; dans le cas contraire, le décalage correspond à la somme de tous les éléments d’information de classe présents 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 entre une ` type ` donnée, issue de ` signal ` dans l'objet ` sender `, et ` functor `, afin de l'intégrer dans une boucle d'événements spécifique de ` context`. Renvoie un descripteur vers la connexion, qui peut être utilisé pour la déconnecter ultérieurement. Cela peut s'avérer utile pour connecter un signal obtenu via l'introspection d'un méta-objet à un lambda capturant des variables locales.

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

La connexion sera automatiquement interrompue si l’émetteur ou le contexte est détruit. Cependant, vous devez vous assurer que tous les objets utilisés au sein du foncteur sont toujours actifs lorsque le signal est émis.

Remarque : cette fonction est thread-safe.

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 entre l'type spécifiée, issue de l'signal de l'objet sender, et le method de l'objet receiver. Renvoie un descripteur de connexion qui pourra être utilisé ultérieurement pour la déconnecter.

Le descripteur de connexion sera invalide si la connexion ne peut pas être établie, par exemple si les paramètres sont invalides. Vous pouvez vérifier si le descripteur ` QMetaObject::Connection ` est valide en le convertissant en booléen. Transmettez le descripteur renvoyé à la fonction ` QObject::disconnect()` pour déconnecter la connexion.

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

Remarque : cette fonction est thread-safe.

Cette fonction a été introduite dans Qt 6.10.

Voir également QObject::connect() et QObject::disconnect().

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

Recherche de manière récursive tous les objets enfants de l'object donné, puis relie les signaux correspondants de ces derniers aux slots de object qui respectent la forme suivante :

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

Supposons que notre objet possède un objet enfant de type QPushButton avec l’ object name button1 . Le slot permettant de capter le signal clicked() du bouton serait :

void on_button1_clicked();

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

Voir également QObject::setObjectName().

QMetaMethod QMetaObject::constructor(int index) const

Renvoie les métadonnées du constructeur associé à l'index on indiquée.

Voir également constructorCount() et newInstance().

int QMetaObject::constructorCount() const

Renvoie le nombre de constructeurs de cette classe.

Voir également constructor() et indexOfConstructor().

QMetaEnum QMetaObject::enumerator(int index) const

Renvoie les métadonnées de l'énumérateur associé à l'index donné.

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

int QMetaObject::enumeratorCount() const

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

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

int QMetaObject::enumeratorOffset() const

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

Si la classe ne possède aucune superclasse dotée d'énumérateurs, le décalage est égal à 0 ; sinon, il correspond à la somme de tous les décalages des énumérateurs présents dans les superclasses de la classe.

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

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

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

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

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

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

Notez que l'constructor doit être sous forme normalisée, telle que renvoyée par normalizedSignature().

Voir également constructor(), constructorCount() et normalizedSignature().

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

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

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

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

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

Notez que l’ method doit être sous forme normalisée, telle que renvoyée par normalizedSignature().

Voir également method(), methodCount(), methodOffset() et normalizedSignature().

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

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

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

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

Recherche « signal » et renvoie son index ; sinon, renvoie -1.

Cette fonction est identique à indexOfMethod(), sauf qu’elle renvoie -1 si la méthode existe mais n’est pas un signal.

Notez que l'signal doit être sous forme normalisée, telle que renvoyée par normalizedSignature().

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

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

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

Cette fonction est identique à ` indexOfMethod()`, sauf qu’elle renvoie -1 si la méthode existe mais n’est pas un slot.

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

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

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

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

Appelle la fonction ` function ` avec ` arguments ` dans la boucle d'événements de ` context`. ` function ` peut être un functor ou un pointeur vers une fonction membre. Renvoie ` true ` si la fonction a pu être appelé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 appelée en utilisant ce type de connexion. Sinon, Qt::AutoConnection sera utilisé.

Remarque : cette fonction est thread-safe.

Ces fonctions ont été introduites dans Qt 6.7.

Appelle la fonction ` function ` dans la boucle d'événements de ` context`. ` function ` peut être un foncteur ou un pointeur vers une fonction membre. Renvoie ` true ` si la fonction a pu être appelée. Renvoie ` false ` si la fonction n'existe pas ou si les paramètres ne correspondent pas. La valeur de retour de l'appel de fonction est stockée dans ` ret`.

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

Remarque : cette fonction est thread-safe.

Appelle une méthode enregistrée dans le système de méta-objets sur l’objet obj, identifiée par son nom member. Cela inclut les slots, les signaux et les méthodes de type « Q_INVOKABLE ». Renvoie true si le membre a pu être appelé. Renvoie false s’il n’existe pas de membre de ce type ou si les paramètres ne correspondent pas.

Pour les surcharges comportant un paramètre `QTemplatedMetaMethodReturnArgument`, la valeur de retour de l’appel à la fonction ` member ` est placée dans ` ret`. Pour les surcharges ne comportant pas un tel membre, la valeur de retour de la fonction appelée (le cas échéant) sera ignorée. `QTemplatedMetaMethodReturnArgument` est un type interne que vous ne devez pas utiliser directement. Utilisez plutôt la fonction `qReturnArg()`.

Les surcharges comportant un paramètre Qt::ConnectionType type permettent de choisir explicitement si l’appel sera synchrone ou non :

• Si type vaut Qt::DirectConnection, le membre sera appelé immédiatement dans le thread actuel.
• Si type est Qt::QueuedConnection, un QEvent sera envoyé et le membre sera appelé dès que l’application entrera dans la boucle d’événements du thread dans lequel l’ obj a été créé ou vers lequel il a été déplacé.
• Si type est Qt::BlockingQueuedConnection, la méthode sera appelée de la même manière que pour Qt::QueuedConnection, sauf que le thread actuel se bloquera jusqu’à ce que l’événement soit délivré. L’utilisation de ce type de connexion pour la communication entre des objets d’un même thread entraînera des blocages (deadlocks).
• Si type est Qt::AutoConnection, le membre est appelé de manière synchrone si obj se trouve dans le même thread que l’appelant ; sinon, il l’appellera de manière asynchrone. C’est le comportement des surcharges qui ne possèdent pas le paramètre type.

Il suffit de passer le nom du signal ou du slot à cette fonction, et non la signature complète. Par exemple, pour appeler de manière asynchrone le slot quit() sur un QThread, utilisez le code suivant :

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

Avec les appels de méthodes asynchrones, les paramètres doivent être des types copiables, car Qt doit copier les arguments pour les stocker dans un événement en arrière-plan. Depuis Qt 6.5, cette fonction enregistre automatiquement les types utilisés ; cependant, cela a pour effet secondaire de rendre impossible les appels utilisant des types qui ne sont que déclarés en avant. De plus, 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 `const`.

Pour appeler de manière synchrone le slot compute(QString, int, double) sur un objet quelconque obj et récupérer 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 a fallu préciser explicitement le type de l’ QString, car le littéral de caractère n’est pas exactement du type requis. Si la méthode prenait à la place un QStringView, un qsizetype et un float, l’appel devrait s’écrire 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é à l’aide des macros ` Q_ARG()` et ` Q_RETURN_ARG()`, comme suit :

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

Ces macros sont conservées pour des raisons de compatibilité avec Qt 6.4 et les versions antérieures, et peuvent être librement combinées avec des paramètres qui n’utilisent pas la macro. Elles peuvent s’avérer nécessaires dans de rares cas, notamment lors de l’appel d’une méthode utilisant un typedef vers un type déclaré en avance comme paramètre ou comme type de retour.

Remarque : cette fonction est thread-safe.

Ces fonctions ont été introduites dans Qt 6.5.

Voir également Q_ARG(), Q_RETURN_ARG() et QMetaMethod::invoke().

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

Renvoie le métatype correspondant à ce méta-objet. Si le méta-objet provient d'un espace de noms, un métatype non valide est renvoyé.

Cette fonction a été introduite dans Qt 6.2.

QMetaMethod QMetaObject::method(int index) const

Renvoie les métadonnées de la méthode associée à l'index donné.

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

int QMetaObject::methodCount() const

Renvoie le nombre de méthodes de cette classe, y compris celles fournies par chaque classe de base. Cela inclut les signaux et les slots, ainsi que les fonctions membres classiques.

Utilisez un code similaire à celui ci-dessous pour obtenir un objet ` 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 pour cette classe ; c'est-à-dire l'index de la première fonction membre de cette classe.

Le décalage correspond à la somme de toutes les méthodes des superclasses de la classe (ce qui est toujours positif puisque ` QObject ` possède le slot ` deleteLater()` et le signal ` destroyed()`).

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

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

Crée 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 transmis à celui-ci de la même manière que pour les connexions signal-slot.

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

Cette fonction a été introduite dans Qt 6.5.

Voir également constructor().

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

Normalise la signature de l'method on fournie.

Qt utilise des signatures normalisées pour déterminer si deux signaux et slots donnés sont compatibles. La normalisation réduit au minimum les espaces, place « const » au début 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 objet ` type`.

Voir QMetaObject::normalizedSignature() pour une description de la manière dont Qt effectue la normalisation.

Exemple :

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

Voir également normalizedSignature().

QMetaProperty QMetaObject::property(int index) const

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

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

int QMetaObject::propertyCount() const

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

Utilisez un code similaire à celui-ci pour obtenir une instance de ` 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 également ` property()`, ` propertyOffset()` et ` indexOfProperty()`.

int QMetaObject::propertyOffset() const

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

Le décalage correspond à la somme de toutes les propriétés des superclasses de la classe (cette valeur 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.

Voir aussi className().

QMetaProperty QMetaObject::userProperty() const

Renvoie la propriété pour laquelle l'indicateur « USER » est défini sur « true ».

Voir aussi QMetaProperty::isUser().