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

#include "../../../../../../calligraplan-4.0.1/src/libs/kernel/kptproject.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 'kptproject.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.0. 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_ZN6KPlato7ProjectE_t {};
} // unnamed namespace

template <> constexpr inline auto KPlato::Project::qt_create_metaobjectdata<qt_meta_tag_ZN6KPlato7ProjectE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KPlato::Project",
        "freedaysCalendarChanged",
        "",
        "KPlato::Calendar*",
        "calendar",
        "scheduleManagersSwapped",
        "KPlato::ScheduleManager*",
        "from",
        "to",
        "aboutToBeDeleted",
        "projectChanged",
        "wbsDefinitionChanged",
        "projectCalculated",
        "sm",
        "currentScheduleChanged",
        "sigProgress",
        "maxProgress",
        "sigCalculationStarted",
        "KPlato::Project*",
        "project",
        "sigCalculationFinished",
        "nodeChanged",
        "KPlato::Node*",
        "nodeToBeAdded",
        "nodeAdded",
        "nodeToBeRemoved",
        "nodeRemoved",
        "nodeToBeMoved",
        "node",
        "pos",
        "newParent",
        "newPos",
        "nodeMoved",
        "documentAdded",
        "KPlato::Document*",
        "index",
        "documentRemoved",
        "documentChanged",
        "resourceGroupChanged",
        "KPlato::ResourceGroup*",
        "group",
        "resourceGroupToBeAdded",
        "parent",
        "row",
        "resourceGroupAdded",
        "resourceGroupToBeRemoved",
        "resourceGroupRemoved",
        "resourceChanged",
        "KPlato::Resource*",
        "resource",
        "resourceToBeAdded",
        "resourceAdded",
        "resourceToBeRemoved",
        "resourceRemoved",
        "scheduleManagerChanged",
        "sch",
        "property",
        "scheduleManagerAdded",
        "const KPlato::ScheduleManager*",
        "scheduleManagerToBeAdded",
        "scheduleManagerRemoved",
        "scheduleManagerToBeRemoved",
        "scheduleManagerMoved",
        "scheduleManagerToBeMoved",
        "scheduleChanged",
        "KPlato::MainSchedule*",
        "scheduleToBeAdded",
        "manager",
        "scheduleAdded",
        "const KPlato::MainSchedule*",
        "scheduleToBeRemoved",
        "scheduleRemoved",
        "calendarChanged",
        "cal",
        "calendarToBeAdded",
        "const KPlato::Calendar*",
        "calendarAdded",
        "calendarToBeRemoved",
        "calendarRemoved",
        "defaultCalendarChanged",
        "standardWorktimeChanged",
        "KPlato::StandardWorktime*",
        "relationToBeAdded",
        "KPlato::Relation*",
        "rel",
        "parentIndex",
        "childIndex",
        "relationAdded",
        "relationToBeRemoved",
        "relationRemoved",
        "relationToBeModified",
        "relationModified",
        "localeChanged",
        "taskModulesChanged",
        "QList<QUrl>",
        "modules",
        "setProgress",
        "progress",
        "setMaxProgress",
        "max",
        "swapScheduleManagers",
        "nodeDestroyed",
        "obj",
        "emitProjectCalculated"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'freedaysCalendarChanged'
        QtMocHelpers::SignalData<void(KPlato::Calendar *)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'scheduleManagersSwapped'
        QtMocHelpers::SignalData<void(KPlato::ScheduleManager *, KPlato::ScheduleManager *)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 7 }, { 0x80000000 | 6, 8 },
        }}),
        // Signal 'aboutToBeDeleted'
        QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'projectChanged'
        QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'wbsDefinitionChanged'
        QtMocHelpers::SignalData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'projectCalculated'
        QtMocHelpers::SignalData<void(KPlato::ScheduleManager *)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 13 },
        }}),
        // Signal 'currentScheduleChanged'
        QtMocHelpers::SignalData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sigProgress'
        QtMocHelpers::SignalData<void(int)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Signal 'maxProgress'
        QtMocHelpers::SignalData<void(int)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Signal 'sigCalculationStarted'
        QtMocHelpers::SignalData<void(KPlato::Project *, KPlato::ScheduleManager *)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 19 }, { 0x80000000 | 6, 13 },
        }}),
        // Signal 'sigCalculationFinished'
        QtMocHelpers::SignalData<void(KPlato::Project *, KPlato::ScheduleManager *)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 19 }, { 0x80000000 | 6, 13 },
        }}),
        // Signal 'nodeChanged'
        QtMocHelpers::SignalData<void(KPlato::Node *, int)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 22, 2 }, { QMetaType::Int, 2 },
        }}),
        // Signal 'nodeToBeAdded'
        QtMocHelpers::SignalData<void(KPlato::Node *, int)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 22, 2 }, { QMetaType::Int, 2 },
        }}),
        // Signal 'nodeAdded'
        QtMocHelpers::SignalData<void(KPlato::Node *)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 22, 2 },
        }}),
        // Signal 'nodeToBeRemoved'
        QtMocHelpers::SignalData<void(KPlato::Node *)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 22, 2 },
        }}),
        // Signal 'nodeRemoved'
        QtMocHelpers::SignalData<void(KPlato::Node *)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 22, 2 },
        }}),
        // Signal 'nodeToBeMoved'
        QtMocHelpers::SignalData<void(KPlato::Node *, int, KPlato::Node *, int)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 22, 28 }, { QMetaType::Int, 29 }, { 0x80000000 | 22, 30 }, { QMetaType::Int, 31 },
        }}),
        // Signal 'nodeMoved'
        QtMocHelpers::SignalData<void(KPlato::Node *)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 22, 2 },
        }}),
        // Signal 'documentAdded'
        QtMocHelpers::SignalData<void(KPlato::Node *, KPlato::Document *, int)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 22, 2 }, { 0x80000000 | 34, 2 }, { QMetaType::Int, 35 },
        }}),
        // Signal 'documentRemoved'
        QtMocHelpers::SignalData<void(KPlato::Node *, KPlato::Document *, int)>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 22, 2 }, { 0x80000000 | 34, 2 }, { QMetaType::Int, 35 },
        }}),
        // Signal 'documentChanged'
        QtMocHelpers::SignalData<void(KPlato::Node *, KPlato::Document *, int)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 22, 2 }, { 0x80000000 | 34, 2 }, { QMetaType::Int, 35 },
        }}),
        // Signal 'resourceGroupChanged'
        QtMocHelpers::SignalData<void(KPlato::ResourceGroup *)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 39, 40 },
        }}),
        // Signal 'resourceGroupToBeAdded'
        QtMocHelpers::SignalData<void(KPlato::Project *, KPlato::ResourceGroup *, int)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 19 }, { 0x80000000 | 39, 42 }, { QMetaType::Int, 43 },
        }}),
        // Signal 'resourceGroupAdded'
        QtMocHelpers::SignalData<void(KPlato::ResourceGroup *)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 39, 40 },
        }}),
        // Signal 'resourceGroupToBeRemoved'
        QtMocHelpers::SignalData<void(KPlato::Project *, KPlato::ResourceGroup *, int, KPlato::ResourceGroup *)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 19 }, { 0x80000000 | 39, 42 }, { QMetaType::Int, 43 }, { 0x80000000 | 39, 40 },
        }}),
        // Signal 'resourceGroupRemoved'
        QtMocHelpers::SignalData<void()>(46, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'resourceChanged'
        QtMocHelpers::SignalData<void(KPlato::Resource *)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'resourceToBeAdded'
        QtMocHelpers::SignalData<void(KPlato::Project *, int)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 19 }, { QMetaType::Int, 43 },
        }}),
        // Signal 'resourceAdded'
        QtMocHelpers::SignalData<void(KPlato::Resource *)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'resourceToBeRemoved'
        QtMocHelpers::SignalData<void(KPlato::Project *, int, KPlato::Resource *)>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 19 }, { QMetaType::Int, 43 }, { 0x80000000 | 48, 49 },
        }}),
        // Signal 'resourceRemoved'
        QtMocHelpers::SignalData<void()>(53, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'scheduleManagerChanged'
        QtMocHelpers::SignalData<void(KPlato::ScheduleManager *, int)>(54, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 55 }, { QMetaType::Int, 56 },
        }}),
        // Signal 'scheduleManagerChanged'
        QtMocHelpers::SignalData<void(KPlato::ScheduleManager *)>(54, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 6, 55 },
        }}),
        // Signal 'scheduleManagerAdded'
        QtMocHelpers::SignalData<void(const KPlato::ScheduleManager *)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 58, 55 },
        }}),
        // Signal 'scheduleManagerToBeAdded'
        QtMocHelpers::SignalData<void(const KPlato::ScheduleManager *, int)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 58, 55 }, { QMetaType::Int, 43 },
        }}),
        // Signal 'scheduleManagerRemoved'
        QtMocHelpers::SignalData<void(const KPlato::ScheduleManager *)>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 58, 55 },
        }}),
        // Signal 'scheduleManagerToBeRemoved'
        QtMocHelpers::SignalData<void(const KPlato::ScheduleManager *)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 58, 55 },
        }}),
        // Signal 'scheduleManagerMoved'
        QtMocHelpers::SignalData<void(const KPlato::ScheduleManager *, int)>(62, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 58, 55 }, { QMetaType::Int, 43 },
        }}),
        // Signal 'scheduleManagerToBeMoved'
        QtMocHelpers::SignalData<void(const KPlato::ScheduleManager *)>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 58, 55 },
        }}),
        // Signal 'scheduleChanged'
        QtMocHelpers::SignalData<void(KPlato::MainSchedule *)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 65, 55 },
        }}),
        // Signal 'scheduleToBeAdded'
        QtMocHelpers::SignalData<void(const KPlato::ScheduleManager *, int)>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 58, 67 }, { QMetaType::Int, 43 },
        }}),
        // Signal 'scheduleAdded'
        QtMocHelpers::SignalData<void(const KPlato::MainSchedule *)>(68, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 69, 55 },
        }}),
        // Signal 'scheduleToBeRemoved'
        QtMocHelpers::SignalData<void(const KPlato::MainSchedule *)>(70, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 69, 55 },
        }}),
        // Signal 'scheduleRemoved'
        QtMocHelpers::SignalData<void(const KPlato::MainSchedule *)>(71, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 69, 55 },
        }}),
        // Signal 'calendarChanged'
        QtMocHelpers::SignalData<void(KPlato::Calendar *)>(72, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 73 },
        }}),
        // Signal 'calendarToBeAdded'
        QtMocHelpers::SignalData<void(const KPlato::Calendar *, int)>(74, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 75, 73 }, { QMetaType::Int, 43 },
        }}),
        // Signal 'calendarAdded'
        QtMocHelpers::SignalData<void(const KPlato::Calendar *)>(76, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 75, 73 },
        }}),
        // Signal 'calendarToBeRemoved'
        QtMocHelpers::SignalData<void(const KPlato::Calendar *)>(77, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 75, 73 },
        }}),
        // Signal 'calendarRemoved'
        QtMocHelpers::SignalData<void(const KPlato::Calendar *)>(78, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 75, 73 },
        }}),
        // Signal 'defaultCalendarChanged'
        QtMocHelpers::SignalData<void(KPlato::Calendar *)>(79, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 73 },
        }}),
        // Signal 'standardWorktimeChanged'
        QtMocHelpers::SignalData<void(KPlato::StandardWorktime *)>(80, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 81, 2 },
        }}),
        // Signal 'relationToBeAdded'
        QtMocHelpers::SignalData<void(KPlato::Relation *, int, int)>(82, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 83, 84 }, { QMetaType::Int, 85 }, { QMetaType::Int, 86 },
        }}),
        // Signal 'relationAdded'
        QtMocHelpers::SignalData<void(KPlato::Relation *)>(87, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 83, 84 },
        }}),
        // Signal 'relationToBeRemoved'
        QtMocHelpers::SignalData<void(KPlato::Relation *)>(88, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 83, 84 },
        }}),
        // Signal 'relationRemoved'
        QtMocHelpers::SignalData<void(KPlato::Relation *)>(89, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 83, 84 },
        }}),
        // Signal 'relationToBeModified'
        QtMocHelpers::SignalData<void(KPlato::Relation *)>(90, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 83, 84 },
        }}),
        // Signal 'relationModified'
        QtMocHelpers::SignalData<void(KPlato::Relation *)>(91, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 83, 84 },
        }}),
        // Signal 'localeChanged'
        QtMocHelpers::SignalData<void()>(92, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'taskModulesChanged'
        QtMocHelpers::SignalData<void(const QList<QUrl> &)>(93, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 94, 95 },
        }}),
        // Slot 'setProgress'
        QtMocHelpers::SlotData<void(int, KPlato::ScheduleManager *)>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 97 }, { 0x80000000 | 6, 13 },
        }}),
        // Slot 'setProgress'
        QtMocHelpers::SlotData<void(int)>(96, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 97 },
        }}),
        // Slot 'setMaxProgress'
        QtMocHelpers::SlotData<void(int, KPlato::ScheduleManager *)>(98, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 99 }, { 0x80000000 | 6, 13 },
        }}),
        // Slot 'setMaxProgress'
        QtMocHelpers::SlotData<void(int)>(98, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 99 },
        }}),
        // Slot 'swapScheduleManagers'
        QtMocHelpers::SlotData<void(KPlato::ScheduleManager *, KPlato::ScheduleManager *)>(100, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 7 }, { 0x80000000 | 6, 8 },
        }}),
        // Slot 'nodeDestroyed'
        QtMocHelpers::SlotData<void(QObject *)>(101, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QObjectStar, 102 },
        }}),
        // Slot 'emitProjectCalculated'
        QtMocHelpers::SlotData<void(KPlato::Project *, KPlato::ScheduleManager *)>(103, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 18, 19 }, { 0x80000000 | 6, 13 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Project, qt_meta_tag_ZN6KPlato7ProjectE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KPlato::Project::staticMetaObject = { {
    QMetaObject::SuperData::link<Node::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6KPlato7ProjectE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6KPlato7ProjectE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6KPlato7ProjectE_t>.metaTypes,
    nullptr
} };

void KPlato::Project::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Project *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->freedaysCalendarChanged((*reinterpret_cast<std::add_pointer_t<KPlato::Calendar*>>(_a[1]))); break;
        case 1: _t->scheduleManagersSwapped((*reinterpret_cast<std::add_pointer_t<KPlato::ScheduleManager*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<KPlato::ScheduleManager*>>(_a[2]))); break;
        case 2: _t->aboutToBeDeleted(); break;
        case 3: _t->projectChanged(); break;
        case 4: _t->wbsDefinitionChanged(); break;
        case 5: _t->projectCalculated((*reinterpret_cast<std::add_pointer_t<KPlato::ScheduleManager*>>(_a[1]))); break;
        case 6: _t->currentScheduleChanged(); break;
        case 7: _t->sigProgress((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 8: _t->maxProgress((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 9: _t->sigCalculationStarted((*reinterpret_cast<std::add_pointer_t<KPlato::Project*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<KPlato::ScheduleManager*>>(_a[2]))); break;
        case 10: _t->sigCalculationFinished((*reinterpret_cast<std::add_pointer_t<KPlato::Project*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<KPlato::ScheduleManager*>>(_a[2]))); break;
        case 11: _t->nodeChanged((*reinterpret_cast<std::add_pointer_t<KPlato::Node*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 12: _t->nodeToBeAdded((*reinterpret_cast<std::add_pointer_t<KPlato::Node*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 13: _t->nodeAdded((*reinterpret_cast<std::add_pointer_t<KPlato::Node*>>(_a[1]))); break;
        case 14: _t->nodeToBeRemoved((*reinterpret_cast<std::add_pointer_t<KPlato::Node*>>(_a[1]))); break;
        case 15: _t->nodeRemoved((*reinterpret_cast<std::add_pointer_t<KPlato::Node*>>(_a[1]))); break;
        case 16: _t->nodeToBeMoved((*reinterpret_cast<std::add_pointer_t<KPlato::Node*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<KPlato::Node*>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 17: _t->nodeMoved((*reinterpret_cast<std::add_pointer_t<KPlato::Node*>>(_a[1]))); break;
        case 18: _t->documentAdded((*reinterpret_cast<std::add_pointer_t<KPlato::Node*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<KPlato::Document*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 19: _t->documentRemoved((*reinterpret_cast<std::add_pointer_t<KPlato::Node*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<KPlato::Document*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 20: _t->documentChanged((*reinterpret_cast<std::add_pointer_t<KPlato::Node*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<KPlato::Document*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 21: _t->resourceGroupChanged((*reinterpret_cast<std::add_pointer_t<KPlato::ResourceGroup*>>(_a[1]))); break;
        case 22: _t->resourceGroupToBeAdded((*reinterpret_cast<std::add_pointer_t<KPlato::Project*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<KPlato::ResourceGroup*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 23: _t->resourceGroupAdded((*reinterpret_cast<std::add_pointer_t<KPlato::ResourceGroup*>>(_a[1]))); break;
        case 24: _t->resourceGroupToBeRemoved((*reinterpret_cast<std::add_pointer_t<KPlato::Project*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<KPlato::ResourceGroup*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<KPlato::ResourceGroup*>>(_a[4]))); break;
        case 25: _t->resourceGroupRemoved(); break;
        case 26: _t->resourceChanged((*reinterpret_cast<std::add_pointer_t<KPlato::Resource*>>(_a[1]))); break;
        case 27: _t->resourceToBeAdded((*reinterpret_cast<std::add_pointer_t<KPlato::Project*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 28: _t->resourceAdded((*reinterpret_cast<std::add_pointer_t<KPlato::Resource*>>(_a[1]))); break;
        case 29: _t->resourceToBeRemoved((*reinterpret_cast<std::add_pointer_t<KPlato::Project*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<KPlato::Resource*>>(_a[3]))); break;
        case 30: _t->resourceRemoved(); break;
        case 31: _t->scheduleManagerChanged((*reinterpret_cast<std::add_pointer_t<KPlato::ScheduleManager*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 32: _t->scheduleManagerChanged((*reinterpret_cast<std::add_pointer_t<KPlato::ScheduleManager*>>(_a[1]))); break;
        case 33: _t->scheduleManagerAdded((*reinterpret_cast<std::add_pointer_t<const KPlato::ScheduleManager*>>(_a[1]))); break;
        case 34: _t->scheduleManagerToBeAdded((*reinterpret_cast<std::add_pointer_t<const KPlato::ScheduleManager*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 35: _t->scheduleManagerRemoved((*reinterpret_cast<std::add_pointer_t<const KPlato::ScheduleManager*>>(_a[1]))); break;
        case 36: _t->scheduleManagerToBeRemoved((*reinterpret_cast<std::add_pointer_t<const KPlato::ScheduleManager*>>(_a[1]))); break;
        case 37: _t->scheduleManagerMoved((*reinterpret_cast<std::add_pointer_t<const KPlato::ScheduleManager*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 38: _t->scheduleManagerToBeMoved((*reinterpret_cast<std::add_pointer_t<const KPlato::ScheduleManager*>>(_a[1]))); break;
        case 39: _t->scheduleChanged((*reinterpret_cast<std::add_pointer_t<KPlato::MainSchedule*>>(_a[1]))); break;
        case 40: _t->scheduleToBeAdded((*reinterpret_cast<std::add_pointer_t<const KPlato::ScheduleManager*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 41: _t->scheduleAdded((*reinterpret_cast<std::add_pointer_t<const KPlato::MainSchedule*>>(_a[1]))); break;
        case 42: _t->scheduleToBeRemoved((*reinterpret_cast<std::add_pointer_t<const KPlato::MainSchedule*>>(_a[1]))); break;
        case 43: _t->scheduleRemoved((*reinterpret_cast<std::add_pointer_t<const KPlato::MainSchedule*>>(_a[1]))); break;
        case 44: _t->calendarChanged((*reinterpret_cast<std::add_pointer_t<KPlato::Calendar*>>(_a[1]))); break;
        case 45: _t->calendarToBeAdded((*reinterpret_cast<std::add_pointer_t<const KPlato::Calendar*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 46: _t->calendarAdded((*reinterpret_cast<std::add_pointer_t<const KPlato::Calendar*>>(_a[1]))); break;
        case 47: _t->calendarToBeRemoved((*reinterpret_cast<std::add_pointer_t<const KPlato::Calendar*>>(_a[1]))); break;
        case 48: _t->calendarRemoved((*reinterpret_cast<std::add_pointer_t<const KPlato::Calendar*>>(_a[1]))); break;
        case 49: _t->defaultCalendarChanged((*reinterpret_cast<std::add_pointer_t<KPlato::Calendar*>>(_a[1]))); break;
        case 50: _t->standardWorktimeChanged((*reinterpret_cast<std::add_pointer_t<KPlato::StandardWorktime*>>(_a[1]))); break;
        case 51: _t->relationToBeAdded((*reinterpret_cast<std::add_pointer_t<KPlato::Relation*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 52: _t->relationAdded((*reinterpret_cast<std::add_pointer_t<KPlato::Relation*>>(_a[1]))); break;
        case 53: _t->relationToBeRemoved((*reinterpret_cast<std::add_pointer_t<KPlato::Relation*>>(_a[1]))); break;
        case 54: _t->relationRemoved((*reinterpret_cast<std::add_pointer_t<KPlato::Relation*>>(_a[1]))); break;
        case 55: _t->relationToBeModified((*reinterpret_cast<std::add_pointer_t<KPlato::Relation*>>(_a[1]))); break;
        case 56: _t->relationModified((*reinterpret_cast<std::add_pointer_t<KPlato::Relation*>>(_a[1]))); break;
        case 57: _t->localeChanged(); break;
        case 58: _t->taskModulesChanged((*reinterpret_cast<std::add_pointer_t<QList<QUrl>>>(_a[1]))); break;
        case 59: _t->setProgress((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<KPlato::ScheduleManager*>>(_a[2]))); break;
        case 60: _t->setProgress((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 61: _t->setMaxProgress((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<KPlato::ScheduleManager*>>(_a[2]))); break;
        case 62: _t->setMaxProgress((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 63: _t->swapScheduleManagers((*reinterpret_cast<std::add_pointer_t<KPlato::ScheduleManager*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<KPlato::ScheduleManager*>>(_a[2]))); break;
        case 64: _t->nodeDestroyed((*reinterpret_cast<std::add_pointer_t<QObject*>>(_a[1]))); break;
        case 65: _t->emitProjectCalculated((*reinterpret_cast<std::add_pointer_t<KPlato::Project*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<KPlato::ScheduleManager*>>(_a[2]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Calendar* >(); break;
            }
            break;
        case 1:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::ScheduleManager* >(); break;
            }
            break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::ScheduleManager* >(); break;
            }
            break;
        case 9:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Project* >(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::ScheduleManager* >(); break;
            }
            break;
        case 10:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Project* >(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::ScheduleManager* >(); break;
            }
            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< KPlato::Node* >(); 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< KPlato::Node* >(); 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< KPlato::Node* >(); 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< KPlato::Node* >(); break;
            }
            break;
        case 15:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Node* >(); break;
            }
            break;
        case 16:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Node* >(); break;
            }
            break;
        case 17:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Node* >(); break;
            }
            break;
        case 18:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Node* >(); break;
            }
            break;
        case 19:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Node* >(); break;
            }
            break;
        case 20:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Node* >(); break;
            }
            break;
        case 21:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::ResourceGroup* >(); break;
            }
            break;
        case 22:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Project* >(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::ResourceGroup* >(); break;
            }
            break;
        case 23:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::ResourceGroup* >(); break;
            }
            break;
        case 24:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Project* >(); break;
            case 3:
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::ResourceGroup* >(); break;
            }
            break;
        case 26:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Resource* >(); break;
            }
            break;
        case 27:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Project* >(); break;
            }
            break;
        case 28:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Resource* >(); break;
            }
            break;
        case 29:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Project* >(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Resource* >(); break;
            }
            break;
        case 31:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::ScheduleManager* >(); break;
            }
            break;
        case 32:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::ScheduleManager* >(); break;
            }
            break;
        case 44:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Calendar* >(); break;
            }
            break;
        case 49:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Calendar* >(); break;
            }
            break;
        case 59:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::ScheduleManager* >(); break;
            }
            break;
        case 61:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::ScheduleManager* >(); break;
            }
            break;
        case 63:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::ScheduleManager* >(); break;
            }
            break;
        case 65:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::Project* >(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KPlato::ScheduleManager* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Calendar * )>(_a, &Project::freedaysCalendarChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::ScheduleManager * , KPlato::ScheduleManager * )>(_a, &Project::scheduleManagersSwapped, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)()>(_a, &Project::aboutToBeDeleted, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)()>(_a, &Project::projectChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)()>(_a, &Project::wbsDefinitionChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::ScheduleManager * )>(_a, &Project::projectCalculated, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)()>(_a, &Project::currentScheduleChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(int )>(_a, &Project::sigProgress, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(int )>(_a, &Project::maxProgress, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Project * , KPlato::ScheduleManager * )>(_a, &Project::sigCalculationStarted, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Project * , KPlato::ScheduleManager * )>(_a, &Project::sigCalculationFinished, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Node * , int )>(_a, &Project::nodeChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Node * , int )>(_a, &Project::nodeToBeAdded, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Node * )>(_a, &Project::nodeAdded, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Node * )>(_a, &Project::nodeToBeRemoved, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Node * )>(_a, &Project::nodeRemoved, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Node * , int , KPlato::Node * , int )>(_a, &Project::nodeToBeMoved, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Node * )>(_a, &Project::nodeMoved, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Node * , KPlato::Document * , int )>(_a, &Project::documentAdded, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Node * , KPlato::Document * , int )>(_a, &Project::documentRemoved, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Node * , KPlato::Document * , int )>(_a, &Project::documentChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::ResourceGroup * )>(_a, &Project::resourceGroupChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Project * , KPlato::ResourceGroup * , int )>(_a, &Project::resourceGroupToBeAdded, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::ResourceGroup * )>(_a, &Project::resourceGroupAdded, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Project * , KPlato::ResourceGroup * , int , KPlato::ResourceGroup * )>(_a, &Project::resourceGroupToBeRemoved, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)()>(_a, &Project::resourceGroupRemoved, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Resource * )>(_a, &Project::resourceChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Project * , int )>(_a, &Project::resourceToBeAdded, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Resource * )>(_a, &Project::resourceAdded, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Project * , int , KPlato::Resource * )>(_a, &Project::resourceToBeRemoved, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)()>(_a, &Project::resourceRemoved, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::ScheduleManager * , int )>(_a, &Project::scheduleManagerChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(const KPlato::ScheduleManager * )>(_a, &Project::scheduleManagerAdded, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(const KPlato::ScheduleManager * , int )>(_a, &Project::scheduleManagerToBeAdded, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(const KPlato::ScheduleManager * )>(_a, &Project::scheduleManagerRemoved, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(const KPlato::ScheduleManager * )>(_a, &Project::scheduleManagerToBeRemoved, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(const KPlato::ScheduleManager * , int )>(_a, &Project::scheduleManagerMoved, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(const KPlato::ScheduleManager * )>(_a, &Project::scheduleManagerToBeMoved, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::MainSchedule * )>(_a, &Project::scheduleChanged, 39))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(const KPlato::ScheduleManager * , int )>(_a, &Project::scheduleToBeAdded, 40))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(const KPlato::MainSchedule * )>(_a, &Project::scheduleAdded, 41))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(const KPlato::MainSchedule * )>(_a, &Project::scheduleToBeRemoved, 42))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(const KPlato::MainSchedule * )>(_a, &Project::scheduleRemoved, 43))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Calendar * )>(_a, &Project::calendarChanged, 44))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(const KPlato::Calendar * , int )>(_a, &Project::calendarToBeAdded, 45))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(const KPlato::Calendar * )>(_a, &Project::calendarAdded, 46))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(const KPlato::Calendar * )>(_a, &Project::calendarToBeRemoved, 47))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(const KPlato::Calendar * )>(_a, &Project::calendarRemoved, 48))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Calendar * )>(_a, &Project::defaultCalendarChanged, 49))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::StandardWorktime * )>(_a, &Project::standardWorktimeChanged, 50))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Relation * , int , int )>(_a, &Project::relationToBeAdded, 51))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Relation * )>(_a, &Project::relationAdded, 52))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Relation * )>(_a, &Project::relationToBeRemoved, 53))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Relation * )>(_a, &Project::relationRemoved, 54))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Relation * )>(_a, &Project::relationToBeModified, 55))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(KPlato::Relation * )>(_a, &Project::relationModified, 56))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)()>(_a, &Project::localeChanged, 57))
            return;
        if (QtMocHelpers::indexOfMethod<void (Project::*)(const QList<QUrl> & )>(_a, &Project::taskModulesChanged, 58))
            return;
    }
}

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

void *KPlato::Project::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6KPlato7ProjectE_t>.strings))
        return static_cast<void*>(this);
    return Node::qt_metacast(_clname);
}

int KPlato::Project::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Node::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 66)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 66;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 66)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 66;
    }
    return _id;
}

// SIGNAL 0
void KPlato::Project::freedaysCalendarChanged(KPlato::Calendar * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void KPlato::Project::scheduleManagersSwapped(KPlato::ScheduleManager * _t1, KPlato::ScheduleManager * _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}

// SIGNAL 2
void KPlato::Project::aboutToBeDeleted()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void KPlato::Project::projectChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void KPlato::Project::wbsDefinitionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void KPlato::Project::projectCalculated(KPlato::ScheduleManager * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void KPlato::Project::currentScheduleChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void KPlato::Project::sigProgress(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void KPlato::Project::maxProgress(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void KPlato::Project::sigCalculationStarted(KPlato::Project * _t1, KPlato::ScheduleManager * _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1, _t2);
}

// SIGNAL 10
void KPlato::Project::sigCalculationFinished(KPlato::Project * _t1, KPlato::ScheduleManager * _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1, _t2);
}

// SIGNAL 11
void KPlato::Project::nodeChanged(KPlato::Node * _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1, _t2);
}

// SIGNAL 12
void KPlato::Project::nodeToBeAdded(KPlato::Node * _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1, _t2);
}

// SIGNAL 13
void KPlato::Project::nodeAdded(KPlato::Node * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void KPlato::Project::nodeToBeRemoved(KPlato::Node * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void KPlato::Project::nodeRemoved(KPlato::Node * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

// SIGNAL 16
void KPlato::Project::nodeToBeMoved(KPlato::Node * _t1, int _t2, KPlato::Node * _t3, int _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 17
void KPlato::Project::nodeMoved(KPlato::Node * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

// SIGNAL 18
void KPlato::Project::documentAdded(KPlato::Node * _t1, KPlato::Document * _t2, int _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1, _t2, _t3);
}

// SIGNAL 19
void KPlato::Project::documentRemoved(KPlato::Node * _t1, KPlato::Document * _t2, int _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1, _t2, _t3);
}

// SIGNAL 20
void KPlato::Project::documentChanged(KPlato::Node * _t1, KPlato::Document * _t2, int _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1, _t2, _t3);
}

// SIGNAL 21
void KPlato::Project::resourceGroupChanged(KPlato::ResourceGroup * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void KPlato::Project::resourceGroupToBeAdded(KPlato::Project * _t1, KPlato::ResourceGroup * _t2, int _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1, _t2, _t3);
}

// SIGNAL 23
void KPlato::Project::resourceGroupAdded(KPlato::ResourceGroup * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void KPlato::Project::resourceGroupToBeRemoved(KPlato::Project * _t1, KPlato::ResourceGroup * _t2, int _t3, KPlato::ResourceGroup * _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 25
void KPlato::Project::resourceGroupRemoved()
{
    QMetaObject::activate(this, &staticMetaObject, 25, nullptr);
}

// SIGNAL 26
void KPlato::Project::resourceChanged(KPlato::Resource * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 26, nullptr, _t1);
}

// SIGNAL 27
void KPlato::Project::resourceToBeAdded(KPlato::Project * _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1, _t2);
}

// SIGNAL 28
void KPlato::Project::resourceAdded(KPlato::Resource * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1);
}

// SIGNAL 29
void KPlato::Project::resourceToBeRemoved(KPlato::Project * _t1, int _t2, KPlato::Resource * _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 29, nullptr, _t1, _t2, _t3);
}

// SIGNAL 30
void KPlato::Project::resourceRemoved()
{
    QMetaObject::activate(this, &staticMetaObject, 30, nullptr);
}

// SIGNAL 31
void KPlato::Project::scheduleManagerChanged(KPlato::ScheduleManager * _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1, _t2);
}

// SIGNAL 33
void KPlato::Project::scheduleManagerAdded(const KPlato::ScheduleManager * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 33, nullptr, _t1);
}

// SIGNAL 34
void KPlato::Project::scheduleManagerToBeAdded(const KPlato::ScheduleManager * _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 34, nullptr, _t1, _t2);
}

// SIGNAL 35
void KPlato::Project::scheduleManagerRemoved(const KPlato::ScheduleManager * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 35, nullptr, _t1);
}

// SIGNAL 36
void KPlato::Project::scheduleManagerToBeRemoved(const KPlato::ScheduleManager * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 36, nullptr, _t1);
}

// SIGNAL 37
void KPlato::Project::scheduleManagerMoved(const KPlato::ScheduleManager * _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 37, nullptr, _t1, _t2);
}

// SIGNAL 38
void KPlato::Project::scheduleManagerToBeMoved(const KPlato::ScheduleManager * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 38, nullptr, _t1);
}

// SIGNAL 39
void KPlato::Project::scheduleChanged(KPlato::MainSchedule * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 39, nullptr, _t1);
}

// SIGNAL 40
void KPlato::Project::scheduleToBeAdded(const KPlato::ScheduleManager * _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 40, nullptr, _t1, _t2);
}

// SIGNAL 41
void KPlato::Project::scheduleAdded(const KPlato::MainSchedule * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 41, nullptr, _t1);
}

// SIGNAL 42
void KPlato::Project::scheduleToBeRemoved(const KPlato::MainSchedule * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 42, nullptr, _t1);
}

// SIGNAL 43
void KPlato::Project::scheduleRemoved(const KPlato::MainSchedule * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 43, nullptr, _t1);
}

// SIGNAL 44
void KPlato::Project::calendarChanged(KPlato::Calendar * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 44, nullptr, _t1);
}

// SIGNAL 45
void KPlato::Project::calendarToBeAdded(const KPlato::Calendar * _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 45, nullptr, _t1, _t2);
}

// SIGNAL 46
void KPlato::Project::calendarAdded(const KPlato::Calendar * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 46, nullptr, _t1);
}

// SIGNAL 47
void KPlato::Project::calendarToBeRemoved(const KPlato::Calendar * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 47, nullptr, _t1);
}

// SIGNAL 48
void KPlato::Project::calendarRemoved(const KPlato::Calendar * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 48, nullptr, _t1);
}

// SIGNAL 49
void KPlato::Project::defaultCalendarChanged(KPlato::Calendar * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 49, nullptr, _t1);
}

// SIGNAL 50
void KPlato::Project::standardWorktimeChanged(KPlato::StandardWorktime * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 50, nullptr, _t1);
}

// SIGNAL 51
void KPlato::Project::relationToBeAdded(KPlato::Relation * _t1, int _t2, int _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 51, nullptr, _t1, _t2, _t3);
}

// SIGNAL 52
void KPlato::Project::relationAdded(KPlato::Relation * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 52, nullptr, _t1);
}

// SIGNAL 53
void KPlato::Project::relationToBeRemoved(KPlato::Relation * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 53, nullptr, _t1);
}

// SIGNAL 54
void KPlato::Project::relationRemoved(KPlato::Relation * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 54, nullptr, _t1);
}

// SIGNAL 55
void KPlato::Project::relationToBeModified(KPlato::Relation * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 55, nullptr, _t1);
}

// SIGNAL 56
void KPlato::Project::relationModified(KPlato::Relation * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 56, nullptr, _t1);
}

// SIGNAL 57
void KPlato::Project::localeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 57, nullptr);
}

// SIGNAL 58
void KPlato::Project::taskModulesChanged(const QList<QUrl> & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 58, nullptr, _t1);
}
QT_WARNING_POP
