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); // enable debug log
     Foo myfoo;
     QProperty<int> prop(42);
     QObject::connect(&myfoo, &Foo::myValChanged, [&]() {
         if (debugout)
             qDebug() << myfoo.myVal();
     });
     myfoo.bindableMyVal().setBinding([&]() { return prop.value(); }); // prints "42"

     prop = 5; // prints "5"
     debugout = false;
     prop = 6; // prints nothing
     debugout = true;
     prop = 7; // prints "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(MyClass, CustomType xProp, CustomType(5, 10),
                                      &MyClass::xChanged)

Member Function Documentation

Assigns newValue to this property and removes the property's associated binding, if present. If the property value changes as a result, calls the Callback function on owner.

QObjectBindableProperty::QObjectBindableProperty()

Constructs a property with a default constructed instance of T.

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

Constructs a property that is tied to the provided binding expression f. The property's value is set to the result of evaluating the new binding. Whenever a dependency of the binding changes, the binding will be re-evaluated, and the property's value gets updated accordingly.

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

Move-Constructs a property with the provided initialValue.

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

Constructs a property with the provided initialValue.

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

Constructs a property that is tied to the provided binding expression. The property's value is set to the result of evaluating the new binding. Whenever a dependency of the binding changes, the binding will be re-evaluated, and the property's value gets updated accordingly.

When the property value changes, owner is notified via the Callback function.

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

Constructs a property that is tied to the provided binding expression. The property's value is set to the result of evaluating the new binding. Whenever a dependency of the binding changes, the binding will be re-evaluated, and the property's value gets updated accordingly.

When the property value changes, owner is notified via the Callback function.

[default] QObjectBindableProperty::~QObjectBindableProperty()

Destroys the property.

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

Subscribes the given functor f as a callback that is called whenever the value of the property changes.

The callback f is expected to be a type that has a plain call operator () without any parameters. This means that you can provide a C++ lambda expression, a std::function or even a custom struct with a call operator.

The returned property change handler object keeps track of the subscription. When it goes out of scope, the callback is unsubscribed.

This method is in some cases easier to use than onValueChanged(), as the returned object is not a template. It can therefore more easily be stored, e.g. as a member in a class.

See also onValueChanged() and subscribe().

QPropertyBinding<T> QObjectBindableProperty::binding() const

Returns the binding expression that is associated with this property. A default constructed QPropertyBinding<T> will be returned if no such association exists.

See also setBinding().

bool QObjectBindableProperty::hasBinding() const

Returns true if the property is associated with a binding; false otherwise.

void QObjectBindableProperty::notify()

Programmatically signals a change of the property. Any binding which depend on it will be notified, and if the property has a signal, it will be emitted.

This can be useful in combination with setValueBypassingBindings to defer signalling the change until a class invariant has been restored.

See also Qt::beginPropertyUpdateGroup() and setValueBypassingBindings().

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

Registers the given functor f as a callback that shall be called whenever the value of the property changes. On each value change, the handler is either called immediately, or deferred, depending on the context.

The callback f is expected to be a type that has a plain call operator () without any parameters. This means that you can provide a C++ lambda expression, a std::function or even a custom struct with a call operator.

The returned property change handler object keeps track of the registration. When it goes out of scope, the callback is de-registered.

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

Associates the value of this property with the provided newBinding expression and returns the previously associated binding. The property's value is set to the result of evaluating the new binding. Whenever a dependency of the binding changes, the binding will be re-evaluated, and the property's value gets updated accordingly. When the property value changes, the owner is notified via the Callback function.

See also binding().

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

This is an overloaded function.

Associates the value of this property with the provided functor f and returns the previously associated binding. The property's value is set to the result of evaluating the new binding by invoking the call operator () of f. Whenever a dependency of the binding changes, the binding will be re-evaluated, and the property's value gets updated accordingly.

When the property value changes, the owner is notified via the Callback function.

See also Formulating a Property Binding.

bool QObjectBindableProperty::setBinding(const QUntypedPropertyBinding &newBinding)

This is an overloaded function.

Associates the value of this property with the provided newBinding expression. The property's value is set to the result of evaluating the new binding. Whenever a dependency of the binding changes, the binding will be re-evaluated, and the property's value gets updated accordingly.

Returns true if the type of this property is the same as the type the binding function returns; false otherwise.

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

Subscribes the given functor f as a callback that is called immediately and whenever the value of the property changes in the future. On each value change, the handler is either called immediately, or deferred, depending on the context.

The callback f is expected to be a type that has a plain call operator () without any parameters. This means that you can provide a C++ lambda expression, a std::function or even a custom struct with a call operator.

The returned property change handler object keeps track of the subscription. When it goes out of scope, the callback is unsubscribed.

QPropertyBinding<T> QObjectBindableProperty::takeBinding()

Disassociates the binding expression from this property and returns it. After calling this function, the value of the property will only change if you assign a new value to it, or when a new binding is set.

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

Returns the value of the property. This may evaluate a binding expression that is tied to this property, before returning the value.

See also setValue().