/****************************************************************************
** Generated from 'Example.IVI.Climate.qface'
**
** Created by: The QFace generator (QtAS 5.12.8)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "climatecontrol.h"
#include "climatecontrol_p.h"
#include "climatecontrolbackendinterface.h"

#include <QQmlEngine>
#include <QIviServiceObject>
#include <QIviProxyServiceObject>

/*!
    \class ClimateControl
    \inmodule Example.IVI.Climate

    The ClimateControl provides a QML interface to the climate control of the vehicle.
*/

/*!
    \qmltype UiClimateControl
    \instantiates ClimateControl
    \inherits AbstractZonedFeature

    The ClimateControl provides a QML interface to the climate control of the vehicle.
*/

/*! \internal */
ClimateControlPrivate::ClimateControlPrivate(const QString &interface, const QString &zone, ClimateControl *parent)
    : QIviAbstractZonedFeaturePrivate(interface, zone, parent)
    , q_ptr(parent)
    , m_airConditioning(bool(false))
    , m_heater(bool(false))
    , m_fanSpeedLevel(int(0))
    , m_steeringWheelHeater(int(0))
    , m_targetTemperature(qreal(0.0))
    , m_seatCooler(int(0))
    , m_seatHeater(int(0))
    , m_outsideTemperature(int(0))
    , m_outsideTemperatureLabel(QString())
    , m_zoneSynchronization(bool(false))
    , m_defrost(bool(false))
    , m_recirculationMode(ClimateModule::RecirculationOff)
    , m_recirculation(bool(false))
    , m_recirculationSensitivityLevel(int(0))
    , m_climateMode(ClimateModule::ClimateOff)
    , m_automaticClimateFanIntensityLevel(int(0))
    , m_airflowDirections(ClimateModule::AirflowDirections())
{
    m_supportsPropertyOverriding = true;
}

/*! \internal */
ClimateControlPrivate *ClimateControlPrivate::get(ClimateControl *v)
{
    return reinterpret_cast<ClimateControlPrivate *>(v->d_ptr.data());
}

/*! \internal */
const ClimateControlPrivate *ClimateControlPrivate::get(const ClimateControl *v)
{
    return reinterpret_cast<const ClimateControlPrivate *>(v->d_ptr.data());
}

/*! \internal */
ClimateControl *ClimateControlPrivate::getParent()
{
    return q_ptr;
}

/*! \internal */
void ClimateControlPrivate::clearToDefaults()
{
    m_airConditioning = bool(false);
    m_heater = bool(false);
    m_fanSpeedLevel = int(0);
    m_steeringWheelHeater = int(0);
    m_targetTemperature = qreal(0.0);
    m_seatCooler = int(0);
    m_seatHeater = int(0);
    m_outsideTemperature = int(0);
    m_outsideTemperatureLabel = QString();
    m_zoneSynchronization = bool(false);
    m_defrost = bool(false);
    m_recirculationMode = ClimateModule::RecirculationOff;
    m_recirculation = bool(false);
    m_recirculationSensitivityLevel = int(0);
    m_climateMode = ClimateModule::ClimateOff;
    m_automaticClimateFanIntensityLevel = int(0);
    m_airflowDirections = ClimateModule::AirflowDirections();
}

/*! \internal */
void ClimateControlPrivate::onAirConditioningChanged(bool airConditioning, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("airConditioning");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<bool>(airConditioning);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_airConditioning != airConditioning) {
        ClimateControlPrivate::get(f)->m_airConditioning = airConditioning;
        emit f->airConditioningChanged(airConditioning);
    }
}

/*! \internal */
void ClimateControlPrivate::onHeaterChanged(bool heater, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("heater");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<bool>(heater);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_heater != heater) {
        ClimateControlPrivate::get(f)->m_heater = heater;
        emit f->heaterChanged(heater);
    }
}

/*! \internal */
void ClimateControlPrivate::onFanSpeedLevelChanged(int fanSpeedLevel, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("fanSpeedLevel");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<int>(fanSpeedLevel);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_fanSpeedLevel != fanSpeedLevel) {
        ClimateControlPrivate::get(f)->m_fanSpeedLevel = fanSpeedLevel;
        emit f->fanSpeedLevelChanged(fanSpeedLevel);
    }
}

/*! \internal */
void ClimateControlPrivate::onSteeringWheelHeaterChanged(int steeringWheelHeater, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("steeringWheelHeater");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<int>(steeringWheelHeater);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_steeringWheelHeater != steeringWheelHeater) {
        ClimateControlPrivate::get(f)->m_steeringWheelHeater = steeringWheelHeater;
        emit f->steeringWheelHeaterChanged(steeringWheelHeater);
    }
}

/*! \internal */
void ClimateControlPrivate::onTargetTemperatureChanged(qreal targetTemperature, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("targetTemperature");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<qreal>(targetTemperature);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_targetTemperature != targetTemperature) {
        ClimateControlPrivate::get(f)->m_targetTemperature = targetTemperature;
        emit f->targetTemperatureChanged(targetTemperature);
    }
}

/*! \internal */
void ClimateControlPrivate::onSeatCoolerChanged(int seatCooler, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("seatCooler");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<int>(seatCooler);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_seatCooler != seatCooler) {
        ClimateControlPrivate::get(f)->m_seatCooler = seatCooler;
        emit f->seatCoolerChanged(seatCooler);
    }
}

/*! \internal */
void ClimateControlPrivate::onSeatHeaterChanged(int seatHeater, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("seatHeater");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<int>(seatHeater);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_seatHeater != seatHeater) {
        ClimateControlPrivate::get(f)->m_seatHeater = seatHeater;
        emit f->seatHeaterChanged(seatHeater);
    }
}

/*! \internal */
void ClimateControlPrivate::onOutsideTemperatureChanged(int outsideTemperature, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("outsideTemperature");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<int>(outsideTemperature);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_outsideTemperature != outsideTemperature) {
        ClimateControlPrivate::get(f)->m_outsideTemperature = outsideTemperature;
        emit f->outsideTemperatureChanged(outsideTemperature);
    }
}

/*! \internal */
void ClimateControlPrivate::onOutsideTemperatureLabelChanged(const QString &outsideTemperatureLabel, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("outsideTemperatureLabel");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<QString>(outsideTemperatureLabel);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_outsideTemperatureLabel != outsideTemperatureLabel) {
        ClimateControlPrivate::get(f)->m_outsideTemperatureLabel = outsideTemperatureLabel;
        emit f->outsideTemperatureLabelChanged(outsideTemperatureLabel);
    }
}

/*! \internal */
void ClimateControlPrivate::onZoneSynchronizationChanged(bool zoneSynchronization, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("zoneSynchronization");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<bool>(zoneSynchronization);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_zoneSynchronization != zoneSynchronization) {
        ClimateControlPrivate::get(f)->m_zoneSynchronization = zoneSynchronization;
        emit f->zoneSynchronizationChanged(zoneSynchronization);
    }
}

/*! \internal */
void ClimateControlPrivate::onDefrostChanged(bool defrost, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("defrost");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<bool>(defrost);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_defrost != defrost) {
        ClimateControlPrivate::get(f)->m_defrost = defrost;
        emit f->defrostChanged(defrost);
    }
}

/*! \internal */
void ClimateControlPrivate::onRecirculationModeChanged(ClimateModule::RecirculationMode recirculationMode, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("recirculationMode");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<ClimateModule::RecirculationMode>(recirculationMode);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_recirculationMode != recirculationMode) {
        ClimateControlPrivate::get(f)->m_recirculationMode = recirculationMode;
        emit f->recirculationModeChanged(recirculationMode);
    }
}

/*! \internal */
void ClimateControlPrivate::onRecirculationChanged(bool recirculation, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("recirculation");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<bool>(recirculation);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_recirculation != recirculation) {
        ClimateControlPrivate::get(f)->m_recirculation = recirculation;
        emit f->recirculationChanged(recirculation);
    }
}

/*! \internal */
void ClimateControlPrivate::onRecirculationSensitivityLevelChanged(int recirculationSensitivityLevel, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("recirculationSensitivityLevel");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<int>(recirculationSensitivityLevel);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_recirculationSensitivityLevel != recirculationSensitivityLevel) {
        ClimateControlPrivate::get(f)->m_recirculationSensitivityLevel = recirculationSensitivityLevel;
        emit f->recirculationSensitivityLevelChanged(recirculationSensitivityLevel);
    }
}

/*! \internal */
void ClimateControlPrivate::onClimateModeChanged(ClimateModule::ClimateMode climateMode, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("climateMode");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<ClimateModule::ClimateMode>(climateMode);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_climateMode != climateMode) {
        ClimateControlPrivate::get(f)->m_climateMode = climateMode;
        emit f->climateModeChanged(climateMode);
    }
}

/*! \internal */
void ClimateControlPrivate::onAutomaticClimateFanIntensityLevelChanged(int automaticClimateFanIntensityLevel, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("automaticClimateFanIntensityLevel");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<int>(automaticClimateFanIntensityLevel);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_automaticClimateFanIntensityLevel != automaticClimateFanIntensityLevel) {
        ClimateControlPrivate::get(f)->m_automaticClimateFanIntensityLevel = automaticClimateFanIntensityLevel;
        emit f->automaticClimateFanIntensityLevelChanged(automaticClimateFanIntensityLevel);
    }
}

/*! \internal */
void ClimateControlPrivate::onAirflowDirectionsChanged(ClimateModule::AirflowDirections airflowDirections, const QString &zone)
{
    auto q = getParent();
    auto f = qobject_cast<ClimateControl*>(q->zoneAt(zone));
    if (!f)
        f = q;
    if (f->zone() != zone)
        return;
    if (Q_UNLIKELY(m_propertyOverride)) {
        const int pi = f->metaObject()->indexOfProperty("airflowDirections");
        if (m_propertyOverride->isOverridden(pi)) {
            QVariant v = qVariantFromValue<ClimateModule::AirflowDirections>(airflowDirections);
            m_propertyOverride->setProperty(pi, v);
            return;
        }
    }
    if (ClimateControlPrivate::get(f)->m_airflowDirections != airflowDirections) {
        ClimateControlPrivate::get(f)->m_airflowDirections = airflowDirections;
        emit f->airflowDirectionsChanged(airflowDirections);
    }
}

bool ClimateControlPrivate::notify(const QByteArray &propertyName, const QVariant &value)
{
    auto q = getParent();
    if (propertyName == QByteArray("airConditioning")) {
        emit q->airConditioningChanged(value.value<bool>());
        return true;
    }
    if (propertyName == QByteArray("heater")) {
        emit q->heaterChanged(value.value<bool>());
        return true;
    }
    if (propertyName == QByteArray("fanSpeedLevel")) {
        emit q->fanSpeedLevelChanged(value.value<int>());
        return true;
    }
    if (propertyName == QByteArray("steeringWheelHeater")) {
        emit q->steeringWheelHeaterChanged(value.value<int>());
        return true;
    }
    if (propertyName == QByteArray("targetTemperature")) {
        emit q->targetTemperatureChanged(value.value<qreal>());
        return true;
    }
    if (propertyName == QByteArray("seatCooler")) {
        emit q->seatCoolerChanged(value.value<int>());
        return true;
    }
    if (propertyName == QByteArray("seatHeater")) {
        emit q->seatHeaterChanged(value.value<int>());
        return true;
    }
    if (propertyName == QByteArray("outsideTemperature")) {
        emit q->outsideTemperatureChanged(value.value<int>());
        return true;
    }
    if (propertyName == QByteArray("outsideTemperatureLabel")) {
        emit q->outsideTemperatureLabelChanged(value.value<QString>());
        return true;
    }
    if (propertyName == QByteArray("zoneSynchronization")) {
        emit q->zoneSynchronizationChanged(value.value<bool>());
        return true;
    }
    if (propertyName == QByteArray("defrost")) {
        emit q->defrostChanged(value.value<bool>());
        return true;
    }
    if (propertyName == QByteArray("recirculationMode")) {
        emit q->recirculationModeChanged(value.value<ClimateModule::RecirculationMode>());
        return true;
    }
    if (propertyName == QByteArray("recirculation")) {
        emit q->recirculationChanged(value.value<bool>());
        return true;
    }
    if (propertyName == QByteArray("recirculationSensitivityLevel")) {
        emit q->recirculationSensitivityLevelChanged(value.value<int>());
        return true;
    }
    if (propertyName == QByteArray("climateMode")) {
        emit q->climateModeChanged(value.value<ClimateModule::ClimateMode>());
        return true;
    }
    if (propertyName == QByteArray("automaticClimateFanIntensityLevel")) {
        emit q->automaticClimateFanIntensityLevelChanged(value.value<int>());
        return true;
    }
    if (propertyName == QByteArray("airflowDirections")) {
        emit q->airflowDirectionsChanged(value.value<ClimateModule::AirflowDirections>());
        return true;
    }
    return QIviAbstractZonedFeaturePrivate::notify(propertyName, value);
}

/*!
   Default constructs an instance of ClimateControl to the given \a zone.

   If \a zone is not provided the General zone will be created.

   The \a parent argument is passed on to the \l QIviAbstractZonedFeature base class.
*/
ClimateControl::ClimateControl(const QString &zone, QObject *parent)
    : QIviAbstractZonedFeature(*new ClimateControlPrivate(QLatin1String(Climate_ClimateControl_iid), zone, this), parent)
{
}

/*! \internal */
ClimateControl::~ClimateControl()
{
}

/*! \internal */
void ClimateControl::registerQmlTypes(const QString& uri, int majorVersion, int minorVersion)
{
    qmlRegisterType<ClimateControl>(uri.toLatin1(), majorVersion, minorVersion, "UiClimateControl");
}

/*!
    \property ClimateControl::airConditioning
    \brief Value is true if the air conditioning is enabled.

*/

/*!
    \qmlproperty bool UiClimateControl::airConditioning
    \brief Value is true if the air conditioning is enabled.

*/
bool ClimateControl::airConditioning() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("airConditioning")).value<bool>();
    return d->m_airConditioning;
}

void ClimateControl::setAirConditioning(bool airConditioning)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("airConditioning");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit airConditioningChanged(d->m_propertyOverride->property(pi).value<bool>());
            return;
        }
        forceUpdate = property("airConditioningDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("airConditioningDirtyOverride", {});
        QVariant v = qVariantFromValue<bool>(airConditioning);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_airConditioning == airConditioning)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setAirConditioning(airConditioning, zone());
    else
        emit airConditioningChanged(d->m_airConditioning);
}

/*!
    \property ClimateControl::heater
    \brief value is true if the heater is enabled.

*/

/*!
    \qmlproperty bool UiClimateControl::heater
    \brief value is true if the heater is enabled.

*/
bool ClimateControl::heater() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("heater")).value<bool>();
    return d->m_heater;
}

void ClimateControl::setHeater(bool heater)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("heater");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit heaterChanged(d->m_propertyOverride->property(pi).value<bool>());
            return;
        }
        forceUpdate = property("heaterDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("heaterDirtyOverride", {});
        QVariant v = qVariantFromValue<bool>(heater);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_heater == heater)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setHeater(heater, zone());
    else
        emit heaterChanged(d->m_heater);
}

/*!
    \property ClimateControl::fanSpeedLevel
    \brief value holds the fan speed level, where the level can be between minimumValue(off) to maximumValue
    (strongest).

*/

/*!
    \qmlproperty int UiClimateControl::fanSpeedLevel
    \brief value holds the fan speed level, where the level can be between minimumValue(off) to maximumValue
    (strongest).

*/
int ClimateControl::fanSpeedLevel() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("fanSpeedLevel")).value<int>();
    return d->m_fanSpeedLevel;
}

void ClimateControl::setFanSpeedLevel(int fanSpeedLevel)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("fanSpeedLevel");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit fanSpeedLevelChanged(d->m_propertyOverride->property(pi).value<int>());
            return;
        }
        forceUpdate = property("fanSpeedLevelDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("fanSpeedLevelDirtyOverride", {});
        QVariant v = qVariantFromValue<int>(fanSpeedLevel);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_fanSpeedLevel == fanSpeedLevel)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setFanSpeedLevel(fanSpeedLevel, zone());
    else
        emit fanSpeedLevelChanged(d->m_fanSpeedLevel);
}

/*!
    \property ClimateControl::steeringWheelHeater
    \brief value holds the steering wheel heater level, where the level can be between minimumValue(off) to
    maximumValue (warmest).

*/

/*!
    \qmlproperty int UiClimateControl::steeringWheelHeater
    \brief value holds the steering wheel heater level, where the level can be between minimumValue(off) to
    maximumValue (warmest).

*/
int ClimateControl::steeringWheelHeater() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("steeringWheelHeater")).value<int>();
    return d->m_steeringWheelHeater;
}

void ClimateControl::setSteeringWheelHeater(int steeringWheelHeater)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("steeringWheelHeater");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit steeringWheelHeaterChanged(d->m_propertyOverride->property(pi).value<int>());
            return;
        }
        forceUpdate = property("steeringWheelHeaterDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("steeringWheelHeaterDirtyOverride", {});
        QVariant v = qVariantFromValue<int>(steeringWheelHeater);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_steeringWheelHeater == steeringWheelHeater)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setSteeringWheelHeater(steeringWheelHeater, zone());
    else
        emit steeringWheelHeaterChanged(d->m_steeringWheelHeater);
}

/*!
    \property ClimateControl::targetTemperature
    \brief value holds the target temperature of the zone expressed in centigrades, where the temperature can
    be between minimumValue(coolest) to maximumValue (warmest).

*/

/*!
    \qmlproperty qreal UiClimateControl::targetTemperature
    \brief value holds the target temperature of the zone expressed in centigrades, where the temperature can
    be between minimumValue(coolest) to maximumValue (warmest).

*/
qreal ClimateControl::targetTemperature() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("targetTemperature")).value<qreal>();
    return d->m_targetTemperature;
}

void ClimateControl::setTargetTemperature(qreal targetTemperature)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("targetTemperature");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit targetTemperatureChanged(d->m_propertyOverride->property(pi).value<qreal>());
            return;
        }
        forceUpdate = property("targetTemperatureDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("targetTemperatureDirtyOverride", {});
        QVariant v = qVariantFromValue<qreal>(targetTemperature);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_targetTemperature == targetTemperature)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setTargetTemperature(targetTemperature, zone());
    else
        emit targetTemperatureChanged(d->m_targetTemperature);
}

/*!
    \property ClimateControl::seatCooler
    \brief value holds the seat cooler level, where the level can be between minimumValue(off) to maximumValue
    (coolest).

*/

/*!
    \qmlproperty int UiClimateControl::seatCooler
    \brief value holds the seat cooler level, where the level can be between minimumValue(off) to maximumValue
    (coolest).

*/
int ClimateControl::seatCooler() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("seatCooler")).value<int>();
    return d->m_seatCooler;
}

void ClimateControl::setSeatCooler(int seatCooler)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("seatCooler");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit seatCoolerChanged(d->m_propertyOverride->property(pi).value<int>());
            return;
        }
        forceUpdate = property("seatCoolerDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("seatCoolerDirtyOverride", {});
        QVariant v = qVariantFromValue<int>(seatCooler);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_seatCooler == seatCooler)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setSeatCooler(seatCooler, zone());
    else
        emit seatCoolerChanged(d->m_seatCooler);
}

/*!
    \property ClimateControl::seatHeater
    \brief value holds the seat heater level, where the level can be between minimumValue(off) to maximumValue
    (warmest).

*/

/*!
    \qmlproperty int UiClimateControl::seatHeater
    \brief value holds the seat heater level, where the level can be between minimumValue(off) to maximumValue
    (warmest).

*/
int ClimateControl::seatHeater() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("seatHeater")).value<int>();
    return d->m_seatHeater;
}

void ClimateControl::setSeatHeater(int seatHeater)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("seatHeater");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit seatHeaterChanged(d->m_propertyOverride->property(pi).value<int>());
            return;
        }
        forceUpdate = property("seatHeaterDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("seatHeaterDirtyOverride", {});
        QVariant v = qVariantFromValue<int>(seatHeater);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_seatHeater == seatHeater)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setSeatHeater(seatHeater, zone());
    else
        emit seatHeaterChanged(d->m_seatHeater);
}

/*!
    \property ClimateControl::outsideTemperature
    \brief value holds the outside temperature of the zone expressed in centigrades, where the temperature can
    be between minimumValue(coolest) to maximumValue (warmest).

*/

/*!
    \qmlproperty int UiClimateControl::outsideTemperature
    \brief value holds the outside temperature of the zone expressed in centigrades, where the temperature can
    be between minimumValue(coolest) to maximumValue (warmest).

*/
int ClimateControl::outsideTemperature() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("outsideTemperature")).value<int>();
    return d->m_outsideTemperature;
}

void ClimateControl::setOutsideTemperature(int outsideTemperature)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("outsideTemperature");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit outsideTemperatureChanged(d->m_propertyOverride->property(pi).value<int>());
            return;
        }
        forceUpdate = property("outsideTemperatureDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("outsideTemperatureDirtyOverride", {});
        QVariant v = qVariantFromValue<int>(outsideTemperature);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_outsideTemperature == outsideTemperature)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setOutsideTemperature(outsideTemperature, zone());
    else
        emit outsideTemperatureChanged(d->m_outsideTemperature);
}

/*!
    \property ClimateControl::outsideTemperatureLabel
    \brief outside temp lable

*/

/*!
    \qmlproperty QString UiClimateControl::outsideTemperatureLabel
    \brief outside temp lable

*/
QString ClimateControl::outsideTemperatureLabel() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("outsideTemperatureLabel")).value<QString>();
    return d->m_outsideTemperatureLabel;
}

void ClimateControl::setOutsideTemperatureLabel(const QString &outsideTemperatureLabel)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("outsideTemperatureLabel");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit outsideTemperatureLabelChanged(d->m_propertyOverride->property(pi).value<QString>());
            return;
        }
        forceUpdate = property("outsideTemperatureLabelDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("outsideTemperatureLabelDirtyOverride", {});
        QVariant v = qVariantFromValue<QString>(outsideTemperatureLabel);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_outsideTemperatureLabel == outsideTemperatureLabel)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setOutsideTemperatureLabel(outsideTemperatureLabel, zone());
    else
        emit outsideTemperatureLabelChanged(d->m_outsideTemperatureLabel);
}

/*!
    \property ClimateControl::zoneSynchronization
    \brief value is true if the zone synchronization is enabled.

    Which zones and properties are synchronized is controlled by the backend implementing it.
*/

/*!
    \qmlproperty bool UiClimateControl::zoneSynchronization
    \brief value is true if the zone synchronization is enabled.

    Which zones and properties are synchronized is controlled by the backend implementing it.
*/
bool ClimateControl::zoneSynchronization() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("zoneSynchronization")).value<bool>();
    return d->m_zoneSynchronization;
}

void ClimateControl::setZoneSynchronization(bool zoneSynchronization)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("zoneSynchronization");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit zoneSynchronizationChanged(d->m_propertyOverride->property(pi).value<bool>());
            return;
        }
        forceUpdate = property("zoneSynchronizationDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("zoneSynchronizationDirtyOverride", {});
        QVariant v = qVariantFromValue<bool>(zoneSynchronization);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_zoneSynchronization == zoneSynchronization)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setZoneSynchronization(zoneSynchronization, zone());
    else
        emit zoneSynchronizationChanged(d->m_zoneSynchronization);
}

/*!
    \property ClimateControl::defrost
    \brief value is true if defrost is enabled. Usually that means that the fans are on the highest level to
    remove ice from the windshield.

*/

/*!
    \qmlproperty bool UiClimateControl::defrost
    \brief value is true if defrost is enabled. Usually that means that the fans are on the highest level to
    remove ice from the windshield.

*/
bool ClimateControl::defrost() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("defrost")).value<bool>();
    return d->m_defrost;
}

void ClimateControl::setDefrost(bool defrost)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("defrost");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit defrostChanged(d->m_propertyOverride->property(pi).value<bool>());
            return;
        }
        forceUpdate = property("defrostDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("defrostDirtyOverride", {});
        QVariant v = qVariantFromValue<bool>(defrost);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_defrost == defrost)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setDefrost(defrost, zone());
    else
        emit defrostChanged(d->m_defrost);
}

/*!
    \property ClimateControl::recirculationMode
    \brief value holds the recirculation mode

*/

/*!
    \qmlproperty ClimateModule::RecirculationMode UiClimateControl::recirculationMode
    \brief value holds the recirculation mode

*/
ClimateModule::RecirculationMode ClimateControl::recirculationMode() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("recirculationMode")).value<ClimateModule::RecirculationMode>();
    return d->m_recirculationMode;
}

void ClimateControl::setRecirculationMode(ClimateModule::RecirculationMode recirculationMode)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("recirculationMode");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit recirculationModeChanged(d->m_propertyOverride->property(pi).value<ClimateModule::RecirculationMode>());
            return;
        }
        forceUpdate = property("recirculationModeDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("recirculationModeDirtyOverride", {});
        QVariant v = qVariantFromValue<ClimateModule::RecirculationMode>(recirculationMode);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_recirculationMode == recirculationMode)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setRecirculationMode(recirculationMode, zone());
    else
        emit recirculationModeChanged(d->m_recirculationMode);
}

/*!
    \property ClimateControl::recirculation
    \brief value is true if the recirculation is currently running.

*/

/*!
    \qmlproperty bool UiClimateControl::recirculation
    \brief value is true if the recirculation is currently running.

*/
bool ClimateControl::recirculation() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("recirculation")).value<bool>();
    return d->m_recirculation;
}

void ClimateControl::setRecirculation(bool recirculation)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("recirculation");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit recirculationChanged(d->m_propertyOverride->property(pi).value<bool>());
            return;
        }
        forceUpdate = property("recirculationDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("recirculationDirtyOverride", {});
        QVariant v = qVariantFromValue<bool>(recirculation);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_recirculation == recirculation)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setRecirculation(recirculation, zone());
    else
        emit recirculationChanged(d->m_recirculation);
}

/*!
    \property ClimateControl::recirculationSensitivityLevel
    \brief value holds the sensitivity level of the recirculation system when the recirculationMode is set to
    AutoRecirculation, where the level can be between minimumValue(least sensitive) to maximumValue(most
    sensitive).

*/

/*!
    \qmlproperty int UiClimateControl::recirculationSensitivityLevel
    \brief value holds the sensitivity level of the recirculation system when the recirculationMode is set to
    AutoRecirculation, where the level can be between minimumValue(least sensitive) to maximumValue(most
    sensitive).

*/
int ClimateControl::recirculationSensitivityLevel() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("recirculationSensitivityLevel")).value<int>();
    return d->m_recirculationSensitivityLevel;
}

void ClimateControl::setRecirculationSensitivityLevel(int recirculationSensitivityLevel)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("recirculationSensitivityLevel");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit recirculationSensitivityLevelChanged(d->m_propertyOverride->property(pi).value<int>());
            return;
        }
        forceUpdate = property("recirculationSensitivityLevelDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("recirculationSensitivityLevelDirtyOverride", {});
        QVariant v = qVariantFromValue<int>(recirculationSensitivityLevel);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_recirculationSensitivityLevel == recirculationSensitivityLevel)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setRecirculationSensitivityLevel(recirculationSensitivityLevel, zone());
    else
        emit recirculationSensitivityLevelChanged(d->m_recirculationSensitivityLevel);
}

/*!
    \property ClimateControl::climateMode
    \brief value holds the climate mode

*/

/*!
    \qmlproperty ClimateModule::ClimateMode UiClimateControl::climateMode
    \brief value holds the climate mode

*/
ClimateModule::ClimateMode ClimateControl::climateMode() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("climateMode")).value<ClimateModule::ClimateMode>();
    return d->m_climateMode;
}

void ClimateControl::setClimateMode(ClimateModule::ClimateMode climateMode)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("climateMode");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit climateModeChanged(d->m_propertyOverride->property(pi).value<ClimateModule::ClimateMode>());
            return;
        }
        forceUpdate = property("climateModeDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("climateModeDirtyOverride", {});
        QVariant v = qVariantFromValue<ClimateModule::ClimateMode>(climateMode);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_climateMode == climateMode)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setClimateMode(climateMode, zone());
    else
        emit climateModeChanged(d->m_climateMode);
}

/*!
    \property ClimateControl::automaticClimateFanIntensityLevel
    \brief value holds the intensity level of the fan when the climateMode is set to AutoClimate, where the
    level can be between minimumValue(least intensity) to maximumValue(most intensity).

*/

/*!
    \qmlproperty int UiClimateControl::automaticClimateFanIntensityLevel
    \brief value holds the intensity level of the fan when the climateMode is set to AutoClimate, where the
    level can be between minimumValue(least intensity) to maximumValue(most intensity).

*/
int ClimateControl::automaticClimateFanIntensityLevel() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("automaticClimateFanIntensityLevel")).value<int>();
    return d->m_automaticClimateFanIntensityLevel;
}

void ClimateControl::setAutomaticClimateFanIntensityLevel(int automaticClimateFanIntensityLevel)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("automaticClimateFanIntensityLevel");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit automaticClimateFanIntensityLevelChanged(d->m_propertyOverride->property(pi).value<int>());
            return;
        }
        forceUpdate = property("automaticClimateFanIntensityLevelDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("automaticClimateFanIntensityLevelDirtyOverride", {});
        QVariant v = qVariantFromValue<int>(automaticClimateFanIntensityLevel);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_automaticClimateFanIntensityLevel == automaticClimateFanIntensityLevel)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setAutomaticClimateFanIntensityLevel(automaticClimateFanIntensityLevel, zone());
    else
        emit automaticClimateFanIntensityLevelChanged(d->m_automaticClimateFanIntensityLevel);
}

/*!
    \property ClimateControl::airflowDirections
    \brief value holds the combination of flags indicating the areas where airflow is on.

*/

/*!
    \qmlproperty ClimateModule::AirflowDirections UiClimateControl::airflowDirections
    \brief value holds the combination of flags indicating the areas where airflow is on.

*/
ClimateModule::AirflowDirections ClimateControl::airflowDirections() const
{
    const auto d = ClimateControlPrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("airflowDirections")).value<ClimateModule::AirflowDirections>();
    return d->m_airflowDirections;
}

void ClimateControl::setAirflowDirections(ClimateModule::AirflowDirections airflowDirections)
{
    auto d = ClimateControlPrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("airflowDirections");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit airflowDirectionsChanged(d->m_propertyOverride->property(pi).value<ClimateModule::AirflowDirections>());
            return;
        }
        forceUpdate = property("airflowDirectionsDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("airflowDirectionsDirtyOverride", {});
        QVariant v = qVariantFromValue<ClimateModule::AirflowDirections>(airflowDirections);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_airflowDirections == airflowDirections)
        return;
    if (ClimateControlBackendInterface *backend = climatecontrolBackend())
        backend->setAirflowDirections(airflowDirections, zone());
    else
        emit airflowDirectionsChanged(d->m_airflowDirections);
}

/*! \internal */
QIviAbstractZonedFeature *ClimateControl::createZoneFeature(const QString &zone)
{
    return new ClimateControl(zone, this);
}

/*! \internal */
void ClimateControl::connectToServiceObject(QIviServiceObject *serviceObject)
{
    auto d = ClimateControlPrivate::get(this);

    auto *backend = climatecontrolBackend();
    if (!backend)
        return;

    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::airConditioningChanged,
        d, &ClimateControlPrivate::onAirConditioningChanged);
    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::heaterChanged,
        d, &ClimateControlPrivate::onHeaterChanged);
    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::fanSpeedLevelChanged,
        d, &ClimateControlPrivate::onFanSpeedLevelChanged);
    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::steeringWheelHeaterChanged,
        d, &ClimateControlPrivate::onSteeringWheelHeaterChanged);
    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::targetTemperatureChanged,
        d, &ClimateControlPrivate::onTargetTemperatureChanged);
    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::seatCoolerChanged,
        d, &ClimateControlPrivate::onSeatCoolerChanged);
    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::seatHeaterChanged,
        d, &ClimateControlPrivate::onSeatHeaterChanged);
    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::outsideTemperatureChanged,
        d, &ClimateControlPrivate::onOutsideTemperatureChanged);
    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::outsideTemperatureLabelChanged,
        d, &ClimateControlPrivate::onOutsideTemperatureLabelChanged);
    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::zoneSynchronizationChanged,
        d, &ClimateControlPrivate::onZoneSynchronizationChanged);
    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::defrostChanged,
        d, &ClimateControlPrivate::onDefrostChanged);
    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::recirculationModeChanged,
        d, &ClimateControlPrivate::onRecirculationModeChanged);
    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::recirculationChanged,
        d, &ClimateControlPrivate::onRecirculationChanged);
    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::recirculationSensitivityLevelChanged,
        d, &ClimateControlPrivate::onRecirculationSensitivityLevelChanged);
    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::climateModeChanged,
        d, &ClimateControlPrivate::onClimateModeChanged);
    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::automaticClimateFanIntensityLevelChanged,
        d, &ClimateControlPrivate::onAutomaticClimateFanIntensityLevelChanged);
    QObjectPrivate::connect(backend, &ClimateControlBackendInterface::airflowDirectionsChanged,
        d, &ClimateControlPrivate::onAirflowDirectionsChanged);

    QIviAbstractZonedFeature::connectToServiceObject(serviceObject);
}

/*! \internal */
void ClimateControl::clearServiceObject()
{
    auto d = ClimateControlPrivate::get(this);
    d->clearToDefaults();
    QIviAbstractZonedFeature::clearServiceObject();
}

/*! \internal */
ClimateControlBackendInterface *ClimateControl::climatecontrolBackend() const
{
    return qivi_interface_cast<ClimateControlBackendInterface*>(backend());
}


#include "moc_climatecontrol.cpp"