Qt Qml Two Way Binding Problems

[Dirk (Gast)]

Hallo, ich bringe mir immer noch Qt Qml alleine bei und knappere schon 
länger an TwoWay Bindings, deshalb konnte ich mich über dieses 
veröffentlichtes Video von der Firma KDAB freuen.

https://www.kdab.com/kdab-qt-world-summit-2019/#component
QML Component Design: the two-way binding problem

Die PowerPoints wurden auch veröffentlicht, aber das Beispiel konnte ich 
im Internet nicht finden, deshalb hab ich einige Dinge aus der PPT 
extrahiert.

Das Interface wurde wie folgt dargestellt:

#ifndef BOOLEANVALUE_H
#define BOOLEANVALUE_H
#include <QObject>
#include <QDebug>
#include <QTimer>


class BooleanValue : public QObject
{
    Q_OBJECT
    Q_PROPERTY(bool isOn READ isOn WRITE setOn NOTIFY isOnChanged)

public:
    explicit BooleanValue(QObject *parent = nullptr);
    explicit BooleanValue(bool initValue, QObject *parent = nullptr);

    bool isOn() const;
    Q_SLOT void setOn(bool isOn); // Be sure to make it a slot or Q_INVOKABLE

    //convenience API is now possible
    Q_INVOKABLE void toggle();


signals:
    void isOnChanged(bool isOn);

    // New for my personal test currently uncomment
private slots:
    //void timeout();

private:
    bool m_isOn = false;

    // New for my personal test currently uncomment
    // QTimer *m_timer;


};

#endif // BOOLEANVALUE_H

Die Implementierung konnte ich nicht finden, deshalb hab ich es 
implementiert nach besten Gewissen.

#include "booleanvalue.h"

BooleanValue::BooleanValue(QObject *parent) : QObject(parent)
{
    //    m_timer = new QTimer(this);
    //    m_timer->setSingleShot(true);
    //    m_timer->setInterval(100);
    //    connect(m_timer,&QTimer::timeout,this,&BooleanValue::timeout);
}

BooleanValue::BooleanValue(bool initValue, QObject *parent) : QObject(parent)
{
    m_isOn = initValue;
}

bool BooleanValue::isOn() const
{
    return m_isOn;
}

void BooleanValue::setOn(bool isOn)
{
    if(m_isOn == isOn)
        return;

    m_isOn = isOn;
    emit isOnChanged(m_isOn);

}


void BooleanValue::toggle()
{
    // New for my personal test currently uncomment
    // m_timer->start();
    m_isOn = !m_isOn;
    emit isOnChanged(m_isOn);
    qDebug() << "m_isOn Changed";
}

// New for my personal test currently uncomment
//void BooleanValue::timeout()
//{
//    m_isOn = !m_isOn;
//    emit isOnChanged(m_isOn);
//    qDebug() << "m_isOn Changed";
//}

Die Type ist dann in der main.c registiert.

qmlRegisterType<BooleanValue>("BooleanValue", 1, 0, "BooleanValue");

main.qml

import QtQuick 2.12
import QtQuick.Window 2.12

Window {
    visible: true
    width: 640
    height: 480
    title: qsTr("Hello World")

        CheckBox{

            id: someController
            text: "checkbox"
        }
        Rectangle{
            color: someController.checked ? "red" : "blue"
            width: 100
            height: 100
            anchors.centerIn: parent
        }
}

CheckBox.qml

import QtQuick 2.0
import BooleanValue 1.0
import QtQuick.Controls 2.12
import QtQuick.Layouts 1.12

Item {
    id: root

    property alias checked: internal.isOn
    property alias text: label.text

    implicitHeight: checkbox.height
    implicitWidth: checkbox.width + checkbox.implicitWidth + 4
    //ui related code




    Rectangle {
        id: checkbox
        implicitWidth: 48
        implicitHeight: 48
        Rectangle{
            color: root.checked ?  "black" : "white"
            anchors{
                fill: parent
                margins: 8
            }
            border {
                color: "black"
                width: 1
            }
        }

        Text{
            id: label
            anchors{
                left: checkbox.right
                verticalCenter: checkbox.verticalCenter
                margins: 4
            }
            font.pointSize: 16


        }

        BooleanValue {
            id: internal
        }

        MouseArea {
            anchors.fill: parent
            onClicked: {
                internal.toggle(); // works, using convenience function on BooleanValue
                // internal.setOn(!internal.isOn) // works too
                // internal.isOn = !internal.isOn // Wrong: breaks the binding
            }
        }

    }
}

Die Zeile würde das TwoWay Binding brechen, soweit so gut.

// internal.isOn = !internal.isOn // Wrong: breaks the

Wieso wird über das Q_PROPERTY Marco ein Setter angegeben?

 Q_PROPERTY(bool isOn READ isOn WRITE setOn NOTIFY isOnChanged)

Wieso nicht nur ein Readonly Property und eine Funktion Q_INVOKABLE oder 
Slot zum setzen?

 Q_PROPERTY(bool isOn READ isOn NOTIFY isOnChanged)

Somit kommt doch keiner mehr auf die Idee

internal.isOn = !internal.isOn // Wrong: breaks the binding

sondern benutzt immer den Slot in Qml Code zuschreiben

internal.setOn(!internal.isOn)