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

#include <memory>
#include "plugins/CopyEngine/Ultracopier-Spec/CopyEngine.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'CopyEngine.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.15.18. 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
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
struct qt_meta_stringdata_CopyEngine_t {
    QByteArrayData data[153];
    char stringdata0[2575];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_CopyEngine_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_CopyEngine_t qt_meta_stringdata_CopyEngine = {
    {
QT_MOC_LITERAL(0, 0, 10), // "CopyEngine"
QT_MOC_LITERAL(1, 11, 12), // "signal_pause"
QT_MOC_LITERAL(2, 24, 0), // ""
QT_MOC_LITERAL(3, 25, 13), // "signal_resume"
QT_MOC_LITERAL(4, 39, 11), // "signal_skip"
QT_MOC_LITERAL(5, 51, 8), // "uint64_t"
QT_MOC_LITERAL(6, 60, 2), // "id"
QT_MOC_LITERAL(7, 63, 25), // "signal_setSpeedLimitation"
QT_MOC_LITERAL(8, 89, 7), // "int64_t"
QT_MOC_LITERAL(9, 97, 15), // "speedLimitation"
QT_MOC_LITERAL(10, 113, 18), // "signal_removeItems"
QT_MOC_LITERAL(11, 132, 21), // "std::vector<uint64_t>"
QT_MOC_LITERAL(12, 154, 3), // "ids"
QT_MOC_LITERAL(13, 158, 21), // "signal_moveItemsOnTop"
QT_MOC_LITERAL(14, 180, 18), // "signal_moveItemsUp"
QT_MOC_LITERAL(15, 199, 20), // "signal_moveItemsDown"
QT_MOC_LITERAL(16, 220, 24), // "signal_moveItemsOnBottom"
QT_MOC_LITERAL(17, 245, 16), // "signal_forceMode"
QT_MOC_LITERAL(18, 262, 21), // "Ultracopier::CopyMode"
QT_MOC_LITERAL(19, 284, 4), // "mode"
QT_MOC_LITERAL(20, 289, 25), // "signal_exportTransferList"
QT_MOC_LITERAL(21, 315, 11), // "std::string"
QT_MOC_LITERAL(22, 327, 8), // "fileName"
QT_MOC_LITERAL(23, 336, 25), // "signal_importTransferList"
QT_MOC_LITERAL(24, 362, 34), // "signal_exportErrorIntoTransfe..."
QT_MOC_LITERAL(25, 397, 25), // "signal_setCollisionAction"
QT_MOC_LITERAL(26, 423, 16), // "FileExistsAction"
QT_MOC_LITERAL(27, 440, 31), // "alwaysDoThisActionForFileExists"
QT_MOC_LITERAL(28, 472, 25), // "signal_setFolderCollision"
QT_MOC_LITERAL(29, 498, 18), // "FolderExistsAction"
QT_MOC_LITERAL(30, 517, 6), // "action"
QT_MOC_LITERAL(31, 524, 9), // "tryCancel"
QT_MOC_LITERAL(32, 534, 18), // "getNeedPutAtBottom"
QT_MOC_LITERAL(33, 553, 8), // "fileInfo"
QT_MOC_LITERAL(34, 562, 11), // "errorString"
QT_MOC_LITERAL(35, 574, 20), // "TransferThreadAsync*"
QT_MOC_LITERAL(36, 595, 6), // "thread"
QT_MOC_LITERAL(37, 602, 9), // "ErrorType"
QT_MOC_LITERAL(38, 612, 9), // "errorType"
QT_MOC_LITERAL(39, 622, 16), // "debugInformation"
QT_MOC_LITERAL(40, 639, 23), // "Ultracopier::DebugLevel"
QT_MOC_LITERAL(41, 663, 5), // "level"
QT_MOC_LITERAL(42, 669, 8), // "fonction"
QT_MOC_LITERAL(43, 678, 4), // "text"
QT_MOC_LITERAL(44, 683, 4), // "file"
QT_MOC_LITERAL(45, 688, 5), // "ligne"
QT_MOC_LITERAL(46, 694, 17), // "queryOneNewDialog"
QT_MOC_LITERAL(47, 712, 15), // "send_setFilters"
QT_MOC_LITERAL(48, 728, 26), // "std::vector<Filters_rules>"
QT_MOC_LITERAL(49, 755, 7), // "include"
QT_MOC_LITERAL(50, 763, 7), // "exclude"
QT_MOC_LITERAL(51, 771, 25), // "send_sendNewRenamingRules"
QT_MOC_LITERAL(52, 797, 17), // "firstRenamingRule"
QT_MOC_LITERAL(53, 815, 17), // "otherRenamingRule"
QT_MOC_LITERAL(54, 833, 25), // "send_followTheStrictOrder"
QT_MOC_LITERAL(55, 859, 20), // "followTheStrictOrder"
QT_MOC_LITERAL(56, 880, 20), // "send_ignoreBlackList"
QT_MOC_LITERAL(57, 901, 15), // "ignoreBlackList"
QT_MOC_LITERAL(58, 917, 36), // "send_deletePartiallyTransferr..."
QT_MOC_LITERAL(59, 954, 31), // "deletePartiallyTransferredFiles"
QT_MOC_LITERAL(60, 986, 20), // "send_setInodeThreads"
QT_MOC_LITERAL(61, 1007, 12), // "inodeThreads"
QT_MOC_LITERAL(62, 1020, 23), // "send_moveTheWholeFolder"
QT_MOC_LITERAL(63, 1044, 18), // "moveTheWholeFolder"
QT_MOC_LITERAL(64, 1063, 36), // "send_setRenameTheOriginalDest..."
QT_MOC_LITERAL(65, 1100, 28), // "renameTheOriginalDestination"
QT_MOC_LITERAL(66, 1129, 18), // "updateTheDebugInfo"
QT_MOC_LITERAL(67, 1148, 24), // "std::vector<std::string>"
QT_MOC_LITERAL(68, 1173, 7), // "newList"
QT_MOC_LITERAL(69, 1181, 8), // "newList2"
QT_MOC_LITERAL(70, 1190, 22), // "numberOfInodeOperation"
QT_MOC_LITERAL(71, 1213, 21), // "fileAlreadyExistsSlot"
QT_MOC_LITERAL(72, 1235, 6), // "source"
QT_MOC_LITERAL(73, 1242, 11), // "destination"
QT_MOC_LITERAL(74, 1254, 6), // "isSame"
QT_MOC_LITERAL(75, 1261, 15), // "errorOnFileSlot"
QT_MOC_LITERAL(76, 1277, 23), // "folderAlreadyExistsSlot"
QT_MOC_LITERAL(77, 1301, 17), // "ScanFileOrFolder*"
QT_MOC_LITERAL(78, 1319, 17), // "errorOnFolderSlot"
QT_MOC_LITERAL(79, 1337, 23), // "mkPathErrorOnFolderSlot"
QT_MOC_LITERAL(80, 1361, 17), // "fileAlreadyExists"
QT_MOC_LITERAL(81, 1379, 11), // "errorOnFile"
QT_MOC_LITERAL(82, 1391, 19), // "folderAlreadyExists"
QT_MOC_LITERAL(83, 1411, 13), // "errorOnFolder"
QT_MOC_LITERAL(84, 1425, 19), // "mkPathErrorOnFolder"
QT_MOC_LITERAL(85, 1445, 16), // "showOneNewDialog"
QT_MOC_LITERAL(86, 1462, 14), // "sendNewFilters"
QT_MOC_LITERAL(87, 1477, 16), // "showFilterDialog"
QT_MOC_LITERAL(88, 1494, 20), // "sendNewRenamingRules"
QT_MOC_LITERAL(89, 1515, 17), // "showRenamingRules"
QT_MOC_LITERAL(90, 1533, 23), // "get_realBytesTransfered"
QT_MOC_LITERAL(91, 1557, 19), // "realBytesTransfered"
QT_MOC_LITERAL(92, 1577, 18), // "newActionInProgess"
QT_MOC_LITERAL(93, 1596, 35), // "Ultracopier::EngineActionInPr..."
QT_MOC_LITERAL(94, 1632, 19), // "haveNeedPutAtBottom"
QT_MOC_LITERAL(95, 1652, 15), // "needPutAtBottom"
QT_MOC_LITERAL(96, 1668, 16), // "missingDiskSpace"
QT_MOC_LITERAL(97, 1685, 22), // "std::vector<Diskspace>"
QT_MOC_LITERAL(98, 1708, 4), // "list"
QT_MOC_LITERAL(99, 1713, 27), // "exportErrorIntoTransferList"
QT_MOC_LITERAL(100, 1741, 13), // "userAddFolder"
QT_MOC_LITERAL(101, 1755, 11), // "userAddFile"
QT_MOC_LITERAL(102, 1767, 5), // "pause"
QT_MOC_LITERAL(103, 1773, 6), // "resume"
QT_MOC_LITERAL(104, 1780, 4), // "skip"
QT_MOC_LITERAL(105, 1785, 6), // "cancel"
QT_MOC_LITERAL(106, 1792, 11), // "removeItems"
QT_MOC_LITERAL(107, 1804, 14), // "moveItemsOnTop"
QT_MOC_LITERAL(108, 1819, 11), // "moveItemsUp"
QT_MOC_LITERAL(109, 1831, 13), // "moveItemsDown"
QT_MOC_LITERAL(110, 1845, 17), // "moveItemsOnBottom"
QT_MOC_LITERAL(111, 1863, 9), // "forceMode"
QT_MOC_LITERAL(112, 1873, 18), // "exportTransferList"
QT_MOC_LITERAL(113, 1892, 18), // "importTransferList"
QT_MOC_LITERAL(114, 1911, 18), // "setSpeedLimitation"
QT_MOC_LITERAL(115, 1930, 16), // "setRightTransfer"
QT_MOC_LITERAL(116, 1947, 15), // "doRightTransfer"
QT_MOC_LITERAL(117, 1963, 11), // "setKeepDate"
QT_MOC_LITERAL(118, 1975, 8), // "keepDate"
QT_MOC_LITERAL(119, 1984, 14), // "setOsSpecFlags"
QT_MOC_LITERAL(120, 1999, 13), // "os_spec_flags"
QT_MOC_LITERAL(121, 2013, 13), // "setNativeCopy"
QT_MOC_LITERAL(122, 2027, 11), // "native_copy"
QT_MOC_LITERAL(123, 2039, 21), // "setMoveTheWholeFolder"
QT_MOC_LITERAL(124, 2061, 23), // "setFollowTheStrictOrder"
QT_MOC_LITERAL(125, 2085, 18), // "setignoreBlackList"
QT_MOC_LITERAL(126, 2104, 34), // "setDeletePartiallyTransferred..."
QT_MOC_LITERAL(127, 2139, 15), // "setInodeThreads"
QT_MOC_LITERAL(128, 2155, 31), // "setRenameTheOriginalDestination"
QT_MOC_LITERAL(129, 2187, 20), // "inodeThreadsFinished"
QT_MOC_LITERAL(130, 2208, 12), // "setAutoStart"
QT_MOC_LITERAL(131, 2221, 9), // "autoStart"
QT_MOC_LITERAL(132, 2231, 31), // "setCheckDestinationFolderExists"
QT_MOC_LITERAL(133, 2263, 28), // "checkDestinationFolderExists"
QT_MOC_LITERAL(134, 2292, 13), // "setMkFullPath"
QT_MOC_LITERAL(135, 2306, 10), // "mkFullPath"
QT_MOC_LITERAL(136, 2317, 11), // "setChecksum"
QT_MOC_LITERAL(137, 2329, 8), // "checksum"
QT_MOC_LITERAL(138, 2338, 15), // "resetTempWidget"
QT_MOC_LITERAL(139, 2354, 18), // "setFolderCollision"
QT_MOC_LITERAL(140, 2373, 5), // "index"
QT_MOC_LITERAL(141, 2379, 14), // "setFolderError"
QT_MOC_LITERAL(142, 2394, 16), // "setFileCollision"
QT_MOC_LITERAL(143, 2411, 12), // "setFileError"
QT_MOC_LITERAL(144, 2424, 17), // "newLanguageLoaded"
QT_MOC_LITERAL(145, 2442, 26), // "setComboBoxFolderCollision"
QT_MOC_LITERAL(146, 2469, 14), // "changeComboBox"
QT_MOC_LITERAL(147, 2484, 22), // "setComboBoxFolderError"
QT_MOC_LITERAL(148, 2507, 15), // "FileErrorAction"
QT_MOC_LITERAL(149, 2523, 19), // "warningTransferList"
QT_MOC_LITERAL(150, 2543, 7), // "warning"
QT_MOC_LITERAL(151, 2551, 17), // "errorTransferList"
QT_MOC_LITERAL(152, 2569, 5) // "error"

    },
    "CopyEngine\0signal_pause\0\0signal_resume\0"
    "signal_skip\0uint64_t\0id\0"
    "signal_setSpeedLimitation\0int64_t\0"
    "speedLimitation\0signal_removeItems\0"
    "std::vector<uint64_t>\0ids\0"
    "signal_moveItemsOnTop\0signal_moveItemsUp\0"
    "signal_moveItemsDown\0signal_moveItemsOnBottom\0"
    "signal_forceMode\0Ultracopier::CopyMode\0"
    "mode\0signal_exportTransferList\0"
    "std::string\0fileName\0signal_importTransferList\0"
    "signal_exportErrorIntoTransferList\0"
    "signal_setCollisionAction\0FileExistsAction\0"
    "alwaysDoThisActionForFileExists\0"
    "signal_setFolderCollision\0FolderExistsAction\0"
    "action\0tryCancel\0getNeedPutAtBottom\0"
    "fileInfo\0errorString\0TransferThreadAsync*\0"
    "thread\0ErrorType\0errorType\0debugInformation\0"
    "Ultracopier::DebugLevel\0level\0fonction\0"
    "text\0file\0ligne\0queryOneNewDialog\0"
    "send_setFilters\0std::vector<Filters_rules>\0"
    "include\0exclude\0send_sendNewRenamingRules\0"
    "firstRenamingRule\0otherRenamingRule\0"
    "send_followTheStrictOrder\0"
    "followTheStrictOrder\0send_ignoreBlackList\0"
    "ignoreBlackList\0send_deletePartiallyTransferredFiles\0"
    "deletePartiallyTransferredFiles\0"
    "send_setInodeThreads\0inodeThreads\0"
    "send_moveTheWholeFolder\0moveTheWholeFolder\0"
    "send_setRenameTheOriginalDestination\0"
    "renameTheOriginalDestination\0"
    "updateTheDebugInfo\0std::vector<std::string>\0"
    "newList\0newList2\0numberOfInodeOperation\0"
    "fileAlreadyExistsSlot\0source\0destination\0"
    "isSame\0errorOnFileSlot\0folderAlreadyExistsSlot\0"
    "ScanFileOrFolder*\0errorOnFolderSlot\0"
    "mkPathErrorOnFolderSlot\0fileAlreadyExists\0"
    "errorOnFile\0folderAlreadyExists\0"
    "errorOnFolder\0mkPathErrorOnFolder\0"
    "showOneNewDialog\0sendNewFilters\0"
    "showFilterDialog\0sendNewRenamingRules\0"
    "showRenamingRules\0get_realBytesTransfered\0"
    "realBytesTransfered\0newActionInProgess\0"
    "Ultracopier::EngineActionInProgress\0"
    "haveNeedPutAtBottom\0needPutAtBottom\0"
    "missingDiskSpace\0std::vector<Diskspace>\0"
    "list\0exportErrorIntoTransferList\0"
    "userAddFolder\0userAddFile\0pause\0resume\0"
    "skip\0cancel\0removeItems\0moveItemsOnTop\0"
    "moveItemsUp\0moveItemsDown\0moveItemsOnBottom\0"
    "forceMode\0exportTransferList\0"
    "importTransferList\0setSpeedLimitation\0"
    "setRightTransfer\0doRightTransfer\0"
    "setKeepDate\0keepDate\0setOsSpecFlags\0"
    "os_spec_flags\0setNativeCopy\0native_copy\0"
    "setMoveTheWholeFolder\0setFollowTheStrictOrder\0"
    "setignoreBlackList\0"
    "setDeletePartiallyTransferredFiles\0"
    "setInodeThreads\0setRenameTheOriginalDestination\0"
    "inodeThreadsFinished\0setAutoStart\0"
    "autoStart\0setCheckDestinationFolderExists\0"
    "checkDestinationFolderExists\0setMkFullPath\0"
    "mkFullPath\0setChecksum\0checksum\0"
    "resetTempWidget\0setFolderCollision\0"
    "index\0setFolderError\0setFileCollision\0"
    "setFileError\0newLanguageLoaded\0"
    "setComboBoxFolderCollision\0changeComboBox\0"
    "setComboBoxFolderError\0FileErrorAction\0"
    "warningTransferList\0warning\0"
    "errorTransferList\0error"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_CopyEngine[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
      90,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
      27,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    0,  464,    2, 0x06 /* Public */,
       3,    0,  465,    2, 0x06 /* Public */,
       4,    1,  466,    2, 0x06 /* Public */,
       7,    1,  469,    2, 0x06 /* Public */,
      10,    1,  472,    2, 0x06 /* Public */,
      13,    1,  475,    2, 0x06 /* Public */,
      14,    1,  478,    2, 0x06 /* Public */,
      15,    1,  481,    2, 0x06 /* Public */,
      16,    1,  484,    2, 0x06 /* Public */,
      17,    1,  487,    2, 0x06 /* Public */,
      20,    1,  490,    2, 0x06 /* Public */,
      23,    1,  493,    2, 0x06 /* Public */,
      24,    1,  496,    2, 0x06 /* Public */,
      25,    1,  499,    2, 0x06 /* Public */,
      28,    1,  502,    2, 0x06 /* Public */,
      31,    0,  505,    2, 0x06 /* Public */,
      32,    4,  506,    2, 0x06 /* Public */,
      39,    5,  515,    2, 0x06 /* Public */,
      46,    0,  526,    2, 0x06 /* Public */,
      47,    2,  527,    2, 0x06 /* Public */,
      51,    2,  532,    2, 0x06 /* Public */,
      54,    1,  537,    2, 0x06 /* Public */,
      56,    1,  540,    2, 0x06 /* Public */,
      58,    1,  543,    2, 0x06 /* Public */,
      60,    1,  546,    2, 0x06 /* Public */,
      62,    1,  549,    2, 0x06 /* Public */,
      64,    1,  552,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
      66,    3,  555,    2, 0x08 /* Private */,
      71,    4,  562,    2, 0x08 /* Private */,
      75,    4,  571,    2, 0x08 /* Private */,
      76,    4,  580,    2, 0x08 /* Private */,
      78,    4,  589,    2, 0x08 /* Private */,
      79,    3,  598,    2, 0x08 /* Private */,
      80,    4,  605,    2, 0x08 /* Private */,
      81,    4,  614,    2, 0x08 /* Private */,
      82,    4,  623,    2, 0x08 /* Private */,
      83,    4,  632,    2, 0x08 /* Private */,
      84,    3,  641,    2, 0x08 /* Private */,
      85,    0,  648,    2, 0x08 /* Private */,
      86,    0,  649,    2, 0x08 /* Private */,
      87,    0,  650,    2, 0x08 /* Private */,
      88,    2,  651,    2, 0x08 /* Private */,
      89,    0,  656,    2, 0x08 /* Private */,
      90,    1,  657,    2, 0x08 /* Private */,
      92,    1,  660,    2, 0x08 /* Private */,
      94,    5,  663,    2, 0x08 /* Private */,
      96,    1,  674,    2, 0x08 /* Private */,
      99,    0,  677,    2, 0x08 /* Private */,
     100,    1,  678,    2, 0x0a /* Public */,
     101,    1,  681,    2, 0x0a /* Public */,
     102,    0,  684,    2, 0x0a /* Public */,
     103,    0,  685,    2, 0x0a /* Public */,
     104,    1,  686,    2, 0x0a /* Public */,
     105,    0,  689,    2, 0x0a /* Public */,
     106,    1,  690,    2, 0x0a /* Public */,
     107,    1,  693,    2, 0x0a /* Public */,
     108,    1,  696,    2, 0x0a /* Public */,
     109,    1,  699,    2, 0x0a /* Public */,
     110,    1,  702,    2, 0x0a /* Public */,
     111,    1,  705,    2, 0x0a /* Public */,
     112,    0,  708,    2, 0x0a /* Public */,
     113,    0,  709,    2, 0x0a /* Public */,
     114,    1,  710,    2, 0x0a /* Public */,
     115,    1,  713,    2, 0x0a /* Public */,
     117,    1,  716,    2, 0x0a /* Public */,
     119,    1,  719,    2, 0x0a /* Public */,
     121,    1,  722,    2, 0x0a /* Public */,
     123,    1,  725,    2, 0x0a /* Public */,
     124,    1,  728,    2, 0x0a /* Public */,
     125,    1,  731,    2, 0x0a /* Public */,
     126,    1,  734,    2, 0x0a /* Public */,
     127,    1,  737,    2, 0x0a /* Public */,
     128,    1,  740,    2, 0x0a /* Public */,
     129,    0,  743,    2, 0x0a /* Public */,
     130,    1,  744,    2, 0x0a /* Public */,
     132,    1,  747,    2, 0x0a /* Public */,
     134,    1,  750,    2, 0x0a /* Public */,
     136,    1,  753,    2, 0x0a /* Public */,
     138,    0,  756,    2, 0x0a /* Public */,
     139,    1,  757,    2, 0x0a /* Public */,
     141,    1,  760,    2, 0x0a /* Public */,
     142,    1,  763,    2, 0x0a /* Public */,
     143,    1,  766,    2, 0x0a /* Public */,
     144,    0,  769,    2, 0x0a /* Public */,
     145,    2,  770,    2, 0x08 /* Private */,
     145,    1,  775,    2, 0x28 /* Private | MethodCloned */,
     147,    2,  778,    2, 0x08 /* Private */,
     147,    1,  783,    2, 0x28 /* Private | MethodCloned */,
     149,    1,  786,    2, 0x08 /* Private */,
     151,    1,  789,    2, 0x08 /* Private */,

 // signals: parameters
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 5,    6,
    QMetaType::Void, 0x80000000 | 8,    9,
    QMetaType::Void, 0x80000000 | 11,   12,
    QMetaType::Void, 0x80000000 | 11,   12,
    QMetaType::Void, 0x80000000 | 11,   12,
    QMetaType::Void, 0x80000000 | 11,   12,
    QMetaType::Void, 0x80000000 | 11,   12,
    QMetaType::Void, 0x80000000 | 18,   19,
    QMetaType::Void, 0x80000000 | 21,   22,
    QMetaType::Void, 0x80000000 | 21,   22,
    QMetaType::Void, 0x80000000 | 21,   22,
    QMetaType::Void, 0x80000000 | 26,   27,
    QMetaType::Void, 0x80000000 | 29,   30,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 21, 0x80000000 | 21, 0x80000000 | 35, 0x80000000 | 37,   33,   34,   36,   38,
    QMetaType::Void, 0x80000000 | 40, 0x80000000 | 21, 0x80000000 | 21, 0x80000000 | 21, QMetaType::Int,   41,   42,   43,   44,   45,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 48, 0x80000000 | 48,   49,   50,
    QMetaType::Void, 0x80000000 | 21, 0x80000000 | 21,   52,   53,
    QMetaType::Void, QMetaType::Bool,   55,
    QMetaType::Void, QMetaType::Bool,   57,
    QMetaType::Void, QMetaType::Bool,   59,
    QMetaType::Void, QMetaType::Int,   61,
    QMetaType::Void, QMetaType::Bool,   63,
    QMetaType::Void, QMetaType::Bool,   65,

 // slots: parameters
    QMetaType::Void, 0x80000000 | 67, 0x80000000 | 67, QMetaType::Int,   68,   69,   70,
    QMetaType::Void, 0x80000000 | 21, 0x80000000 | 21, QMetaType::Bool, 0x80000000 | 35,   72,   73,   74,   36,
    QMetaType::Void, 0x80000000 | 21, 0x80000000 | 21, 0x80000000 | 35, 0x80000000 | 37,   33,   34,   36,   38,
    QMetaType::Void, 0x80000000 | 21, 0x80000000 | 21, QMetaType::Bool, 0x80000000 | 77,   72,   73,   74,   36,
    QMetaType::Void, 0x80000000 | 21, 0x80000000 | 21, 0x80000000 | 77, 0x80000000 | 37,   33,   34,   36,   38,
    QMetaType::Void, 0x80000000 | 21, 0x80000000 | 21, 0x80000000 | 37,    2,    2,   38,
    QMetaType::Void, 0x80000000 | 21, 0x80000000 | 21, QMetaType::Bool, 0x80000000 | 35,   72,   73,   74,   36,
    QMetaType::Void, 0x80000000 | 21, 0x80000000 | 21, 0x80000000 | 35, 0x80000000 | 37,   33,   34,   36,   38,
    QMetaType::Void, 0x80000000 | 21, 0x80000000 | 21, QMetaType::Bool, 0x80000000 | 77,   72,   73,   74,   36,
    QMetaType::Void, 0x80000000 | 21, 0x80000000 | 21, 0x80000000 | 77, 0x80000000 | 37,   33,   34,   36,   38,
    QMetaType::Void, 0x80000000 | 21, 0x80000000 | 21, 0x80000000 | 37,    2,    2,   38,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 21, 0x80000000 | 21,   52,   53,
    QMetaType::Void,
    QMetaType::Void, QMetaType::ULongLong,   91,
    QMetaType::Void, 0x80000000 | 93,    2,
    QMetaType::Void, QMetaType::Bool, 0x80000000 | 21, 0x80000000 | 21, 0x80000000 | 35, 0x80000000 | 37,   95,   33,   34,   36,   38,
    QMetaType::Void, 0x80000000 | 97,   98,
    QMetaType::Void,
    QMetaType::Bool, 0x80000000 | 18,   19,
    QMetaType::Bool, 0x80000000 | 18,   19,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 5,    6,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 11,   12,
    QMetaType::Void, 0x80000000 | 11,   12,
    QMetaType::Void, 0x80000000 | 11,   12,
    QMetaType::Void, 0x80000000 | 11,   12,
    QMetaType::Void, 0x80000000 | 11,   12,
    QMetaType::Void, 0x80000000 | 18,   19,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Bool, 0x80000000 | 8,    9,
    QMetaType::Void, QMetaType::Bool,  116,
    QMetaType::Void, QMetaType::Bool,  118,
    QMetaType::Void, QMetaType::Bool,  120,
    QMetaType::Void, QMetaType::Bool,  122,
    QMetaType::Void, QMetaType::Bool,   63,
    QMetaType::Void, QMetaType::Bool,   55,
    QMetaType::Void, QMetaType::Bool,   57,
    QMetaType::Void, QMetaType::Bool,   59,
    QMetaType::Void, QMetaType::Int,   61,
    QMetaType::Void, QMetaType::Bool,   65,
    QMetaType::Void,
    QMetaType::Void, QMetaType::Bool,  131,
    QMetaType::Void, QMetaType::Bool,  133,
    QMetaType::Void, QMetaType::Bool,  135,
    QMetaType::Void, QMetaType::Bool,  137,
    QMetaType::Void,
    QMetaType::Void, QMetaType::Int,  140,
    QMetaType::Void, QMetaType::Int,  140,
    QMetaType::Void, QMetaType::Int,  140,
    QMetaType::Void, QMetaType::Int,  140,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 29, QMetaType::Bool,   30,  146,
    QMetaType::Void, 0x80000000 | 29,   30,
    QMetaType::Void, 0x80000000 | 148, QMetaType::Bool,   30,  146,
    QMetaType::Void, 0x80000000 | 148,   30,
    QMetaType::Void, 0x80000000 | 21,  150,
    QMetaType::Void, 0x80000000 | 21,  152,

       0        // eod
};

void CopyEngine::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<CopyEngine *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->signal_pause(); break;
        case 1: _t->signal_resume(); break;
        case 2: _t->signal_skip((*reinterpret_cast< const uint64_t(*)>(_a[1]))); break;
        case 3: _t->signal_setSpeedLimitation((*reinterpret_cast< const int64_t(*)>(_a[1]))); break;
        case 4: _t->signal_removeItems((*reinterpret_cast< const std::vector<uint64_t>(*)>(_a[1]))); break;
        case 5: _t->signal_moveItemsOnTop((*reinterpret_cast< const std::vector<uint64_t>(*)>(_a[1]))); break;
        case 6: _t->signal_moveItemsUp((*reinterpret_cast< const std::vector<uint64_t>(*)>(_a[1]))); break;
        case 7: _t->signal_moveItemsDown((*reinterpret_cast< const std::vector<uint64_t>(*)>(_a[1]))); break;
        case 8: _t->signal_moveItemsOnBottom((*reinterpret_cast< const std::vector<uint64_t>(*)>(_a[1]))); break;
        case 9: _t->signal_forceMode((*reinterpret_cast< const Ultracopier::CopyMode(*)>(_a[1]))); break;
        case 10: _t->signal_exportTransferList((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        case 11: _t->signal_importTransferList((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        case 12: _t->signal_exportErrorIntoTransferList((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        case 13: _t->signal_setCollisionAction((*reinterpret_cast< FileExistsAction(*)>(_a[1]))); break;
        case 14: _t->signal_setFolderCollision((*reinterpret_cast< FolderExistsAction(*)>(_a[1]))); break;
        case 15: _t->tryCancel(); break;
        case 16: _t->getNeedPutAtBottom((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< TransferThreadAsync*(*)>(_a[3])),(*reinterpret_cast< const ErrorType(*)>(_a[4]))); break;
        case 17: _t->debugInformation((*reinterpret_cast< const Ultracopier::DebugLevel(*)>(_a[1])),(*reinterpret_cast< std::string(*)>(_a[2])),(*reinterpret_cast< std::string(*)>(_a[3])),(*reinterpret_cast< std::string(*)>(_a[4])),(*reinterpret_cast< int(*)>(_a[5]))); break;
        case 18: _t->queryOneNewDialog(); break;
        case 19: _t->send_setFilters((*reinterpret_cast< const std::vector<Filters_rules>(*)>(_a[1])),(*reinterpret_cast< const std::vector<Filters_rules>(*)>(_a[2]))); break;
        case 20: _t->send_sendNewRenamingRules((*reinterpret_cast< std::string(*)>(_a[1])),(*reinterpret_cast< std::string(*)>(_a[2]))); break;
        case 21: _t->send_followTheStrictOrder((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 22: _t->send_ignoreBlackList((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 23: _t->send_deletePartiallyTransferredFiles((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 24: _t->send_setInodeThreads((*reinterpret_cast< const int(*)>(_a[1]))); break;
        case 25: _t->send_moveTheWholeFolder((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 26: _t->send_setRenameTheOriginalDestination((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 27: _t->updateTheDebugInfo((*reinterpret_cast< const std::vector<std::string>(*)>(_a[1])),(*reinterpret_cast< const std::vector<std::string>(*)>(_a[2])),(*reinterpret_cast< const int(*)>(_a[3]))); break;
        case 28: _t->fileAlreadyExistsSlot((*reinterpret_cast< std::string(*)>(_a[1])),(*reinterpret_cast< std::string(*)>(_a[2])),(*reinterpret_cast< bool(*)>(_a[3])),(*reinterpret_cast< TransferThreadAsync*(*)>(_a[4]))); break;
        case 29: _t->errorOnFileSlot((*reinterpret_cast< std::string(*)>(_a[1])),(*reinterpret_cast< std::string(*)>(_a[2])),(*reinterpret_cast< TransferThreadAsync*(*)>(_a[3])),(*reinterpret_cast< const ErrorType(*)>(_a[4]))); break;
        case 30: _t->folderAlreadyExistsSlot((*reinterpret_cast< std::string(*)>(_a[1])),(*reinterpret_cast< std::string(*)>(_a[2])),(*reinterpret_cast< bool(*)>(_a[3])),(*reinterpret_cast< ScanFileOrFolder*(*)>(_a[4]))); break;
        case 31: _t->errorOnFolderSlot((*reinterpret_cast< std::string(*)>(_a[1])),(*reinterpret_cast< std::string(*)>(_a[2])),(*reinterpret_cast< ScanFileOrFolder*(*)>(_a[3])),(*reinterpret_cast< ErrorType(*)>(_a[4]))); break;
        case 32: _t->mkPathErrorOnFolderSlot((*reinterpret_cast< std::string(*)>(_a[1])),(*reinterpret_cast< std::string(*)>(_a[2])),(*reinterpret_cast< ErrorType(*)>(_a[3]))); break;
        case 33: _t->fileAlreadyExists((*reinterpret_cast< std::string(*)>(_a[1])),(*reinterpret_cast< std::string(*)>(_a[2])),(*reinterpret_cast< bool(*)>(_a[3])),(*reinterpret_cast< TransferThreadAsync*(*)>(_a[4]))); break;
        case 34: _t->errorOnFile((*reinterpret_cast< std::string(*)>(_a[1])),(*reinterpret_cast< std::string(*)>(_a[2])),(*reinterpret_cast< TransferThreadAsync*(*)>(_a[3])),(*reinterpret_cast< const ErrorType(*)>(_a[4]))); break;
        case 35: _t->folderAlreadyExists((*reinterpret_cast< std::string(*)>(_a[1])),(*reinterpret_cast< std::string(*)>(_a[2])),(*reinterpret_cast< bool(*)>(_a[3])),(*reinterpret_cast< ScanFileOrFolder*(*)>(_a[4]))); break;
        case 36: _t->errorOnFolder((*reinterpret_cast< std::string(*)>(_a[1])),(*reinterpret_cast< std::string(*)>(_a[2])),(*reinterpret_cast< ScanFileOrFolder*(*)>(_a[3])),(*reinterpret_cast< ErrorType(*)>(_a[4]))); break;
        case 37: _t->mkPathErrorOnFolder((*reinterpret_cast< std::string(*)>(_a[1])),(*reinterpret_cast< std::string(*)>(_a[2])),(*reinterpret_cast< const ErrorType(*)>(_a[3]))); break;
        case 38: _t->showOneNewDialog(); break;
        case 39: _t->sendNewFilters(); break;
        case 40: _t->showFilterDialog(); break;
        case 41: _t->sendNewRenamingRules((*reinterpret_cast< std::string(*)>(_a[1])),(*reinterpret_cast< std::string(*)>(_a[2]))); break;
        case 42: _t->showRenamingRules(); break;
        case 43: _t->get_realBytesTransfered((*reinterpret_cast< quint64(*)>(_a[1]))); break;
        case 44: _t->newActionInProgess((*reinterpret_cast< Ultracopier::EngineActionInProgress(*)>(_a[1]))); break;
        case 45: _t->haveNeedPutAtBottom((*reinterpret_cast< bool(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< const std::string(*)>(_a[3])),(*reinterpret_cast< TransferThreadAsync*(*)>(_a[4])),(*reinterpret_cast< const ErrorType(*)>(_a[5]))); break;
        case 46: _t->missingDiskSpace((*reinterpret_cast< std::vector<Diskspace>(*)>(_a[1]))); break;
        case 47: _t->exportErrorIntoTransferList(); break;
        case 48: { bool _r = _t->userAddFolder((*reinterpret_cast< const Ultracopier::CopyMode(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = std::move(_r); }  break;
        case 49: { bool _r = _t->userAddFile((*reinterpret_cast< const Ultracopier::CopyMode(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = std::move(_r); }  break;
        case 50: _t->pause(); break;
        case 51: _t->resume(); break;
        case 52: _t->skip((*reinterpret_cast< const uint64_t(*)>(_a[1]))); break;
        case 53: _t->cancel(); break;
        case 54: _t->removeItems((*reinterpret_cast< const std::vector<uint64_t>(*)>(_a[1]))); break;
        case 55: _t->moveItemsOnTop((*reinterpret_cast< const std::vector<uint64_t>(*)>(_a[1]))); break;
        case 56: _t->moveItemsUp((*reinterpret_cast< const std::vector<uint64_t>(*)>(_a[1]))); break;
        case 57: _t->moveItemsDown((*reinterpret_cast< const std::vector<uint64_t>(*)>(_a[1]))); break;
        case 58: _t->moveItemsOnBottom((*reinterpret_cast< const std::vector<uint64_t>(*)>(_a[1]))); break;
        case 59: _t->forceMode((*reinterpret_cast< const Ultracopier::CopyMode(*)>(_a[1]))); break;
        case 60: _t->exportTransferList(); break;
        case 61: _t->importTransferList(); break;
        case 62: { bool _r = _t->setSpeedLimitation((*reinterpret_cast< const int64_t(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = std::move(_r); }  break;
        case 63: _t->setRightTransfer((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 64: _t->setKeepDate((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 65: _t->setOsSpecFlags((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 66: _t->setNativeCopy((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 67: _t->setMoveTheWholeFolder((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 68: _t->setFollowTheStrictOrder((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 69: _t->setignoreBlackList((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 70: _t->setDeletePartiallyTransferredFiles((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 71: _t->setInodeThreads((*reinterpret_cast< const int(*)>(_a[1]))); break;
        case 72: _t->setRenameTheOriginalDestination((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 73: _t->inodeThreadsFinished(); break;
        case 74: _t->setAutoStart((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 75: _t->setCheckDestinationFolderExists((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 76: _t->setMkFullPath((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 77: _t->setChecksum((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 78: _t->resetTempWidget(); break;
        case 79: _t->setFolderCollision((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 80: _t->setFolderError((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 81: _t->setFileCollision((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 82: _t->setFileError((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 83: _t->newLanguageLoaded(); break;
        case 84: _t->setComboBoxFolderCollision((*reinterpret_cast< FolderExistsAction(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
        case 85: _t->setComboBoxFolderCollision((*reinterpret_cast< FolderExistsAction(*)>(_a[1]))); break;
        case 86: _t->setComboBoxFolderError((*reinterpret_cast< FileErrorAction(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
        case 87: _t->setComboBoxFolderError((*reinterpret_cast< FileErrorAction(*)>(_a[1]))); break;
        case 88: _t->warningTransferList((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        case 89: _t->errorTransferList((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 16:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< TransferThreadAsync* >(); break;
            }
            break;
        case 28:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 3:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< TransferThreadAsync* >(); break;
            }
            break;
        case 29:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< TransferThreadAsync* >(); break;
            }
            break;
        case 30:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 3:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< ScanFileOrFolder* >(); break;
            }
            break;
        case 31:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< ScanFileOrFolder* >(); break;
            }
            break;
        case 33:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 3:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< TransferThreadAsync* >(); break;
            }
            break;
        case 34:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< TransferThreadAsync* >(); break;
            }
            break;
        case 35:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 3:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< ScanFileOrFolder* >(); break;
            }
            break;
        case 36:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< ScanFileOrFolder* >(); break;
            }
            break;
        case 45:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 3:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< TransferThreadAsync* >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (CopyEngine::*)() const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::signal_pause)) {
                *result = 0;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)() const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::signal_resume)) {
                *result = 1;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const uint64_t & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::signal_skip)) {
                *result = 2;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const int64_t & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::signal_setSpeedLimitation)) {
                *result = 3;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const std::vector<uint64_t> & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::signal_removeItems)) {
                *result = 4;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const std::vector<uint64_t> & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::signal_moveItemsOnTop)) {
                *result = 5;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const std::vector<uint64_t> & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::signal_moveItemsUp)) {
                *result = 6;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const std::vector<uint64_t> & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::signal_moveItemsDown)) {
                *result = 7;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const std::vector<uint64_t> & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::signal_moveItemsOnBottom)) {
                *result = 8;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const Ultracopier::CopyMode & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::signal_forceMode)) {
                *result = 9;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const std::string & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::signal_exportTransferList)) {
                *result = 10;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const std::string & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::signal_importTransferList)) {
                *result = 11;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const std::string & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::signal_exportErrorIntoTransferList)) {
                *result = 12;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(FileExistsAction ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::signal_setCollisionAction)) {
                *result = 13;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(FolderExistsAction ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::signal_setFolderCollision)) {
                *result = 14;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)() const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::tryCancel)) {
                *result = 15;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const std::string & , const std::string & , TransferThreadAsync * , const ErrorType & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::getNeedPutAtBottom)) {
                *result = 16;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const Ultracopier::DebugLevel & , std::string , std::string , std::string , int ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::debugInformation)) {
                *result = 17;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)() const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::queryOneNewDialog)) {
                *result = 18;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const std::vector<Filters_rules> & , const std::vector<Filters_rules> & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::send_setFilters)) {
                *result = 19;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(std::string , std::string ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::send_sendNewRenamingRules)) {
                *result = 20;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const bool & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::send_followTheStrictOrder)) {
                *result = 21;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const bool & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::send_ignoreBlackList)) {
                *result = 22;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const bool & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::send_deletePartiallyTransferredFiles)) {
                *result = 23;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const int & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::send_setInodeThreads)) {
                *result = 24;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const bool & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::send_moveTheWholeFolder)) {
                *result = 25;
                return;
            }
        }
        {
            using _t = void (CopyEngine::*)(const bool & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&CopyEngine::send_setRenameTheOriginalDestination)) {
                *result = 26;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject CopyEngine::staticMetaObject = { {
    QMetaObject::SuperData::link<PluginInterface_CopyEngine::staticMetaObject>(),
    qt_meta_stringdata_CopyEngine.data,
    qt_meta_data_CopyEngine,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *CopyEngine::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_CopyEngine.stringdata0))
        return static_cast<void*>(this);
    return PluginInterface_CopyEngine::qt_metacast(_clname);
}

int CopyEngine::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PluginInterface_CopyEngine::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 90)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 90;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 90)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 90;
    }
    return _id;
}

// SIGNAL 0
void CopyEngine::signal_pause()const
{
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void CopyEngine::signal_resume()const
{
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void CopyEngine::signal_skip(const uint64_t & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 2, _a);
}

// SIGNAL 3
void CopyEngine::signal_setSpeedLimitation(const int64_t & _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 3, _a);
}

// SIGNAL 4
void CopyEngine::signal_removeItems(const std::vector<uint64_t> & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 4, _a);
}

// SIGNAL 5
void CopyEngine::signal_moveItemsOnTop(const std::vector<uint64_t> & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 5, _a);
}

// SIGNAL 6
void CopyEngine::signal_moveItemsUp(const std::vector<uint64_t> & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 6, _a);
}

// SIGNAL 7
void CopyEngine::signal_moveItemsDown(const std::vector<uint64_t> & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 7, _a);
}

// SIGNAL 8
void CopyEngine::signal_moveItemsOnBottom(const std::vector<uint64_t> & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 8, _a);
}

// SIGNAL 9
void CopyEngine::signal_forceMode(const Ultracopier::CopyMode & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 9, _a);
}

// SIGNAL 10
void CopyEngine::signal_exportTransferList(const std::string & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 10, _a);
}

// SIGNAL 11
void CopyEngine::signal_importTransferList(const std::string & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 11, _a);
}

// SIGNAL 12
void CopyEngine::signal_exportErrorIntoTransferList(const std::string & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 12, _a);
}

// SIGNAL 13
void CopyEngine::signal_setCollisionAction(FileExistsAction _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 13, _a);
}

// SIGNAL 14
void CopyEngine::signal_setFolderCollision(FolderExistsAction _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 14, _a);
}

// SIGNAL 15
void CopyEngine::tryCancel()const
{
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 15, nullptr);
}

// SIGNAL 16
void CopyEngine::getNeedPutAtBottom(const std::string & _t1, const std::string & _t2, TransferThreadAsync * _t3, const ErrorType & _t4)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t4))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 16, _a);
}

// SIGNAL 17
void CopyEngine::debugInformation(const Ultracopier::DebugLevel & _t1, std::string _t2, std::string _t3, std::string _t4, int _t5)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t4))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t5))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 17, _a);
}

// SIGNAL 18
void CopyEngine::queryOneNewDialog()const
{
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 18, nullptr);
}

// SIGNAL 19
void CopyEngine::send_setFilters(const std::vector<Filters_rules> & _t1, const std::vector<Filters_rules> & _t2)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 19, _a);
}

// SIGNAL 20
void CopyEngine::send_sendNewRenamingRules(std::string _t1, std::string _t2)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 20, _a);
}

// SIGNAL 21
void CopyEngine::send_followTheStrictOrder(const bool & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 21, _a);
}

// SIGNAL 22
void CopyEngine::send_ignoreBlackList(const bool & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 22, _a);
}

// SIGNAL 23
void CopyEngine::send_deletePartiallyTransferredFiles(const bool & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 23, _a);
}

// SIGNAL 24
void CopyEngine::send_setInodeThreads(const int & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 24, _a);
}

// SIGNAL 25
void CopyEngine::send_moveTheWholeFolder(const bool & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 25, _a);
}

// SIGNAL 26
void CopyEngine::send_setRenameTheOriginalDestination(const bool & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< CopyEngine *>(this), &staticMetaObject, 26, _a);
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
