/****************************************************************************
** Meta object code from reading C++ file 'cryptoconfigmodule_p.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 "../../../../libkleo-26.04.3/src/ui/cryptoconfigmodule_p.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 'cryptoconfigmodule_p.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_ZN4Kleo24CryptoConfigComponentGUIE_t {};
} // unnamed namespace

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

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

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

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

void *Kleo::CryptoConfigComponentGUI::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Kleo24CryptoConfigComponentGUIE_t>.strings))
        return static_cast<void*>(this);
    return QWidget::qt_metacast(_clname);
}

int Kleo::CryptoConfigComponentGUI::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QWidget::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN4Kleo20CryptoConfigGroupGUIE_t {};
} // unnamed namespace

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

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

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

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

void *Kleo::CryptoConfigGroupGUI::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Kleo20CryptoConfigGroupGUIE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int Kleo::CryptoConfigGroupGUI::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN4Kleo20CryptoConfigEntryGUIE_t {};
} // unnamed namespace

template <> constexpr inline auto Kleo::CryptoConfigEntryGUI::qt_create_metaobjectdata<qt_meta_tag_ZN4Kleo20CryptoConfigEntryGUIE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Kleo::CryptoConfigEntryGUI",
        "changed",
        "",
        "slotChanged"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'changed'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotChanged'
        QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessProtected, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<CryptoConfigEntryGUI, qt_meta_tag_ZN4Kleo20CryptoConfigEntryGUIE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Kleo::CryptoConfigEntryGUI::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Kleo20CryptoConfigEntryGUIE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Kleo20CryptoConfigEntryGUIE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN4Kleo20CryptoConfigEntryGUIE_t>.metaTypes,
    nullptr
} };

void Kleo::CryptoConfigEntryGUI::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<CryptoConfigEntryGUI *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->changed(); break;
        case 1: _t->slotChanged(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (CryptoConfigEntryGUI::*)()>(_a, &CryptoConfigEntryGUI::changed, 0))
            return;
    }
}

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

void *Kleo::CryptoConfigEntryGUI::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Kleo20CryptoConfigEntryGUIE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

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

// SIGNAL 0
void Kleo::CryptoConfigEntryGUI::changed()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN4Kleo25CryptoConfigEntryLineEditE_t {};
} // unnamed namespace

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

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

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

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

void *Kleo::CryptoConfigEntryLineEdit::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Kleo25CryptoConfigEntryLineEditE_t>.strings))
        return static_cast<void*>(this);
    return CryptoConfigEntryGUI::qt_metacast(_clname);
}

int Kleo::CryptoConfigEntryLineEdit::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CryptoConfigEntryGUI::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN4Kleo27CryptoConfigEntryDebugLevelE_t {};
} // unnamed namespace

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

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

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

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

void *Kleo::CryptoConfigEntryDebugLevel::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Kleo27CryptoConfigEntryDebugLevelE_t>.strings))
        return static_cast<void*>(this);
    return CryptoConfigEntryGUI::qt_metacast(_clname);
}

int Kleo::CryptoConfigEntryDebugLevel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CryptoConfigEntryGUI::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN4Kleo21CryptoConfigEntryPathE_t {};
} // unnamed namespace

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

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

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

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

void *Kleo::CryptoConfigEntryPath::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Kleo21CryptoConfigEntryPathE_t>.strings))
        return static_cast<void*>(this);
    return CryptoConfigEntryGUI::qt_metacast(_clname);
}

int Kleo::CryptoConfigEntryPath::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CryptoConfigEntryGUI::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN4Kleo24CryptoConfigEntryDirPathE_t {};
} // unnamed namespace

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

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

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

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

void *Kleo::CryptoConfigEntryDirPath::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Kleo24CryptoConfigEntryDirPathE_t>.strings))
        return static_cast<void*>(this);
    return CryptoConfigEntryGUI::qt_metacast(_clname);
}

int Kleo::CryptoConfigEntryDirPath::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CryptoConfigEntryGUI::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN4Kleo24CryptoConfigEntrySpinBoxE_t {};
} // unnamed namespace

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

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

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

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

void *Kleo::CryptoConfigEntrySpinBox::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Kleo24CryptoConfigEntrySpinBoxE_t>.strings))
        return static_cast<void*>(this);
    return CryptoConfigEntryGUI::qt_metacast(_clname);
}

int Kleo::CryptoConfigEntrySpinBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CryptoConfigEntryGUI::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN4Kleo25CryptoConfigEntryCheckBoxE_t {};
} // unnamed namespace

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

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

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

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

void *Kleo::CryptoConfigEntryCheckBox::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Kleo25CryptoConfigEntryCheckBoxE_t>.strings))
        return static_cast<void*>(this);
    return CryptoConfigEntryGUI::qt_metacast(_clname);
}

int Kleo::CryptoConfigEntryCheckBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CryptoConfigEntryGUI::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN4Kleo24CryptoConfigEntryLDAPURLE_t {};
} // unnamed namespace

template <> constexpr inline auto Kleo::CryptoConfigEntryLDAPURL::qt_create_metaobjectdata<qt_meta_tag_ZN4Kleo24CryptoConfigEntryLDAPURLE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Kleo::CryptoConfigEntryLDAPURL",
        "slotOpenDialog",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'slotOpenDialog'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<CryptoConfigEntryLDAPURL, qt_meta_tag_ZN4Kleo24CryptoConfigEntryLDAPURLE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Kleo::CryptoConfigEntryLDAPURL::staticMetaObject = { {
    QMetaObject::SuperData::link<CryptoConfigEntryGUI::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Kleo24CryptoConfigEntryLDAPURLE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Kleo24CryptoConfigEntryLDAPURLE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN4Kleo24CryptoConfigEntryLDAPURLE_t>.metaTypes,
    nullptr
} };

void Kleo::CryptoConfigEntryLDAPURL::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<CryptoConfigEntryLDAPURL *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->slotOpenDialog(); break;
        default: ;
        }
    }
    (void)_a;
}

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

void *Kleo::CryptoConfigEntryLDAPURL::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Kleo24CryptoConfigEntryLDAPURLE_t>.strings))
        return static_cast<void*>(this);
    return CryptoConfigEntryGUI::qt_metacast(_clname);
}

int Kleo::CryptoConfigEntryLDAPURL::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CryptoConfigEntryGUI::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}
QT_WARNING_POP
