/****************************************************************************
** Meta object code from reading C++ file 'convolver.hpp'
**
** 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-8.2.8/src/convolver.hpp"
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'convolver.hpp' 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_ZN15ConvolverWorkerE_t {};
} // unnamed namespace

template <> constexpr inline auto ConvolverWorker::qt_create_metaobjectdata<qt_meta_tag_ZN15ConvolverWorkerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ConvolverWorker",
        "onNewKernel",
        "",
        "ConvolverKernelManager::KernelData",
        "data",
        "init_zita",
        "onNewChartMag",
        "QList<QPointF>",
        "mag_L",
        "mag_R",
        "onNewSpectrum",
        "linear_L",
        "linear_R",
        "log_L",
        "log_R",
        "onInvalidKernel",
        "name"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'onNewKernel'
        QtMocHelpers::SignalData<void(ConvolverKernelManager::KernelData, bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { QMetaType::Bool, 5 },
        }}),
        // Signal 'onNewChartMag'
        QtMocHelpers::SignalData<void(QList<QPointF>, QList<QPointF>)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 8 }, { 0x80000000 | 7, 9 },
        }}),
        // Signal 'onNewSpectrum'
        QtMocHelpers::SignalData<void(QList<QPointF>, QList<QPointF>, QList<QPointF>, QList<QPointF>)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 11 }, { 0x80000000 | 7, 12 }, { 0x80000000 | 7, 13 }, { 0x80000000 | 7, 14 },
        }}),
        // Signal 'onInvalidKernel'
        QtMocHelpers::SignalData<void(QString)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 16 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ConvolverWorker, qt_meta_tag_ZN15ConvolverWorkerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ConvolverWorker::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15ConvolverWorkerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15ConvolverWorkerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15ConvolverWorkerE_t>.metaTypes,
    nullptr
} };

void ConvolverWorker::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ConvolverWorker *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->onNewKernel((*reinterpret_cast<std::add_pointer_t<ConvolverKernelManager::KernelData>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 1: _t->onNewChartMag((*reinterpret_cast<std::add_pointer_t<QList<QPointF>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<QPointF>>>(_a[2]))); break;
        case 2: _t->onNewSpectrum((*reinterpret_cast<std::add_pointer_t<QList<QPointF>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<QPointF>>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QList<QPointF>>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QList<QPointF>>>(_a[4]))); break;
        case 3: _t->onInvalidKernel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (ConvolverWorker::*)(ConvolverKernelManager::KernelData , bool )>(_a, &ConvolverWorker::onNewKernel, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConvolverWorker::*)(QList<QPointF> , QList<QPointF> )>(_a, &ConvolverWorker::onNewChartMag, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConvolverWorker::*)(QList<QPointF> , QList<QPointF> , QList<QPointF> , QList<QPointF> )>(_a, &ConvolverWorker::onNewSpectrum, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConvolverWorker::*)(QString )>(_a, &ConvolverWorker::onInvalidKernel, 3))
            return;
    }
}

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

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

int ConvolverWorker::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 4)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 4;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 4)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 4;
    }
    return _id;
}

// SIGNAL 0
void ConvolverWorker::onNewKernel(ConvolverKernelManager::KernelData _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}

// SIGNAL 1
void ConvolverWorker::onNewChartMag(QList<QPointF> _t1, QList<QPointF> _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}

// SIGNAL 2
void ConvolverWorker::onNewSpectrum(QList<QPointF> _t1, QList<QPointF> _t2, QList<QPointF> _t3, QList<QPointF> _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 3
void ConvolverWorker::onInvalidKernel(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN9ConvolverE_t {};
} // unnamed namespace

template <> constexpr inline auto Convolver::qt_create_metaobjectdata<qt_meta_tag_ZN9ConvolverE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Convolver",
        "QML.Element",
        "BackendConvolver",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "Use the c++ instance",
        "newKernelLoaded",
        "",
        "name",
        "success",
        "kernelInitializedChanged",
        "kernelIsSofaChanged",
        "kernelRateChanged",
        "kernelSamplesChanged",
        "kernelDurationChanged",
        "kernelChannelsChanged",
        "sofaDatabaseChanged",
        "sofaMeasurementsChanged",
        "sofaIndexChanged",
        "sofaAzimuthChanged",
        "sofaElevationChanged",
        "sofaRadiusChanged",
        "sofaMinAzimuthChanged",
        "sofaMaxAzimuthChanged",
        "sofaMinElevationChanged",
        "sofaMaxElevationChanged",
        "sofaMinRadiusChanged",
        "sofaMaxRadiusChanged",
        "interpPointsChanged",
        "chartMagLChanged",
        "chartMagRChanged",
        "chartMagLfftLinearChanged",
        "chartMagRfftLinearChanged",
        "chartMagLfftLogChanged",
        "chartMagRfftLogChanged",
        "kernelCombinationStopped",
        "combineKernels",
        "kernel1",
        "kernel2",
        "outputName",
        "applySofaOrientation",
        "kernelIsInitialized",
        "kernelIsSofa",
        "kernelChannels",
        "kernelRate",
        "kernelSamples",
        "kernelDuration",
        "sofaDatabase",
        "sofaMeasurements",
        "sofaIndex",
        "sofaAzimuth",
        "sofaElevation",
        "sofaRadius",
        "sofaMinAzimuth",
        "sofaMaxAzimuth",
        "sofaMinElevation",
        "sofaMaxElevation",
        "sofaMinRadius",
        "sofaMaxRadius",
        "interpPoints",
        "chartMagL",
        "QList<QPointF>",
        "chartMagR",
        "chartMagLfftLinear",
        "chartMagRfftLinear",
        "chartMagLfftLog",
        "chartMagRfftLog"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'newKernelLoaded'
        QtMocHelpers::SignalData<void(QString, bool)>(7, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 9 }, { QMetaType::Bool, 10 },
        }}),
        // Signal 'kernelInitializedChanged'
        QtMocHelpers::SignalData<void()>(11, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'kernelIsSofaChanged'
        QtMocHelpers::SignalData<void()>(12, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'kernelRateChanged'
        QtMocHelpers::SignalData<void()>(13, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'kernelSamplesChanged'
        QtMocHelpers::SignalData<void()>(14, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'kernelDurationChanged'
        QtMocHelpers::SignalData<void()>(15, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'kernelChannelsChanged'
        QtMocHelpers::SignalData<void()>(16, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sofaDatabaseChanged'
        QtMocHelpers::SignalData<void()>(17, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sofaMeasurementsChanged'
        QtMocHelpers::SignalData<void()>(18, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sofaIndexChanged'
        QtMocHelpers::SignalData<void()>(19, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sofaAzimuthChanged'
        QtMocHelpers::SignalData<void()>(20, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sofaElevationChanged'
        QtMocHelpers::SignalData<void()>(21, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sofaRadiusChanged'
        QtMocHelpers::SignalData<void()>(22, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sofaMinAzimuthChanged'
        QtMocHelpers::SignalData<void()>(23, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sofaMaxAzimuthChanged'
        QtMocHelpers::SignalData<void()>(24, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sofaMinElevationChanged'
        QtMocHelpers::SignalData<void()>(25, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sofaMaxElevationChanged'
        QtMocHelpers::SignalData<void()>(26, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sofaMinRadiusChanged'
        QtMocHelpers::SignalData<void()>(27, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sofaMaxRadiusChanged'
        QtMocHelpers::SignalData<void()>(28, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'interpPointsChanged'
        QtMocHelpers::SignalData<void()>(29, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'chartMagLChanged'
        QtMocHelpers::SignalData<void()>(30, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'chartMagRChanged'
        QtMocHelpers::SignalData<void()>(31, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'chartMagLfftLinearChanged'
        QtMocHelpers::SignalData<void()>(32, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'chartMagRfftLinearChanged'
        QtMocHelpers::SignalData<void()>(33, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'chartMagLfftLogChanged'
        QtMocHelpers::SignalData<void()>(34, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'chartMagRfftLogChanged'
        QtMocHelpers::SignalData<void()>(35, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'kernelCombinationStopped'
        QtMocHelpers::SignalData<void()>(36, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'combineKernels'
        QtMocHelpers::MethodData<void(const QString &, const QString &, const QString &)>(37, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 38 }, { QMetaType::QString, 39 }, { QMetaType::QString, 40 },
        }}),
        // Method 'applySofaOrientation'
        QtMocHelpers::MethodData<void()>(41, 8, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'kernelIsInitialized'
        QtMocHelpers::PropertyData<bool>(42, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 1),
        // property 'kernelIsSofa'
        QtMocHelpers::PropertyData<bool>(43, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 2),
        // property 'kernelChannels'
        QtMocHelpers::PropertyData<int>(44, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable, 6),
        // property 'kernelRate'
        QtMocHelpers::PropertyData<QString>(45, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 3),
        // property 'kernelSamples'
        QtMocHelpers::PropertyData<QString>(46, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 4),
        // property 'kernelDuration'
        QtMocHelpers::PropertyData<QString>(47, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 5),
        // property 'sofaDatabase'
        QtMocHelpers::PropertyData<QString>(48, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 7),
        // property 'sofaMeasurements'
        QtMocHelpers::PropertyData<float>(49, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable, 8),
        // property 'sofaIndex'
        QtMocHelpers::PropertyData<float>(50, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable, 9),
        // property 'sofaAzimuth'
        QtMocHelpers::PropertyData<float>(51, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable, 10),
        // property 'sofaElevation'
        QtMocHelpers::PropertyData<float>(52, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable, 11),
        // property 'sofaRadius'
        QtMocHelpers::PropertyData<float>(53, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable, 12),
        // property 'sofaMinAzimuth'
        QtMocHelpers::PropertyData<float>(54, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable, 13),
        // property 'sofaMaxAzimuth'
        QtMocHelpers::PropertyData<float>(55, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable, 14),
        // property 'sofaMinElevation'
        QtMocHelpers::PropertyData<float>(56, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable, 15),
        // property 'sofaMaxElevation'
        QtMocHelpers::PropertyData<float>(57, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable, 16),
        // property 'sofaMinRadius'
        QtMocHelpers::PropertyData<float>(58, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable, 17),
        // property 'sofaMaxRadius'
        QtMocHelpers::PropertyData<float>(59, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable, 18),
        // property 'interpPoints'
        QtMocHelpers::PropertyData<int>(60, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable, 19),
        // property 'chartMagL'
        QtMocHelpers::PropertyData<QList<QPointF>>(61, 0x80000000 | 62, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 20),
        // property 'chartMagR'
        QtMocHelpers::PropertyData<QList<QPointF>>(63, 0x80000000 | 62, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 21),
        // property 'chartMagLfftLinear'
        QtMocHelpers::PropertyData<QList<QPointF>>(64, 0x80000000 | 62, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 22),
        // property 'chartMagRfftLinear'
        QtMocHelpers::PropertyData<QList<QPointF>>(65, 0x80000000 | 62, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 23),
        // property 'chartMagLfftLog'
        QtMocHelpers::PropertyData<QList<QPointF>>(66, 0x80000000 | 62, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 24),
        // property 'chartMagRfftLog'
        QtMocHelpers::PropertyData<QList<QPointF>>(67, 0x80000000 | 62, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 25),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<Convolver, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Convolver::staticMetaObject = { {
    QMetaObject::SuperData::link<PluginBase::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9ConvolverE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9ConvolverE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN9ConvolverE_t>.metaTypes,
    nullptr
} };

void Convolver::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Convolver *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->newKernelLoaded((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 1: _t->kernelInitializedChanged(); break;
        case 2: _t->kernelIsSofaChanged(); break;
        case 3: _t->kernelRateChanged(); break;
        case 4: _t->kernelSamplesChanged(); break;
        case 5: _t->kernelDurationChanged(); break;
        case 6: _t->kernelChannelsChanged(); break;
        case 7: _t->sofaDatabaseChanged(); break;
        case 8: _t->sofaMeasurementsChanged(); break;
        case 9: _t->sofaIndexChanged(); break;
        case 10: _t->sofaAzimuthChanged(); break;
        case 11: _t->sofaElevationChanged(); break;
        case 12: _t->sofaRadiusChanged(); break;
        case 13: _t->sofaMinAzimuthChanged(); break;
        case 14: _t->sofaMaxAzimuthChanged(); break;
        case 15: _t->sofaMinElevationChanged(); break;
        case 16: _t->sofaMaxElevationChanged(); break;
        case 17: _t->sofaMinRadiusChanged(); break;
        case 18: _t->sofaMaxRadiusChanged(); break;
        case 19: _t->interpPointsChanged(); break;
        case 20: _t->chartMagLChanged(); break;
        case 21: _t->chartMagRChanged(); break;
        case 22: _t->chartMagLfftLinearChanged(); break;
        case 23: _t->chartMagRfftLinearChanged(); break;
        case 24: _t->chartMagLfftLogChanged(); break;
        case 25: _t->chartMagRfftLogChanged(); break;
        case 26: _t->kernelCombinationStopped(); break;
        case 27: _t->combineKernels((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 28: _t->applySofaOrientation(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)(QString , bool )>(_a, &Convolver::newKernelLoaded, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::kernelInitializedChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::kernelIsSofaChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::kernelRateChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::kernelSamplesChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::kernelDurationChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::kernelChannelsChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::sofaDatabaseChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::sofaMeasurementsChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::sofaIndexChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::sofaAzimuthChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::sofaElevationChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::sofaRadiusChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::sofaMinAzimuthChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::sofaMaxAzimuthChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::sofaMinElevationChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::sofaMaxElevationChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::sofaMinRadiusChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::sofaMaxRadiusChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::interpPointsChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::chartMagLChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::chartMagRChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::chartMagLfftLinearChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::chartMagRfftLinearChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::chartMagLfftLogChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::chartMagRfftLogChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (Convolver::*)()>(_a, &Convolver::kernelCombinationStopped, 26))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->kernel_is_initialized; break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->kernelIsSofa; break;
        case 2: *reinterpret_cast<int*>(_v) = _t->kernelChannels; break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->kernelRate; break;
        case 4: *reinterpret_cast<QString*>(_v) = _t->kernelSamples; break;
        case 5: *reinterpret_cast<QString*>(_v) = _t->kernelDuration; break;
        case 6: *reinterpret_cast<QString*>(_v) = _t->sofaDatabase; break;
        case 7: *reinterpret_cast<float*>(_v) = _t->sofaMeasurements; break;
        case 8: *reinterpret_cast<float*>(_v) = _t->sofaIndex; break;
        case 9: *reinterpret_cast<float*>(_v) = _t->sofaAzimuth; break;
        case 10: *reinterpret_cast<float*>(_v) = _t->sofaElevation; break;
        case 11: *reinterpret_cast<float*>(_v) = _t->sofaRadius; break;
        case 12: *reinterpret_cast<float*>(_v) = _t->sofaMinAzimuth; break;
        case 13: *reinterpret_cast<float*>(_v) = _t->sofaMaxAzimuth; break;
        case 14: *reinterpret_cast<float*>(_v) = _t->sofaMinElevation; break;
        case 15: *reinterpret_cast<float*>(_v) = _t->sofaMaxElevation; break;
        case 16: *reinterpret_cast<float*>(_v) = _t->sofaMinRadius; break;
        case 17: *reinterpret_cast<float*>(_v) = _t->sofaMaxRadius; break;
        case 18: *reinterpret_cast<int*>(_v) = _t->interpPoints; break;
        case 19: *reinterpret_cast<QList<QPointF>*>(_v) = _t->chartMagL; break;
        case 20: *reinterpret_cast<QList<QPointF>*>(_v) = _t->chartMagR; break;
        case 21: *reinterpret_cast<QList<QPointF>*>(_v) = _t->chartMagLfftLinear; break;
        case 22: *reinterpret_cast<QList<QPointF>*>(_v) = _t->chartMagRfftLinear; break;
        case 23: *reinterpret_cast<QList<QPointF>*>(_v) = _t->chartMagLfftLog; break;
        case 24: *reinterpret_cast<QList<QPointF>*>(_v) = _t->chartMagRfftLog; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0:
            if (QtMocHelpers::setProperty(_t->kernel_is_initialized, *reinterpret_cast<bool*>(_v)))
                Q_EMIT _t->kernelInitializedChanged();
            break;
        case 1:
            if (QtMocHelpers::setProperty(_t->kernelIsSofa, *reinterpret_cast<bool*>(_v)))
                Q_EMIT _t->kernelIsSofaChanged();
            break;
        case 2:
            if (QtMocHelpers::setProperty(_t->kernelChannels, *reinterpret_cast<int*>(_v)))
                Q_EMIT _t->kernelChannelsChanged();
            break;
        case 3:
            if (QtMocHelpers::setProperty(_t->kernelRate, *reinterpret_cast<QString*>(_v)))
                Q_EMIT _t->kernelRateChanged();
            break;
        case 4:
            if (QtMocHelpers::setProperty(_t->kernelSamples, *reinterpret_cast<QString*>(_v)))
                Q_EMIT _t->kernelSamplesChanged();
            break;
        case 5:
            if (QtMocHelpers::setProperty(_t->kernelDuration, *reinterpret_cast<QString*>(_v)))
                Q_EMIT _t->kernelDurationChanged();
            break;
        case 6:
            if (QtMocHelpers::setProperty(_t->sofaDatabase, *reinterpret_cast<QString*>(_v)))
                Q_EMIT _t->sofaDatabaseChanged();
            break;
        case 7:
            if (QtMocHelpers::setProperty(_t->sofaMeasurements, *reinterpret_cast<float*>(_v)))
                Q_EMIT _t->sofaMeasurementsChanged();
            break;
        case 8:
            if (QtMocHelpers::setProperty(_t->sofaIndex, *reinterpret_cast<float*>(_v)))
                Q_EMIT _t->sofaIndexChanged();
            break;
        case 9:
            if (QtMocHelpers::setProperty(_t->sofaAzimuth, *reinterpret_cast<float*>(_v)))
                Q_EMIT _t->sofaAzimuthChanged();
            break;
        case 10:
            if (QtMocHelpers::setProperty(_t->sofaElevation, *reinterpret_cast<float*>(_v)))
                Q_EMIT _t->sofaElevationChanged();
            break;
        case 11:
            if (QtMocHelpers::setProperty(_t->sofaRadius, *reinterpret_cast<float*>(_v)))
                Q_EMIT _t->sofaRadiusChanged();
            break;
        case 12:
            if (QtMocHelpers::setProperty(_t->sofaMinAzimuth, *reinterpret_cast<float*>(_v)))
                Q_EMIT _t->sofaMinAzimuthChanged();
            break;
        case 13:
            if (QtMocHelpers::setProperty(_t->sofaMaxAzimuth, *reinterpret_cast<float*>(_v)))
                Q_EMIT _t->sofaMaxAzimuthChanged();
            break;
        case 14:
            if (QtMocHelpers::setProperty(_t->sofaMinElevation, *reinterpret_cast<float*>(_v)))
                Q_EMIT _t->sofaMinElevationChanged();
            break;
        case 15:
            if (QtMocHelpers::setProperty(_t->sofaMaxElevation, *reinterpret_cast<float*>(_v)))
                Q_EMIT _t->sofaMaxElevationChanged();
            break;
        case 16:
            if (QtMocHelpers::setProperty(_t->sofaMinRadius, *reinterpret_cast<float*>(_v)))
                Q_EMIT _t->sofaMinRadiusChanged();
            break;
        case 17:
            if (QtMocHelpers::setProperty(_t->sofaMaxRadius, *reinterpret_cast<float*>(_v)))
                Q_EMIT _t->sofaMaxRadiusChanged();
            break;
        case 18:
            if (QtMocHelpers::setProperty(_t->interpPoints, *reinterpret_cast<int*>(_v)))
                Q_EMIT _t->interpPointsChanged();
            break;
        case 19:
            if (QtMocHelpers::setProperty(_t->chartMagL, *reinterpret_cast<QList<QPointF>*>(_v)))
                Q_EMIT _t->chartMagLChanged();
            break;
        case 20:
            if (QtMocHelpers::setProperty(_t->chartMagR, *reinterpret_cast<QList<QPointF>*>(_v)))
                Q_EMIT _t->chartMagRChanged();
            break;
        case 21:
            if (QtMocHelpers::setProperty(_t->chartMagLfftLinear, *reinterpret_cast<QList<QPointF>*>(_v)))
                Q_EMIT _t->chartMagLfftLinearChanged();
            break;
        case 22:
            if (QtMocHelpers::setProperty(_t->chartMagRfftLinear, *reinterpret_cast<QList<QPointF>*>(_v)))
                Q_EMIT _t->chartMagRfftLinearChanged();
            break;
        case 23:
            if (QtMocHelpers::setProperty(_t->chartMagLfftLog, *reinterpret_cast<QList<QPointF>*>(_v)))
                Q_EMIT _t->chartMagLfftLogChanged();
            break;
        case 24:
            if (QtMocHelpers::setProperty(_t->chartMagRfftLog, *reinterpret_cast<QList<QPointF>*>(_v)))
                Q_EMIT _t->chartMagRfftLogChanged();
            break;
        default: break;
        }
    }
}

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

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

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

// SIGNAL 0
void Convolver::newKernelLoaded(QString _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SIGNAL 22
void Convolver::chartMagLfftLinearChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 22, nullptr);
}

// SIGNAL 23
void Convolver::chartMagRfftLinearChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 23, nullptr);
}

// SIGNAL 24
void Convolver::chartMagLfftLogChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 24, nullptr);
}

// SIGNAL 25
void Convolver::chartMagRfftLogChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 25, nullptr);
}

// SIGNAL 26
void Convolver::kernelCombinationStopped()
{
    QMetaObject::activate(this, &staticMetaObject, 26, nullptr);
}
QT_WARNING_POP
