Software livre não escreve para C++ propriedade, quando vinculado ao componente e componente de alterações de valor

Question 1

Eu estou trabalhando em um projeto de software livre. Na INTERFACE do usuário que eu estou trabalhando, eu preciso tanto de atualização do controle deslizante de C++ e ler o valor atual em C++ do software livre. Propriedades parece ser a solução certa. Até agora tenho lido diversas questões sobre ISSO, sem sucesso, Duas vias de ligação C++ modelo de software livre, Propriedades Alteradas não o sinal de trigger, etc... Na minha atual código declarei uma propriedade na minha classe de C++

class MyClass : public QObject {
    Q_OBJECT
public:
    MyClass(QObject*);
    Q_PROPERTY(double myValue READ getMyValue WRITE setMyValue NOTIFY myValueChanged)

    void setMyValue(double n) {
        std::cerr << "myValue  being update: " << n << "\n";
        myValue = n;
    }

    double myValue = 30;
...
}

E expostas em Qt através de um singleton

qmlRegisterSingletonInstance("com.me.test", 1, 0, "MyClass", &myClass);

Em seguida, atou o C++ propriedade de um controle deslizante de software livre

import com.me.test
ApplicationWindow {
    Slider {
        id: slider
        height: 30
        width: 100
        from: 0
        to: 100
        value: myClass.myValue
        onValueChanged {
            console.log("value = " + value)
            console.log("myClass.myValue = " + myClass.myValue)
        }

        /* Doesn't help
        Binding {
            target: slider
            property: "value"
            value: myClass.myValue
        }*/
    }
}

A ligação parece funcionar. Eu posso modificar o valor de myValue em seguida, emitem myValueChanged para fazer a atualização de software livre é deslizante. Mas, dado que myClass.myValue é delimitada a slider.value. Eu assumir ambos os valores é atualizado ao mesmo tempo. Mas arrastando o controle deslizante mostra que eles têm valores diferentes. O seguinte é o que é impressa no console quando eu arrasto o meu controle.

qml: value = 19.863013698630137
qml: myClass.myValue = 30

Além disso setMyValue parece não ser chamado, a menos que uma atribuição explícita é feita como myClass.myValue = 0. Eu também tentei o componente de Vinculação, sem sucesso. Por que esse é o caso e eu poderia fazer o C++ propriedade atualizada sempre que eu arraste o controle deslizante?

Qt: 6.2.1
Compilador: clang/gcc
Sistema operacional: Windows/Linux

Atualização: testado um enlace reverso. Ainda imprimir o mesmo resultado

import com.me.test
ApplicationWindow {
    Slider {
        id: slider
        height: 30
        width: 100
        from: 0
        to: 100
        value: myClass.myValue
        onValueChanged {
            console.log("value = " + value)
            console.log("myClass.myValue = " + myClass.myValue)
        }
        Binding {
            target: myClass
            property: "myValue"
            value: slider.value
        }
    }
}

Question 2

A atualização de C++ propriedade do software livre, você pode usar Binding:

import com.me.test
ApplicationWindow {
    Slider {
        id: slider
        height: 30
        width: 100
        from: 0
        to: 100
        value: myClass.myValue
        onValueChanged {
            console.log("value = " + value)
            console.log("myClass.myValue = " + myClass.myValue)
        }
         // C++ property was bounded to QML above, now we should bind QML to C++
        Binding {
            target: myClass 
            property: "myValue"
            value: slider.value
        }
    }
}

Question 3

Aqui está um mínimo exemplo de trabalho de duas forma de atualizar Slider:

main.cpp:

data dataObj;
engine.rootContext()->setContextProperty("dataCpp", (QObject*)&dataObj);

dados.h:

class data : public QObject
{
    Q_OBJECT
    Q_PROPERTY(int value READ value WRITE setValue NOTIFY valueChanged)
public:
    explicit data(QObject *parent = nullptr);
    int value(void);
    void setValue(int new_value);
public slots:
    void reset(void);
signals:
    void valueChanged();
private:
    int dataValue;
};

data.cpp:

data::data(QObject *parent) : QObject(parent)
{
    dataValue = 250;
}

int data::value()
{
    return dataValue;
}

void data::setValue(int new_value)
{
    if(dataValue != new_value)
    {
        qDebug() << "setting" << new_value;
        dataValue = new_value;
        emit valueChanged();
    }
}

void data::reset()
{
    if(dataValue != 0)
    {
        qDebug() << "resetting to 0";
        dataValue = 0;
        emit valueChanged();
    }
}

principal.software livre:

Slider {
    id: slider
    height: 50
    width: 500
    from: 0
    to: 500
    live: false
    value: dataCpp.value
    onValueChanged: dataCpp.value = value
}

Button{
    anchors.top: slider.bottom
    text: "Reset"
    onPressed: dataCpp.reset()
}

Question 4

Você está perdendo o sinal quando modificar o valor:

Q_PROPERTY(double myValue READ getMyValue WRITE setMyValue NOTIFY myValueChanged)

Isso significa que você promessa de que você vai enviar o myValueChanged sinal sempre que o código C++ altera o valor. Assim, o seguinte deve funcionar:

void setMyValue(double n) {
    std::cerr << "myValue  being update: " << n << "\n";
    myValue = n;
    emit(myValueChanged());
}

Jakub Warchoł · Answer 1 · 2021-11-24T09:12:14

A atualização de C++ propriedade do software livre, você pode usar Binding:

import com.me.test
ApplicationWindow {
    Slider {
        id: slider
        height: 30
        width: 100
        from: 0
        to: 100
        value: myClass.myValue
        onValueChanged {
            console.log("value = " + value)
            console.log("myClass.myValue = " + myClass.myValue)
        }
         // C++ property was bounded to QML above, now we should bind QML to C++
        Binding {
            target: myClass 
            property: "myValue"
            value: slider.value
        }
    }
}

o que acontece quando myClass.myValue vai ser atualizado e vai disparar a sua myValueChanged?
@folibis Ele irá atualizar o controle deslizante de " valor de propriedade. Claro, o setMyValue o método deve iniciar com a comparação entre o valor novo e o valor atual, e emitir myValueChanged somente se o valor foi realmente atualizado. Em outro caso, você poderia ver uma associação de loop
Obrigado pela resposta. Eu tentei a sugestão de solução. Mas ainda não está vendo setter chamado, nem o valor de console.log("myClass.myValue = " + myClass.myValue) alterado.
@MaryChang No código acima, você vai ver console.log("myClass.myValue = " + myClass.myValue) quando você mover um controle deslizante. Para ver myClass.myValue o valor alterado, ter um olhar para as Ligações

Arun Kumar B · Answer 2 · 2021-12-14T13:21:29

Aqui está um mínimo exemplo de trabalho de duas forma de atualizar Slider:

main.cpp:

data dataObj;
engine.rootContext()->setContextProperty("dataCpp", (QObject*)&dataObj);

dados.h:

class data : public QObject
{
    Q_OBJECT
    Q_PROPERTY(int value READ value WRITE setValue NOTIFY valueChanged)
public:
    explicit data(QObject *parent = nullptr);
    int value(void);
    void setValue(int new_value);
public slots:
    void reset(void);
signals:
    void valueChanged();
private:
    int dataValue;
};

data.cpp:

data::data(QObject *parent) : QObject(parent)
{
    dataValue = 250;
}

int data::value()
{
    return dataValue;
}

void data::setValue(int new_value)
{
    if(dataValue != new_value)
    {
        qDebug() << "setting" << new_value;
        dataValue = new_value;
        emit valueChanged();
    }
}

void data::reset()
{
    if(dataValue != 0)
    {
        qDebug() << "resetting to 0";
        dataValue = 0;
        emit valueChanged();
    }
}

principal.software livre:

Slider {
    id: slider
    height: 50
    width: 500
    from: 0
    to: 500
    live: false
    value: dataCpp.value
    onValueChanged: dataCpp.value = value
}

Button{
    anchors.top: slider.bottom
    text: "Reset"
    onPressed: dataCpp.reset()
}

Vincent Fourmond · Answer 3 · 2021-12-14T15:18:53

Você está perdendo o sinal quando modificar o valor:

Q_PROPERTY(double myValue READ getMyValue WRITE setMyValue NOTIFY myValueChanged)

Isso significa que você promessa de que você vai enviar o myValueChanged sinal sempre que o código C++ altera o valor. Assim, o seguinte deve funcionar:

void setMyValue(double n) {
    std::cerr << "myValue  being update: " << n << "\n";
    myValue = n;
    emit(myValueChanged());
}

Software livre não escreve para C++ propriedade, quando vinculado ao componente e componente de alterações de valor

Pergunta

Em outros idiomas

Esta página está em outros idiomas

Popular nesta categoria

Perguntas populares nesta categoria