/****************************************************************************
** Meta object code from reading C++ file 'scriptargwidgets.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/scriptargwidgets.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'scriptargwidgets.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_ZN13ArgLookTowardE_t {};
} // unnamed namespace

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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