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

#include "../../../../src/kid3-3.3.1/src/app/cli/clicommand.h"
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'clicommand.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 63
#error "This file was generated using the moc from 4.8.7. 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
static const uint qt_meta_data_CliCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount

 // signals: signature, parameters, type, tag, flags
      12,   11,   11,   11, 0x05,

 // slots: signature, parameters, type, tag, flags
      23,   11,   11,   11, 0x09,

       0        // eod
};

static const char qt_meta_stringdata_CliCommand[] = {
    "CliCommand\0\0finished()\0terminate()\0"
};

void CliCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Q_ASSERT(staticMetaObject.cast(_o));
        CliCommand *_t = static_cast<CliCommand *>(_o);
        switch (_id) {
        case 0: _t->finished(); break;
        case 1: _t->terminate(); break;
        default: ;
        }
    }
    Q_UNUSED(_a);
}

const QMetaObjectExtraData CliCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject CliCommand::staticMetaObject = {
    { &QObject::staticMetaObject, qt_meta_stringdata_CliCommand,
      qt_meta_data_CliCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &CliCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *CliCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_CliCommand))
        return static_cast<void*>(const_cast< CliCommand*>(this));
    return QObject::qt_metacast(_clname);
}

int CliCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    return _id;
}

// SIGNAL 0
void CliCommand::finished()
{
    QMetaObject::activate(this, &staticMetaObject, 0, 0);
}
static const uint qt_meta_data_HelpCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_HelpCommand[] = {
    "HelpCommand\0"
};

void HelpCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData HelpCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject HelpCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_HelpCommand,
      qt_meta_data_HelpCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &HelpCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *HelpCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_HelpCommand))
        return static_cast<void*>(const_cast< HelpCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int HelpCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_TimeoutCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_TimeoutCommand[] = {
    "TimeoutCommand\0"
};

void TimeoutCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData TimeoutCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject TimeoutCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_TimeoutCommand,
      qt_meta_data_TimeoutCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &TimeoutCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *TimeoutCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_TimeoutCommand))
        return static_cast<void*>(const_cast< TimeoutCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int TimeoutCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_QuitCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_QuitCommand[] = {
    "QuitCommand\0"
};

void QuitCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData QuitCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject QuitCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_QuitCommand,
      qt_meta_data_QuitCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &QuitCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *QuitCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_QuitCommand))
        return static_cast<void*>(const_cast< QuitCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int QuitCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_CdCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_CdCommand[] = {
    "CdCommand\0"
};

void CdCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData CdCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject CdCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_CdCommand,
      qt_meta_data_CdCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &CdCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *CdCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_CdCommand))
        return static_cast<void*>(const_cast< CdCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int CdCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_PwdCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_PwdCommand[] = {
    "PwdCommand\0"
};

void PwdCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData PwdCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject PwdCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_PwdCommand,
      qt_meta_data_PwdCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &PwdCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *PwdCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_PwdCommand))
        return static_cast<void*>(const_cast< PwdCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int PwdCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_LsCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_LsCommand[] = {
    "LsCommand\0"
};

void LsCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData LsCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject LsCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_LsCommand,
      qt_meta_data_LsCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &LsCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *LsCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_LsCommand))
        return static_cast<void*>(const_cast< LsCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int LsCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_SaveCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_SaveCommand[] = {
    "SaveCommand\0"
};

void SaveCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData SaveCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject SaveCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_SaveCommand,
      qt_meta_data_SaveCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &SaveCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *SaveCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_SaveCommand))
        return static_cast<void*>(const_cast< SaveCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int SaveCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_SelectCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_SelectCommand[] = {
    "SelectCommand\0"
};

void SelectCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData SelectCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject SelectCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_SelectCommand,
      qt_meta_data_SelectCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &SelectCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *SelectCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_SelectCommand))
        return static_cast<void*>(const_cast< SelectCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int SelectCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_TagCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_TagCommand[] = {
    "TagCommand\0"
};

void TagCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData TagCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject TagCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_TagCommand,
      qt_meta_data_TagCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &TagCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *TagCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_TagCommand))
        return static_cast<void*>(const_cast< TagCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int TagCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_GetCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_GetCommand[] = {
    "GetCommand\0"
};

void GetCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData GetCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject GetCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_GetCommand,
      qt_meta_data_GetCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &GetCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *GetCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_GetCommand))
        return static_cast<void*>(const_cast< GetCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int GetCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_SetCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_SetCommand[] = {
    "SetCommand\0"
};

void SetCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData SetCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject SetCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_SetCommand,
      qt_meta_data_SetCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &SetCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *SetCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_SetCommand))
        return static_cast<void*>(const_cast< SetCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int SetCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_RevertCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_RevertCommand[] = {
    "RevertCommand\0"
};

void RevertCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData RevertCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject RevertCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_RevertCommand,
      qt_meta_data_RevertCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &RevertCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *RevertCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_RevertCommand))
        return static_cast<void*>(const_cast< RevertCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int RevertCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_ImportCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_ImportCommand[] = {
    "ImportCommand\0"
};

void ImportCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData ImportCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject ImportCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_ImportCommand,
      qt_meta_data_ImportCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &ImportCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *ImportCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_ImportCommand))
        return static_cast<void*>(const_cast< ImportCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int ImportCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_BatchImportCommand[] = {

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

 // slots: signature, parameters, type, tag, flags
      30,   20,   19,   19, 0x08,

       0        // eod
};

static const char qt_meta_stringdata_BatchImportCommand[] = {
    "BatchImportCommand\0\0type,text\0"
    "onReportImportEvent(int,QString)\0"
};

void BatchImportCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Q_ASSERT(staticMetaObject.cast(_o));
        BatchImportCommand *_t = static_cast<BatchImportCommand *>(_o);
        switch (_id) {
        case 0: _t->onReportImportEvent((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2]))); break;
        default: ;
        }
    }
}

const QMetaObjectExtraData BatchImportCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject BatchImportCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_BatchImportCommand,
      qt_meta_data_BatchImportCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &BatchImportCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *BatchImportCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_BatchImportCommand))
        return static_cast<void*>(const_cast< BatchImportCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int BatchImportCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
static const uint qt_meta_data_AlbumArtCommand[] = {

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

 // slots: signature, parameters, type, tag, flags
      35,   17,   16,   16, 0x08,

       0        // eod
};

static const char qt_meta_stringdata_AlbumArtCommand[] = {
    "AlbumArtCommand\0\0data,mimeType,url\0"
    "onDownloadFinished(QByteArray,QString,QString)\0"
};

void AlbumArtCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Q_ASSERT(staticMetaObject.cast(_o));
        AlbumArtCommand *_t = static_cast<AlbumArtCommand *>(_o);
        switch (_id) {
        case 0: _t->onDownloadFinished((*reinterpret_cast< const QByteArray(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< const QString(*)>(_a[3]))); break;
        default: ;
        }
    }
}

const QMetaObjectExtraData AlbumArtCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject AlbumArtCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_AlbumArtCommand,
      qt_meta_data_AlbumArtCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &AlbumArtCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *AlbumArtCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_AlbumArtCommand))
        return static_cast<void*>(const_cast< AlbumArtCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int AlbumArtCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
static const uint qt_meta_data_ExportCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_ExportCommand[] = {
    "ExportCommand\0"
};

void ExportCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData ExportCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject ExportCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_ExportCommand,
      qt_meta_data_ExportCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &ExportCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *ExportCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_ExportCommand))
        return static_cast<void*>(const_cast< ExportCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int ExportCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_PlaylistCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_PlaylistCommand[] = {
    "PlaylistCommand\0"
};

void PlaylistCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData PlaylistCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject PlaylistCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_PlaylistCommand,
      qt_meta_data_PlaylistCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &PlaylistCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *PlaylistCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_PlaylistCommand))
        return static_cast<void*>(const_cast< PlaylistCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int PlaylistCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_FilenameFormatCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_FilenameFormatCommand[] = {
    "FilenameFormatCommand\0"
};

void FilenameFormatCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData FilenameFormatCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject FilenameFormatCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_FilenameFormatCommand,
      qt_meta_data_FilenameFormatCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &FilenameFormatCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *FilenameFormatCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_FilenameFormatCommand))
        return static_cast<void*>(const_cast< FilenameFormatCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int FilenameFormatCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_TagFormatCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_TagFormatCommand[] = {
    "TagFormatCommand\0"
};

void TagFormatCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData TagFormatCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject TagFormatCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_TagFormatCommand,
      qt_meta_data_TagFormatCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &TagFormatCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *TagFormatCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_TagFormatCommand))
        return static_cast<void*>(const_cast< TagFormatCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int TagFormatCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_TextEncodingCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_TextEncodingCommand[] = {
    "TextEncodingCommand\0"
};

void TextEncodingCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData TextEncodingCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject TextEncodingCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_TextEncodingCommand,
      qt_meta_data_TextEncodingCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &TextEncodingCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *TextEncodingCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_TextEncodingCommand))
        return static_cast<void*>(const_cast< TextEncodingCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int TextEncodingCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_RenameDirectoryCommand[] = {

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

 // slots: signature, parameters, type, tag, flags
      35,   24,   23,   23, 0x08,
      66,   23,   23,   23, 0x08,

       0        // eod
};

static const char qt_meta_stringdata_RenameDirectoryCommand[] = {
    "RenameDirectoryCommand\0\0actionStrs\0"
    "onActionScheduled(QStringList)\0"
    "onRenameActionsScheduled()\0"
};

void RenameDirectoryCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Q_ASSERT(staticMetaObject.cast(_o));
        RenameDirectoryCommand *_t = static_cast<RenameDirectoryCommand *>(_o);
        switch (_id) {
        case 0: _t->onActionScheduled((*reinterpret_cast< const QStringList(*)>(_a[1]))); break;
        case 1: _t->onRenameActionsScheduled(); break;
        default: ;
        }
    }
}

const QMetaObjectExtraData RenameDirectoryCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject RenameDirectoryCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_RenameDirectoryCommand,
      qt_meta_data_RenameDirectoryCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &RenameDirectoryCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *RenameDirectoryCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_RenameDirectoryCommand))
        return static_cast<void*>(const_cast< RenameDirectoryCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int RenameDirectoryCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    return _id;
}
static const uint qt_meta_data_NumberTracksCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_NumberTracksCommand[] = {
    "NumberTracksCommand\0"
};

void NumberTracksCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData NumberTracksCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject NumberTracksCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_NumberTracksCommand,
      qt_meta_data_NumberTracksCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &NumberTracksCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *NumberTracksCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_NumberTracksCommand))
        return static_cast<void*>(const_cast< NumberTracksCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int NumberTracksCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_FilterCommand[] = {

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

 // slots: signature, parameters, type, tag, flags
      29,   15,   14,   14, 0x08,

       0        // eod
};

static const char qt_meta_stringdata_FilterCommand[] = {
    "FilterCommand\0\0type,fileName\0"
    "onFileFiltered(int,QString)\0"
};

void FilterCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Q_ASSERT(staticMetaObject.cast(_o));
        FilterCommand *_t = static_cast<FilterCommand *>(_o);
        switch (_id) {
        case 0: _t->onFileFiltered((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2]))); break;
        default: ;
        }
    }
}

const QMetaObjectExtraData FilterCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject FilterCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_FilterCommand,
      qt_meta_data_FilterCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &FilterCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *FilterCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_FilterCommand))
        return static_cast<void*>(const_cast< FilterCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int FilterCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
static const uint qt_meta_data_ToId3v24Command[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_ToId3v24Command[] = {
    "ToId3v24Command\0"
};

void ToId3v24Command::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData ToId3v24Command::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject ToId3v24Command::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_ToId3v24Command,
      qt_meta_data_ToId3v24Command, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &ToId3v24Command::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *ToId3v24Command::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_ToId3v24Command))
        return static_cast<void*>(const_cast< ToId3v24Command*>(this));
    return CliCommand::qt_metacast(_clname);
}

int ToId3v24Command::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_ToId3v23Command[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_ToId3v23Command[] = {
    "ToId3v23Command\0"
};

void ToId3v23Command::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData ToId3v23Command::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject ToId3v23Command::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_ToId3v23Command,
      qt_meta_data_ToId3v23Command, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &ToId3v23Command::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *ToId3v23Command::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_ToId3v23Command))
        return static_cast<void*>(const_cast< ToId3v23Command*>(this));
    return CliCommand::qt_metacast(_clname);
}

int ToId3v23Command::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_TagToFilenameCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_TagToFilenameCommand[] = {
    "TagToFilenameCommand\0"
};

void TagToFilenameCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData TagToFilenameCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject TagToFilenameCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_TagToFilenameCommand,
      qt_meta_data_TagToFilenameCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &TagToFilenameCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *TagToFilenameCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_TagToFilenameCommand))
        return static_cast<void*>(const_cast< TagToFilenameCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int TagToFilenameCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_FilenameToTagCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_FilenameToTagCommand[] = {
    "FilenameToTagCommand\0"
};

void FilenameToTagCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData FilenameToTagCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject FilenameToTagCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_FilenameToTagCommand,
      qt_meta_data_FilenameToTagCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &FilenameToTagCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *FilenameToTagCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_FilenameToTagCommand))
        return static_cast<void*>(const_cast< FilenameToTagCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int FilenameToTagCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_TagToOtherTagCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_TagToOtherTagCommand[] = {
    "TagToOtherTagCommand\0"
};

void TagToOtherTagCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData TagToOtherTagCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject TagToOtherTagCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_TagToOtherTagCommand,
      qt_meta_data_TagToOtherTagCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &TagToOtherTagCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *TagToOtherTagCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_TagToOtherTagCommand))
        return static_cast<void*>(const_cast< TagToOtherTagCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int TagToOtherTagCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_CopyCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_CopyCommand[] = {
    "CopyCommand\0"
};

void CopyCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData CopyCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject CopyCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_CopyCommand,
      qt_meta_data_CopyCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &CopyCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *CopyCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_CopyCommand))
        return static_cast<void*>(const_cast< CopyCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int CopyCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_PasteCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_PasteCommand[] = {
    "PasteCommand\0"
};

void PasteCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData PasteCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject PasteCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_PasteCommand,
      qt_meta_data_PasteCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &PasteCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *PasteCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_PasteCommand))
        return static_cast<void*>(const_cast< PasteCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int PasteCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_RemoveCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_RemoveCommand[] = {
    "RemoveCommand\0"
};

void RemoveCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData RemoveCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject RemoveCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_RemoveCommand,
      qt_meta_data_RemoveCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &RemoveCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *RemoveCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_RemoveCommand))
        return static_cast<void*>(const_cast< RemoveCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int RemoveCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_PlayCommand[] = {

 // content:
       6,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_PlayCommand[] = {
    "PlayCommand\0"
};

void PlayCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObjectExtraData PlayCommand::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject PlayCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_PlayCommand,
      qt_meta_data_PlayCommand, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &PlayCommand::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *PlayCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_PlayCommand))
        return static_cast<void*>(const_cast< PlayCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int PlayCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
QT_END_MOC_NAMESPACE
