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

#include "../../../../src/kid3-3.4.5/src/core/config/importconfig.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'importconfig.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.6.2. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

QT_BEGIN_MOC_NAMESPACE
struct qt_meta_stringdata_ImportConfig_t {
    QByteArrayData data[48];
    char stringdata0[1016];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ImportConfig_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ImportConfig_t qt_meta_stringdata_ImportConfig = {
    {
QT_MOC_LITERAL(0, 0, 12), // "ImportConfig"
QT_MOC_LITERAL(1, 13, 23), // "availablePluginsChanged"
QT_MOC_LITERAL(2, 37, 0), // ""
QT_MOC_LITERAL(3, 38, 16), // "availablePlugins"
QT_MOC_LITERAL(4, 55, 19), // "importServerChanged"
QT_MOC_LITERAL(5, 75, 12), // "importServer"
QT_MOC_LITERAL(6, 88, 17), // "importDestChanged"
QT_MOC_LITERAL(7, 106, 17), // "Frame::TagVersion"
QT_MOC_LITERAL(8, 124, 10), // "importDest"
QT_MOC_LITERAL(9, 135, 24), // "importFormatNamesChanged"
QT_MOC_LITERAL(10, 160, 17), // "importFormatNames"
QT_MOC_LITERAL(11, 178, 26), // "importFormatHeadersChanged"
QT_MOC_LITERAL(12, 205, 19), // "importFormatHeaders"
QT_MOC_LITERAL(13, 225, 25), // "importFormatTracksChanged"
QT_MOC_LITERAL(14, 251, 18), // "importFormatTracks"
QT_MOC_LITERAL(15, 270, 24), // "importFormatIndexChanged"
QT_MOC_LITERAL(16, 295, 17), // "importFormatIndex"
QT_MOC_LITERAL(17, 313, 24), // "maxTimeDifferenceChanged"
QT_MOC_LITERAL(18, 338, 17), // "maxTimeDifference"
QT_MOC_LITERAL(19, 356, 27), // "importVisibleColumnsChanged"
QT_MOC_LITERAL(20, 384, 20), // "importVisibleColumns"
QT_MOC_LITERAL(21, 405, 27), // "importWindowGeometryChanged"
QT_MOC_LITERAL(22, 433, 20), // "importWindowGeometry"
QT_MOC_LITERAL(23, 454, 22), // "importTagsNamesChanged"
QT_MOC_LITERAL(24, 477, 15), // "importTagsNames"
QT_MOC_LITERAL(25, 493, 24), // "importTagsSourcesChanged"
QT_MOC_LITERAL(26, 518, 17), // "importTagsSources"
QT_MOC_LITERAL(27, 536, 28), // "importTagsExtractionsChanged"
QT_MOC_LITERAL(28, 565, 21), // "importTagsExtractions"
QT_MOC_LITERAL(29, 587, 22), // "importTagsIndexChanged"
QT_MOC_LITERAL(30, 610, 15), // "importTagsIndex"
QT_MOC_LITERAL(31, 626, 25), // "pictureSourceNamesChanged"
QT_MOC_LITERAL(32, 652, 18), // "pictureSourceNames"
QT_MOC_LITERAL(33, 671, 24), // "pictureSourceUrlsChanged"
QT_MOC_LITERAL(34, 696, 17), // "pictureSourceUrls"
QT_MOC_LITERAL(35, 714, 25), // "pictureSourceIndexChanged"
QT_MOC_LITERAL(36, 740, 18), // "pictureSourceIndex"
QT_MOC_LITERAL(37, 759, 35), // "browseCoverArtWindowGeometryC..."
QT_MOC_LITERAL(38, 795, 28), // "browseCoverArtWindowGeometry"
QT_MOC_LITERAL(39, 824, 25), // "matchPictureUrlMapChanged"
QT_MOC_LITERAL(40, 850, 21), // "QMap<QString,QString>"
QT_MOC_LITERAL(41, 872, 18), // "matchPictureUrlMap"
QT_MOC_LITERAL(42, 891, 16), // "importDirChanged"
QT_MOC_LITERAL(43, 908, 9), // "importDir"
QT_MOC_LITERAL(44, 918, 22), // "disabledPluginsChanged"
QT_MOC_LITERAL(45, 941, 15), // "disabledPlugins"
QT_MOC_LITERAL(46, 957, 32), // "enableTimeDifferenceCheckChanged"
QT_MOC_LITERAL(47, 990, 25) // "enableTimeDifferenceCheck"

    },
    "ImportConfig\0availablePluginsChanged\0"
    "\0availablePlugins\0importServerChanged\0"
    "importServer\0importDestChanged\0"
    "Frame::TagVersion\0importDest\0"
    "importFormatNamesChanged\0importFormatNames\0"
    "importFormatHeadersChanged\0"
    "importFormatHeaders\0importFormatTracksChanged\0"
    "importFormatTracks\0importFormatIndexChanged\0"
    "importFormatIndex\0maxTimeDifferenceChanged\0"
    "maxTimeDifference\0importVisibleColumnsChanged\0"
    "importVisibleColumns\0importWindowGeometryChanged\0"
    "importWindowGeometry\0importTagsNamesChanged\0"
    "importTagsNames\0importTagsSourcesChanged\0"
    "importTagsSources\0importTagsExtractionsChanged\0"
    "importTagsExtractions\0importTagsIndexChanged\0"
    "importTagsIndex\0pictureSourceNamesChanged\0"
    "pictureSourceNames\0pictureSourceUrlsChanged\0"
    "pictureSourceUrls\0pictureSourceIndexChanged\0"
    "pictureSourceIndex\0"
    "browseCoverArtWindowGeometryChanged\0"
    "browseCoverArtWindowGeometry\0"
    "matchPictureUrlMapChanged\0"
    "QMap<QString,QString>\0matchPictureUrlMap\0"
    "importDirChanged\0importDir\0"
    "disabledPluginsChanged\0disabledPlugins\0"
    "enableTimeDifferenceCheckChanged\0"
    "enableTimeDifferenceCheck"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ImportConfig[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
      22,   14, // methods
      22,  190, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
      22,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    1,  124,    2, 0x06 /* Public */,
       4,    1,  127,    2, 0x06 /* Public */,
       6,    1,  130,    2, 0x06 /* Public */,
       9,    1,  133,    2, 0x06 /* Public */,
      11,    1,  136,    2, 0x06 /* Public */,
      13,    1,  139,    2, 0x06 /* Public */,
      15,    1,  142,    2, 0x06 /* Public */,
      17,    1,  145,    2, 0x06 /* Public */,
      19,    1,  148,    2, 0x06 /* Public */,
      21,    1,  151,    2, 0x06 /* Public */,
      23,    1,  154,    2, 0x06 /* Public */,
      25,    1,  157,    2, 0x06 /* Public */,
      27,    1,  160,    2, 0x06 /* Public */,
      29,    1,  163,    2, 0x06 /* Public */,
      31,    1,  166,    2, 0x06 /* Public */,
      33,    1,  169,    2, 0x06 /* Public */,
      35,    1,  172,    2, 0x06 /* Public */,
      37,    1,  175,    2, 0x06 /* Public */,
      39,    1,  178,    2, 0x06 /* Public */,
      42,    1,  181,    2, 0x06 /* Public */,
      44,    1,  184,    2, 0x06 /* Public */,
      46,    1,  187,    2, 0x06 /* Public */,

 // signals: parameters
    QMetaType::Void, QMetaType::QStringList,    3,
    QMetaType::Void, QMetaType::Int,    5,
    QMetaType::Void, 0x80000000 | 7,    8,
    QMetaType::Void, QMetaType::QStringList,   10,
    QMetaType::Void, QMetaType::QStringList,   12,
    QMetaType::Void, QMetaType::QStringList,   14,
    QMetaType::Void, QMetaType::Int,   16,
    QMetaType::Void, QMetaType::Int,   18,
    QMetaType::Void, QMetaType::ULongLong,   20,
    QMetaType::Void, QMetaType::QByteArray,   22,
    QMetaType::Void, QMetaType::QStringList,   24,
    QMetaType::Void, QMetaType::QStringList,   26,
    QMetaType::Void, QMetaType::QStringList,   28,
    QMetaType::Void, QMetaType::Int,   30,
    QMetaType::Void, QMetaType::QStringList,   32,
    QMetaType::Void, QMetaType::QStringList,   34,
    QMetaType::Void, QMetaType::Int,   36,
    QMetaType::Void, QMetaType::QByteArray,   38,
    QMetaType::Void, 0x80000000 | 40,   41,
    QMetaType::Void, QMetaType::QString,   43,
    QMetaType::Void, QMetaType::QStringList,   45,
    QMetaType::Void, QMetaType::Bool,   47,

 // properties: name, type, flags
       3, QMetaType::QStringList, 0x00495103,
       5, QMetaType::Int, 0x00495103,
       8, QMetaType::Int, 0x00495003,
      10, QMetaType::QStringList, 0x00495103,
      12, QMetaType::QStringList, 0x00495103,
      14, QMetaType::QStringList, 0x00495103,
      16, QMetaType::Int, 0x00495103,
      18, QMetaType::Int, 0x00495103,
      20, QMetaType::ULongLong, 0x00495103,
      22, QMetaType::QByteArray, 0x00495103,
      24, QMetaType::QStringList, 0x00495103,
      26, QMetaType::QStringList, 0x00495103,
      28, QMetaType::QStringList, 0x00495103,
      30, QMetaType::Int, 0x00495103,
      32, QMetaType::QStringList, 0x00495103,
      34, QMetaType::QStringList, 0x00495103,
      36, QMetaType::Int, 0x00495103,
      38, QMetaType::QByteArray, 0x00495103,
      41, QMetaType::QVariantMap, 0x00495003,
      43, QMetaType::QString, 0x00495103,
      45, QMetaType::QStringList, 0x00495103,
      47, QMetaType::Bool, 0x00495103,

 // properties: notify_signal_id
       0,
       1,
       2,
       3,
       4,
       5,
       6,
       7,
       8,
       9,
      10,
      11,
      12,
      13,
      14,
      15,
      16,
      17,
      18,
      19,
      20,
      21,

       0        // eod
};

void ImportConfig::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ImportConfig *_t = static_cast<ImportConfig *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->availablePluginsChanged((*reinterpret_cast< const QStringList(*)>(_a[1]))); break;
        case 1: _t->importServerChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 2: _t->importDestChanged((*reinterpret_cast< Frame::TagVersion(*)>(_a[1]))); break;
        case 3: _t->importFormatNamesChanged((*reinterpret_cast< const QStringList(*)>(_a[1]))); break;
        case 4: _t->importFormatHeadersChanged((*reinterpret_cast< const QStringList(*)>(_a[1]))); break;
        case 5: _t->importFormatTracksChanged((*reinterpret_cast< const QStringList(*)>(_a[1]))); break;
        case 6: _t->importFormatIndexChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 7: _t->maxTimeDifferenceChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 8: _t->importVisibleColumnsChanged((*reinterpret_cast< quint64(*)>(_a[1]))); break;
        case 9: _t->importWindowGeometryChanged((*reinterpret_cast< const QByteArray(*)>(_a[1]))); break;
        case 10: _t->importTagsNamesChanged((*reinterpret_cast< const QStringList(*)>(_a[1]))); break;
        case 11: _t->importTagsSourcesChanged((*reinterpret_cast< const QStringList(*)>(_a[1]))); break;
        case 12: _t->importTagsExtractionsChanged((*reinterpret_cast< const QStringList(*)>(_a[1]))); break;
        case 13: _t->importTagsIndexChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 14: _t->pictureSourceNamesChanged((*reinterpret_cast< const QStringList(*)>(_a[1]))); break;
        case 15: _t->pictureSourceUrlsChanged((*reinterpret_cast< const QStringList(*)>(_a[1]))); break;
        case 16: _t->pictureSourceIndexChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 17: _t->browseCoverArtWindowGeometryChanged((*reinterpret_cast< const QByteArray(*)>(_a[1]))); break;
        case 18: _t->matchPictureUrlMapChanged((*reinterpret_cast< const QMap<QString,QString>(*)>(_a[1]))); break;
        case 19: _t->importDirChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 20: _t->disabledPluginsChanged((*reinterpret_cast< const QStringList(*)>(_a[1]))); break;
        case 21: _t->enableTimeDifferenceCheckChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ImportConfig::*_t)(const QStringList & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::availablePluginsChanged)) {
                *result = 0;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(int );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::importServerChanged)) {
                *result = 1;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(Frame::TagVersion );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::importDestChanged)) {
                *result = 2;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(const QStringList & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::importFormatNamesChanged)) {
                *result = 3;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(const QStringList & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::importFormatHeadersChanged)) {
                *result = 4;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(const QStringList & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::importFormatTracksChanged)) {
                *result = 5;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(int );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::importFormatIndexChanged)) {
                *result = 6;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(int );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::maxTimeDifferenceChanged)) {
                *result = 7;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(quint64 );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::importVisibleColumnsChanged)) {
                *result = 8;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(const QByteArray & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::importWindowGeometryChanged)) {
                *result = 9;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(const QStringList & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::importTagsNamesChanged)) {
                *result = 10;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(const QStringList & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::importTagsSourcesChanged)) {
                *result = 11;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(const QStringList & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::importTagsExtractionsChanged)) {
                *result = 12;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(int );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::importTagsIndexChanged)) {
                *result = 13;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(const QStringList & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::pictureSourceNamesChanged)) {
                *result = 14;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(const QStringList & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::pictureSourceUrlsChanged)) {
                *result = 15;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(int );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::pictureSourceIndexChanged)) {
                *result = 16;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(const QByteArray & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::browseCoverArtWindowGeometryChanged)) {
                *result = 17;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(const QMap<QString,QString> & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::matchPictureUrlMapChanged)) {
                *result = 18;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::importDirChanged)) {
                *result = 19;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(const QStringList & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::disabledPluginsChanged)) {
                *result = 20;
                return;
            }
        }
        {
            typedef void (ImportConfig::*_t)(bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ImportConfig::enableTimeDifferenceCheckChanged)) {
                *result = 21;
                return;
            }
        }
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        ImportConfig *_t = static_cast<ImportConfig *>(_o);
        Q_UNUSED(_t)
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< QStringList*>(_v) = _t->availablePlugins(); break;
        case 1: *reinterpret_cast< int*>(_v) = _t->importServer(); break;
        case 2: *reinterpret_cast< int*>(_v) = _t->importDest(); break;
        case 3: *reinterpret_cast< QStringList*>(_v) = _t->importFormatNames(); break;
        case 4: *reinterpret_cast< QStringList*>(_v) = _t->importFormatHeaders(); break;
        case 5: *reinterpret_cast< QStringList*>(_v) = _t->importFormatTracks(); break;
        case 6: *reinterpret_cast< int*>(_v) = _t->importFormatIndex(); break;
        case 7: *reinterpret_cast< int*>(_v) = _t->maxTimeDifference(); break;
        case 8: *reinterpret_cast< quint64*>(_v) = _t->importVisibleColumns(); break;
        case 9: *reinterpret_cast< QByteArray*>(_v) = _t->importWindowGeometry(); break;
        case 10: *reinterpret_cast< QStringList*>(_v) = _t->importTagsNames(); break;
        case 11: *reinterpret_cast< QStringList*>(_v) = _t->importTagsSources(); break;
        case 12: *reinterpret_cast< QStringList*>(_v) = _t->importTagsExtractions(); break;
        case 13: *reinterpret_cast< int*>(_v) = _t->importTagsIndex(); break;
        case 14: *reinterpret_cast< QStringList*>(_v) = _t->pictureSourceNames(); break;
        case 15: *reinterpret_cast< QStringList*>(_v) = _t->pictureSourceUrls(); break;
        case 16: *reinterpret_cast< int*>(_v) = _t->pictureSourceIndex(); break;
        case 17: *reinterpret_cast< QByteArray*>(_v) = _t->browseCoverArtWindowGeometry(); break;
        case 18: *reinterpret_cast< QVariantMap*>(_v) = _t->matchPictureUrlVariantMap(); break;
        case 19: *reinterpret_cast< QString*>(_v) = _t->importDir(); break;
        case 20: *reinterpret_cast< QStringList*>(_v) = _t->disabledPlugins(); break;
        case 21: *reinterpret_cast< bool*>(_v) = _t->enableTimeDifferenceCheck(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
        ImportConfig *_t = static_cast<ImportConfig *>(_o);
        Q_UNUSED(_t)
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setAvailablePlugins(*reinterpret_cast< QStringList*>(_v)); break;
        case 1: _t->setImportServer(*reinterpret_cast< int*>(_v)); break;
        case 2: _t->setImportDestInt(*reinterpret_cast< int*>(_v)); break;
        case 3: _t->setImportFormatNames(*reinterpret_cast< QStringList*>(_v)); break;
        case 4: _t->setImportFormatHeaders(*reinterpret_cast< QStringList*>(_v)); break;
        case 5: _t->setImportFormatTracks(*reinterpret_cast< QStringList*>(_v)); break;
        case 6: _t->setImportFormatIndex(*reinterpret_cast< int*>(_v)); break;
        case 7: _t->setMaxTimeDifference(*reinterpret_cast< int*>(_v)); break;
        case 8: _t->setImportVisibleColumns(*reinterpret_cast< quint64*>(_v)); break;
        case 9: _t->setImportWindowGeometry(*reinterpret_cast< QByteArray*>(_v)); break;
        case 10: _t->setImportTagsNames(*reinterpret_cast< QStringList*>(_v)); break;
        case 11: _t->setImportTagsSources(*reinterpret_cast< QStringList*>(_v)); break;
        case 12: _t->setImportTagsExtractions(*reinterpret_cast< QStringList*>(_v)); break;
        case 13: _t->setImportTagsIndex(*reinterpret_cast< int*>(_v)); break;
        case 14: _t->setPictureSourceNames(*reinterpret_cast< QStringList*>(_v)); break;
        case 15: _t->setPictureSourceUrls(*reinterpret_cast< QStringList*>(_v)); break;
        case 16: _t->setPictureSourceIndex(*reinterpret_cast< int*>(_v)); break;
        case 17: _t->setBrowseCoverArtWindowGeometry(*reinterpret_cast< QByteArray*>(_v)); break;
        case 18: _t->setMatchPictureUrlVariantMap(*reinterpret_cast< QVariantMap*>(_v)); break;
        case 19: _t->setImportDir(*reinterpret_cast< QString*>(_v)); break;
        case 20: _t->setDisabledPlugins(*reinterpret_cast< QStringList*>(_v)); break;
        case 21: _t->setEnableTimeDifferenceCheck(*reinterpret_cast< bool*>(_v)); break;
        default: break;
        }
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

const QMetaObject ImportConfig::staticMetaObject = {
    { &StoredConfig<ImportConfig>::staticMetaObject, qt_meta_stringdata_ImportConfig.data,
      qt_meta_data_ImportConfig,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *ImportConfig::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_ImportConfig.stringdata0))
        return static_cast<void*>(const_cast< ImportConfig*>(this));
    return StoredConfig<ImportConfig>::qt_metacast(_clname);
}

int ImportConfig::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = StoredConfig<ImportConfig>::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 22)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 22;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 22)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 22;
    }
#ifndef QT_NO_PROPERTIES
   else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 22;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 22;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 22;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 22;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 22;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 22;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}

// SIGNAL 0
void ImportConfig::availablePluginsChanged(const QStringList & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void ImportConfig::importServerChanged(int _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void ImportConfig::importDestChanged(Frame::TagVersion _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}

// SIGNAL 3
void ImportConfig::importFormatNamesChanged(const QStringList & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 3, _a);
}

// SIGNAL 4
void ImportConfig::importFormatHeadersChanged(const QStringList & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 4, _a);
}

// SIGNAL 5
void ImportConfig::importFormatTracksChanged(const QStringList & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 5, _a);
}

// SIGNAL 6
void ImportConfig::importFormatIndexChanged(int _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 6, _a);
}

// SIGNAL 7
void ImportConfig::maxTimeDifferenceChanged(int _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 7, _a);
}

// SIGNAL 8
void ImportConfig::importVisibleColumnsChanged(quint64 _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 8, _a);
}

// SIGNAL 9
void ImportConfig::importWindowGeometryChanged(const QByteArray & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 9, _a);
}

// SIGNAL 10
void ImportConfig::importTagsNamesChanged(const QStringList & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 10, _a);
}

// SIGNAL 11
void ImportConfig::importTagsSourcesChanged(const QStringList & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 11, _a);
}

// SIGNAL 12
void ImportConfig::importTagsExtractionsChanged(const QStringList & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 12, _a);
}

// SIGNAL 13
void ImportConfig::importTagsIndexChanged(int _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 13, _a);
}

// SIGNAL 14
void ImportConfig::pictureSourceNamesChanged(const QStringList & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 14, _a);
}

// SIGNAL 15
void ImportConfig::pictureSourceUrlsChanged(const QStringList & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 15, _a);
}

// SIGNAL 16
void ImportConfig::pictureSourceIndexChanged(int _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 16, _a);
}

// SIGNAL 17
void ImportConfig::browseCoverArtWindowGeometryChanged(const QByteArray & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 17, _a);
}

// SIGNAL 18
void ImportConfig::matchPictureUrlMapChanged(const QMap<QString,QString> & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 18, _a);
}

// SIGNAL 19
void ImportConfig::importDirChanged(const QString & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 19, _a);
}

// SIGNAL 20
void ImportConfig::disabledPluginsChanged(const QStringList & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 20, _a);
}

// SIGNAL 21
void ImportConfig::enableTimeDifferenceCheckChanged(bool _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 21, _a);
}
QT_END_MOC_NAMESPACE
