/****************************************************************************
** Meta object code from reading C++ file 'kid3application.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 "../../../../kid3-3.10.1/src/core/model/kid3application.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 'kid3application.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_ZN15Kid3ApplicationE_t {};
} // unnamed namespace

template <> constexpr inline auto Kid3Application::qt_create_metaobjectdata<qt_meta_tag_ZN15Kid3ApplicationE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Kid3Application",
        "fileRootIndexChanged",
        "",
        "QModelIndex",
        "index",
        "dirRootIndexChanged",
        "directoryOpened",
        "confirmedOpenDirectoryRequested",
        "paths",
        "fileSelectionUpdateRequested",
        "selectedFilesUpdated",
        "selectedFilesChanged",
        "QItemSelection",
        "selected",
        "deselected",
        "frameModified",
        "TaggedFile*",
        "taggedFile",
        "Frame::TagNumber",
        "tagNr",
        "modifiedChanged",
        "modified",
        "filteredChanged",
        "filtered",
        "dirNameChanged",
        "name",
        "fileFiltered",
        "type",
        "fileName",
        "passed",
        "total",
        "aboutToPlayAudio",
        "renameActionsScheduled",
        "toggleExpandedRequested",
        "expandFileListRequested",
        "expandFileListFinished",
        "fileSelectionChanged",
        "coverArtImageIdChanged",
        "id",
        "frameEditorChanged",
        "longRunningOperationProgress",
        "done",
        "bool*",
        "abort",
        "openDrop",
        "openDropUrls",
        "QList<QUrl>",
        "urlList",
        "unloadAllTags",
        "revertFileModifications",
        "setFileNameOfSelectedFile",
        "applyFilenameFormat",
        "applyTagFormat",
        "applyTextEncoding",
        "convertToId3v24",
        "convertToId3v23",
        "copyTags",
        "Frame::TagVersion",
        "tagMask",
        "pasteTags",
        "copyToOtherTag",
        "copyTag",
        "srcTagNr",
        "dstTagNr",
        "removeTags",
        "getTagsFromFilename",
        "getFilenameFromTags",
        "tagVersion",
        "editFrame",
        "deleteFrame",
        "frameName",
        "selectAndAddFrame",
        "editOrAddPicture",
        "imageDownloaded",
        "data",
        "mimeType",
        "url",
        "firstFile",
        "select",
        "onlyTaggedFiles",
        "nextFile",
        "previousFile",
        "selectCurrentFile",
        "selectAllFiles",
        "deselectAllFiles",
        "selectAllInDirectory",
        "invertSelection",
        "selectFile",
        "filePath",
        "fetchDirectory",
        "expandDirectory",
        "requestExpandFileList",
        "notifyExpandFileListFinished",
        "fileSelected",
        "findText",
        "TagSearcher::Parameters",
        "params",
        "replaceText",
        "replaceAll",
        "scheduleRenameActions",
        "applyFilter",
        "FileFilter&",
        "fileFilter",
        "expression",
        "abortFilter",
        "batchImport",
        "BatchImportProfile",
        "profile",
        "profileName",
        "playAudio",
        "showAudioPlayer",
        "activateMprisInterface",
        "deactivateMprisInterface",
        "onAboutToPlay",
        "closeFileHandle",
        "applyFilterAfterReset",
        "filterNextFile",
        "QPersistentModelIndex",
        "batchImportNextFile",
        "scheduleNextRenameAction",
        "performRenameActionsAfterReset",
        "renameAfterReset",
        "onDirectoryOpened",
        "onDirectoryLoaded",
        "onFrameEdited",
        "const Frame*",
        "frame",
        "onFrameAdded",
        "onTag2FrameAdded",
        "updateCoverArtImageId",
        "onApplicationStateChanged",
        "Qt::ApplicationState",
        "state",
        "getServerImporterNames",
        "getAudioPlayer",
        "tag",
        "Kid3ApplicationTagContext*",
        "applyChangedConfiguration",
        "saveConfig",
        "readConfig",
        "openDirectory",
        "fileCheck",
        "saveDirectory",
        "frameModelsToTags",
        "tagsToFrameModels",
        "importTags",
        "path",
        "fmtIdx",
        "importFromTags",
        "source",
        "extraction",
        "importFromTagsToSelection",
        "exportTags",
        "writePlaylist",
        "getPlaylistItems",
        "setPlaylistItems",
        "items",
        "performRenameActions",
        "renameDirectory",
        "format",
        "create",
        "numberTracks",
        "nr",
        "Kid3Application::NumberTrackOptions",
        "options",
        "downloadImage",
        "allFilesInDir",
        "getFrame",
        "getAllFrames",
        "QVariantMap",
        "setFrame",
        "value",
        "getPictureData",
        "setPictureData",
        "getTotalNumberOfTracksInDir",
        "createFilterString",
        "getFileSelectionRows",
        "QVariantList",
        "setFileSelectionIndexes",
        "indexes",
        "getSelectedFilePaths",
        "setCoverArtImageData",
        "picture",
        "selectFileName",
        "caption",
        "dir",
        "filter",
        "saveFile",
        "selectDirName",
        "hasGui",
        "fileProxyModel",
        "FileProxyModel*",
        "dirProxyModel",
        "DirProxyModel*",
        "fileSelectionModel",
        "QItemSelectionModel*",
        "dirSelectionModel",
        "selectionInfo",
        "TaggedFileSelection*",
        "fileRootIndex",
        "dirRootIndex",
        "dirName",
        "filterPassedCount",
        "filterTotalCount",
        "statusBarHeight",
        "navigationBarHeight",
        "frameEditor",
        "FrameEditorObject*",
        "coverArtImageId",
        "dirRenamer",
        "DirRenamer*",
        "batchImporter",
        "BatchImporter*",
        "downloadClient",
        "DownloadClient*",
        "NumberTrackOption",
        "NumberTracksEnabled",
        "NumberTracksResetCounterForEachDirectory",
        "NumberTrackOptions"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'fileRootIndexChanged'
        QtMocHelpers::SignalData<void(const QModelIndex &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'dirRootIndexChanged'
        QtMocHelpers::SignalData<void(const QModelIndex &)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'directoryOpened'
        QtMocHelpers::SignalData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'confirmedOpenDirectoryRequested'
        QtMocHelpers::SignalData<void(const QStringList &)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 8 },
        }}),
        // Signal 'fileSelectionUpdateRequested'
        QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'selectedFilesUpdated'
        QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'selectedFilesChanged'
        QtMocHelpers::SignalData<void(const QItemSelection &, const QItemSelection &)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 12, 13 }, { 0x80000000 | 12, 14 },
        }}),
        // Signal 'frameModified'
        QtMocHelpers::SignalData<void(TaggedFile *, Frame::TagNumber)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 16, 17 }, { 0x80000000 | 18, 19 },
        }}),
        // Signal 'modifiedChanged'
        QtMocHelpers::SignalData<void(bool)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 21 },
        }}),
        // Signal 'filteredChanged'
        QtMocHelpers::SignalData<void(bool)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 23 },
        }}),
        // Signal 'dirNameChanged'
        QtMocHelpers::SignalData<void(const QString &)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 25 },
        }}),
        // Signal 'fileFiltered'
        QtMocHelpers::SignalData<void(int, const QString &, int, int)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 27 }, { QMetaType::QString, 28 }, { QMetaType::Int, 29 }, { QMetaType::Int, 30 },
        }}),
        // Signal 'aboutToPlayAudio'
        QtMocHelpers::SignalData<void()>(31, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'renameActionsScheduled'
        QtMocHelpers::SignalData<void()>(32, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'toggleExpandedRequested'
        QtMocHelpers::SignalData<void(const QModelIndex &)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'expandFileListRequested'
        QtMocHelpers::SignalData<void()>(34, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'expandFileListFinished'
        QtMocHelpers::SignalData<void()>(35, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fileSelectionChanged'
        QtMocHelpers::SignalData<void()>(36, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'coverArtImageIdChanged'
        QtMocHelpers::SignalData<void(const QString &)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 38 },
        }}),
        // Signal 'frameEditorChanged'
        QtMocHelpers::SignalData<void()>(39, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'longRunningOperationProgress'
        QtMocHelpers::SignalData<void(const QString &, int, int, bool *)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 25 }, { QMetaType::Int, 41 }, { QMetaType::Int, 30 }, { 0x80000000 | 42, 43 },
        }}),
        // Slot 'openDrop'
        QtMocHelpers::SlotData<void(const QStringList &)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 8 },
        }}),
        // Slot 'openDropUrls'
        QtMocHelpers::SlotData<void(const QList<QUrl> &)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 46, 47 },
        }}),
        // Slot 'unloadAllTags'
        QtMocHelpers::SlotData<void()>(48, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'revertFileModifications'
        QtMocHelpers::SlotData<void()>(49, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setFileNameOfSelectedFile'
        QtMocHelpers::SlotData<void(const QString &)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 25 },
        }}),
        // Slot 'applyFilenameFormat'
        QtMocHelpers::SlotData<void()>(51, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'applyTagFormat'
        QtMocHelpers::SlotData<void()>(52, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'applyTextEncoding'
        QtMocHelpers::SlotData<void()>(53, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'convertToId3v24'
        QtMocHelpers::SlotData<void()>(54, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'convertToId3v23'
        QtMocHelpers::SlotData<void()>(55, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'copyTags'
        QtMocHelpers::SlotData<void(Frame::TagVersion)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 57, 58 },
        }}),
        // Slot 'pasteTags'
        QtMocHelpers::SlotData<void(Frame::TagVersion)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 57, 58 },
        }}),
        // Slot 'copyToOtherTag'
        QtMocHelpers::SlotData<void(Frame::TagVersion)>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 57, 58 },
        }}),
        // Slot 'copyTag'
        QtMocHelpers::SlotData<void(Frame::TagNumber, Frame::TagNumber)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 62 }, { 0x80000000 | 18, 63 },
        }}),
        // Slot 'removeTags'
        QtMocHelpers::SlotData<void(Frame::TagVersion)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 57, 58 },
        }}),
        // Slot 'getTagsFromFilename'
        QtMocHelpers::SlotData<void(Frame::TagVersion)>(65, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 57, 58 },
        }}),
        // Slot 'getFilenameFromTags'
        QtMocHelpers::SlotData<void(Frame::TagVersion)>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 57, 67 },
        }}),
        // Slot 'editFrame'
        QtMocHelpers::SlotData<void(Frame::TagNumber)>(68, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 19 },
        }}),
        // Slot 'deleteFrame'
        QtMocHelpers::SlotData<void(Frame::TagNumber, const QString &, int)>(69, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 19 }, { QMetaType::QString, 70 }, { QMetaType::Int, 4 },
        }}),
        // Slot 'deleteFrame'
        QtMocHelpers::SlotData<void(Frame::TagNumber, const QString &)>(69, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 18, 19 }, { QMetaType::QString, 70 },
        }}),
        // Slot 'deleteFrame'
        QtMocHelpers::SlotData<void(Frame::TagNumber)>(69, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 18, 19 },
        }}),
        // Slot 'selectAndAddFrame'
        QtMocHelpers::SlotData<void(Frame::TagNumber)>(71, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 19 },
        }}),
        // Slot 'editOrAddPicture'
        QtMocHelpers::SlotData<void(int)>(72, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 4 },
        }}),
        // Slot 'editOrAddPicture'
        QtMocHelpers::SlotData<void()>(72, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'imageDownloaded'
        QtMocHelpers::SlotData<void(const QByteArray &, const QString &, const QString &)>(73, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 74 }, { QMetaType::QString, 75 }, { QMetaType::QString, 76 },
        }}),
        // Slot 'firstFile'
        QtMocHelpers::SlotData<bool(bool, bool)>(77, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Bool, 78 }, { QMetaType::Bool, 79 },
        }}),
        // Slot 'firstFile'
        QtMocHelpers::SlotData<bool(bool)>(77, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::Bool, 78 },
        }}),
        // Slot 'firstFile'
        QtMocHelpers::SlotData<bool()>(77, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool),
        // Slot 'nextFile'
        QtMocHelpers::SlotData<bool(bool, bool)>(80, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Bool, 78 }, { QMetaType::Bool, 79 },
        }}),
        // Slot 'nextFile'
        QtMocHelpers::SlotData<bool(bool)>(80, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::Bool, 78 },
        }}),
        // Slot 'nextFile'
        QtMocHelpers::SlotData<bool()>(80, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool),
        // Slot 'previousFile'
        QtMocHelpers::SlotData<bool(bool, bool)>(81, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Bool, 78 }, { QMetaType::Bool, 79 },
        }}),
        // Slot 'previousFile'
        QtMocHelpers::SlotData<bool(bool)>(81, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::Bool, 78 },
        }}),
        // Slot 'previousFile'
        QtMocHelpers::SlotData<bool()>(81, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool),
        // Slot 'selectCurrentFile'
        QtMocHelpers::SlotData<bool(bool)>(82, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Bool, 78 },
        }}),
        // Slot 'selectCurrentFile'
        QtMocHelpers::SlotData<bool()>(82, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool),
        // Slot 'selectAllFiles'
        QtMocHelpers::SlotData<void()>(83, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'deselectAllFiles'
        QtMocHelpers::SlotData<void()>(84, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectAllInDirectory'
        QtMocHelpers::SlotData<void()>(85, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'invertSelection'
        QtMocHelpers::SlotData<void()>(86, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectFile'
        QtMocHelpers::SlotData<bool(const QString &, bool)>(87, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 88 }, { QMetaType::Bool, 78 },
        }}),
        // Slot 'selectFile'
        QtMocHelpers::SlotData<bool(const QString &)>(87, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QString, 88 },
        }}),
        // Slot 'fetchDirectory'
        QtMocHelpers::SlotData<void(const QModelIndex &)>(89, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Slot 'expandDirectory'
        QtMocHelpers::SlotData<void(const QModelIndex &)>(90, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Slot 'requestExpandFileList'
        QtMocHelpers::SlotData<void()>(91, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'notifyExpandFileListFinished'
        QtMocHelpers::SlotData<void()>(92, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'fileSelected'
        QtMocHelpers::SlotData<void(const QItemSelection &, const QItemSelection &)>(93, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 12, 13 }, { 0x80000000 | 12, 14 },
        }}),
        // Slot 'findText'
        QtMocHelpers::SlotData<void(const TagSearcher::Parameters &)>(94, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 95, 96 },
        }}),
        // Slot 'replaceText'
        QtMocHelpers::SlotData<void(const TagSearcher::Parameters &)>(97, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 95, 96 },
        }}),
        // Slot 'replaceAll'
        QtMocHelpers::SlotData<void(const TagSearcher::Parameters &)>(98, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 95, 96 },
        }}),
        // Slot 'scheduleRenameActions'
        QtMocHelpers::SlotData<void()>(99, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'applyFilter'
        QtMocHelpers::SlotData<void(FileFilter &)>(100, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 101, 102 },
        }}),
        // Slot 'applyFilter'
        QtMocHelpers::SlotData<void(const QString &)>(100, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 103 },
        }}),
        // Slot 'abortFilter'
        QtMocHelpers::SlotData<void()>(104, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'batchImport'
        QtMocHelpers::SlotData<void(const BatchImportProfile &, Frame::TagVersion)>(105, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 106, 107 }, { 0x80000000 | 57, 67 },
        }}),
        // Slot 'batchImport'
        QtMocHelpers::SlotData<bool(const QString &, Frame::TagVersion)>(105, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 108 }, { 0x80000000 | 57, 67 },
        }}),
        // Slot 'playAudio'
        QtMocHelpers::SlotData<void()>(109, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'showAudioPlayer'
        QtMocHelpers::SlotData<void()>(110, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'activateMprisInterface'
        QtMocHelpers::SlotData<void()>(111, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'deactivateMprisInterface'
        QtMocHelpers::SlotData<void()>(112, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onAboutToPlay'
        QtMocHelpers::SlotData<void(const QString &)>(113, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 88 },
        }}),
        // Slot 'closeFileHandle'
        QtMocHelpers::SlotData<void(const QString &)>(114, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 88 },
        }}),
        // Slot 'applyFilterAfterReset'
        QtMocHelpers::SlotData<void()>(115, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'filterNextFile'
        QtMocHelpers::SlotData<void(const QPersistentModelIndex &)>(116, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 117, 4 },
        }}),
        // Slot 'batchImportNextFile'
        QtMocHelpers::SlotData<void(const QPersistentModelIndex &)>(118, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 117, 4 },
        }}),
        // Slot 'scheduleNextRenameAction'
        QtMocHelpers::SlotData<void(const QPersistentModelIndex &)>(119, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 117, 4 },
        }}),
        // Slot 'performRenameActionsAfterReset'
        QtMocHelpers::SlotData<void()>(120, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'renameAfterReset'
        QtMocHelpers::SlotData<void()>(121, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'onDirectoryOpened'
        QtMocHelpers::SlotData<void()>(122, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'onDirectoryLoaded'
        QtMocHelpers::SlotData<void()>(123, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'onFrameEdited'
        QtMocHelpers::SlotData<void(const Frame *)>(124, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 125, 126 },
        }}),
        // Slot 'onFrameAdded'
        QtMocHelpers::SlotData<void(const Frame *, Frame::TagNumber)>(127, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 125, 126 }, { 0x80000000 | 18, 19 },
        }}),
        // Slot 'onFrameAdded'
        QtMocHelpers::SlotData<void(const Frame *)>(127, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 125, 126 },
        }}),
        // Slot 'onTag2FrameAdded'
        QtMocHelpers::SlotData<void(const Frame *)>(128, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 125, 126 },
        }}),
        // Slot 'updateCoverArtImageId'
        QtMocHelpers::SlotData<void()>(129, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'onApplicationStateChanged'
        QtMocHelpers::SlotData<void(Qt::ApplicationState)>(130, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 131, 132 },
        }}),
        // Method 'getServerImporterNames'
        QtMocHelpers::MethodData<QStringList() const>(133, 2, QMC::AccessPublic, QMetaType::QStringList),
        // Method 'getAudioPlayer'
        QtMocHelpers::MethodData<QObject *()>(134, 2, QMC::AccessPublic, QMetaType::QObjectStar),
        // Method 'tag'
        QtMocHelpers::MethodData<Kid3ApplicationTagContext *(Frame::TagNumber) const>(135, 2, QMC::AccessPublic, 0x80000000 | 136, {{
            { 0x80000000 | 18, 19 },
        }}),
        // Method 'applyChangedConfiguration'
        QtMocHelpers::MethodData<void()>(137, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'saveConfig'
        QtMocHelpers::MethodData<void()>(138, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'readConfig'
        QtMocHelpers::MethodData<void()>(139, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'openDirectory'
        QtMocHelpers::MethodData<bool(const QStringList &, bool)>(140, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QStringList, 8 }, { QMetaType::Bool, 141 },
        }}),
        // Method 'openDirectory'
        QtMocHelpers::MethodData<bool(const QStringList &)>(140, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QStringList, 8 },
        }}),
        // Method 'saveDirectory'
        QtMocHelpers::MethodData<QStringList()>(142, 2, QMC::AccessPublic, QMetaType::QStringList),
        // Method 'frameModelsToTags'
        QtMocHelpers::MethodData<void()>(143, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'tagsToFrameModels'
        QtMocHelpers::MethodData<void()>(144, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'importTags'
        QtMocHelpers::MethodData<bool(Frame::TagVersion, const QString &, int)>(145, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 57, 58 }, { QMetaType::QString, 146 }, { QMetaType::Int, 147 },
        }}),
        // Method 'importFromTags'
        QtMocHelpers::MethodData<void(Frame::TagVersion, const QString &, const QString &)>(148, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 57, 58 }, { QMetaType::QString, 149 }, { QMetaType::QString, 150 },
        }}),
        // Method 'importFromTagsToSelection'
        QtMocHelpers::MethodData<QStringList(Frame::TagVersion, const QString &, const QString &)>(151, 2, QMC::AccessPublic, QMetaType::QStringList, {{
            { 0x80000000 | 57, 58 }, { QMetaType::QString, 149 }, { QMetaType::QString, 150 },
        }}),
        // Method 'exportTags'
        QtMocHelpers::MethodData<bool(Frame::TagVersion, const QString &, int)>(152, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 57, 67 }, { QMetaType::QString, 146 }, { QMetaType::Int, 147 },
        }}),
        // Method 'writePlaylist'
        QtMocHelpers::MethodData<bool()>(153, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'getPlaylistItems'
        QtMocHelpers::MethodData<QStringList(const QString &)>(154, 2, QMC::AccessPublic, QMetaType::QStringList, {{
            { QMetaType::QString, 146 },
        }}),
        // Method 'setPlaylistItems'
        QtMocHelpers::MethodData<bool(const QString &, const QStringList &)>(155, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 146 }, { QMetaType::QStringList, 156 },
        }}),
        // Method 'performRenameActions'
        QtMocHelpers::MethodData<QString()>(157, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'renameDirectory'
        QtMocHelpers::MethodData<bool(Frame::TagVersion, const QString &, bool)>(158, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 57, 58 }, { QMetaType::QString, 159 }, { QMetaType::Bool, 160 },
        }}),
        // Method 'numberTracks'
        QtMocHelpers::MethodData<void(int, int, Frame::TagVersion, Kid3Application::NumberTrackOptions)>(161, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 162 }, { QMetaType::Int, 30 }, { 0x80000000 | 57, 67 }, { 0x80000000 | 163, 164 },
        }}),
        // Method 'numberTracks'
        QtMocHelpers::MethodData<void(int, int, Frame::TagVersion)>(161, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 162 }, { QMetaType::Int, 30 }, { 0x80000000 | 57, 67 },
        }}),
        // Method 'downloadImage'
        QtMocHelpers::MethodData<void(const QString &, bool)>(165, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 76 }, { QMetaType::Bool, 166 },
        }}),
        // Method 'getFrame'
        QtMocHelpers::MethodData<QString(Frame::TagVersion, const QString &) const>(167, 2, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 57, 58 }, { QMetaType::QString, 25 },
        }}),
        // Method 'getAllFrames'
        QtMocHelpers::MethodData<QVariantMap(Frame::TagVersion) const>(168, 2, QMC::AccessPublic, 0x80000000 | 169, {{
            { 0x80000000 | 57, 58 },
        }}),
        // Method 'setFrame'
        QtMocHelpers::MethodData<bool(Frame::TagVersion, const QString &, const QString &)>(170, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 57, 58 }, { QMetaType::QString, 25 }, { QMetaType::QString, 171 },
        }}),
        // Method 'getPictureData'
        QtMocHelpers::MethodData<QByteArray() const>(172, 2, QMC::AccessPublic, QMetaType::QByteArray),
        // Method 'setPictureData'
        QtMocHelpers::MethodData<void(const QByteArray &)>(173, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 74 },
        }}),
        // Method 'getTotalNumberOfTracksInDir'
        QtMocHelpers::MethodData<int() const>(174, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'createFilterString'
        QtMocHelpers::MethodData<QString() const>(175, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'getFileSelectionRows'
        QtMocHelpers::MethodData<QVariantList() const>(176, 2, QMC::AccessPublic, 0x80000000 | 177),
        // Method 'setFileSelectionIndexes'
        QtMocHelpers::MethodData<void(const QVariantList &)>(178, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 177, 179 },
        }}),
        // Method 'getSelectedFilePaths'
        QtMocHelpers::MethodData<QStringList(bool) const>(180, 2, QMC::AccessPublic, QMetaType::QStringList, {{
            { QMetaType::Bool, 79 },
        }}),
        // Method 'getSelectedFilePaths'
        QtMocHelpers::MethodData<QStringList() const>(180, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QStringList),
        // Method 'setCoverArtImageData'
        QtMocHelpers::MethodData<void(const QByteArray &)>(181, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 182 },
        }}),
        // Method 'selectFileName'
        QtMocHelpers::MethodData<QString(const QString &, const QString &, const QString &, bool)>(183, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 184 }, { QMetaType::QString, 185 }, { QMetaType::QString, 186 }, { QMetaType::Bool, 187 },
        }}),
        // Method 'selectFileName'
        QtMocHelpers::MethodData<QString(const QString &, const QString &, const QString &)>(183, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString, {{
            { QMetaType::QString, 184 }, { QMetaType::QString, 185 }, { QMetaType::QString, 186 },
        }}),
        // Method 'selectFileName'
        QtMocHelpers::MethodData<QString(const QString &, const QString &)>(183, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString, {{
            { QMetaType::QString, 184 }, { QMetaType::QString, 185 },
        }}),
        // Method 'selectFileName'
        QtMocHelpers::MethodData<QString(const QString &)>(183, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString, {{
            { QMetaType::QString, 184 },
        }}),
        // Method 'selectFileName'
        QtMocHelpers::MethodData<QString()>(183, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString),
        // Method 'selectDirName'
        QtMocHelpers::MethodData<QString(const QString &, const QString &)>(188, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 184 }, { QMetaType::QString, 185 },
        }}),
        // Method 'selectDirName'
        QtMocHelpers::MethodData<QString(const QString &)>(188, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString, {{
            { QMetaType::QString, 184 },
        }}),
        // Method 'selectDirName'
        QtMocHelpers::MethodData<QString()>(188, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString),
        // Method 'hasGui'
        QtMocHelpers::MethodData<bool() const>(189, 2, QMC::AccessPublic, QMetaType::Bool),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'fileProxyModel'
        QtMocHelpers::PropertyData<FileProxyModel*>(190, 0x80000000 | 191, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'dirProxyModel'
        QtMocHelpers::PropertyData<DirProxyModel*>(192, 0x80000000 | 193, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'fileSelectionModel'
        QtMocHelpers::PropertyData<QItemSelectionModel*>(194, 0x80000000 | 195, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'dirSelectionModel'
        QtMocHelpers::PropertyData<QItemSelectionModel*>(196, 0x80000000 | 195, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'selectionInfo'
        QtMocHelpers::PropertyData<TaggedFileSelection*>(197, 0x80000000 | 198, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'fileRootIndex'
        QtMocHelpers::PropertyData<QModelIndex>(199, 0x80000000 | 3, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
        // property 'dirRootIndex'
        QtMocHelpers::PropertyData<QModelIndex>(200, 0x80000000 | 3, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 1),
        // property 'dirName'
        QtMocHelpers::PropertyData<QString>(201, QMetaType::QString, QMC::DefaultPropertyFlags, 10),
        // property 'modified'
        QtMocHelpers::PropertyData<bool>(21, QMetaType::Bool, QMC::DefaultPropertyFlags, 8),
        // property 'filtered'
        QtMocHelpers::PropertyData<bool>(23, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 9),
        // property 'filterPassedCount'
        QtMocHelpers::PropertyData<int>(202, QMetaType::Int, QMC::DefaultPropertyFlags, 11),
        // property 'filterTotalCount'
        QtMocHelpers::PropertyData<int>(203, QMetaType::Int, QMC::DefaultPropertyFlags, 11),
        // property 'statusBarHeight'
        QtMocHelpers::PropertyData<int>(204, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'navigationBarHeight'
        QtMocHelpers::PropertyData<int>(205, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'frameEditor'
        QtMocHelpers::PropertyData<FrameEditorObject*>(206, 0x80000000 | 207, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 19),
        // property 'coverArtImageId'
        QtMocHelpers::PropertyData<QString>(208, QMetaType::QString, QMC::DefaultPropertyFlags, 18),
        // property 'dirRenamer'
        QtMocHelpers::PropertyData<DirRenamer*>(209, 0x80000000 | 210, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'batchImporter'
        QtMocHelpers::PropertyData<BatchImporter*>(211, 0x80000000 | 212, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'downloadClient'
        QtMocHelpers::PropertyData<DownloadClient*>(213, 0x80000000 | 214, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'NumberTrackOption'
        QtMocHelpers::EnumData<enum NumberTrackOption>(215, 215, QMC::EnumFlags{}).add({
            {  216, NumberTrackOption::NumberTracksEnabled },
            {  217, NumberTrackOption::NumberTracksResetCounterForEachDirectory },
        }),
        // flag 'NumberTrackOptions'
        QtMocHelpers::EnumData<NumberTrackOptions>(218, 215, QMC::EnumIsFlag).add({
            {  216, NumberTrackOption::NumberTracksEnabled },
            {  217, NumberTrackOption::NumberTracksResetCounterForEachDirectory },
        }),
    };
    return QtMocHelpers::metaObjectData<Kid3Application, qt_meta_tag_ZN15Kid3ApplicationE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Kid3Application::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15Kid3ApplicationE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15Kid3ApplicationE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15Kid3ApplicationE_t>.metaTypes,
    nullptr
} };

void Kid3Application::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Kid3Application *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->fileRootIndexChanged((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 1: _t->dirRootIndexChanged((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 2: _t->directoryOpened(); break;
        case 3: _t->confirmedOpenDirectoryRequested((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 4: _t->fileSelectionUpdateRequested(); break;
        case 5: _t->selectedFilesUpdated(); break;
        case 6: _t->selectedFilesChanged((*reinterpret_cast<std::add_pointer_t<QItemSelection>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QItemSelection>>(_a[2]))); break;
        case 7: _t->frameModified((*reinterpret_cast<std::add_pointer_t<TaggedFile*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Frame::TagNumber>>(_a[2]))); break;
        case 8: _t->modifiedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: _t->filteredChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 10: _t->dirNameChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 11: _t->fileFiltered((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 12: _t->aboutToPlayAudio(); break;
        case 13: _t->renameActionsScheduled(); break;
        case 14: _t->toggleExpandedRequested((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 15: _t->expandFileListRequested(); break;
        case 16: _t->expandFileListFinished(); break;
        case 17: _t->fileSelectionChanged(); break;
        case 18: _t->coverArtImageIdChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 19: _t->frameEditorChanged(); break;
        case 20: _t->longRunningOperationProgress((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool*>>(_a[4]))); break;
        case 21: _t->openDrop((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 22: _t->openDropUrls((*reinterpret_cast<std::add_pointer_t<QList<QUrl>>>(_a[1]))); break;
        case 23: _t->unloadAllTags(); break;
        case 24: _t->revertFileModifications(); break;
        case 25: _t->setFileNameOfSelectedFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 26: _t->applyFilenameFormat(); break;
        case 27: _t->applyTagFormat(); break;
        case 28: _t->applyTextEncoding(); break;
        case 29: _t->convertToId3v24(); break;
        case 30: _t->convertToId3v23(); break;
        case 31: _t->copyTags((*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[1]))); break;
        case 32: _t->pasteTags((*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[1]))); break;
        case 33: _t->copyToOtherTag((*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[1]))); break;
        case 34: _t->copyTag((*reinterpret_cast<std::add_pointer_t<Frame::TagNumber>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Frame::TagNumber>>(_a[2]))); break;
        case 35: _t->removeTags((*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[1]))); break;
        case 36: _t->getTagsFromFilename((*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[1]))); break;
        case 37: _t->getFilenameFromTags((*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[1]))); break;
        case 38: _t->editFrame((*reinterpret_cast<std::add_pointer_t<Frame::TagNumber>>(_a[1]))); break;
        case 39: _t->deleteFrame((*reinterpret_cast<std::add_pointer_t<Frame::TagNumber>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 40: _t->deleteFrame((*reinterpret_cast<std::add_pointer_t<Frame::TagNumber>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 41: _t->deleteFrame((*reinterpret_cast<std::add_pointer_t<Frame::TagNumber>>(_a[1]))); break;
        case 42: _t->selectAndAddFrame((*reinterpret_cast<std::add_pointer_t<Frame::TagNumber>>(_a[1]))); break;
        case 43: _t->editOrAddPicture((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 44: _t->editOrAddPicture(); break;
        case 45: _t->imageDownloaded((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 46: { bool _r = _t->firstFile((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 47: { bool _r = _t->firstFile((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 48: { bool _r = _t->firstFile();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 49: { bool _r = _t->nextFile((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 50: { bool _r = _t->nextFile((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 51: { bool _r = _t->nextFile();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 52: { bool _r = _t->previousFile((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 53: { bool _r = _t->previousFile((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 54: { bool _r = _t->previousFile();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 55: { bool _r = _t->selectCurrentFile((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 56: { bool _r = _t->selectCurrentFile();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 57: _t->selectAllFiles(); break;
        case 58: _t->deselectAllFiles(); break;
        case 59: _t->selectAllInDirectory(); break;
        case 60: _t->invertSelection(); break;
        case 61: { bool _r = _t->selectFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 62: { bool _r = _t->selectFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 63: _t->fetchDirectory((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 64: _t->expandDirectory((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 65: _t->requestExpandFileList(); break;
        case 66: _t->notifyExpandFileListFinished(); break;
        case 67: _t->fileSelected((*reinterpret_cast<std::add_pointer_t<QItemSelection>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QItemSelection>>(_a[2]))); break;
        case 68: _t->findText((*reinterpret_cast<std::add_pointer_t<TagSearcher::Parameters>>(_a[1]))); break;
        case 69: _t->replaceText((*reinterpret_cast<std::add_pointer_t<TagSearcher::Parameters>>(_a[1]))); break;
        case 70: _t->replaceAll((*reinterpret_cast<std::add_pointer_t<TagSearcher::Parameters>>(_a[1]))); break;
        case 71: _t->scheduleRenameActions(); break;
        case 72: _t->applyFilter((*reinterpret_cast<std::add_pointer_t<FileFilter&>>(_a[1]))); break;
        case 73: _t->applyFilter((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 74: _t->abortFilter(); break;
        case 75: _t->batchImport((*reinterpret_cast<std::add_pointer_t<BatchImportProfile>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[2]))); break;
        case 76: { bool _r = _t->batchImport((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 77: _t->playAudio(); break;
        case 78: _t->showAudioPlayer(); break;
        case 79: _t->activateMprisInterface(); break;
        case 80: _t->deactivateMprisInterface(); break;
        case 81: _t->onAboutToPlay((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 82: _t->closeFileHandle((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 83: _t->applyFilterAfterReset(); break;
        case 84: _t->filterNextFile((*reinterpret_cast<std::add_pointer_t<QPersistentModelIndex>>(_a[1]))); break;
        case 85: _t->batchImportNextFile((*reinterpret_cast<std::add_pointer_t<QPersistentModelIndex>>(_a[1]))); break;
        case 86: _t->scheduleNextRenameAction((*reinterpret_cast<std::add_pointer_t<QPersistentModelIndex>>(_a[1]))); break;
        case 87: _t->performRenameActionsAfterReset(); break;
        case 88: _t->renameAfterReset(); break;
        case 89: _t->onDirectoryOpened(); break;
        case 90: _t->onDirectoryLoaded(); break;
        case 91: _t->onFrameEdited((*reinterpret_cast<std::add_pointer_t<const Frame*>>(_a[1]))); break;
        case 92: _t->onFrameAdded((*reinterpret_cast<std::add_pointer_t<const Frame*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Frame::TagNumber>>(_a[2]))); break;
        case 93: _t->onFrameAdded((*reinterpret_cast<std::add_pointer_t<const Frame*>>(_a[1]))); break;
        case 94: _t->onTag2FrameAdded((*reinterpret_cast<std::add_pointer_t<const Frame*>>(_a[1]))); break;
        case 95: _t->updateCoverArtImageId(); break;
        case 96: _t->onApplicationStateChanged((*reinterpret_cast<std::add_pointer_t<Qt::ApplicationState>>(_a[1]))); break;
        case 97: { QStringList _r = _t->getServerImporterNames();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 98: { QObject* _r = _t->getAudioPlayer();
            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = std::move(_r); }  break;
        case 99: { Kid3ApplicationTagContext* _r = _t->tag((*reinterpret_cast<std::add_pointer_t<Frame::TagNumber>>(_a[1])));
            if (_a[0]) *reinterpret_cast<Kid3ApplicationTagContext**>(_a[0]) = std::move(_r); }  break;
        case 100: _t->applyChangedConfiguration(); break;
        case 101: _t->saveConfig(); break;
        case 102: _t->readConfig(); break;
        case 103: { bool _r = _t->openDirectory((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 104: { bool _r = _t->openDirectory((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 105: { QStringList _r = _t->saveDirectory();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 106: _t->frameModelsToTags(); break;
        case 107: _t->tagsToFrameModels(); break;
        case 108: { bool _r = _t->importTags((*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 109: _t->importFromTags((*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 110: { QStringList _r = _t->importFromTagsToSelection((*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 111: { bool _r = _t->exportTags((*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 112: { bool _r = _t->writePlaylist();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 113: { QStringList _r = _t->getPlaylistItems((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 114: { bool _r = _t->setPlaylistItems((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 115: { QString _r = _t->performRenameActions();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 116: { bool _r = _t->renameDirectory((*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 117: _t->numberTracks((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<Kid3Application::NumberTrackOptions>>(_a[4]))); break;
        case 118: _t->numberTracks((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[3]))); break;
        case 119: _t->downloadImage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 120: { QString _r = _t->getFrame((*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 121: { QVariantMap _r = _t->getAllFrames((*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVariantMap*>(_a[0]) = std::move(_r); }  break;
        case 122: { bool _r = _t->setFrame((*reinterpret_cast<std::add_pointer_t<Frame::TagVersion>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 123: { QByteArray _r = _t->getPictureData();
            if (_a[0]) *reinterpret_cast<QByteArray*>(_a[0]) = std::move(_r); }  break;
        case 124: _t->setPictureData((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 125: { int _r = _t->getTotalNumberOfTracksInDir();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 126: { QString _r = _t->createFilterString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 127: { QVariantList _r = _t->getFileSelectionRows();
            if (_a[0]) *reinterpret_cast<QVariantList*>(_a[0]) = std::move(_r); }  break;
        case 128: _t->setFileSelectionIndexes((*reinterpret_cast<std::add_pointer_t<QVariantList>>(_a[1]))); break;
        case 129: { QStringList _r = _t->getSelectedFilePaths((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 130: { QStringList _r = _t->getSelectedFilePaths();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 131: _t->setCoverArtImageData((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 132: { QString _r = _t->selectFileName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 133: { QString _r = _t->selectFileName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 134: { QString _r = _t->selectFileName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 135: { QString _r = _t->selectFileName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 136: { QString _r = _t->selectFileName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 137: { QString _r = _t->selectDirName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 138: { QString _r = _t->selectDirName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 139: { QString _r = _t->selectDirName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 140: { bool _r = _t->hasGui();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 6:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QItemSelection >(); break;
            }
            break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< TaggedFile* >(); break;
            }
            break;
        case 67:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QItemSelection >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)(const QModelIndex & )>(_a, &Kid3Application::fileRootIndexChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)(const QModelIndex & )>(_a, &Kid3Application::dirRootIndexChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)()>(_a, &Kid3Application::directoryOpened, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)(const QStringList & )>(_a, &Kid3Application::confirmedOpenDirectoryRequested, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)()>(_a, &Kid3Application::fileSelectionUpdateRequested, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)()>(_a, &Kid3Application::selectedFilesUpdated, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)(const QItemSelection & , const QItemSelection & )>(_a, &Kid3Application::selectedFilesChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)(TaggedFile * , Frame::TagNumber )>(_a, &Kid3Application::frameModified, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)(bool )>(_a, &Kid3Application::modifiedChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)(bool )>(_a, &Kid3Application::filteredChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)(const QString & )>(_a, &Kid3Application::dirNameChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)(int , const QString & , int , int )>(_a, &Kid3Application::fileFiltered, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)()>(_a, &Kid3Application::aboutToPlayAudio, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)()>(_a, &Kid3Application::renameActionsScheduled, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)(const QModelIndex & )>(_a, &Kid3Application::toggleExpandedRequested, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)()>(_a, &Kid3Application::expandFileListRequested, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)()>(_a, &Kid3Application::expandFileListFinished, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)()>(_a, &Kid3Application::fileSelectionChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)(const QString & )>(_a, &Kid3Application::coverArtImageIdChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)()>(_a, &Kid3Application::frameEditorChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (Kid3Application::*)(const QString & , int , int , bool * )>(_a, &Kid3Application::longRunningOperationProgress, 20))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 17:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< BatchImporter* >(); break;
        case 16:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< DirRenamer* >(); break;
        case 18:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< DownloadClient* >(); break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< FileProxyModel* >(); break;
        case 14:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< FrameEditorObject* >(); break;
        case 3:
        case 2:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QItemSelectionModel* >(); break;
        case 4:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< TaggedFileSelection* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<FileProxyModel**>(_v) = _t->getFileProxyModel(); break;
        case 1: *reinterpret_cast<DirProxyModel**>(_v) = _t->getDirProxyModel(); break;
        case 2: *reinterpret_cast<QItemSelectionModel**>(_v) = _t->getFileSelectionModel(); break;
        case 3: *reinterpret_cast<QItemSelectionModel**>(_v) = _t->getDirSelectionModel(); break;
        case 4: *reinterpret_cast<TaggedFileSelection**>(_v) = _t->selectionInfo(); break;
        case 5: *reinterpret_cast<QModelIndex*>(_v) = _t->getRootIndex(); break;
        case 6: *reinterpret_cast<QModelIndex*>(_v) = _t->getDirRootIndex(); break;
        case 7: *reinterpret_cast<QString*>(_v) = _t->getDirName(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->isModified(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->isFiltered(); break;
        case 10: *reinterpret_cast<int*>(_v) = _t->filterPassedCount(); break;
        case 11: *reinterpret_cast<int*>(_v) = _t->filterTotalCount(); break;
        case 12: *reinterpret_cast<int*>(_v) = _t->statusBarHeight(); break;
        case 13: *reinterpret_cast<int*>(_v) = _t->navigationBarHeight(); break;
        case 14: *reinterpret_cast<FrameEditorObject**>(_v) = _t->frameEditor(); break;
        case 15: *reinterpret_cast<QString*>(_v) = _t->coverArtImageId(); break;
        case 16: *reinterpret_cast<DirRenamer**>(_v) = _t->getDirRenamer(); break;
        case 17: *reinterpret_cast<BatchImporter**>(_v) = _t->getBatchImporter(); break;
        case 18: *reinterpret_cast<DownloadClient**>(_v) = _t->getDownloadClient(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 9: _t->setFiltered(*reinterpret_cast<bool*>(_v)); break;
        case 14: _t->setFrameEditor(*reinterpret_cast<FrameEditorObject**>(_v)); break;
        default: break;
        }
    }
}

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

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

int Kid3Application::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 < 141)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 141;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 141)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 141;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 19;
    }
    return _id;
}

// SIGNAL 0
void Kid3Application::fileRootIndexChanged(const QModelIndex & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void Kid3Application::dirRootIndexChanged(const QModelIndex & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void Kid3Application::directoryOpened()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void Kid3Application::confirmedOpenDirectoryRequested(const QStringList & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void Kid3Application::fileSelectionUpdateRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void Kid3Application::selectedFilesUpdated()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

// SIGNAL 6
void Kid3Application::selectedFilesChanged(const QItemSelection & _t1, const QItemSelection & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1, _t2);
}

// SIGNAL 7
void Kid3Application::frameModified(TaggedFile * _t1, Frame::TagNumber _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1, _t2);
}

// SIGNAL 8
void Kid3Application::modifiedChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void Kid3Application::filteredChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void Kid3Application::dirNameChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void Kid3Application::fileFiltered(int _t1, const QString & _t2, int _t3, int _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 12
void Kid3Application::aboutToPlayAudio()
{
    QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
}

// SIGNAL 13
void Kid3Application::renameActionsScheduled()
{
    QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}

// SIGNAL 14
void Kid3Application::toggleExpandedRequested(const QModelIndex & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void Kid3Application::expandFileListRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
}

// SIGNAL 16
void Kid3Application::expandFileListFinished()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

// SIGNAL 17
void Kid3Application::fileSelectionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
}

// SIGNAL 18
void Kid3Application::coverArtImageIdChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 19
void Kid3Application::frameEditorChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 19, nullptr);
}

// SIGNAL 20
void Kid3Application::longRunningOperationProgress(const QString & _t1, int _t2, int _t3, bool * _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1, _t2, _t3, _t4);
}
namespace {
struct qt_meta_tag_ZN25Kid3ApplicationTagContextE_t {};
} // unnamed namespace

template <> constexpr inline auto Kid3ApplicationTagContext::qt_create_metaobjectdata<qt_meta_tag_ZN25Kid3ApplicationTagContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Kid3ApplicationTagContext",
        "copyTags",
        "",
        "pasteTags",
        "copyToOtherTag",
        "removeTags",
        "getTagsFromFilename",
        "getFilenameFromTags",
        "editFrame",
        "deleteFrame",
        "addFrame",
        "genreModel",
        "GenreModel*",
        "frameModel",
        "FrameTableModel*",
        "frameSelectionModel",
        "QItemSelectionModel*",
        "frameList",
        "FrameList*"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'copyTags'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'pasteTags'
        QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'copyToOtherTag'
        QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'removeTags'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'getTagsFromFilename'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'getFilenameFromTags'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'editFrame'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'deleteFrame'
        QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addFrame'
        QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'genreModel'
        QtMocHelpers::PropertyData<GenreModel*>(11, 0x80000000 | 12, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'frameModel'
        QtMocHelpers::PropertyData<FrameTableModel*>(13, 0x80000000 | 14, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'frameSelectionModel'
        QtMocHelpers::PropertyData<QItemSelectionModel*>(15, 0x80000000 | 16, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'frameList'
        QtMocHelpers::PropertyData<FrameList*>(17, 0x80000000 | 18, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Kid3ApplicationTagContext, qt_meta_tag_ZN25Kid3ApplicationTagContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Kid3ApplicationTagContext::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25Kid3ApplicationTagContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25Kid3ApplicationTagContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN25Kid3ApplicationTagContextE_t>.metaTypes,
    nullptr
} };

void Kid3ApplicationTagContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Kid3ApplicationTagContext *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->copyTags(); break;
        case 1: _t->pasteTags(); break;
        case 2: _t->copyToOtherTag(); break;
        case 3: _t->removeTags(); break;
        case 4: _t->getTagsFromFilename(); break;
        case 5: _t->getFilenameFromTags(); break;
        case 6: _t->editFrame(); break;
        case 7: _t->deleteFrame(); break;
        case 8: _t->addFrame(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 3:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< FrameList* >(); break;
        case 1:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< FrameTableModel* >(); break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< GenreModel* >(); break;
        case 2:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QItemSelectionModel* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<GenreModel**>(_v) = _t->genreModel(); break;
        case 1: *reinterpret_cast<FrameTableModel**>(_v) = _t->frameModel(); break;
        case 2: *reinterpret_cast<QItemSelectionModel**>(_v) = _t->frameSelectionModel(); break;
        case 3: *reinterpret_cast<FrameList**>(_v) = _t->frameList(); break;
        default: break;
        }
    }
}

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

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

int Kid3ApplicationTagContext::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 < 9)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 9;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 9)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 9;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 4;
    }
    return _id;
}
QT_WARNING_POP
