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

#include "../../../../../dde-control-center/src/plugin-sound/operation/soundmodel.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 'soundmodel.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.2. 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_ZN10SoundModelE_t {};
} // unnamed namespace

template <> constexpr inline auto SoundModel::qt_create_metaobjectdata<qt_meta_tag_ZN10SoundModelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "SoundModel",
        "QML.Element",
        "QML.Singleton",
        "true",
        "speakerOnChanged",
        "",
        "speakerOn",
        "microphoneOnChanged",
        "microphoneOn",
        "soundEffectOnChanged",
        "soundEffectOn",
        "speakerVolumeChanged",
        "speakerVolume",
        "speakerBalanceChanged",
        "speakerBalance",
        "microphoneVolumeChanged",
        "microphoneVolume",
        "defaultSourceChanged",
        "QDBusObjectPath",
        "defaultSource",
        "defaultSinkChanged",
        "defaultSink",
        "audioCardsChanged",
        "audioCards",
        "maxUIVolumeChanged",
        "value",
        "increaseVolumeChanged",
        "reduceNoiseChanged",
        "reduceNoise",
        "pausePlayerChanged",
        "pausePlayer",
        "isPortEnableChanged",
        "enable",
        "bluetoothModeOptsChanged",
        "modeOpts",
        "bluetoothModeChanged",
        "mode",
        "setPortChanged",
        "Port*",
        "port",
        "outPutPortComboChanged",
        "outPutPort",
        "requestSwitchEnable",
        "cardId",
        "cardName",
        "inputDevicesVisibleChanged",
        "name",
        "flag",
        "outputDevicesVisibleChanged",
        "onSetAudioServerFinish",
        "curAudioServerChanged",
        "audioFrame",
        "microphoneFeedbackChanged",
        "microphoneFeedback",
        "portAdded",
        "const Port*",
        "portRemoved",
        "portId",
        "Port::Direction",
        "direction",
        "soundDeviceStatusChanged",
        "soundEffectDataChanged",
        "DDesktopServices::SystemSoundEffect",
        "effect",
        "enableSoundEffectChanged",
        "enableSoundEffect",
        "isLaptopChanged",
        "isLaptop",
        "outPutPortComboIndexChanged",
        "inPutPortComboChanged",
        "inPutPortComboIndexChanged",
        "soundEffectsModelChanged",
        "inPutPortCountChanged",
        "outPutCountChanged",
        "playAniIconPathChanged",
        "audioMonoChanged",
        "showBluetoothModeChanged",
        "outPutPortComboEnableChanged",
        "inPutPortComboEnableChanged",
        "showInputBluetoothModeChanged",
        "soundEffectsModel",
        "SoundEffectsModel*",
        "getListName",
        "index",
        "getSoundEffectsRowCount",
        "soundInputDeviceModel",
        "SoundDeviceModel*",
        "soundOutputDeviceModel",
        "getDeviceManagerRowCount",
        "portType",
        "audioServerModel",
        "AudioServerModel*",
        "increaseVolume",
        "outPutPortCombo",
        "outPutPortComboIndex",
        "inPutPortCombo",
        "inPutPortComboIndex",
        "inPutPortCount",
        "outPutCount",
        "audioServerStatus",
        "audioServer",
        "audioMono",
        "bluetoothModeOpts",
        "currentBluetoothAudioMode",
        "showBluetoothMode",
        "showInputBluetoothMode",
        "outPutPortComboEnable",
        "inPutPortComboEnable"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'speakerOnChanged'
        QtMocHelpers::SignalData<void(bool) const>(4, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 6 },
        }}),
        // Signal 'microphoneOnChanged'
        QtMocHelpers::SignalData<void(bool) const>(7, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 8 },
        }}),
        // Signal 'soundEffectOnChanged'
        QtMocHelpers::SignalData<void(bool) const>(9, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 10 },
        }}),
        // Signal 'speakerVolumeChanged'
        QtMocHelpers::SignalData<void(double) const>(11, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 12 },
        }}),
        // Signal 'speakerBalanceChanged'
        QtMocHelpers::SignalData<void(double) const>(13, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 14 },
        }}),
        // Signal 'microphoneVolumeChanged'
        QtMocHelpers::SignalData<void(double) const>(15, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 16 },
        }}),
        // Signal 'defaultSourceChanged'
        QtMocHelpers::SignalData<void(const QDBusObjectPath &) const>(17, 5, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 19 },
        }}),
        // Signal 'defaultSinkChanged'
        QtMocHelpers::SignalData<void(const QDBusObjectPath &) const>(20, 5, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 21 },
        }}),
        // Signal 'audioCardsChanged'
        QtMocHelpers::SignalData<void(const QString &) const>(22, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 23 },
        }}),
        // Signal 'maxUIVolumeChanged'
        QtMocHelpers::SignalData<void(double) const>(24, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 25 },
        }}),
        // Signal 'increaseVolumeChanged'
        QtMocHelpers::SignalData<void(bool) const>(26, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 25 },
        }}),
        // Signal 'reduceNoiseChanged'
        QtMocHelpers::SignalData<void(bool) const>(27, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 28 },
        }}),
        // Signal 'pausePlayerChanged'
        QtMocHelpers::SignalData<void(bool) const>(29, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 30 },
        }}),
        // Signal 'isPortEnableChanged'
        QtMocHelpers::SignalData<void(bool) const>(31, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 32 },
        }}),
        // Signal 'bluetoothModeOptsChanged'
        QtMocHelpers::SignalData<void(const QStringList &) const>(33, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 34 },
        }}),
        // Signal 'bluetoothModeChanged'
        QtMocHelpers::SignalData<void(const QString &)>(35, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 36 },
        }}),
        // Signal 'setPortChanged'
        QtMocHelpers::SignalData<void(Port *) const>(37, 5, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 38, 39 },
        }}),
        // Signal 'outPutPortComboChanged'
        QtMocHelpers::SignalData<void(const QStringList &) const>(40, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 41 },
        }}),
        // Signal 'requestSwitchEnable'
        QtMocHelpers::SignalData<void(unsigned int, QString)>(42, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 43 }, { QMetaType::QString, 44 },
        }}),
        // Signal 'inputDevicesVisibleChanged'
        QtMocHelpers::SignalData<void(QString, bool)>(45, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 46 }, { QMetaType::Bool, 47 },
        }}),
        // Signal 'outputDevicesVisibleChanged'
        QtMocHelpers::SignalData<void(QString, bool)>(48, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 46 }, { QMetaType::Bool, 47 },
        }}),
        // Signal 'onSetAudioServerFinish'
        QtMocHelpers::SignalData<void(bool)>(49, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 25 },
        }}),
        // Signal 'curAudioServerChanged'
        QtMocHelpers::SignalData<void(const QString &)>(50, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 51 },
        }}),
        // Signal 'microphoneFeedbackChanged'
        QtMocHelpers::SignalData<void(double) const>(52, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 53 },
        }}),
        // Signal 'portAdded'
        QtMocHelpers::SignalData<void(const Port *)>(54, 5, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 55, 39 },
        }}),
        // Signal 'portRemoved'
        QtMocHelpers::SignalData<void(const QString &, const uint &, const Port::Direction &)>(56, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 57 }, { QMetaType::UInt, 43 }, { 0x80000000 | 58, 59 },
        }}),
        // Signal 'soundDeviceStatusChanged'
        QtMocHelpers::SignalData<void()>(60, 5, QMC::AccessPublic, QMetaType::Void),
        // Signal 'soundEffectDataChanged'
        QtMocHelpers::SignalData<void(DDesktopServices::SystemSoundEffect, const bool)>(61, 5, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 62, 63 }, { QMetaType::Bool, 32 },
        }}),
        // Signal 'enableSoundEffectChanged'
        QtMocHelpers::SignalData<void(bool)>(64, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 65 },
        }}),
        // Signal 'isLaptopChanged'
        QtMocHelpers::SignalData<void(bool)>(66, 5, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 67 },
        }}),
        // Signal 'outPutPortComboIndexChanged'
        QtMocHelpers::SignalData<void()>(68, 5, QMC::AccessPublic, QMetaType::Void),
        // Signal 'inPutPortComboChanged'
        QtMocHelpers::SignalData<void()>(69, 5, QMC::AccessPublic, QMetaType::Void),
        // Signal 'inPutPortComboIndexChanged'
        QtMocHelpers::SignalData<void()>(70, 5, QMC::AccessPublic, QMetaType::Void),
        // Signal 'soundEffectsModelChanged'
        QtMocHelpers::SignalData<void()>(71, 5, QMC::AccessPublic, QMetaType::Void),
        // Signal 'inPutPortCountChanged'
        QtMocHelpers::SignalData<void()>(72, 5, QMC::AccessPublic, QMetaType::Void),
        // Signal 'outPutCountChanged'
        QtMocHelpers::SignalData<void()>(73, 5, QMC::AccessPublic, QMetaType::Void),
        // Signal 'playAniIconPathChanged'
        QtMocHelpers::SignalData<void()>(74, 5, QMC::AccessPublic, QMetaType::Void),
        // Signal 'audioMonoChanged'
        QtMocHelpers::SignalData<void()>(75, 5, QMC::AccessPublic, QMetaType::Void),
        // Signal 'showBluetoothModeChanged'
        QtMocHelpers::SignalData<void()>(76, 5, QMC::AccessPublic, QMetaType::Void),
        // Signal 'outPutPortComboEnableChanged'
        QtMocHelpers::SignalData<void()>(77, 5, QMC::AccessPublic, QMetaType::Void),
        // Signal 'inPutPortComboEnableChanged'
        QtMocHelpers::SignalData<void()>(78, 5, QMC::AccessPublic, QMetaType::Void),
        // Signal 'showInputBluetoothModeChanged'
        QtMocHelpers::SignalData<void()>(79, 5, QMC::AccessPublic, QMetaType::Void),
        // Method 'soundEffectsModel'
        QtMocHelpers::MethodData<SoundEffectsModel *() const>(80, 5, QMC::AccessPublic, 0x80000000 | 81),
        // Method 'getListName'
        QtMocHelpers::MethodData<QString(int) const>(82, 5, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::Int, 83 },
        }}),
        // Method 'getSoundEffectsRowCount'
        QtMocHelpers::MethodData<int() const>(84, 5, QMC::AccessPublic, QMetaType::Int),
        // Method 'soundInputDeviceModel'
        QtMocHelpers::MethodData<SoundDeviceModel *() const>(85, 5, QMC::AccessPublic, 0x80000000 | 86),
        // Method 'soundOutputDeviceModel'
        QtMocHelpers::MethodData<SoundDeviceModel *() const>(87, 5, QMC::AccessPublic, 0x80000000 | 86),
        // Method 'getDeviceManagerRowCount'
        QtMocHelpers::MethodData<int(int) const>(88, 5, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 89 },
        }}),
        // Method 'audioServerModel'
        QtMocHelpers::MethodData<AudioServerModel *() const>(90, 5, QMC::AccessPublic, 0x80000000 | 91),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'speakerVolume'
        QtMocHelpers::PropertyData<double>(12, QMetaType::Double, QMC::DefaultPropertyFlags, 3),
        // property 'increaseVolume'
        QtMocHelpers::PropertyData<bool>(92, QMetaType::Bool, QMC::DefaultPropertyFlags, 10),
        // property 'speakerBalance'
        QtMocHelpers::PropertyData<double>(14, QMetaType::Double, QMC::DefaultPropertyFlags, 4),
        // property 'outPutPortCombo'
        QtMocHelpers::PropertyData<QStringList>(93, QMetaType::QStringList, QMC::DefaultPropertyFlags, 17),
        // property 'pausePlayer'
        QtMocHelpers::PropertyData<bool>(30, QMetaType::Bool, QMC::DefaultPropertyFlags, 12),
        // property 'microphoneVolume'
        QtMocHelpers::PropertyData<double>(16, QMetaType::Double, QMC::DefaultPropertyFlags, 5),
        // property 'reduceNoise'
        QtMocHelpers::PropertyData<bool>(28, QMetaType::Bool, QMC::DefaultPropertyFlags, 11),
        // property 'outPutPortComboIndex'
        QtMocHelpers::PropertyData<int>(94, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Final, 30),
        // property 'microphoneFeedback'
        QtMocHelpers::PropertyData<double>(53, QMetaType::Double, QMC::DefaultPropertyFlags, 23),
        // property 'enableSoundEffect'
        QtMocHelpers::PropertyData<bool>(65, QMetaType::Bool, QMC::DefaultPropertyFlags, 28),
        // property 'inPutPortCombo'
        QtMocHelpers::PropertyData<QStringList>(95, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final, 31),
        // property 'inPutPortComboIndex'
        QtMocHelpers::PropertyData<int>(96, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final, 32),
        // property 'inPutPortCount'
        QtMocHelpers::PropertyData<int>(97, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Final, 34),
        // property 'outPutCount'
        QtMocHelpers::PropertyData<int>(98, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Final, 35),
        // property 'audioServerStatus'
        QtMocHelpers::PropertyData<bool>(99, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Final, 21),
        // property 'audioServer'
        QtMocHelpers::PropertyData<QString>(100, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Final, 22),
        // property 'audioMono'
        QtMocHelpers::PropertyData<bool>(101, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Final, 37),
        // property 'bluetoothModeOpts'
        QtMocHelpers::PropertyData<QStringList>(102, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Final, 14),
        // property 'currentBluetoothAudioMode'
        QtMocHelpers::PropertyData<QString>(103, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Final, 15),
        // property 'showBluetoothMode'
        QtMocHelpers::PropertyData<bool>(104, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Final, 38),
        // property 'showInputBluetoothMode'
        QtMocHelpers::PropertyData<bool>(105, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Final, 41),
        // property 'outPutPortComboEnable'
        QtMocHelpers::PropertyData<bool>(106, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Final, 39),
        // property 'inPutPortComboEnable'
        QtMocHelpers::PropertyData<bool>(107, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Final, 40),
        // property 'speakerOn'
        QtMocHelpers::PropertyData<bool>(6, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Final, 0),
        // property 'microphoneOn'
        QtMocHelpers::PropertyData<bool>(8, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Final, 1),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    0 },
            {    2,    3 },
    });
    return QtMocHelpers::metaObjectData<SoundModel, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject SoundModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10SoundModelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10SoundModelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN10SoundModelE_t>.metaTypes,
    nullptr
} };

void SoundModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<SoundModel *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->speakerOnChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 1: _t->microphoneOnChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 2: _t->soundEffectOnChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 3: _t->speakerVolumeChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 4: _t->speakerBalanceChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 5: _t->microphoneVolumeChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 6: _t->defaultSourceChanged((*reinterpret_cast<std::add_pointer_t<QDBusObjectPath>>(_a[1]))); break;
        case 7: _t->defaultSinkChanged((*reinterpret_cast<std::add_pointer_t<QDBusObjectPath>>(_a[1]))); break;
        case 8: _t->audioCardsChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 9: _t->maxUIVolumeChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 10: _t->increaseVolumeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 11: _t->reduceNoiseChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 12: _t->pausePlayerChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 13: _t->isPortEnableChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 14: _t->bluetoothModeOptsChanged((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 15: _t->bluetoothModeChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 16: _t->setPortChanged((*reinterpret_cast<std::add_pointer_t<Port*>>(_a[1]))); break;
        case 17: _t->outPutPortComboChanged((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 18: _t->requestSwitchEnable((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 19: _t->inputDevicesVisibleChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 20: _t->outputDevicesVisibleChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 21: _t->onSetAudioServerFinish((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 22: _t->curAudioServerChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 23: _t->microphoneFeedbackChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 24: _t->portAdded((*reinterpret_cast<std::add_pointer_t<const Port*>>(_a[1]))); break;
        case 25: _t->portRemoved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<uint>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<Port::Direction>>(_a[3]))); break;
        case 26: _t->soundDeviceStatusChanged(); break;
        case 27: _t->soundEffectDataChanged((*reinterpret_cast<std::add_pointer_t<DDesktopServices::SystemSoundEffect>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 28: _t->enableSoundEffectChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 29: _t->isLaptopChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 30: _t->outPutPortComboIndexChanged(); break;
        case 31: _t->inPutPortComboChanged(); break;
        case 32: _t->inPutPortComboIndexChanged(); break;
        case 33: _t->soundEffectsModelChanged(); break;
        case 34: _t->inPutPortCountChanged(); break;
        case 35: _t->outPutCountChanged(); break;
        case 36: _t->playAniIconPathChanged(); break;
        case 37: _t->audioMonoChanged(); break;
        case 38: _t->showBluetoothModeChanged(); break;
        case 39: _t->outPutPortComboEnableChanged(); break;
        case 40: _t->inPutPortComboEnableChanged(); break;
        case 41: _t->showInputBluetoothModeChanged(); break;
        case 42: { SoundEffectsModel* _r = _t->soundEffectsModel();
            if (_a[0]) *reinterpret_cast<SoundEffectsModel**>(_a[0]) = std::move(_r); }  break;
        case 43: { QString _r = _t->getListName((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 44: { int _r = _t->getSoundEffectsRowCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 45: { SoundDeviceModel* _r = _t->soundInputDeviceModel();
            if (_a[0]) *reinterpret_cast<SoundDeviceModel**>(_a[0]) = std::move(_r); }  break;
        case 46: { SoundDeviceModel* _r = _t->soundOutputDeviceModel();
            if (_a[0]) *reinterpret_cast<SoundDeviceModel**>(_a[0]) = std::move(_r); }  break;
        case 47: { int _r = _t->getDeviceManagerRowCount((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 48: { AudioServerModel* _r = _t->audioServerModel();
            if (_a[0]) *reinterpret_cast<AudioServerModel**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 6:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusObjectPath >(); break;
            }
            break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusObjectPath >(); break;
            }
            break;
        case 16:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Port* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(bool ) const>(_a, &SoundModel::speakerOnChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(bool ) const>(_a, &SoundModel::microphoneOnChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(bool ) const>(_a, &SoundModel::soundEffectOnChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(double ) const>(_a, &SoundModel::speakerVolumeChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(double ) const>(_a, &SoundModel::speakerBalanceChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(double ) const>(_a, &SoundModel::microphoneVolumeChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(const QDBusObjectPath & ) const>(_a, &SoundModel::defaultSourceChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(const QDBusObjectPath & ) const>(_a, &SoundModel::defaultSinkChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(const QString & ) const>(_a, &SoundModel::audioCardsChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(double ) const>(_a, &SoundModel::maxUIVolumeChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(bool ) const>(_a, &SoundModel::increaseVolumeChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(bool ) const>(_a, &SoundModel::reduceNoiseChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(bool ) const>(_a, &SoundModel::pausePlayerChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(bool ) const>(_a, &SoundModel::isPortEnableChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(const QStringList & ) const>(_a, &SoundModel::bluetoothModeOptsChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(const QString & )>(_a, &SoundModel::bluetoothModeChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(Port * ) const>(_a, &SoundModel::setPortChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(const QStringList & ) const>(_a, &SoundModel::outPutPortComboChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(unsigned int , QString )>(_a, &SoundModel::requestSwitchEnable, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(QString , bool )>(_a, &SoundModel::inputDevicesVisibleChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(QString , bool )>(_a, &SoundModel::outputDevicesVisibleChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(bool )>(_a, &SoundModel::onSetAudioServerFinish, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(const QString & )>(_a, &SoundModel::curAudioServerChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(double ) const>(_a, &SoundModel::microphoneFeedbackChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(const Port * )>(_a, &SoundModel::portAdded, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(const QString & , const uint & , const Port::Direction & )>(_a, &SoundModel::portRemoved, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)()>(_a, &SoundModel::soundDeviceStatusChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(DDesktopServices::SystemSoundEffect , const bool )>(_a, &SoundModel::soundEffectDataChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(bool )>(_a, &SoundModel::enableSoundEffectChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)(bool )>(_a, &SoundModel::isLaptopChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)()>(_a, &SoundModel::outPutPortComboIndexChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)()>(_a, &SoundModel::inPutPortComboChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)()>(_a, &SoundModel::inPutPortComboIndexChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)()>(_a, &SoundModel::soundEffectsModelChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)()>(_a, &SoundModel::inPutPortCountChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)()>(_a, &SoundModel::outPutCountChanged, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)()>(_a, &SoundModel::playAniIconPathChanged, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)()>(_a, &SoundModel::audioMonoChanged, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)()>(_a, &SoundModel::showBluetoothModeChanged, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)()>(_a, &SoundModel::outPutPortComboEnableChanged, 39))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)()>(_a, &SoundModel::inPutPortComboEnableChanged, 40))
            return;
        if (QtMocHelpers::indexOfMethod<void (SoundModel::*)()>(_a, &SoundModel::showInputBluetoothModeChanged, 41))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<double*>(_v) = _t->speakerVolume(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->isIncreaseVolume(); break;
        case 2: *reinterpret_cast<double*>(_v) = _t->speakerBalance(); break;
        case 3: *reinterpret_cast<QStringList*>(_v) = _t->outPutPortCombo(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->pausePlayer(); break;
        case 5: *reinterpret_cast<double*>(_v) = _t->microphoneVolume(); break;
        case 6: *reinterpret_cast<bool*>(_v) = _t->reduceNoise(); break;
        case 7: *reinterpret_cast<int*>(_v) = _t->outPutPortComboIndex(); break;
        case 8: *reinterpret_cast<double*>(_v) = _t->microphoneFeedback(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->enableSoundEffect(); break;
        case 10: *reinterpret_cast<QStringList*>(_v) = _t->inPutPortCombo(); break;
        case 11: *reinterpret_cast<int*>(_v) = _t->inPutPortComboIndex(); break;
        case 12: *reinterpret_cast<int*>(_v) = _t->inPutPortCount(); break;
        case 13: *reinterpret_cast<int*>(_v) = _t->outPutCount(); break;
        case 14: *reinterpret_cast<bool*>(_v) = _t->audioServerChangedState(); break;
        case 15: *reinterpret_cast<QString*>(_v) = _t->audioServer(); break;
        case 16: *reinterpret_cast<bool*>(_v) = _t->audioMono(); break;
        case 17: *reinterpret_cast<QStringList*>(_v) = _t->bluetoothAudioModeOpts(); break;
        case 18: *reinterpret_cast<QString*>(_v) = _t->currentBluetoothAudioMode(); break;
        case 19: *reinterpret_cast<bool*>(_v) = _t->showBluetoothMode(); break;
        case 20: *reinterpret_cast<bool*>(_v) = _t->showInputBluetoothMode(); break;
        case 21: *reinterpret_cast<bool*>(_v) = _t->outPutPortComboEnable(); break;
        case 22: *reinterpret_cast<bool*>(_v) = _t->inPutPortComboEnable(); break;
        case 23: *reinterpret_cast<bool*>(_v) = _t->speakerOn(); break;
        case 24: *reinterpret_cast<bool*>(_v) = _t->microphoneOn(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 10: _t->setInPutPortCombo(*reinterpret_cast<QStringList*>(_v)); break;
        case 11: _t->setInPutPortComboIndex(*reinterpret_cast<int*>(_v)); break;
        default: break;
        }
    }
}

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

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

int SoundModel::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 < 49)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 49;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 49)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 49;
    }
    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 SoundModel::speakerOnChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void SoundModel::microphoneOnChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void SoundModel::soundEffectOnChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void SoundModel::speakerVolumeChanged(double _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void SoundModel::speakerBalanceChanged(double _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void SoundModel::microphoneVolumeChanged(double _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void SoundModel::defaultSourceChanged(const QDBusObjectPath & _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void SoundModel::defaultSinkChanged(const QDBusObjectPath & _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void SoundModel::audioCardsChanged(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void SoundModel::maxUIVolumeChanged(double _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void SoundModel::increaseVolumeChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void SoundModel::reduceNoiseChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void SoundModel::pausePlayerChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void SoundModel::isPortEnableChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void SoundModel::bluetoothModeOptsChanged(const QStringList & _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void SoundModel::bluetoothModeChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

// SIGNAL 16
void SoundModel::setPortChanged(Port * _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 16, nullptr, _t1);
}

// SIGNAL 17
void SoundModel::outPutPortComboChanged(const QStringList & _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 17, nullptr, _t1);
}

// SIGNAL 18
void SoundModel::requestSwitchEnable(unsigned int _t1, QString _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1, _t2);
}

// SIGNAL 19
void SoundModel::inputDevicesVisibleChanged(QString _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1, _t2);
}

// SIGNAL 20
void SoundModel::outputDevicesVisibleChanged(QString _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1, _t2);
}

// SIGNAL 21
void SoundModel::onSetAudioServerFinish(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void SoundModel::curAudioServerChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void SoundModel::microphoneFeedbackChanged(double _t1)const
{
    QMetaObject::activate<void>(const_cast< SoundModel *>(this), &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void SoundModel::portAdded(const Port * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}

// SIGNAL 25
void SoundModel::portRemoved(const QString & _t1, const uint & _t2, const Port::Direction & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1, _t2, _t3);
}

// SIGNAL 26
void SoundModel::soundDeviceStatusChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 26, nullptr);
}

// SIGNAL 27
void SoundModel::soundEffectDataChanged(DDesktopServices::SystemSoundEffect _t1, const bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1, _t2);
}

// SIGNAL 28
void SoundModel::enableSoundEffectChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1);
}

// SIGNAL 29
void SoundModel::isLaptopChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 29, nullptr, _t1);
}

// SIGNAL 30
void SoundModel::outPutPortComboIndexChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 30, nullptr);
}

// SIGNAL 31
void SoundModel::inPutPortComboChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 31, nullptr);
}

// SIGNAL 32
void SoundModel::inPutPortComboIndexChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 32, nullptr);
}

// SIGNAL 33
void SoundModel::soundEffectsModelChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 33, nullptr);
}

// SIGNAL 34
void SoundModel::inPutPortCountChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 34, nullptr);
}

// SIGNAL 35
void SoundModel::outPutCountChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 35, nullptr);
}

// SIGNAL 36
void SoundModel::playAniIconPathChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 36, nullptr);
}

// SIGNAL 37
void SoundModel::audioMonoChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 37, nullptr);
}

// SIGNAL 38
void SoundModel::showBluetoothModeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 38, nullptr);
}

// SIGNAL 39
void SoundModel::outPutPortComboEnableChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 39, nullptr);
}

// SIGNAL 40
void SoundModel::inPutPortComboEnableChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 40, nullptr);
}

// SIGNAL 41
void SoundModel::showInputBluetoothModeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 41, nullptr);
}
QT_WARNING_POP
