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

#include "../../../../discover-6.7.3/libdiscover/resources/ResourcesProxyModel.h"
#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 'ResourcesProxyModel.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

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

template <> constexpr inline auto ResourcesCount::qt_create_metaobjectdata<qt_meta_tag_ZN14ResourcesCountE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ResourcesCount",
        "valid",
        "number",
        "string"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'valid'
        QtMocHelpers::PropertyData<bool>(1, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant | QMC::Final),
        // property 'number'
        QtMocHelpers::PropertyData<int>(2, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant | QMC::Final),
        // property 'string'
        QtMocHelpers::PropertyData<QString>(3, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant | QMC::Final),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ResourcesCount, qt_meta_tag_ZN14ResourcesCountE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ResourcesCount::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14ResourcesCountE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14ResourcesCountE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14ResourcesCountE_t>.metaTypes,
    nullptr
} };

void ResourcesCount::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<ResourcesCount *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->m_valid; break;
        case 1: *reinterpret_cast<int*>(_v) = _t->m_number; break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->m_string; break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN19ResourcesProxyModelE_t {};
} // unnamed namespace

template <> constexpr inline auto ResourcesProxyModel::qt_create_metaobjectdata<qt_meta_tag_ZN19ResourcesProxyModelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ResourcesProxyModel",
        "busyChanged",
        "",
        "sortRoleChanged",
        "sortRole",
        "sortOrderChanged",
        "Qt::SortOrder",
        "order",
        "categoryChanged",
        "stateFilterChanged",
        "searchChanged",
        "search",
        "subcategoriesChanged",
        "QVariantList",
        "subcategories",
        "resourcesUrlChanged",
        "QUrl",
        "url",
        "countChanged",
        "filterMinimumStateChanged",
        "filterMinimumState",
        "categorizeChanged",
        "refreshBackend",
        "AbstractResourcesBackend*",
        "backend",
        "QList<QByteArray>",
        "properties",
        "refreshResource",
        "AbstractResource*",
        "resource",
        "removeResource",
        "indexOf",
        "res",
        "resourceAt",
        "row",
        "invalidateFilter",
        "Roles",
        "sortOrder",
        "filteredCategory",
        "std::shared_ptr<Category>",
        "filteredCategoryName",
        "originFilter",
        "stateFilter",
        "AbstractResource::State",
        "mimeTypeFilter",
        "backendFilter",
        "resourcesUrl",
        "extending",
        "allBackends",
        "busy",
        "count",
        "ResourcesCount",
        "categorize",
        "NameRole",
        "IconRole",
        "CommentRole",
        "StateRole",
        "RatingRole",
        "RatingPointsRole",
        "RatingCountRole",
        "SortableRatingRole",
        "InstalledRole",
        "ApplicationRole",
        "OriginRole",
        "DisplayOriginRole",
        "CanUpgrade",
        "PackageNameRole",
        "CategoryRole",
        "CategoryNameRole",
        "SectionRole",
        "MimeTypes",
        "SizeRole",
        "LongDescriptionRole",
        "SourceIconRole",
        "ReleaseDateRole",
        "SearchRelevanceRole"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'busyChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sortRoleChanged'
        QtMocHelpers::SignalData<void(int)>(3, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 4 },
        }}),
        // Signal 'sortOrderChanged'
        QtMocHelpers::SignalData<void(Qt::SortOrder)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Signal 'categoryChanged'
        QtMocHelpers::SignalData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'stateFilterChanged'
        QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'searchChanged'
        QtMocHelpers::SignalData<void(const QString &)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 11 },
        }}),
        // Signal 'subcategoriesChanged'
        QtMocHelpers::SignalData<void(const QVariantList &)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 13, 14 },
        }}),
        // Signal 'resourcesUrlChanged'
        QtMocHelpers::SignalData<void(const QUrl &)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 16, 17 },
        }}),
        // Signal 'countChanged'
        QtMocHelpers::SignalData<void()>(18, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'filterMinimumStateChanged'
        QtMocHelpers::SignalData<void(bool)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 20 },
        }}),
        // Signal 'categorizeChanged'
        QtMocHelpers::SignalData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'refreshBackend'
        QtMocHelpers::SlotData<void(AbstractResourcesBackend *, const QVector<QByteArray> &)>(22, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 23, 24 }, { 0x80000000 | 25, 26 },
        }}),
        // Slot 'refreshResource'
        QtMocHelpers::SlotData<void(AbstractResource *, const QVector<QByteArray> &)>(27, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 28, 29 }, { 0x80000000 | 25, 26 },
        }}),
        // Slot 'removeResource'
        QtMocHelpers::SlotData<void(AbstractResource *)>(30, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 28, 29 },
        }}),
        // Method 'indexOf'
        QtMocHelpers::MethodData<int(AbstractResource *)>(31, 2, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Int, {{
            { 0x80000000 | 28, 32 },
        }}),
        // Method 'resourceAt'
        QtMocHelpers::MethodData<AbstractResource *(int) const>(33, 2, QMC::AccessPublic | QMC::MethodScriptable, 0x80000000 | 28, {{
            { QMetaType::Int, 34 },
        }}),
        // Method 'invalidateFilter'
        QtMocHelpers::MethodData<void()>(35, 2, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'sortRole'
        QtMocHelpers::PropertyData<enum Roles>(4, 0x80000000 | 36, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 1),
        // property 'sortOrder'
        QtMocHelpers::PropertyData<Qt::SortOrder>(37, 0x80000000 | 6, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 2),
        // property 'filteredCategory'
        QtMocHelpers::PropertyData<std::shared_ptr<Category>>(38, 0x80000000 | 39, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 3),
        // property 'filteredCategoryName'
        QtMocHelpers::PropertyData<QString>(40, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 3),
        // property 'originFilter'
        QtMocHelpers::PropertyData<QString>(41, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'stateFilter'
        QtMocHelpers::PropertyData<AbstractResource::State>(42, 0x80000000 | 43, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 4),
        // property 'filterMinimumState'
        QtMocHelpers::PropertyData<bool>(20, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 9),
        // property 'mimeTypeFilter'
        QtMocHelpers::PropertyData<QString>(44, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'backendFilter'
        QtMocHelpers::PropertyData<AbstractResourcesBackend*>(45, 0x80000000 | 23, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
        // property 'search'
        QtMocHelpers::PropertyData<QString>(11, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 5),
        // property 'resourcesUrl'
        QtMocHelpers::PropertyData<QUrl>(46, 0x80000000 | 16, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 7),
        // property 'extending'
        QtMocHelpers::PropertyData<QString>(47, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'allBackends'
        QtMocHelpers::PropertyData<bool>(48, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'subcategories'
        QtMocHelpers::PropertyData<QVariantList>(14, 0x80000000 | 13, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 6),
        // property 'busy'
        QtMocHelpers::PropertyData<bool>(49, QMetaType::Bool, QMC::DefaultPropertyFlags, 0),
        // property 'count'
        QtMocHelpers::PropertyData<ResourcesCount>(50, 0x80000000 | 51, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Final, 8),
        // property 'categorize'
        QtMocHelpers::PropertyData<bool>(52, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 10),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Roles'
        QtMocHelpers::EnumData<enum Roles>(36, 36, QMC::EnumFlags{}).add({
            {   53, Roles::NameRole },
            {   54, Roles::IconRole },
            {   55, Roles::CommentRole },
            {   56, Roles::StateRole },
            {   57, Roles::RatingRole },
            {   58, Roles::RatingPointsRole },
            {   59, Roles::RatingCountRole },
            {   60, Roles::SortableRatingRole },
            {   61, Roles::InstalledRole },
            {   62, Roles::ApplicationRole },
            {   63, Roles::OriginRole },
            {   64, Roles::DisplayOriginRole },
            {   65, Roles::CanUpgrade },
            {   66, Roles::PackageNameRole },
            {   67, Roles::CategoryRole },
            {   68, Roles::CategoryNameRole },
            {   69, Roles::SectionRole },
            {   70, Roles::MimeTypes },
            {   71, Roles::SizeRole },
            {   72, Roles::LongDescriptionRole },
            {   73, Roles::SourceIconRole },
            {   74, Roles::ReleaseDateRole },
            {   75, Roles::SearchRelevanceRole },
        }),
    };
    return QtMocHelpers::metaObjectData<ResourcesProxyModel, qt_meta_tag_ZN19ResourcesProxyModelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN19ResourcesProxyModelE[] = {
    QMetaObject::SuperData::link<AbstractResource::staticMetaObject>(),
    nullptr
};

Q_CONSTINIT const QMetaObject ResourcesProxyModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QAbstractListModel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19ResourcesProxyModelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19ResourcesProxyModelE_t>.data,
    qt_static_metacall,
    qt_meta_extradata_ZN19ResourcesProxyModelE,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19ResourcesProxyModelE_t>.metaTypes,
    nullptr
} };

void ResourcesProxyModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ResourcesProxyModel *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->busyChanged(); break;
        case 1: _t->sortRoleChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 2: _t->sortOrderChanged((*reinterpret_cast<std::add_pointer_t<Qt::SortOrder>>(_a[1]))); break;
        case 3: _t->categoryChanged(); break;
        case 4: _t->stateFilterChanged(); break;
        case 5: _t->searchChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 6: _t->subcategoriesChanged((*reinterpret_cast<std::add_pointer_t<QVariantList>>(_a[1]))); break;
        case 7: _t->resourcesUrlChanged((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1]))); break;
        case 8: _t->countChanged(); break;
        case 9: _t->filterMinimumStateChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 10: _t->categorizeChanged(); break;
        case 11: _t->refreshBackend((*reinterpret_cast<std::add_pointer_t<AbstractResourcesBackend*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<QByteArray>>>(_a[2]))); break;
        case 12: _t->refreshResource((*reinterpret_cast<std::add_pointer_t<AbstractResource*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<QByteArray>>>(_a[2]))); break;
        case 13: _t->removeResource((*reinterpret_cast<std::add_pointer_t<AbstractResource*>>(_a[1]))); break;
        case 14: { int _r = _t->indexOf((*reinterpret_cast<std::add_pointer_t<AbstractResource*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 15: { AbstractResource* _r = _t->resourceAt((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<AbstractResource**>(_a[0]) = std::move(_r); }  break;
        case 16: _t->invalidateFilter(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 11:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< AbstractResourcesBackend* >(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<QByteArray> >(); break;
            }
            break;
        case 12:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< AbstractResource* >(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<QByteArray> >(); break;
            }
            break;
        case 13:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< AbstractResource* >(); break;
            }
            break;
        case 14:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< AbstractResource* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (ResourcesProxyModel::*)()>(_a, &ResourcesProxyModel::busyChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (ResourcesProxyModel::*)(int )>(_a, &ResourcesProxyModel::sortRoleChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (ResourcesProxyModel::*)(Qt::SortOrder )>(_a, &ResourcesProxyModel::sortOrderChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (ResourcesProxyModel::*)()>(_a, &ResourcesProxyModel::categoryChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (ResourcesProxyModel::*)()>(_a, &ResourcesProxyModel::stateFilterChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (ResourcesProxyModel::*)(const QString & )>(_a, &ResourcesProxyModel::searchChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (ResourcesProxyModel::*)(const QVariantList & )>(_a, &ResourcesProxyModel::subcategoriesChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (ResourcesProxyModel::*)(const QUrl & )>(_a, &ResourcesProxyModel::resourcesUrlChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (ResourcesProxyModel::*)()>(_a, &ResourcesProxyModel::countChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (ResourcesProxyModel::*)(bool )>(_a, &ResourcesProxyModel::filterMinimumStateChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (ResourcesProxyModel::*)()>(_a, &ResourcesProxyModel::categorizeChanged, 10))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 8:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< AbstractResourcesBackend* >(); break;
        case 2:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< std::shared_ptr<Category> >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<enum Roles*>(_v) = _t->sortRole(); break;
        case 1: *reinterpret_cast<Qt::SortOrder*>(_v) = _t->sortOrder(); break;
        case 2: *reinterpret_cast<std::shared_ptr<Category>*>(_v) = _t->filteredCategory(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->filteredCategoryName(); break;
        case 4: *reinterpret_cast<QString*>(_v) = _t->originFilter(); break;
        case 5: *reinterpret_cast<AbstractResource::State*>(_v) = _t->stateFilter(); break;
        case 6: *reinterpret_cast<bool*>(_v) = _t->filterMinimumState(); break;
        case 7: *reinterpret_cast<QString*>(_v) = _t->mimeTypeFilter(); break;
        case 8: *reinterpret_cast<AbstractResourcesBackend**>(_v) = _t->backendFilter(); break;
        case 9: *reinterpret_cast<QString*>(_v) = _t->lastSearch(); break;
        case 10: *reinterpret_cast<QUrl*>(_v) = _t->resourcesUrl(); break;
        case 11: *reinterpret_cast<QString*>(_v) = _t->extends(); break;
        case 12: *reinterpret_cast<bool*>(_v) = _t->allBackends(); break;
        case 13: *reinterpret_cast<QVariantList*>(_v) = _t->subcategories(); break;
        case 14: *reinterpret_cast<bool*>(_v) = _t->isBusy(); break;
        case 15: *reinterpret_cast<ResourcesCount*>(_v) = _t->count(); break;
        case 16: *reinterpret_cast<bool*>(_v) = _t->categorize(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setSortRole(*reinterpret_cast<enum Roles*>(_v)); break;
        case 1: _t->setSortOrder(*reinterpret_cast<Qt::SortOrder*>(_v)); break;
        case 2: _t->setFiltersFromCategory(*reinterpret_cast<std::shared_ptr<Category>*>(_v)); break;
        case 3: _t->setFilteredCategoryName(*reinterpret_cast<QString*>(_v)); break;
        case 4: _t->setOriginFilter(*reinterpret_cast<QString*>(_v)); break;
        case 5: _t->setStateFilter(*reinterpret_cast<AbstractResource::State*>(_v)); break;
        case 6: _t->setFilterMinimumState(*reinterpret_cast<bool*>(_v)); break;
        case 7: _t->setMimeTypeFilter(*reinterpret_cast<QString*>(_v)); break;
        case 8: _t->setBackendFilter(*reinterpret_cast<AbstractResourcesBackend**>(_v)); break;
        case 9: _t->setSearch(*reinterpret_cast<QString*>(_v)); break;
        case 10: _t->setResourcesUrl(*reinterpret_cast<QUrl*>(_v)); break;
        case 11: _t->setExtends(*reinterpret_cast<QString*>(_v)); break;
        case 12: _t->setAllBackends(*reinterpret_cast<bool*>(_v)); break;
        case 16: _t->setCategorize(*reinterpret_cast<bool*>(_v)); break;
        default: break;
        }
    }
}

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

void *ResourcesProxyModel::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19ResourcesProxyModelE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "QQmlParserStatus"))
        return static_cast< QQmlParserStatus*>(this);
    if (!strcmp(_clname, "org.qt-project.Qt.QQmlParserStatus"))
        return static_cast< QQmlParserStatus*>(this);
    return QAbstractListModel::qt_metacast(_clname);
}

int ResourcesProxyModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAbstractListModel::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 17)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 17;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 17)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 17;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 17;
    }
    return _id;
}

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

// SIGNAL 1
void ResourcesProxyModel::sortRoleChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void ResourcesProxyModel::sortOrderChanged(Qt::SortOrder _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

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

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

// SIGNAL 5
void ResourcesProxyModel::searchChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void ResourcesProxyModel::subcategoriesChanged(const QVariantList & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void ResourcesProxyModel::resourcesUrlChanged(const QUrl & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

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

// SIGNAL 9
void ResourcesProxyModel::filterMinimumStateChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void ResourcesProxyModel::categorizeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}
QT_WARNING_POP
