QObjectBindableProperty Class

#include <QObject>#include <QProperty>#include <QDebug>class Foo : public QObject
{Q_OBJECT Q_PROPERTY(int myVal READ myVal WRITE setMyVal BINDABLE bindableMyVal)public: int myVal() { return myValMember.value() ; } void setMyVal(int newvalue) { myValMember = newvalue ; } QBindable<int> bindableMyVal() { return &myValMember; }signals: void myValChanged() ;private: Q_OBJECT_BINDABLE_PROPERTY(Foo, int, myValMember, &Foo::myValChanged) ; } ;int main() { bool debugout(true) ; // active le journal de débogageFoo myfoo ; QProperty<int> prop(42) ; QObject::connect(&myfoo, &Foo::myValChanged, [&]() { if (debugout)            qDebug() << myfoo.myVal();
    }) ; myfoo.bindableMyVal().setBinding([&]() { return prop.value() ; }) ; // imprime "42"prop = 5; // imprime "5"debugout = false; prop = 6; // n'imprime riendebugout = true; prop = 7; // imprime "7"}#include "main.moc"

class MyClass : public QObject
{
    Q_OBJECT
    Q_PROPERTY(int x READ x WRITE setX NOTIFY xChanged BINDABLE bindableX)
public:
    int x() const { return xProp; }
    void setX(int x) { xProp = x; }
    QBindable<int> bindableX() { return QBindable<int>(&xProp); }

signals:
    void xChanged();

private:
    // Declare the instance of the bindable property data.
    Q_OBJECT_BINDABLE_PROPERTY(MyClass, int, xProp, &MyClass::xChanged)
};

class MyClass : public QObject
{
    Q_OBJECT
    Q_PROPERTY(int x READ x WRITE setX NOTIFY xChanged BINDABLE bindableX)
public:
    int x() const { return xProp; }
    void setX(int x) { xProp = x; }
    QBindable<int> bindableX() { return QBindable<int>(&xProp); }

signals:
    void xChanged();

private:
    // Declare the instance of int bindable property data and
    // initialize it with the value 5.
    // This is similar to declaring
    // int xProp = 5;
    // without using the new QObjectBindableProperty class.
    Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(MyClass, int, xProp, 5, &MyClass::xChanged)
};

class CustomType
{
public:
    CustomType(int val, int otherVal) : value(val), anotherValue(otherVal) { }

private:
    int value = 0;
    int anotherValue = 0;
};

// later when using CustomType as a property
Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(SomeClass, CustomType, xProp, CustomType(5, 10),
                                    &MyClass::xChanged)

Documentation sur les fonctions membres

QObjectBindableProperty::QObjectBindableProperty()

Construit une propriété avec une instance de T construite par défaut.

[explicit] template <typename Functor> QObjectBindableProperty::QObjectBindableProperty(Functor &&f)

Construit une propriété liée à l'expression de liaison fournie f. La valeur de la propriété est fixée au résultat de l'évaluation de la nouvelle liaison. Chaque fois qu'une dépendance de la liaison change, la liaison est réévaluée et la valeur de la propriété est mise à jour en conséquence.

[explicit] QObjectBindableProperty::QObjectBindableProperty(T &&initialValue)

Move-Construit une propriété avec l'adresse initialValue.

[explicit] QObjectBindableProperty::QObjectBindableProperty(const T &initialValue)

Construit une propriété avec l'adresse initialValue.

[default] QObjectBindableProperty::QObjectBindableProperty(Class *owner, QPropertyBinding<T> &&binding)

Construit une propriété liée à l'expression binding fournie. La valeur de la propriété est fixée au résultat de l'évaluation de la nouvelle liaison. Chaque fois qu'une dépendance de la liaison change, la liaison est réévaluée et la valeur de la propriété est mise à jour en conséquence.

Lorsque la valeur de la propriété change, owner en est informé via la fonction Callback.

[default] QObjectBindableProperty::QObjectBindableProperty(Class *owner, const QPropertyBinding<T> &binding)

Construit une propriété liée à l'expression binding fournie. La valeur de la propriété est fixée au résultat de l'évaluation de la nouvelle liaison. Chaque fois qu'une dépendance de la liaison change, la liaison est réévaluée et la valeur de la propriété est mise à jour en conséquence.

Lorsque la valeur de la propriété change, owner en est informé via la fonction Callback.

[default] QObjectBindableProperty::~QObjectBindableProperty()

Détruit la propriété.

template <typename Functor> QPropertyNotifier QObjectBindableProperty::addNotifier(Functor f)

Souscrit le foncteur donné f en tant que callback qui est appelé chaque fois que la valeur de la propriété change.

Le rappel f doit être un type qui possède un opérateur d'appel simple () sans aucun paramètre. Cela signifie que vous pouvez fournir une expression lambda C++, une std::function ou même une structure personnalisée avec un opérateur d'appel.

L'objet de gestion des changements de propriété renvoyé conserve la trace de l'abonnement. Lorsqu'il sort du champ d'application, le rappel est désabonné.

Cette méthode est dans certains cas plus facile à utiliser que onValueChanged(), car l'objet renvoyé n'est pas un modèle. Il peut donc être stocké plus facilement, par exemple en tant que membre d'une classe.

Voir aussi onValueChanged() et subscribe().

QPropertyBinding<T> QObjectBindableProperty::binding() const

Renvoie l'expression de liaison associée à cette propriété. Un QPropertyBinding<T> construit par défaut sera renvoyé si une telle association n'existe pas.

Voir également setBinding().

bool QObjectBindableProperty::hasBinding() const

Retourne true si la propriété est associée à une liaison, false dans le cas contraire.

void QObjectBindableProperty::notify()

Signale de manière programmatique une modification de la propriété. Toutes les liaisons qui en dépendent seront notifiées et, si la propriété possède un signal, celui-ci sera émis.

Cela peut être utile en combinaison avec setValueBypassingBindings pour différer la signalisation du changement jusqu'à ce qu'un invariant de classe ait été restauré.

Voir aussi Qt::beginPropertyUpdateGroup() et setValueBypassingBindings().

template <typename Functor> QPropertyChangeHandler<Functor> QObjectBindableProperty::onValueChanged(Functor f)

Enregistre le foncteur donné f en tant que rappel qui doit être appelé chaque fois que la valeur de la propriété change. À chaque changement de valeur, le gestionnaire est appelé immédiatement ou de manière différée, en fonction du contexte.

Le callback f est censé être un type qui possède un opérateur d'appel simple () sans aucun paramètre. Cela signifie que vous pouvez fournir une expression lambda C++, une std::function ou même une structure personnalisée avec un opérateur d'appel.

L'objet de gestion des changements de propriété renvoyé conserve la trace de l'enregistrement. Lorsqu'il sort du champ d'application, le rappel est désenregistré.

QPropertyBinding<T> QObjectBindableProperty::setBinding(const QPropertyBinding<T> &newBinding)

Associe la valeur de cette propriété à l'expression newBinding fournie et renvoie la liaison précédemment associée. La valeur de la propriété est fixée au résultat de l'évaluation de la nouvelle liaison. Chaque fois qu'une dépendance de la liaison change, la liaison est réévaluée et la valeur de la propriété est mise à jour en conséquence. Lorsque la valeur de la propriété change, le propriétaire en est informé via la fonction Callback.

Voir aussi binding().

template <typename Functor> QPropertyBinding<T> QObjectBindableProperty::setBinding(Functor f)

Associe la valeur de cette propriété au foncteur fourni f et renvoie la liaison précédemment associée. La valeur de la propriété est fixée au résultat de l'évaluation de la nouvelle liaison en invoquant l'opérateur d'appel () de f. Chaque fois qu'une dépendance de la liaison change, la liaison est réévaluée et la valeur de la propriété est mise à jour en conséquence.

Lorsque la valeur de la propriété change, le propriétaire en est informé par l'intermédiaire de la fonction Callback.

Voir aussi Formulation d'une liaison de propriété.

bool QObjectBindableProperty::setBinding(const QUntypedPropertyBinding &newBinding)

Associe la valeur de cette propriété à l'expression newBinding fournie. La valeur de la propriété est fixée au résultat de l'évaluation de la nouvelle liaison. Chaque fois qu'une dépendance de la liaison change, la liaison est réévaluée et la valeur de la propriété est mise à jour en conséquence.

Retourne true si le type de cette propriété est le même que le type retourné par la fonction de liaison ; false sinon.

Affecte newValue à cette propriété et supprime la liaison associée à la propriété, le cas échéant. Si la valeur de la propriété change en conséquence, la fonction Callback est appelée sur owner.

template <typename Functor> QPropertyChangeHandler<Functor> QObjectBindableProperty::subscribe(Functor f)

Souscrit au foncteur donné f en tant que rappel qui est appelé immédiatement et à chaque fois que la valeur de la propriété change dans le futur. À chaque changement de valeur, le gestionnaire est appelé immédiatement ou de manière différée, en fonction du contexte.

Le callback f est censé être un type qui possède un opérateur d'appel simple () sans aucun paramètre. Cela signifie que vous pouvez fournir une expression lambda C++, une std::function ou même une structure personnalisée avec un opérateur d'appel.

L'objet de gestion des changements de propriété renvoyé conserve la trace de l'abonnement. Lorsqu'il sort du champ d'application, le rappel est désabonné.

QPropertyBinding<T> QObjectBindableProperty::takeBinding()

Dissocie l'expression de liaison de cette propriété et la renvoie. Après l'appel de cette fonction, la valeur de la propriété ne changera que si vous lui attribuez une nouvelle valeur ou si une nouvelle liaison est définie.

QObjectBindableProperty<Class, T, Offset, Signal>::parameter_type QObjectBindableProperty::value() const

Renvoie la valeur de la propriété. Cette fonction peut évaluer une expression de liaison liée à cette propriété avant de renvoyer la valeur.

Voir également setValue().