Qt 如何有条件地禁用与C++；后端？

我正在为一个具有大量属性绑定的嵌入式系统开发QML应用程序：许多传感器数据显示在应用程序的不同页面中。一次只能看到一页

当我在

第2页

上时，

第1页

的属性绑定仍在进行，即使

可见

在

第1页

上设置为

假

。我希望QML只在页面可见时才对绑定更新作出响应，因为这将提高性能

我已经尝试使用

绑定
元素，如这里所述：和这里：，但是我注意到绑定仍然会在QML中更新

我想知道如果不在
第1页
上，是否可以完全消除绑定

下面是我尝试使用Binding元素的代码。我使用了一个按钮来切换激活的
属性，而不是多个页面可见/不可见

main.qml

Rectangle{                                                                               
    x: 280                                                                                         
    y: 20                                                                                          
    width:200                                                                                      
    height:150                                                                                     
    color:"red"                                                                                             
    Text {                                        
        y: 76                                                                                      
        width: 85                                                                                  
        height: 67                                                                                 
        text: "off"                                                  
        Binding on text {                                               
            value: {                                                                               
                // I am surprised to find this prints, regardless of value of controlRect.activated       
                console.log("new value");                                                          
                sensorData.sensorReading.toFixed(1)                                                
            }                                                                                      
            when: controlRect.activated                                                            
        }                                                                                          
    }                                                                                              
}                                                                                                  

Rectangle{                                                                                         
    id: controlRect                                                                                
    x: 20                                                                                          
    y: 20                                                                                          
    width:200                                                                                      
    height:150                                                                                     
    property bool activated: true                                                                  
    color:{                                                                                        
        if (controlRect.activated){                                                                
            "green"                                                                                
        }                                                                                          
        else{                                                                                      
            "yellow"                                                                               
        }                                                                                          
    }                                                                                              

    MouseArea {                                                                                    
        anchors.fill: parent                                                                       
        onClicked: {                                                                               
            console.log("State changed to",!parent.activated);                                     
            parent.activated = !parent.activated                                                   
        }                                                                                          
    }                                                                                         
}                                                                                                  

backend.cpp，在main.cpp中实例化

#include "backend.h"
#include <QQmlContext>

Backend::Backend(QQmlApplicationEngine* engine, QObject *parent) :
    QObject(parent)
{
    sensorData = new SensorData();
     QQmlContext* ctxt(engine->rootContext());

    // Connecting back end object instances to front end
    ctxt->setContextProperty("sensorData", sensorData);
}

#包括“backend.h”
#包括
后端：：后端（QQmlApplicationEngine*引擎，QObject*父级）：
QObject（父对象）
{
sensorData=新的sensorData（）；
QQmlContext*ctxt（引擎->根上下文（））；
//将后端对象实例连接到前端
ctxt->setContextProperty（“传感器数据”，传感器数据）；
}

sensordata.h

#ifndef SENSORDATA_H
#define SENSORDATA_H
#include <QObject>
#include <QTimer>

class SensorData : public QObject
{
    Q_OBJECT
public:
    Q_PROPERTY(double sensorReading MEMBER m_sensorReading NOTIFY sensorReadingChanged)

    explicit SensorData(QObject *parent = nullptr);
    ~SensorData() {}

private:
    double m_sensorReading;
    double temp;
    QTimer m_timer;

signals:
    void sensorReadingChanged();

public slots:
    void slot_updateReading();

};

#endif // SENSORDATA_H

\ifndef传感器数据\u H
#定义传感器数据
#包括
#包括
类传感器数据：公共QObject
{
Q_对象
公众：
Q_属性（双传感器读取成员m_传感器读取通知传感器读取已更改）
显式传感器数据（QObject*parent=nullptr）；
~SensorData（）{}
私人：
双m_传感器读数；
双温；
QTimer mu定时器；
信号：
void sensorReadingChanged（）；
公众时段：
无效插槽_updateReading（）；
};
#endif//SENSORDATA\u H

sensordata.cpp

#include "sensordata.h"
#include <QDebug>

SensorData::SensorData(QObject *parent) :
    QObject(parent)
{
    // for simulating sensor data
    srand( (unsigned)time(NULL) );
    m_timer.setInterval(100);
    m_timer.setSingleShot(false);
    QObject::connect(&m_timer, &QTimer::timeout, this, &SensorData::slot_updateReading);
    m_timer.start();
}

// simulate my sensor data
void SensorData::slot_updateReading(){
    m_sensorReading = modf(rand() /  100000.0, &temp);
    emit sensorReadingChanged(); // emit for QML binding to update
}

#包括“sensordata.h”
#包括
SensorData:：SensorData（QObject*父对象）：
QObject（父对象）
{
//用于模拟传感器数据
srand（（无符号）时间（NULL））；
m_定时器设置间隔（100）；
m_定时器设置单脉冲（假）；
QObject:：connect（&m_timer，&QTimer:：timeout，this，&SensorData:：slot_updateReading）；
m_timer.start（）；
}
//模拟我的传感器数据
void SensorData:：slot_updateReading（）{
m_传感器读数=modf（兰德（）/100000.0，&temp）；
emit sensorReadingChanged（）；//为要更新的QML绑定发出
}
事实上，
绑定
似乎仍在评估
值
属性，但当
when
子句为false时，却没有将其分配给
文本
属性。我会考虑这辆车，但也许有一个背后的理论基础。
解决方案是使用
状态
，如下代码所示。这还可以说明当前未读取该值

Rectangle{
    x: 280
    y: 20
    width:200
    height:150
    color:"red"
    Text {
        id: readout
        y: 76
        width: 85
        height: 67
        text: {
            console.log("new value"); //does not print when deactivated
            sensorData.sensorReading.toFixed(1)
        }

        states: [
            State {
                name: "deactivated"
                when: !controlRect.activated
                PropertyChanges {
                    target: readout
                    text: "off"
                }
            }
        ]
    }
}