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); // Debug-Protokoll aktivieren
    Foo myfoo;
    QProperty<int> prop(42);
    QObject::connect(&myfoo, &Foo::myValChanged, [&]() {
        if (debugout)
            qDebug() << myfoo.myVal();
    });
    myfoo.bindableMyVal().setBinding([&]() { return prop.value(); }); // gibt „42“ aus

    prop = 5; // gibt „5“ aus
    debugout = false;
    prop = 6; // gibt nichts aus
    debugout = true;
    prop = 7; // gibt „7“ aus
}

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

Dokumentation zu Mitgliedsfunktionen

[default] QObjectBindableProperty::QObjectBindableProperty()

Erstellt eine Eigenschaft mit einer standardmäßig erstellten Instanz von T.

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

Erstellt eine Eigenschaft, die an den angegebenen Bindungsausdruck f gebunden ist. Der Wert der Eigenschaft wird auf das Ergebnis der Auswertung der neuen Bindung gesetzt. Immer wenn sich eine Abhängigkeit der Bindung ändert, wird die Bindung neu ausgewertet, und der Wert der Eigenschaft wird entsprechend aktualisiert.

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

Move – Erstellt eine Eigenschaft mit dem angegebenen „ initialValue “.

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

Erstellt eine Eigenschaft mit dem angegebenen ` initialValue`.

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

Erstellt eine Eigenschaft, die mit dem angegebenen Ausdruck „ binding “ verknüpft ist. Der Wert der Eigenschaft wird auf das Ergebnis der Auswertung der neuen Verknüpfung gesetzt. Sobald sich eine Abhängigkeit der Verknüpfung ändert, wird die Verknüpfung neu ausgewertet und der Wert der Eigenschaft entsprechend aktualisiert.

Wenn sich der Wert der Eigenschaft ändert, wird „ owner “ über die Callback-Funktion benachrichtigt.

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

Erstellt eine Eigenschaft, die an den angegebenen Ausdruck „ binding “ gebunden ist. Der Wert der Eigenschaft wird auf das Ergebnis der Auswertung der neuen Bindung gesetzt. Immer wenn sich eine Abhängigkeit der Bindung ändert, wird die Bindung neu ausgewertet und der Wert der Eigenschaft entsprechend aktualisiert.

Wenn sich der Wert der Eigenschaft ändert, wird owner über die Callback-Funktion benachrichtigt.

[implicit] QObjectBindableProperty::~QObjectBindableProperty()

Zerstört das Objekt.

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

Registriert den angegebenen Funktor f als Callback, der immer dann aufgerufen wird, wenn sich der Wert der Eigenschaft ändert.

Der Callback „ f “ muss ein Typ sein, der über einen einfachen Aufrufoperator „ () “ ohne Parameter verfügt. Das bedeutet, dass Sie einen C++-Lambda-Ausdruck, eine `std::function` oder sogar eine benutzerdefinierte Struktur mit einem Aufrufoperator angeben können.

Das zurückgegebene Objekt des Eigenschaftsänderungs-Handlers verwaltet das Abonnement. Wenn es den Gültigkeitsbereich verlässt, wird das Callback abgemeldet.

Diese Methode ist in manchen Fällen einfacher zu verwenden als ` onValueChanged()`, da das zurückgegebene Objekt kein Template ist. Es lässt sich daher leichter speichern, z. B. als Mitglied in einer Klasse.

Siehe auch ` onValueChanged()` und ` subscribe()`.

QPropertyBinding<T> QObjectBindableProperty::binding() const

Gibt den Bindungsausdruck zurück, der dieser Eigenschaft zugeordnet ist. Wenn keine solche Zuordnung vorliegt, wird ein standardmäßig initialisiertes `QPropertyBinding<T>` zurückgegeben.

Siehe auch „ setBinding()“.

bool QObjectBindableProperty::hasBinding() const

Gibt „true“ zurück, wenn die Eigenschaft einer Bindung zugeordnet ist; andernfalls „false“.

void QObjectBindableProperty::notify()

Signalisiert programmgesteuert eine Änderung der Eigenschaft. Alle davon abhängigen Bindungen werden benachrichtigt, und falls die Eigenschaft über ein Signal verfügt, wird dieses ausgelöst.

Dies kann in Kombination mit `setValueBypassingBindings` nützlich sein, um die Signalisierung der Änderung aufzuschieben, bis eine Klasseninvariante wiederhergestellt ist.

Siehe auch „ Qt::beginPropertyUpdateGroup()“ und „ setValueBypassingBindings()“.

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

Registriert den angegebenen Funktor f als Callback, der immer dann aufgerufen wird, wenn sich der Wert der Eigenschaft ändert. Bei jeder Wertänderung wird der Handler je nach Kontext entweder sofort oder zeitversetzt aufgerufen.

Der Callback ` f ` muss ein Typ sein, der über einen einfachen Aufrufoperator ` () ` ohne Parameter verfügt. Das bedeutet, dass Sie einen C++-Lambda-Ausdruck, eine `std::function` oder sogar eine benutzerdefinierte Struktur mit einem Aufrufoperator angeben können.

Das zurückgegebene Objekt des Property-Change-Handlers verwaltet die Registrierung. Wenn es den Gültigkeitsbereich verlässt, wird der Callback abgemeldet.

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

Verknüpft den Wert dieser Eigenschaft mit dem angegebenen Ausdruck „ newBinding “ und gibt die zuvor verknüpfte Bindung zurück. Der Wert der Eigenschaft wird auf das Ergebnis der Auswertung der neuen Bindung gesetzt. Sobald sich eine Abhängigkeit der Bindung ändert, wird die Bindung neu ausgewertet und der Wert der Eigenschaft entsprechend aktualisiert. Wenn sich der Wert der Eigenschaft ändert, wird der Eigentümer über die Callback-Funktion benachrichtigt.

Siehe auch ` binding()`.

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

Verknüpft den Wert dieser Eigenschaft mit dem angegebenen Funktor f und gibt die zuvor verknüpfte Bindung zurück. Der Wert der Eigenschaft wird auf das Ergebnis der Auswertung der neuen Bindung gesetzt, indem der Aufrufoperator () von f aufgerufen wird. Immer wenn sich eine Abhängigkeit der Bindung ändert, wird die Bindung neu ausgewertet und der Wert der Eigenschaft entsprechend aktualisiert.

Wenn sich der Wert der Eigenschaft ändert, wird der Eigentümer über die Callback-Funktion benachrichtigt.

Siehe auch „Erstellen einer Eigenschaftsbindung“.

bool QObjectBindableProperty::setBinding(const QUntypedPropertyBinding &newBinding)

Verknüpft den Wert dieser Eigenschaft mit dem angegebenen Ausdruck „ newBinding “. Der Wert der Eigenschaft wird auf das Ergebnis der Auswertung der neuen Bindung gesetzt. Immer wenn sich eine Abhängigkeit der Bindung ändert, wird die Bindung neu ausgewertet und der Wert der Eigenschaft entsprechend aktualisiert.

Gibt „ true “ zurück, wenn der Typ dieser Eigenschaft mit dem Typ übereinstimmt, den die Bindungsfunktion zurückgibt; andernfalls „ false “.

Weist dieser Eigenschaft den Wert „ newValue “ zu und entfernt die zugehörige Bindung der Eigenschaft, falls vorhanden. Wenn sich der Wert der Eigenschaft dadurch ändert, wird die Callback-Funktion unter owner aufgerufen.

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

Registriert den angegebenen Funktor f als Callback, der sofort und bei jeder zukünftigen Änderung des Werts der Eigenschaft aufgerufen wird. Bei jeder Wertänderung wird der Handler je nach Kontext entweder sofort oder verzögert aufgerufen.

Der Callback ` f ` muss ein Typ sein, der über einen einfachen Aufrufoperator ` () ` ohne Parameter verfügt. Das bedeutet, dass Sie einen C++-Lambda-Ausdruck, eine `std::function` oder sogar eine benutzerdefinierte Struktur mit einem Aufrufoperator angeben können.

Das zurückgegebene Objekt des Handlers für Eigenschaftsänderungen verwaltet das Abonnement. Wenn es den Gültigkeitsbereich verlässt, wird das Abonnement für den Callback aufgehoben.

QPropertyBinding<T> QObjectBindableProperty::takeBinding()

Trennt den Bindungsausdruck von dieser Eigenschaft und gibt ihn zurück. Nach dem Aufruf dieser Funktion ändert sich der Wert der Eigenschaft nur noch, wenn Sie ihr einen neuen Wert zuweisen oder wenn eine neue Bindung festgelegt wird.

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

Gibt den Wert der Eigenschaft zurück. Dabei wird möglicherweise zunächst ein mit dieser Eigenschaft verknüpfter Bindungsausdruck ausgewertet, bevor der Wert zurückgegeben wird.

Siehe auch setValue().