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

#include <memory>
#include "transfers/model/TransfersModel.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#include <QtCore/QList>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'TransfersModel.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.15.17. 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_TransferThread_t {
    QByteArrayData data[12];
    char stringdata0[158];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_TransferThread_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_TransferThread_t qt_meta_stringdata_TransferThread = {
    {
QT_MOC_LITERAL(0, 0, 14), // "TransferThread"
QT_MOC_LITERAL(1, 15, 15), // "onTransferStart"
QT_MOC_LITERAL(2, 31, 0), // ""
QT_MOC_LITERAL(3, 32, 14), // "mega::MegaApi*"
QT_MOC_LITERAL(4, 47, 19), // "mega::MegaTransfer*"
QT_MOC_LITERAL(5, 67, 8), // "transfer"
QT_MOC_LITERAL(6, 76, 16), // "onTransferFinish"
QT_MOC_LITERAL(7, 93, 3), // "api"
QT_MOC_LITERAL(8, 97, 16), // "mega::MegaError*"
QT_MOC_LITERAL(9, 114, 1), // "e"
QT_MOC_LITERAL(10, 116, 16), // "onTransferUpdate"
QT_MOC_LITERAL(11, 133, 24) // "onTransferTemporaryError"

    },
    "TransferThread\0onTransferStart\0\0"
    "mega::MegaApi*\0mega::MegaTransfer*\0"
    "transfer\0onTransferFinish\0api\0"
    "mega::MegaError*\0e\0onTransferUpdate\0"
    "onTransferTemporaryError"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_TransferThread[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    2,   34,    2, 0x0a /* Public */,
       6,    3,   39,    2, 0x0a /* Public */,
      10,    2,   46,    2, 0x0a /* Public */,
      11,    3,   51,    2, 0x0a /* Public */,

 // slots: parameters
    QMetaType::Void, 0x80000000 | 3, 0x80000000 | 4,    2,    5,
    QMetaType::Void, 0x80000000 | 3, 0x80000000 | 4, 0x80000000 | 8,    7,    5,    9,
    QMetaType::Void, 0x80000000 | 3, 0x80000000 | 4,    2,    5,
    QMetaType::Void, 0x80000000 | 3, 0x80000000 | 4, 0x80000000 | 8,    2,    5,    2,

       0        // eod
};

void TransferThread::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<TransferThread *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onTransferStart((*reinterpret_cast< mega::MegaApi*(*)>(_a[1])),(*reinterpret_cast< mega::MegaTransfer*(*)>(_a[2]))); break;
        case 1: _t->onTransferFinish((*reinterpret_cast< mega::MegaApi*(*)>(_a[1])),(*reinterpret_cast< mega::MegaTransfer*(*)>(_a[2])),(*reinterpret_cast< mega::MegaError*(*)>(_a[3]))); break;
        case 2: _t->onTransferUpdate((*reinterpret_cast< mega::MegaApi*(*)>(_a[1])),(*reinterpret_cast< mega::MegaTransfer*(*)>(_a[2]))); break;
        case 3: _t->onTransferTemporaryError((*reinterpret_cast< mega::MegaApi*(*)>(_a[1])),(*reinterpret_cast< mega::MegaTransfer*(*)>(_a[2])),(*reinterpret_cast< mega::MegaError*(*)>(_a[3]))); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject TransferThread::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_meta_stringdata_TransferThread.data,
    qt_meta_data_TransferThread,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *TransferThread::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_TransferThread.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "mega::MegaTransferListener"))
        return static_cast< mega::MegaTransferListener*>(this);
    return QObject::qt_metacast(_clname);
}

int TransferThread::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 < 4)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 4;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 4)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 4;
    }
    return _id;
}
struct qt_meta_stringdata_TransfersModel_t {
    QByteArrayData data[42];
    char stringdata0[834];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_TransfersModel_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_TransfersModel_t qt_meta_stringdata_TransfersModel = {
    {
QT_MOC_LITERAL(0, 0, 14), // "TransfersModel"
QT_MOC_LITERAL(1, 15, 17), // "pauseStateChanged"
QT_MOC_LITERAL(2, 33, 0), // ""
QT_MOC_LITERAL(3, 34, 10), // "pauseState"
QT_MOC_LITERAL(4, 45, 25), // "transferPauseStateChanged"
QT_MOC_LITERAL(5, 71, 21), // "transfersCountUpdated"
QT_MOC_LITERAL(6, 93, 23), // "processTransferInThread"
QT_MOC_LITERAL(7, 117, 33), // "pauseStateChangedByTransferRe..."
QT_MOC_LITERAL(8, 151, 7), // "blockUi"
QT_MOC_LITERAL(9, 159, 9), // "unblockUi"
QT_MOC_LITERAL(10, 169, 18), // "unblockUiAndFilter"
QT_MOC_LITERAL(11, 188, 23), // "modelProcessingFinished"
QT_MOC_LITERAL(12, 212, 16), // "transferFinished"
QT_MOC_LITERAL(13, 229, 11), // "QModelIndex"
QT_MOC_LITERAL(14, 241, 5), // "index"
QT_MOC_LITERAL(15, 247, 19), // "internalMoveStarted"
QT_MOC_LITERAL(16, 267, 20), // "internalMoveFinished"
QT_MOC_LITERAL(17, 288, 26), // "mostPriorityTransferUpdate"
QT_MOC_LITERAL(18, 315, 9), // "uploadTag"
QT_MOC_LITERAL(19, 325, 11), // "downloadTag"
QT_MOC_LITERAL(20, 337, 23), // "transfersProcessChanged"
QT_MOC_LITERAL(21, 361, 20), // "showInFolderFinished"
QT_MOC_LITERAL(22, 382, 22), // "activeTransfersChanged"
QT_MOC_LITERAL(23, 405, 18), // "rowsAboutToBeMoved"
QT_MOC_LITERAL(24, 424, 11), // "TransferTag"
QT_MOC_LITERAL(25, 436, 11), // "firstRowTag"
QT_MOC_LITERAL(26, 448, 23), // "pauseResumeAllTransfers"
QT_MOC_LITERAL(27, 472, 5), // "state"
QT_MOC_LITERAL(28, 478, 26), // "askForMostPriorityTransfer"
QT_MOC_LITERAL(29, 505, 21), // "processStartTransfers"
QT_MOC_LITERAL(30, 527, 51), // "QList<QExplicitlySharedDataPo..."
QT_MOC_LITERAL(31, 579, 16), // "transfersToStart"
QT_MOC_LITERAL(32, 596, 22), // "processUpdateTransfers"
QT_MOC_LITERAL(33, 619, 22), // "processCancelTransfers"
QT_MOC_LITERAL(34, 642, 26), // "processSyncFailedTransfers"
QT_MOC_LITERAL(35, 669, 24), // "cacheCancelTransfersTags"
QT_MOC_LITERAL(36, 694, 22), // "processFailedTransfers"
QT_MOC_LITERAL(37, 717, 18), // "onProcessTransfers"
QT_MOC_LITERAL(38, 736, 20), // "updateTransfersCount"
QT_MOC_LITERAL(39, 757, 24), // "onClearTransfersFinished"
QT_MOC_LITERAL(40, 782, 37), // "onAskForMostPriorityTransfers..."
QT_MOC_LITERAL(41, 820, 13) // "onKeepPCAwake"

    },
    "TransfersModel\0pauseStateChanged\0\0"
    "pauseState\0transferPauseStateChanged\0"
    "transfersCountUpdated\0processTransferInThread\0"
    "pauseStateChangedByTransferResume\0"
    "blockUi\0unblockUi\0unblockUiAndFilter\0"
    "modelProcessingFinished\0transferFinished\0"
    "QModelIndex\0index\0internalMoveStarted\0"
    "internalMoveFinished\0mostPriorityTransferUpdate\0"
    "uploadTag\0downloadTag\0transfersProcessChanged\0"
    "showInFolderFinished\0activeTransfersChanged\0"
    "rowsAboutToBeMoved\0TransferTag\0"
    "firstRowTag\0pauseResumeAllTransfers\0"
    "state\0askForMostPriorityTransfer\0"
    "processStartTransfers\0"
    "QList<QExplicitlySharedDataPointer<TransferData> >&\0"
    "transfersToStart\0processUpdateTransfers\0"
    "processCancelTransfers\0"
    "processSyncFailedTransfers\0"
    "cacheCancelTransfersTags\0"
    "processFailedTransfers\0onProcessTransfers\0"
    "updateTransfersCount\0onClearTransfersFinished\0"
    "onAskForMostPriorityTransfersFinished\0"
    "onKeepPCAwake"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_TransfersModel[] = {

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

 // signals: name, argc, parameters, tag, flags
       1,    1,  164,    2, 0x06 /* Public */,
       4,    0,  167,    2, 0x06 /* Public */,
       5,    0,  168,    2, 0x06 /* Public */,
       6,    0,  169,    2, 0x06 /* Public */,
       7,    0,  170,    2, 0x06 /* Public */,
       8,    0,  171,    2, 0x06 /* Public */,
       9,    0,  172,    2, 0x06 /* Public */,
      10,    0,  173,    2, 0x06 /* Public */,
      11,    0,  174,    2, 0x06 /* Public */,
      12,    1,  175,    2, 0x06 /* Public */,
      15,    0,  178,    2, 0x06 /* Public */,
      16,    0,  179,    2, 0x06 /* Public */,
      17,    2,  180,    2, 0x06 /* Public */,
      20,    0,  185,    2, 0x06 /* Public */,
      21,    1,  186,    2, 0x06 /* Public */,
      22,    0,  189,    2, 0x06 /* Public */,
      23,    1,  190,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
      26,    1,  193,    2, 0x0a /* Public */,
      28,    0,  196,    2, 0x0a /* Public */,
      29,    1,  197,    2, 0x08 /* Private */,
      32,    0,  200,    2, 0x08 /* Private */,
      33,    0,  201,    2, 0x08 /* Private */,
      34,    0,  202,    2, 0x08 /* Private */,
      35,    0,  203,    2, 0x08 /* Private */,
      36,    0,  204,    2, 0x08 /* Private */,
      37,    0,  205,    2, 0x08 /* Private */,
      38,    0,  206,    2, 0x08 /* Private */,
      39,    0,  207,    2, 0x08 /* Private */,
      40,    0,  208,    2, 0x08 /* Private */,
      41,    0,  209,    2, 0x08 /* Private */,

 // signals: parameters
    QMetaType::Void, QMetaType::Bool,    3,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 13,   14,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, QMetaType::Int, QMetaType::Int,   18,   19,
    QMetaType::Void,
    QMetaType::Void, QMetaType::Bool,    2,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 24,   25,

 // slots: parameters
    QMetaType::Void, QMetaType::Bool,   27,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 30,   31,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,

       0        // eod
};

void TransfersModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<TransfersModel *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->pauseStateChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 1: _t->transferPauseStateChanged(); break;
        case 2: _t->transfersCountUpdated(); break;
        case 3: _t->processTransferInThread(); break;
        case 4: _t->pauseStateChangedByTransferResume(); break;
        case 5: _t->blockUi(); break;
        case 6: _t->unblockUi(); break;
        case 7: _t->unblockUiAndFilter(); break;
        case 8: _t->modelProcessingFinished(); break;
        case 9: _t->transferFinished((*reinterpret_cast< const QModelIndex(*)>(_a[1]))); break;
        case 10: _t->internalMoveStarted(); break;
        case 11: _t->internalMoveFinished(); break;
        case 12: _t->mostPriorityTransferUpdate((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
        case 13: _t->transfersProcessChanged(); break;
        case 14: _t->showInFolderFinished((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 15: _t->activeTransfersChanged(); break;
        case 16: _t->rowsAboutToBeMoved((*reinterpret_cast< TransferTag(*)>(_a[1]))); break;
        case 17: _t->pauseResumeAllTransfers((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 18: _t->askForMostPriorityTransfer(); break;
        case 19: _t->processStartTransfers((*reinterpret_cast< QList<QExplicitlySharedDataPointer<TransferData> >(*)>(_a[1]))); break;
        case 20: _t->processUpdateTransfers(); break;
        case 21: _t->processCancelTransfers(); break;
        case 22: _t->processSyncFailedTransfers(); break;
        case 23: _t->cacheCancelTransfersTags(); break;
        case 24: _t->processFailedTransfers(); break;
        case 25: _t->onProcessTransfers(); break;
        case 26: _t->updateTransfersCount(); break;
        case 27: _t->onClearTransfersFinished(); break;
        case 28: _t->onAskForMostPriorityTransfersFinished(); break;
        case 29: _t->onKeepPCAwake(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (TransfersModel::*)(bool );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::pauseStateChanged)) {
                *result = 0;
                return;
            }
        }
        {
            using _t = void (TransfersModel::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::transferPauseStateChanged)) {
                *result = 1;
                return;
            }
        }
        {
            using _t = void (TransfersModel::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::transfersCountUpdated)) {
                *result = 2;
                return;
            }
        }
        {
            using _t = void (TransfersModel::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::processTransferInThread)) {
                *result = 3;
                return;
            }
        }
        {
            using _t = void (TransfersModel::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::pauseStateChangedByTransferResume)) {
                *result = 4;
                return;
            }
        }
        {
            using _t = void (TransfersModel::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::blockUi)) {
                *result = 5;
                return;
            }
        }
        {
            using _t = void (TransfersModel::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::unblockUi)) {
                *result = 6;
                return;
            }
        }
        {
            using _t = void (TransfersModel::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::unblockUiAndFilter)) {
                *result = 7;
                return;
            }
        }
        {
            using _t = void (TransfersModel::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::modelProcessingFinished)) {
                *result = 8;
                return;
            }
        }
        {
            using _t = void (TransfersModel::*)(const QModelIndex & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::transferFinished)) {
                *result = 9;
                return;
            }
        }
        {
            using _t = void (TransfersModel::*)() const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::internalMoveStarted)) {
                *result = 10;
                return;
            }
        }
        {
            using _t = void (TransfersModel::*)() const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::internalMoveFinished)) {
                *result = 11;
                return;
            }
        }
        {
            using _t = void (TransfersModel::*)(int , int );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::mostPriorityTransferUpdate)) {
                *result = 12;
                return;
            }
        }
        {
            using _t = void (TransfersModel::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::transfersProcessChanged)) {
                *result = 13;
                return;
            }
        }
        {
            using _t = void (TransfersModel::*)(bool );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::showInFolderFinished)) {
                *result = 14;
                return;
            }
        }
        {
            using _t = void (TransfersModel::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::activeTransfersChanged)) {
                *result = 15;
                return;
            }
        }
        {
            using _t = void (TransfersModel::*)(TransferTag );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TransfersModel::rowsAboutToBeMoved)) {
                *result = 16;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject TransfersModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QAbstractItemModel::staticMetaObject>(),
    qt_meta_stringdata_TransfersModel.data,
    qt_meta_data_TransfersModel,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int TransfersModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAbstractItemModel::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 30)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 30;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 30)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 30;
    }
    return _id;
}

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

// SIGNAL 1
void TransfersModel::transferPauseStateChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

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

// SIGNAL 3
void TransfersModel::processTransferInThread()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

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

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

// SIGNAL 6
void TransfersModel::unblockUi()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void TransfersModel::unblockUiAndFilter()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void TransfersModel::modelProcessingFinished()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

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

// SIGNAL 10
void TransfersModel::internalMoveStarted()const
{
    QMetaObject::activate(const_cast< TransfersModel *>(this), &staticMetaObject, 10, nullptr);
}

// SIGNAL 11
void TransfersModel::internalMoveFinished()const
{
    QMetaObject::activate(const_cast< TransfersModel *>(this), &staticMetaObject, 11, nullptr);
}

// SIGNAL 12
void TransfersModel::mostPriorityTransferUpdate(int _t1, int _t2)
{
    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(this, &staticMetaObject, 12, _a);
}

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

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

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

// SIGNAL 16
void TransfersModel::rowsAboutToBeMoved(TransferTag _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 16, _a);
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE