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ébogage
    Foo myfoo;
    QProperty<int> prop(42);
    QObject::connect(&myfoo, &Foo::myValChanged, [&]() {
        if (debugout)
            qDebug() << myfoo.myVal();
    });
    myfoo.bindableMyVal().setBinding([&]() { return prop.value(); }); // affiche « 42 »

    prop = 5; // affiche « 5 »
    debugout = false;
    prop = 6; // n'affiche rien
    debugout = true;
    prop = 7; // affiche « 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

[default] QObjectBindableProperty::QObjectBindableProperty()

Crée une propriété avec une instance de type T construite par défaut.

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

Crée une propriété liée à l'expression de liaison fournie : f. La valeur de la propriété est définie sur le résultat de l'évaluation de cette nouvelle liaison. Chaque fois qu'une dépendance de la liaison change, celle-ci est réévaluée et la valeur de la propriété est mise à jour en conséquence.

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

Move : crée une propriété à partir de l'initialValue.

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

Crée une propriété à partir de l'initialValue fournie.

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

Crée une propriété liée à l'expression « binding » fournie. La valeur de la propriété est définie sur le résultat de l'évaluation de la nouvelle liaison. Chaque fois qu'une dépendance de la liaison change, celle-ci 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 de rappel.

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

Crée une propriété liée à l'expression « binding » fournie. La valeur de la propriété est définie sur le résultat de l'évaluation de la nouvelle liaison. Chaque fois qu'une dépendance de la liaison change, celle-ci 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 est notifié via la fonction de rappel.

[implicit] QObjectBindableProperty::~QObjectBindableProperty()

Détruit le bien.

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

Enregistre le foncteur spécifié f en tant que fonction de rappel appelée chaque fois que la valeur de la propriété change.

La fonction de rappel f doit être d'un type disposant d'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 dotée d'un opérateur d'appel.

L’objet gestionnaire de changement de propriété renvoyé assure le suivi de l’abonnement. Lorsqu’il sort de la portée, la fonction de rappel est désabonnée.

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 également ` onValueChanged()` et ` subscribe()`.

QPropertyBinding<T> QObjectBindableProperty::binding() const

Renvoie l'expression de liaison associée à cette propriété. Si aucune association de ce type n'existe, un objet QPropertyBinding<T> instancié par défaut sera renvoyé.

Voir également setBinding().

bool QObjectBindableProperty::hasBinding() const

Renvoie « 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 en seront informées, et si la propriété dispose d’un signal, celui-ci sera émis.

Cela peut s’avérer utile en combinaison avec `setValueBypassingBindings` pour différer la notification de la modification jusqu’à ce qu’une invariante de classe ait été rétablie.

Voir également ` Qt::beginPropertyUpdateGroup()` et ` setValueBypassingBindings()`.

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

Enregistre le foncteur donné f en tant que fonction de rappel qui sera appelée chaque fois que la valeur de la propriété changera. À chaque changement de valeur, la fonction de rappel est soit appelée immédiatement, soit différée, selon le contexte.

La fonction de rappel f doit être d’un type doté d’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 dotée d’un opérateur d’appel.

L’objet gestionnaire de modification de propriété renvoyé assure le suivi de l’enregistrement. Lorsqu’il sort de la portée, le callback est désenregistré.

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

Associe la valeur de cette propriété à l'expression fournie newBinding et renvoie la liaison précédemment associée. La valeur de la propriété est définie sur le résultat de l'évaluation de la nouvelle liaison. Chaque fois qu'une dépendance de la liaison change, celle-ci 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 de rappel.

Voir également 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 définie sur le résultat de l'évaluation de la nouvelle liaison, obtenue en appelant l'opérateur d'appel () de f. Chaque fois qu'une dépendance de la liaison change, celle-ci 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 de rappel.

Voir également «Formulation d’un lien de propriété ».

bool QObjectBindableProperty::setBinding(const QUntypedPropertyBinding &newBinding)

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

Renvoie ` true ` si le type de cette propriété est identique à celui renvoyé par la fonction de liaison ; ` false ` dans le cas contraire.

Attribue la valeur « newValue » à cette propriété et supprime la liaison associée à celle-ci, le cas échéant. Si la valeur de la propriété change à la suite de cette opération, la fonction de rappel est appelée sur owner.

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

Enregistre le foncteur donné f en tant que callback qui est appelé immédiatement et à chaque fois que la valeur de la propriété change par la suite. À chaque changement de valeur, le gestionnaire est soit appelé immédiatement, soit différé, selon le contexte.

La fonction de rappel f doit être d’un type disposant d’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 dotée d’un opérateur d’appel.

L’objet de gestionnaire de modification de propriété renvoyé assure le suivi de l’abonnement. Lorsqu’il sort de la portée, le rappel est désabonné.

QPropertyBinding<T> QObjectBindableProperty::takeBinding()

Dissocie l'expression de liaison de cette propriété et la renvoie. Après avoir appelé 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é. Avant de renvoyer cette valeur, le système peut évaluer une expression de liaison associée à cette propriété.

Voir aussi setValue().