/****************************************************************************
** Meta object code from reading C++ file 'imagingplanner.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 "../../../../kstars-3.8.4.1/kstars/tools/imagingplanner.h"
#include <QtNetwork/QSslError>
#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 'imagingplanner.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_ZN16ImagingPlannerUIE_t {};
} // unnamed namespace

template <> constexpr inline auto ImagingPlannerUI::qt_create_metaobjectdata<qt_meta_tag_ZN16ImagingPlannerUIE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ImagingPlannerUI"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ImagingPlannerUI, qt_meta_tag_ZN16ImagingPlannerUIE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ImagingPlannerUI::staticMetaObject = { {
    QMetaObject::SuperData::link<QFrame::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16ImagingPlannerUIE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16ImagingPlannerUIE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16ImagingPlannerUIE_t>.metaTypes,
    nullptr
} };

void ImagingPlannerUI::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ImagingPlannerUI *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *ImagingPlannerUI::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16ImagingPlannerUIE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::ImagingPlanner"))
        return static_cast< Ui::ImagingPlanner*>(this);
    return QFrame::qt_metacast(_clname);
}

int ImagingPlannerUI::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QFrame::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN13CatalogFilterE_t {};
} // unnamed namespace

template <> constexpr inline auto CatalogFilter::qt_create_metaobjectdata<qt_meta_tag_ZN13CatalogFilterE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "CatalogFilter"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<CatalogFilter, qt_meta_tag_ZN13CatalogFilterE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject CatalogFilter::staticMetaObject = { {
    QMetaObject::SuperData::link<QSortFilterProxyModel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13CatalogFilterE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13CatalogFilterE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13CatalogFilterE_t>.metaTypes,
    nullptr
} };

void CatalogFilter::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<CatalogFilter *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

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

int CatalogFilter::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSortFilterProxyModel::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN14ImagingPlannerE_t {};
} // unnamed namespace

template <> constexpr inline auto ImagingPlanner::qt_create_metaobjectdata<qt_meta_tag_ZN14ImagingPlannerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ImagingPlanner",
        "popupSorry",
        "",
        "message",
        "addRow",
        "QList<QStandardItem*>",
        "itemList",
        "selectionChanged",
        "QItemSelection",
        "selected",
        "deselected",
        "setSelection",
        "flag",
        "enabled",
        "setSelectionIgnored",
        "setSelectionNotIgnored",
        "setSelectionImaged",
        "setSelectionNotImaged",
        "setSelectionPicked",
        "setSelectionNotPicked",
        "centerOnSkymap",
        "reallyCenterOnSkymap",
        "takeScreenshot",
        "slotClose",
        "searchAstrobin",
        "searchWikipedia",
        "searchSimbad",
        "searchSpecialWebPageImages",
        "recompute",
        "sorry",
        "userNotesEditFinished",
        "keywordEditFinished",
        "loadImagedFile",
        "searchSlot",
        "loadCatalogViaMenu",
        "getHelp",
        "openOptionsMenu",
        "addRowSlot",
        "captureRegion",
        "QImage",
        "screenshot"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'popupSorry'
        QtMocHelpers::SignalData<void(const QString &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'addRow'
        QtMocHelpers::SignalData<void(QList<QStandardItem*>)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 },
        }}),
        // Slot 'selectionChanged'
        QtMocHelpers::SlotData<void(const QItemSelection &, const QItemSelection &)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 }, { 0x80000000 | 8, 10 },
        }}),
        // Slot 'setSelection'
        QtMocHelpers::SlotData<void(int, bool)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 12 }, { QMetaType::Bool, 13 },
        }}),
        // Slot 'setSelectionIgnored'
        QtMocHelpers::SlotData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setSelectionNotIgnored'
        QtMocHelpers::SlotData<void()>(15, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setSelectionImaged'
        QtMocHelpers::SlotData<void()>(16, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setSelectionNotImaged'
        QtMocHelpers::SlotData<void()>(17, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setSelectionPicked'
        QtMocHelpers::SlotData<void()>(18, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setSelectionNotPicked'
        QtMocHelpers::SlotData<void()>(19, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'centerOnSkymap'
        QtMocHelpers::SlotData<void()>(20, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'reallyCenterOnSkymap'
        QtMocHelpers::SlotData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'takeScreenshot'
        QtMocHelpers::SlotData<void()>(22, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotClose'
        QtMocHelpers::SlotData<void()>(23, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'searchAstrobin'
        QtMocHelpers::SlotData<void()>(24, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'searchWikipedia'
        QtMocHelpers::SlotData<void()>(25, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'searchSimbad'
        QtMocHelpers::SlotData<void()>(26, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'searchSpecialWebPageImages'
        QtMocHelpers::SlotData<void()>(27, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'recompute'
        QtMocHelpers::SlotData<void()>(28, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'sorry'
        QtMocHelpers::SlotData<void(const QString &)>(29, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'userNotesEditFinished'
        QtMocHelpers::SlotData<void()>(30, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'keywordEditFinished'
        QtMocHelpers::SlotData<void()>(31, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'loadImagedFile'
        QtMocHelpers::SlotData<void()>(32, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'searchSlot'
        QtMocHelpers::SlotData<void()>(33, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'loadCatalogViaMenu'
        QtMocHelpers::SlotData<void()>(34, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'getHelp'
        QtMocHelpers::SlotData<void()>(35, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'openOptionsMenu'
        QtMocHelpers::SlotData<void()>(36, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addRowSlot'
        QtMocHelpers::SlotData<void(QList<QStandardItem*>)>(37, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 5, 6 },
        }}),
        // Slot 'captureRegion'
        QtMocHelpers::SlotData<void(const QImage &)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 39, 40 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ImagingPlanner, qt_meta_tag_ZN14ImagingPlannerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ImagingPlanner::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14ImagingPlannerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14ImagingPlannerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14ImagingPlannerE_t>.metaTypes,
    nullptr
} };

void ImagingPlanner::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ImagingPlanner *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->popupSorry((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 1: _t->addRow((*reinterpret_cast<std::add_pointer_t<QList<QStandardItem*>>>(_a[1]))); break;
        case 2: _t->selectionChanged((*reinterpret_cast<std::add_pointer_t<QItemSelection>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QItemSelection>>(_a[2]))); break;
        case 3: _t->setSelection((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 4: _t->setSelectionIgnored(); break;
        case 5: _t->setSelectionNotIgnored(); break;
        case 6: _t->setSelectionImaged(); break;
        case 7: _t->setSelectionNotImaged(); break;
        case 8: _t->setSelectionPicked(); break;
        case 9: _t->setSelectionNotPicked(); break;
        case 10: _t->centerOnSkymap(); break;
        case 11: _t->reallyCenterOnSkymap(); break;
        case 12: _t->takeScreenshot(); break;
        case 13: _t->slotClose(); break;
        case 14: _t->searchAstrobin(); break;
        case 15: _t->searchWikipedia(); break;
        case 16: _t->searchSimbad(); break;
        case 17: _t->searchSpecialWebPageImages(); break;
        case 18: _t->recompute(); break;
        case 19: _t->sorry((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 20: _t->userNotesEditFinished(); break;
        case 21: _t->keywordEditFinished(); break;
        case 22: _t->loadImagedFile(); break;
        case 23: _t->searchSlot(); break;
        case 24: _t->loadCatalogViaMenu(); break;
        case 25: _t->getHelp(); break;
        case 26: _t->openOptionsMenu(); break;
        case 27: _t->addRowSlot((*reinterpret_cast<std::add_pointer_t<QList<QStandardItem*>>>(_a[1]))); break;
        case 28: _t->captureRegion((*reinterpret_cast<std::add_pointer_t<QImage>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (ImagingPlanner::*)(const QString & )>(_a, &ImagingPlanner::popupSorry, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImagingPlanner::*)(QList<QStandardItem*> )>(_a, &ImagingPlanner::addRow, 1))
            return;
    }
}

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

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

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

// SIGNAL 0
void ImagingPlanner::popupSorry(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void ImagingPlanner::addRow(QList<QStandardItem*> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN19ImagingPlannerPopupE_t {};
} // unnamed namespace

template <> constexpr inline auto ImagingPlannerPopup::qt_create_metaobjectdata<qt_meta_tag_ZN19ImagingPlannerPopupE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ImagingPlannerPopup"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ImagingPlannerPopup, qt_meta_tag_ZN19ImagingPlannerPopupE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ImagingPlannerPopup::staticMetaObject = { {
    QMetaObject::SuperData::link<QMenu::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19ImagingPlannerPopupE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19ImagingPlannerPopupE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19ImagingPlannerPopupE_t>.metaTypes,
    nullptr
} };

void ImagingPlannerPopup::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ImagingPlannerPopup *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

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

int ImagingPlannerPopup::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QMenu::qt_metacall(_c, _id, _a);
    return _id;
}
QT_WARNING_POP
