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

#include "../../../../../../src/services/pipewire/node.hpp"
#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 'node.hpp' 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_ZN2qs7service8pipewire14PwAudioChannelE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::service::pipewire::PwAudioChannel::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7service8pipewire14PwAudioChannelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::service::pipewire::PwAudioChannel",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "toString",
        "",
        "qs::service::pipewire::PwAudioChannel::Enum",
        "value",
        "Enum",
        "Unknown",
        "NA",
        "Mono",
        "FrontCenter",
        "FrontLeft",
        "FrontRight",
        "FrontLeftCenter",
        "FrontRightCenter",
        "FrontLeftWide",
        "FrontRightWide",
        "FrontCenterHigh",
        "FrontLeftHigh",
        "FrontRightHigh",
        "LowFrequencyEffects",
        "LowFrequencyEffects2",
        "LowFrequencyEffectsLeft",
        "LowFrequencyEffectsRight",
        "SideLeft",
        "SideRight",
        "RearCenter",
        "RearLeft",
        "RearRight",
        "RearLeftCenter",
        "RearRightCenter",
        "TopCenter",
        "TopFrontCenter",
        "TopFrontLeft",
        "TopFrontRight",
        "TopFrontLeftCenter",
        "TopFrontRightCenter",
        "TopSideLeft",
        "TopSideRight",
        "TopRearCenter",
        "TopRearLeft",
        "TopRearRight",
        "BottomCenter",
        "BottomLeftCenter",
        "BottomRightCenter",
        "AuxRangeStart",
        "AuxRangeEnd",
        "CustomRangeStart"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString(qs::service::pipewire::PwAudioChannel::Enum)>(5, 6, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 7, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Enum'
        QtMocHelpers::EnumData<enum Enum>(9, 9, QMC::EnumFlags{}).add({
            {   10, Enum::Unknown },
            {   11, Enum::NA },
            {   12, Enum::Mono },
            {   13, Enum::FrontCenter },
            {   14, Enum::FrontLeft },
            {   15, Enum::FrontRight },
            {   16, Enum::FrontLeftCenter },
            {   17, Enum::FrontRightCenter },
            {   18, Enum::FrontLeftWide },
            {   19, Enum::FrontRightWide },
            {   20, Enum::FrontCenterHigh },
            {   21, Enum::FrontLeftHigh },
            {   22, Enum::FrontRightHigh },
            {   23, Enum::LowFrequencyEffects },
            {   24, Enum::LowFrequencyEffects2 },
            {   25, Enum::LowFrequencyEffectsLeft },
            {   26, Enum::LowFrequencyEffectsRight },
            {   27, Enum::SideLeft },
            {   28, Enum::SideRight },
            {   29, Enum::RearCenter },
            {   30, Enum::RearLeft },
            {   31, Enum::RearRight },
            {   32, Enum::RearLeftCenter },
            {   33, Enum::RearRightCenter },
            {   34, Enum::TopCenter },
            {   35, Enum::TopFrontCenter },
            {   36, Enum::TopFrontLeft },
            {   37, Enum::TopFrontRight },
            {   38, Enum::TopFrontLeftCenter },
            {   39, Enum::TopFrontRightCenter },
            {   40, Enum::TopSideLeft },
            {   41, Enum::TopSideRight },
            {   42, Enum::TopRearCenter },
            {   43, Enum::TopRearLeft },
            {   44, Enum::TopRearRight },
            {   45, Enum::BottomCenter },
            {   46, Enum::BottomLeftCenter },
            {   47, Enum::BottomRightCenter },
            {   48, Enum::AuxRangeStart },
            {   49, Enum::AuxRangeEnd },
            {   50, Enum::CustomRangeStart },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<PwAudioChannel, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject qs::service::pipewire::PwAudioChannel::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire14PwAudioChannelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire14PwAudioChannelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7service8pipewire14PwAudioChannelE_t>.metaTypes,
    nullptr
} };

void qs::service::pipewire::PwAudioChannel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PwAudioChannel *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString((*reinterpret_cast<std::add_pointer_t<qs::service::pipewire::PwAudioChannel::Enum>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

const QMetaObject *qs::service::pipewire::PwAudioChannel::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *qs::service::pipewire::PwAudioChannel::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire14PwAudioChannelE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int qs::service::pipewire::PwAudioChannel::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 < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN2qs7service8pipewire10PwNodeTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::service::pipewire::PwNodeType::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7service8pipewire10PwNodeTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::service::pipewire::PwNodeType",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "toString",
        "",
        "qs::service::pipewire::PwNodeType::Flags",
        "type",
        "Flag",
        "Untracked",
        "Audio",
        "Video",
        "Stream",
        "Source",
        "Sink",
        "AudioSink",
        "AudioSource",
        "AudioDuplex",
        "AudioOutStream",
        "AudioInStream",
        "VideoSource",
        "VideoSink"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString(qs::service::pipewire::PwNodeType::Flags)>(5, 6, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 7, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Flag'
        QtMocHelpers::EnumData<enum Flag>(9, 9, QMC::EnumFlags{}).add({
            {   10, Flag::Untracked },
            {   11, Flag::Audio },
            {   12, Flag::Video },
            {   13, Flag::Stream },
            {   14, Flag::Source },
            {   15, Flag::Sink },
            {   16, Flag::AudioSink },
            {   17, Flag::AudioSource },
            {   18, Flag::AudioDuplex },
            {   19, Flag::AudioOutStream },
            {   20, Flag::AudioInStream },
            {   21, Flag::VideoSource },
            {   22, Flag::VideoSink },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<PwNodeType, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject qs::service::pipewire::PwNodeType::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire10PwNodeTypeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire10PwNodeTypeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7service8pipewire10PwNodeTypeE_t>.metaTypes,
    nullptr
} };

void qs::service::pipewire::PwNodeType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PwNodeType *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString((*reinterpret_cast<std::add_pointer_t<qs::service::pipewire::PwNodeType::Flags>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

const QMetaObject *qs::service::pipewire::PwNodeType::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *qs::service::pipewire::PwNodeType::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire10PwNodeTypeE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int qs::service::pipewire::PwNodeType::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 < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN2qs7service8pipewire16PwNodeBoundAudioE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::service::pipewire::PwNodeBoundAudio::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7service8pipewire16PwNodeBoundAudioE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::service::pipewire::PwNodeBoundAudio",
        "volumesChanged",
        "",
        "channelsChanged",
        "mutedChanged",
        "onDeviceReady",
        "onDeviceVolumesChanged",
        "routeDevice",
        "PwVolumeProps",
        "props"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'volumesChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'channelsChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'mutedChanged'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onDeviceReady'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'onDeviceVolumesChanged'
        QtMocHelpers::SlotData<void(qint32, const PwVolumeProps &)>(6, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 7 }, { 0x80000000 | 8, 9 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PwNodeBoundAudio, qt_meta_tag_ZN2qs7service8pipewire16PwNodeBoundAudioE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject qs::service::pipewire::PwNodeBoundAudio::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire16PwNodeBoundAudioE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire16PwNodeBoundAudioE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7service8pipewire16PwNodeBoundAudioE_t>.metaTypes,
    nullptr
} };

void qs::service::pipewire::PwNodeBoundAudio::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PwNodeBoundAudio *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->volumesChanged(); break;
        case 1: _t->channelsChanged(); break;
        case 2: _t->mutedChanged(); break;
        case 3: _t->onDeviceReady(); break;
        case 4: _t->onDeviceVolumesChanged((*reinterpret_cast<std::add_pointer_t<qint32>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<PwVolumeProps>>(_a[2]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (PwNodeBoundAudio::*)()>(_a, &PwNodeBoundAudio::volumesChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (PwNodeBoundAudio::*)()>(_a, &PwNodeBoundAudio::channelsChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (PwNodeBoundAudio::*)()>(_a, &PwNodeBoundAudio::mutedChanged, 2))
            return;
    }
}

const QMetaObject *qs::service::pipewire::PwNodeBoundAudio::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *qs::service::pipewire::PwNodeBoundAudio::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire16PwNodeBoundAudioE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "PwNodeBoundData"))
        return static_cast< PwNodeBoundData*>(this);
    return QObject::qt_metacast(_clname);
}

int qs::service::pipewire::PwNodeBoundAudio::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 < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 5;
    }
    return _id;
}

// SIGNAL 0
void qs::service::pipewire::PwNodeBoundAudio::volumesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void qs::service::pipewire::PwNodeBoundAudio::channelsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void qs::service::pipewire::PwNodeBoundAudio::mutedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}
namespace {
struct qt_meta_tag_ZN2qs7service8pipewire6PwNodeE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::service::pipewire::PwNode::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7service8pipewire6PwNodeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::service::pipewire::PwNode",
        "propertiesChanged",
        "",
        "readyChanged",
        "onCoreSync",
        "id",
        "seq"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'propertiesChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'readyChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onCoreSync'
        QtMocHelpers::SlotData<void(quint32, qint32)>(4, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::UInt, 5 }, { QMetaType::Int, 6 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PwNode, qt_meta_tag_ZN2qs7service8pipewire6PwNodeE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject qs::service::pipewire::PwNode::staticMetaObject = { {
    QMetaObject::SuperData::link<PwBindable<pw_node,"PipeWire:Interface:Node",3>::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire6PwNodeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire6PwNodeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7service8pipewire6PwNodeE_t>.metaTypes,
    nullptr
} };

void qs::service::pipewire::PwNode::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PwNode *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->propertiesChanged(); break;
        case 1: _t->readyChanged(); break;
        case 2: _t->onCoreSync((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qint32>>(_a[2]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (PwNode::*)()>(_a, &PwNode::propertiesChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (PwNode::*)()>(_a, &PwNode::readyChanged, 1))
            return;
    }
}

const QMetaObject *qs::service::pipewire::PwNode::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *qs::service::pipewire::PwNode::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire6PwNodeE_t>.strings))
        return static_cast<void*>(this);
    return PwBindable<pw_node,"PipeWire:Interface:Node",3>::qt_metacast(_clname);
}

int qs::service::pipewire::PwNode::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PwBindable<pw_node,"PipeWire:Interface:Node",3>::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 3;
    }
    return _id;
}

// SIGNAL 0
void qs::service::pipewire::PwNode::propertiesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void qs::service::pipewire::PwNode::readyChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}
QT_WARNING_POP
