/****************************************************************************
** Meta object code from reading C++ file 'easyeffects_db_delay.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../../easyeffects_db_delay.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'easyeffects_db_delay.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN7DbDelayE_t {};
} // unnamed namespace

template <> constexpr inline auto DbDelay::qt_create_metaobjectdata<qt_meta_tag_ZN7DbDelayE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DbDelay",
        "QML.Element",
        "auto",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "bypassChanged",
        "inputGainChanged",
        "outputGainChanged",
        "dryLChanged",
        "dryRChanged",
        "wetLChanged",
        "wetRChanged",
        "modeLLabelsChanged",
        "modeLChanged",
        "modeRLabelsChanged",
        "modeRChanged",
        "timeLChanged",
        "timeRChanged",
        "invertPhaseLChanged",
        "invertPhaseRChanged",
        "sampleLChanged",
        "sampleRChanged",
        "metersLChanged",
        "metersRChanged",
        "centimetersLChanged",
        "centimetersRChanged",
        "temperatureLChanged",
        "temperatureRChanged",
        "bypass",
        "isBypassImmutable",
        "defaultBypassValue",
        "inputGain",
        "isInputGainImmutable",
        "defaultInputGainValue",
        "outputGain",
        "isOutputGainImmutable",
        "defaultOutputGainValue",
        "dryL",
        "isDryLImmutable",
        "defaultDryLValue",
        "dryR",
        "isDryRImmutable",
        "defaultDryRValue",
        "wetL",
        "isWetLImmutable",
        "defaultWetLValue",
        "wetR",
        "isWetRImmutable",
        "defaultWetRValue",
        "modeLLabels",
        "isModeLLabelsImmutable",
        "defaultModeLLabelsValue",
        "modeL",
        "isModeLImmutable",
        "defaultModeLValue",
        "modeRLabels",
        "isModeRLabelsImmutable",
        "defaultModeRLabelsValue",
        "modeR",
        "isModeRImmutable",
        "defaultModeRValue",
        "timeL",
        "isTimeLImmutable",
        "defaultTimeLValue",
        "timeR",
        "isTimeRImmutable",
        "defaultTimeRValue",
        "invertPhaseL",
        "isInvertPhaseLImmutable",
        "defaultInvertPhaseLValue",
        "invertPhaseR",
        "isInvertPhaseRImmutable",
        "defaultInvertPhaseRValue",
        "sampleL",
        "isSampleLImmutable",
        "defaultSampleLValue",
        "sampleR",
        "isSampleRImmutable",
        "defaultSampleRValue",
        "metersL",
        "isMetersLImmutable",
        "defaultMetersLValue",
        "metersR",
        "isMetersRImmutable",
        "defaultMetersRValue",
        "centimetersL",
        "isCentimetersLImmutable",
        "defaultCentimetersLValue",
        "centimetersR",
        "isCentimetersRImmutable",
        "defaultCentimetersRValue",
        "temperatureL",
        "isTemperatureLImmutable",
        "defaultTemperatureLValue",
        "temperatureR",
        "isTemperatureRImmutable",
        "defaultTemperatureRValue"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'bypassChanged'
        QtMocHelpers::SignalData<void()>(7, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'inputGainChanged'
        QtMocHelpers::SignalData<void()>(8, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'outputGainChanged'
        QtMocHelpers::SignalData<void()>(9, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'dryLChanged'
        QtMocHelpers::SignalData<void()>(10, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'dryRChanged'
        QtMocHelpers::SignalData<void()>(11, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'wetLChanged'
        QtMocHelpers::SignalData<void()>(12, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'wetRChanged'
        QtMocHelpers::SignalData<void()>(13, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'modeLLabelsChanged'
        QtMocHelpers::SignalData<void()>(14, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'modeLChanged'
        QtMocHelpers::SignalData<void()>(15, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'modeRLabelsChanged'
        QtMocHelpers::SignalData<void()>(16, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'modeRChanged'
        QtMocHelpers::SignalData<void()>(17, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'timeLChanged'
        QtMocHelpers::SignalData<void()>(18, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'timeRChanged'
        QtMocHelpers::SignalData<void()>(19, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'invertPhaseLChanged'
        QtMocHelpers::SignalData<void()>(20, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'invertPhaseRChanged'
        QtMocHelpers::SignalData<void()>(21, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sampleLChanged'
        QtMocHelpers::SignalData<void()>(22, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sampleRChanged'
        QtMocHelpers::SignalData<void()>(23, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'metersLChanged'
        QtMocHelpers::SignalData<void()>(24, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'metersRChanged'
        QtMocHelpers::SignalData<void()>(25, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'centimetersLChanged'
        QtMocHelpers::SignalData<void()>(26, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'centimetersRChanged'
        QtMocHelpers::SignalData<void()>(27, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'temperatureLChanged'
        QtMocHelpers::SignalData<void()>(28, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'temperatureRChanged'
        QtMocHelpers::SignalData<void()>(29, 6, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'bypass'
        QtMocHelpers::PropertyData<bool>(30, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
        // property 'isBypassImmutable'
        QtMocHelpers::PropertyData<bool>(31, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultBypassValue'
        QtMocHelpers::PropertyData<bool>(32, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'inputGain'
        QtMocHelpers::PropertyData<double>(33, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'isInputGainImmutable'
        QtMocHelpers::PropertyData<bool>(34, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultInputGainValue'
        QtMocHelpers::PropertyData<double>(35, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'outputGain'
        QtMocHelpers::PropertyData<double>(36, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'isOutputGainImmutable'
        QtMocHelpers::PropertyData<bool>(37, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultOutputGainValue'
        QtMocHelpers::PropertyData<double>(38, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'dryL'
        QtMocHelpers::PropertyData<double>(39, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 3),
        // property 'isDryLImmutable'
        QtMocHelpers::PropertyData<bool>(40, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultDryLValue'
        QtMocHelpers::PropertyData<double>(41, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'dryR'
        QtMocHelpers::PropertyData<double>(42, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 4),
        // property 'isDryRImmutable'
        QtMocHelpers::PropertyData<bool>(43, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultDryRValue'
        QtMocHelpers::PropertyData<double>(44, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'wetL'
        QtMocHelpers::PropertyData<double>(45, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 5),
        // property 'isWetLImmutable'
        QtMocHelpers::PropertyData<bool>(46, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultWetLValue'
        QtMocHelpers::PropertyData<double>(47, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'wetR'
        QtMocHelpers::PropertyData<double>(48, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 6),
        // property 'isWetRImmutable'
        QtMocHelpers::PropertyData<bool>(49, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultWetRValue'
        QtMocHelpers::PropertyData<double>(50, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'modeLLabels'
        QtMocHelpers::PropertyData<QStringList>(51, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 7),
        // property 'isModeLLabelsImmutable'
        QtMocHelpers::PropertyData<bool>(52, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultModeLLabelsValue'
        QtMocHelpers::PropertyData<QStringList>(53, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'modeL'
        QtMocHelpers::PropertyData<int>(54, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 8),
        // property 'isModeLImmutable'
        QtMocHelpers::PropertyData<bool>(55, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultModeLValue'
        QtMocHelpers::PropertyData<int>(56, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'modeRLabels'
        QtMocHelpers::PropertyData<QStringList>(57, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 9),
        // property 'isModeRLabelsImmutable'
        QtMocHelpers::PropertyData<bool>(58, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultModeRLabelsValue'
        QtMocHelpers::PropertyData<QStringList>(59, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'modeR'
        QtMocHelpers::PropertyData<int>(60, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 10),
        // property 'isModeRImmutable'
        QtMocHelpers::PropertyData<bool>(61, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultModeRValue'
        QtMocHelpers::PropertyData<int>(62, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'timeL'
        QtMocHelpers::PropertyData<double>(63, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 11),
        // property 'isTimeLImmutable'
        QtMocHelpers::PropertyData<bool>(64, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultTimeLValue'
        QtMocHelpers::PropertyData<double>(65, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'timeR'
        QtMocHelpers::PropertyData<double>(66, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 12),
        // property 'isTimeRImmutable'
        QtMocHelpers::PropertyData<bool>(67, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultTimeRValue'
        QtMocHelpers::PropertyData<double>(68, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'invertPhaseL'
        QtMocHelpers::PropertyData<bool>(69, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 13),
        // property 'isInvertPhaseLImmutable'
        QtMocHelpers::PropertyData<bool>(70, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultInvertPhaseLValue'
        QtMocHelpers::PropertyData<bool>(71, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'invertPhaseR'
        QtMocHelpers::PropertyData<bool>(72, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 14),
        // property 'isInvertPhaseRImmutable'
        QtMocHelpers::PropertyData<bool>(73, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultInvertPhaseRValue'
        QtMocHelpers::PropertyData<bool>(74, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'sampleL'
        QtMocHelpers::PropertyData<double>(75, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 15),
        // property 'isSampleLImmutable'
        QtMocHelpers::PropertyData<bool>(76, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultSampleLValue'
        QtMocHelpers::PropertyData<double>(77, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'sampleR'
        QtMocHelpers::PropertyData<double>(78, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'isSampleRImmutable'
        QtMocHelpers::PropertyData<bool>(79, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultSampleRValue'
        QtMocHelpers::PropertyData<double>(80, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'metersL'
        QtMocHelpers::PropertyData<double>(81, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 17),
        // property 'isMetersLImmutable'
        QtMocHelpers::PropertyData<bool>(82, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultMetersLValue'
        QtMocHelpers::PropertyData<double>(83, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'metersR'
        QtMocHelpers::PropertyData<double>(84, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 18),
        // property 'isMetersRImmutable'
        QtMocHelpers::PropertyData<bool>(85, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultMetersRValue'
        QtMocHelpers::PropertyData<double>(86, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'centimetersL'
        QtMocHelpers::PropertyData<double>(87, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 19),
        // property 'isCentimetersLImmutable'
        QtMocHelpers::PropertyData<bool>(88, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultCentimetersLValue'
        QtMocHelpers::PropertyData<double>(89, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'centimetersR'
        QtMocHelpers::PropertyData<double>(90, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 20),
        // property 'isCentimetersRImmutable'
        QtMocHelpers::PropertyData<bool>(91, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultCentimetersRValue'
        QtMocHelpers::PropertyData<double>(92, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'temperatureL'
        QtMocHelpers::PropertyData<double>(93, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 21),
        // property 'isTemperatureLImmutable'
        QtMocHelpers::PropertyData<bool>(94, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultTemperatureLValue'
        QtMocHelpers::PropertyData<double>(95, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'temperatureR'
        QtMocHelpers::PropertyData<double>(96, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 22),
        // property 'isTemperatureRImmutable'
        QtMocHelpers::PropertyData<bool>(97, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultTemperatureRValue'
        QtMocHelpers::PropertyData<double>(98, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<DbDelay, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject DbDelay::staticMetaObject = { {
    QMetaObject::SuperData::link<KConfigBaseEE::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7DbDelayE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7DbDelayE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN7DbDelayE_t>.metaTypes,
    nullptr
} };

void DbDelay::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DbDelay *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->bypassChanged(); break;
        case 1: _t->inputGainChanged(); break;
        case 2: _t->outputGainChanged(); break;
        case 3: _t->dryLChanged(); break;
        case 4: _t->dryRChanged(); break;
        case 5: _t->wetLChanged(); break;
        case 6: _t->wetRChanged(); break;
        case 7: _t->modeLLabelsChanged(); break;
        case 8: _t->modeLChanged(); break;
        case 9: _t->modeRLabelsChanged(); break;
        case 10: _t->modeRChanged(); break;
        case 11: _t->timeLChanged(); break;
        case 12: _t->timeRChanged(); break;
        case 13: _t->invertPhaseLChanged(); break;
        case 14: _t->invertPhaseRChanged(); break;
        case 15: _t->sampleLChanged(); break;
        case 16: _t->sampleRChanged(); break;
        case 17: _t->metersLChanged(); break;
        case 18: _t->metersRChanged(); break;
        case 19: _t->centimetersLChanged(); break;
        case 20: _t->centimetersRChanged(); break;
        case 21: _t->temperatureLChanged(); break;
        case 22: _t->temperatureRChanged(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::bypassChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::inputGainChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::outputGainChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::dryLChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::dryRChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::wetLChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::wetRChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::modeLLabelsChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::modeLChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::modeRLabelsChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::modeRChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::timeLChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::timeRChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::invertPhaseLChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::invertPhaseRChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::sampleLChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::sampleRChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::metersLChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::metersRChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::centimetersLChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::centimetersRChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::temperatureLChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (DbDelay::*)()>(_a, &DbDelay::temperatureRChanged, 22))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->bypass(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->isBypassImmutable(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->defaultBypassValue(); break;
        case 3: *reinterpret_cast<double*>(_v) = _t->inputGain(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->isInputGainImmutable(); break;
        case 5: *reinterpret_cast<double*>(_v) = _t->defaultInputGainValue(); break;
        case 6: *reinterpret_cast<double*>(_v) = _t->outputGain(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->isOutputGainImmutable(); break;
        case 8: *reinterpret_cast<double*>(_v) = _t->defaultOutputGainValue(); break;
        case 9: *reinterpret_cast<double*>(_v) = _t->dryL(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->isDryLImmutable(); break;
        case 11: *reinterpret_cast<double*>(_v) = _t->defaultDryLValue(); break;
        case 12: *reinterpret_cast<double*>(_v) = _t->dryR(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->isDryRImmutable(); break;
        case 14: *reinterpret_cast<double*>(_v) = _t->defaultDryRValue(); break;
        case 15: *reinterpret_cast<double*>(_v) = _t->wetL(); break;
        case 16: *reinterpret_cast<bool*>(_v) = _t->isWetLImmutable(); break;
        case 17: *reinterpret_cast<double*>(_v) = _t->defaultWetLValue(); break;
        case 18: *reinterpret_cast<double*>(_v) = _t->wetR(); break;
        case 19: *reinterpret_cast<bool*>(_v) = _t->isWetRImmutable(); break;
        case 20: *reinterpret_cast<double*>(_v) = _t->defaultWetRValue(); break;
        case 21: *reinterpret_cast<QStringList*>(_v) = _t->modeLLabels(); break;
        case 22: *reinterpret_cast<bool*>(_v) = _t->isModeLLabelsImmutable(); break;
        case 23: *reinterpret_cast<QStringList*>(_v) = _t->defaultModeLLabelsValue(); break;
        case 24: *reinterpret_cast<int*>(_v) = _t->modeL(); break;
        case 25: *reinterpret_cast<bool*>(_v) = _t->isModeLImmutable(); break;
        case 26: *reinterpret_cast<int*>(_v) = _t->defaultModeLValue(); break;
        case 27: *reinterpret_cast<QStringList*>(_v) = _t->modeRLabels(); break;
        case 28: *reinterpret_cast<bool*>(_v) = _t->isModeRLabelsImmutable(); break;
        case 29: *reinterpret_cast<QStringList*>(_v) = _t->defaultModeRLabelsValue(); break;
        case 30: *reinterpret_cast<int*>(_v) = _t->modeR(); break;
        case 31: *reinterpret_cast<bool*>(_v) = _t->isModeRImmutable(); break;
        case 32: *reinterpret_cast<int*>(_v) = _t->defaultModeRValue(); break;
        case 33: *reinterpret_cast<double*>(_v) = _t->timeL(); break;
        case 34: *reinterpret_cast<bool*>(_v) = _t->isTimeLImmutable(); break;
        case 35: *reinterpret_cast<double*>(_v) = _t->defaultTimeLValue(); break;
        case 36: *reinterpret_cast<double*>(_v) = _t->timeR(); break;
        case 37: *reinterpret_cast<bool*>(_v) = _t->isTimeRImmutable(); break;
        case 38: *reinterpret_cast<double*>(_v) = _t->defaultTimeRValue(); break;
        case 39: *reinterpret_cast<bool*>(_v) = _t->invertPhaseL(); break;
        case 40: *reinterpret_cast<bool*>(_v) = _t->isInvertPhaseLImmutable(); break;
        case 41: *reinterpret_cast<bool*>(_v) = _t->defaultInvertPhaseLValue(); break;
        case 42: *reinterpret_cast<bool*>(_v) = _t->invertPhaseR(); break;
        case 43: *reinterpret_cast<bool*>(_v) = _t->isInvertPhaseRImmutable(); break;
        case 44: *reinterpret_cast<bool*>(_v) = _t->defaultInvertPhaseRValue(); break;
        case 45: *reinterpret_cast<double*>(_v) = _t->sampleL(); break;
        case 46: *reinterpret_cast<bool*>(_v) = _t->isSampleLImmutable(); break;
        case 47: *reinterpret_cast<double*>(_v) = _t->defaultSampleLValue(); break;
        case 48: *reinterpret_cast<double*>(_v) = _t->sampleR(); break;
        case 49: *reinterpret_cast<bool*>(_v) = _t->isSampleRImmutable(); break;
        case 50: *reinterpret_cast<double*>(_v) = _t->defaultSampleRValue(); break;
        case 51: *reinterpret_cast<double*>(_v) = _t->metersL(); break;
        case 52: *reinterpret_cast<bool*>(_v) = _t->isMetersLImmutable(); break;
        case 53: *reinterpret_cast<double*>(_v) = _t->defaultMetersLValue(); break;
        case 54: *reinterpret_cast<double*>(_v) = _t->metersR(); break;
        case 55: *reinterpret_cast<bool*>(_v) = _t->isMetersRImmutable(); break;
        case 56: *reinterpret_cast<double*>(_v) = _t->defaultMetersRValue(); break;
        case 57: *reinterpret_cast<double*>(_v) = _t->centimetersL(); break;
        case 58: *reinterpret_cast<bool*>(_v) = _t->isCentimetersLImmutable(); break;
        case 59: *reinterpret_cast<double*>(_v) = _t->defaultCentimetersLValue(); break;
        case 60: *reinterpret_cast<double*>(_v) = _t->centimetersR(); break;
        case 61: *reinterpret_cast<bool*>(_v) = _t->isCentimetersRImmutable(); break;
        case 62: *reinterpret_cast<double*>(_v) = _t->defaultCentimetersRValue(); break;
        case 63: *reinterpret_cast<double*>(_v) = _t->temperatureL(); break;
        case 64: *reinterpret_cast<bool*>(_v) = _t->isTemperatureLImmutable(); break;
        case 65: *reinterpret_cast<double*>(_v) = _t->defaultTemperatureLValue(); break;
        case 66: *reinterpret_cast<double*>(_v) = _t->temperatureR(); break;
        case 67: *reinterpret_cast<bool*>(_v) = _t->isTemperatureRImmutable(); break;
        case 68: *reinterpret_cast<double*>(_v) = _t->defaultTemperatureRValue(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setBypass(*reinterpret_cast<bool*>(_v)); break;
        case 3: _t->setInputGain(*reinterpret_cast<double*>(_v)); break;
        case 6: _t->setOutputGain(*reinterpret_cast<double*>(_v)); break;
        case 9: _t->setDryL(*reinterpret_cast<double*>(_v)); break;
        case 12: _t->setDryR(*reinterpret_cast<double*>(_v)); break;
        case 15: _t->setWetL(*reinterpret_cast<double*>(_v)); break;
        case 18: _t->setWetR(*reinterpret_cast<double*>(_v)); break;
        case 21: _t->setModeLLabels(*reinterpret_cast<QStringList*>(_v)); break;
        case 24: _t->setModeL(*reinterpret_cast<int*>(_v)); break;
        case 27: _t->setModeRLabels(*reinterpret_cast<QStringList*>(_v)); break;
        case 30: _t->setModeR(*reinterpret_cast<int*>(_v)); break;
        case 33: _t->setTimeL(*reinterpret_cast<double*>(_v)); break;
        case 36: _t->setTimeR(*reinterpret_cast<double*>(_v)); break;
        case 39: _t->setInvertPhaseL(*reinterpret_cast<bool*>(_v)); break;
        case 42: _t->setInvertPhaseR(*reinterpret_cast<bool*>(_v)); break;
        case 45: _t->setSampleL(*reinterpret_cast<double*>(_v)); break;
        case 48: _t->setSampleR(*reinterpret_cast<double*>(_v)); break;
        case 51: _t->setMetersL(*reinterpret_cast<double*>(_v)); break;
        case 54: _t->setMetersR(*reinterpret_cast<double*>(_v)); break;
        case 57: _t->setCentimetersL(*reinterpret_cast<double*>(_v)); break;
        case 60: _t->setCentimetersR(*reinterpret_cast<double*>(_v)); break;
        case 63: _t->setTemperatureL(*reinterpret_cast<double*>(_v)); break;
        case 66: _t->setTemperatureR(*reinterpret_cast<double*>(_v)); break;
        default: break;
        }
    }
}

const QMetaObject *DbDelay::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *DbDelay::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7DbDelayE_t>.strings))
        return static_cast<void*>(this);
    return KConfigBaseEE::qt_metacast(_clname);
}

int DbDelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KConfigBaseEE::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 23)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 23;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 23)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 23;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 69;
    }
    return _id;
}

// SIGNAL 0
void DbDelay::bypassChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void DbDelay::inputGainChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void DbDelay::outputGainChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void DbDelay::dryLChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void DbDelay::dryRChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void DbDelay::wetLChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

// SIGNAL 6
void DbDelay::wetRChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void DbDelay::modeLLabelsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void DbDelay::modeLChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void DbDelay::modeRLabelsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
}

// SIGNAL 10
void DbDelay::modeRChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}

// SIGNAL 11
void DbDelay::timeLChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 11, nullptr);
}

// SIGNAL 12
void DbDelay::timeRChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
}

// SIGNAL 13
void DbDelay::invertPhaseLChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}

// SIGNAL 14
void DbDelay::invertPhaseRChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 14, nullptr);
}

// SIGNAL 15
void DbDelay::sampleLChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
}

// SIGNAL 16
void DbDelay::sampleRChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

// SIGNAL 17
void DbDelay::metersLChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
}

// SIGNAL 18
void DbDelay::metersRChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 18, nullptr);
}

// SIGNAL 19
void DbDelay::centimetersLChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 19, nullptr);
}

// SIGNAL 20
void DbDelay::centimetersRChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 20, nullptr);
}

// SIGNAL 21
void DbDelay::temperatureLChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 21, nullptr);
}

// SIGNAL 22
void DbDelay::temperatureRChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 22, nullptr);
}
QT_WARNING_POP
