Warning, /sdk/clazy/tests/old-style-connect/main.moc is written in an unsupported language. File is not indexed.
0001 /****************************************************************************
0002 ** Meta object code from reading C++ file 'main.cpp'
0003 **
0004 ** Created by: The Qt Meta Object Compiler version 67 (Qt 5.5.0)
0005 **
0006 ** WARNING! All changes made in this file will be lost!
0007 *****************************************************************************/
0008
0009 #include <QtCore/qbytearray.h>
0010 #include <QtCore/qmetatype.h>
0011 #if !defined(Q_MOC_OUTPUT_REVISION)
0012 #error "The header file 'main.cpp' doesn't include <QObject>."
0013 #elif Q_MOC_OUTPUT_REVISION != 67
0014 #error "This file was generated using the moc from 5.5.0. It"
0015 #error "cannot be used with the include files from this version of Qt."
0016 #error "(The moc has changed too much.)"
0017 #endif
0018
0019 QT_BEGIN_MOC_NAMESPACE
0020 struct qt_meta_stringdata_MyObj_t {
0021 QByteArrayData data[7];
0022 char stringdata0[41];
0023 };
0024 #define QT_MOC_LITERAL(idx, ofs, len) \
0025 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0026 qptrdiff(offsetof(qt_meta_stringdata_MyObj_t, stringdata0) + ofs \
0027 - idx * sizeof(QByteArrayData)) \
0028 )
0029 static const qt_meta_stringdata_MyObj_t qt_meta_stringdata_MyObj = {
0030 {
0031 QT_MOC_LITERAL(0, 0, 5), // "MyObj"
0032 QT_MOC_LITERAL(1, 6, 7), // "signal1"
0033 QT_MOC_LITERAL(2, 14, 0), // ""
0034 QT_MOC_LITERAL(3, 15, 5), // "slot1"
0035 QT_MOC_LITERAL(4, 21, 5), // "slot2"
0036 QT_MOC_LITERAL(5, 27, 11), // "slotWithArg"
0037 QT_MOC_LITERAL(6, 39, 1) // "i"
0038
0039 },
0040 "MyObj\0signal1\0\0slot1\0slot2\0slotWithArg\0"
0041 "i"
0042 };
0043 #undef QT_MOC_LITERAL
0044
0045 static const uint qt_meta_data_MyObj[] = {
0046
0047 // content:
0048 7, // revision
0049 0, // classname
0050 0, 0, // classinfo
0051 5, 14, // methods
0052 0, 0, // properties
0053 0, 0, // enums/sets
0054 0, 0, // constructors
0055 0, // flags
0056 1, // signalCount
0057
0058 // signals: name, argc, parameters, tag, flags
0059 1, 0, 39, 2, 0x06 /* Public */,
0060
0061 // slots: name, argc, parameters, tag, flags
0062 3, 0, 40, 2, 0x0a /* Public */,
0063 4, 0, 41, 2, 0x0a /* Public */,
0064 5, 1, 42, 2, 0x0a /* Public */,
0065 5, 0, 45, 2, 0x2a /* Public | MethodCloned */,
0066
0067 // signals: parameters
0068 QMetaType::Void,
0069
0070 // slots: parameters
0071 QMetaType::Void,
0072 QMetaType::Void,
0073 QMetaType::Void, QMetaType::Int, 6,
0074 QMetaType::Void,
0075
0076 0 // eod
0077 };
0078
0079 void MyObj::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0080 {
0081 if (_c == QMetaObject::InvokeMetaMethod) {
0082 MyObj *_t = static_cast<MyObj *>(_o);
0083 Q_UNUSED(_t)
0084 switch (_id) {
0085 case 0: _t->signal1(); break;
0086 case 1: _t->slot1(); break;
0087 case 2: _t->slot2(); break;
0088 case 3: _t->slotWithArg((*reinterpret_cast< int(*)>(_a[1]))); break;
0089 case 4: _t->slotWithArg(); break;
0090 default: ;
0091 }
0092 } else if (_c == QMetaObject::IndexOfMethod) {
0093 int *result = reinterpret_cast<int *>(_a[0]);
0094 void **func = reinterpret_cast<void **>(_a[1]);
0095 {
0096 typedef void (MyObj::*_t)();
0097 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&MyObj::signal1)) {
0098 *result = 0;
0099 }
0100 }
0101 }
0102 }
0103
0104 const QMetaObject MyObj::staticMetaObject = {
0105 { &QObject::staticMetaObject, qt_meta_stringdata_MyObj.data,
0106 qt_meta_data_MyObj, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
0107 };
0108
0109
0110 const QMetaObject *MyObj::metaObject() const
0111 {
0112 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0113 }
0114
0115 void *MyObj::qt_metacast(const char *_clname)
0116 {
0117 if (!_clname) return Q_NULLPTR;
0118 if (!strcmp(_clname, qt_meta_stringdata_MyObj.stringdata0))
0119 return static_cast<void*>(const_cast< MyObj*>(this));
0120 return QObject::qt_metacast(_clname);
0121 }
0122
0123 int MyObj::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0124 {
0125 _id = QObject::qt_metacall(_c, _id, _a);
0126 if (_id < 0)
0127 return _id;
0128 if (_c == QMetaObject::InvokeMetaMethod) {
0129 if (_id < 5)
0130 qt_static_metacall(this, _c, _id, _a);
0131 _id -= 5;
0132 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
0133 if (_id < 5)
0134 *reinterpret_cast<int*>(_a[0]) = -1;
0135 _id -= 5;
0136 }
0137 return _id;
0138 }
0139
0140 // SIGNAL 0
0141 void MyObj::signal1()
0142 {
0143 QMetaObject::activate(this, &staticMetaObject, 0, Q_NULLPTR);
0144 }
0145 struct qt_meta_stringdata_MyObjDerived_t {
0146 QByteArrayData data[1];
0147 char stringdata0[13];
0148 };
0149 #define QT_MOC_LITERAL(idx, ofs, len) \
0150 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0151 qptrdiff(offsetof(qt_meta_stringdata_MyObjDerived_t, stringdata0) + ofs \
0152 - idx * sizeof(QByteArrayData)) \
0153 )
0154 static const qt_meta_stringdata_MyObjDerived_t qt_meta_stringdata_MyObjDerived = {
0155 {
0156 QT_MOC_LITERAL(0, 0, 12) // "MyObjDerived"
0157
0158 },
0159 "MyObjDerived"
0160 };
0161 #undef QT_MOC_LITERAL
0162
0163 static const uint qt_meta_data_MyObjDerived[] = {
0164
0165 // content:
0166 7, // revision
0167 0, // classname
0168 0, 0, // classinfo
0169 0, 0, // methods
0170 0, 0, // properties
0171 0, 0, // enums/sets
0172 0, 0, // constructors
0173 0, // flags
0174 0, // signalCount
0175
0176 0 // eod
0177 };
0178
0179 void MyObjDerived::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0180 {
0181 Q_UNUSED(_o);
0182 Q_UNUSED(_id);
0183 Q_UNUSED(_c);
0184 Q_UNUSED(_a);
0185 }
0186
0187 const QMetaObject MyObjDerived::staticMetaObject = {
0188 { &MyObj::staticMetaObject, qt_meta_stringdata_MyObjDerived.data,
0189 qt_meta_data_MyObjDerived, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
0190 };
0191
0192
0193 const QMetaObject *MyObjDerived::metaObject() const
0194 {
0195 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0196 }
0197
0198 void *MyObjDerived::qt_metacast(const char *_clname)
0199 {
0200 if (!_clname) return Q_NULLPTR;
0201 if (!strcmp(_clname, qt_meta_stringdata_MyObjDerived.stringdata0))
0202 return static_cast<void*>(const_cast< MyObjDerived*>(this));
0203 return MyObj::qt_metacast(_clname);
0204 }
0205
0206 int MyObjDerived::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0207 {
0208 _id = MyObj::qt_metacall(_c, _id, _a);
0209 if (_id < 0)
0210 return _id;
0211 return _id;
0212 }
0213 struct qt_meta_stringdata_OtherObj_t {
0214 QByteArrayData data[3];
0215 char stringdata0[20];
0216 };
0217 #define QT_MOC_LITERAL(idx, ofs, len) \
0218 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0219 qptrdiff(offsetof(qt_meta_stringdata_OtherObj_t, stringdata0) + ofs \
0220 - idx * sizeof(QByteArrayData)) \
0221 )
0222 static const qt_meta_stringdata_OtherObj_t qt_meta_stringdata_OtherObj = {
0223 {
0224 QT_MOC_LITERAL(0, 0, 8), // "OtherObj"
0225 QT_MOC_LITERAL(1, 9, 9), // "otherSlot"
0226 QT_MOC_LITERAL(2, 19, 0) // ""
0227
0228 },
0229 "OtherObj\0otherSlot\0"
0230 };
0231 #undef QT_MOC_LITERAL
0232
0233 static const uint qt_meta_data_OtherObj[] = {
0234
0235 // content:
0236 7, // revision
0237 0, // classname
0238 0, 0, // classinfo
0239 1, 14, // methods
0240 0, 0, // properties
0241 0, 0, // enums/sets
0242 0, 0, // constructors
0243 0, // flags
0244 0, // signalCount
0245
0246 // slots: name, argc, parameters, tag, flags
0247 1, 0, 19, 2, 0x0a /* Public */,
0248
0249 // slots: parameters
0250 QMetaType::Void,
0251
0252 0 // eod
0253 };
0254
0255 void OtherObj::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0256 {
0257 if (_c == QMetaObject::InvokeMetaMethod) {
0258 OtherObj *_t = static_cast<OtherObj *>(_o);
0259 Q_UNUSED(_t)
0260 switch (_id) {
0261 case 0: _t->otherSlot(); break;
0262 default: ;
0263 }
0264 }
0265 Q_UNUSED(_a);
0266 }
0267
0268 const QMetaObject OtherObj::staticMetaObject = {
0269 { &QObject::staticMetaObject, qt_meta_stringdata_OtherObj.data,
0270 qt_meta_data_OtherObj, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
0271 };
0272
0273
0274 const QMetaObject *OtherObj::metaObject() const
0275 {
0276 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0277 }
0278
0279 void *OtherObj::qt_metacast(const char *_clname)
0280 {
0281 if (!_clname) return Q_NULLPTR;
0282 if (!strcmp(_clname, qt_meta_stringdata_OtherObj.stringdata0))
0283 return static_cast<void*>(const_cast< OtherObj*>(this));
0284 return QObject::qt_metacast(_clname);
0285 }
0286
0287 int OtherObj::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0288 {
0289 _id = QObject::qt_metacall(_c, _id, _a);
0290 if (_id < 0)
0291 return _id;
0292 if (_c == QMetaObject::InvokeMetaMethod) {
0293 if (_id < 1)
0294 qt_static_metacall(this, _c, _id, _a);
0295 _id -= 1;
0296 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
0297 if (_id < 1)
0298 *reinterpret_cast<int*>(_a[0]) = -1;
0299 _id -= 1;
0300 }
0301 return _id;
0302 }
0303 struct qt_meta_stringdata_WithNesting_t {
0304 QByteArrayData data[5];
0305 char stringdata0[36];
0306 };
0307 #define QT_MOC_LITERAL(idx, ofs, len) \
0308 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0309 qptrdiff(offsetof(qt_meta_stringdata_WithNesting_t, stringdata0) + ofs \
0310 - idx * sizeof(QByteArrayData)) \
0311 )
0312 static const qt_meta_stringdata_WithNesting_t qt_meta_stringdata_WithNesting = {
0313 {
0314 QT_MOC_LITERAL(0, 0, 11), // "WithNesting"
0315 QT_MOC_LITERAL(1, 12, 7), // "signal1"
0316 QT_MOC_LITERAL(2, 20, 0), // ""
0317 QT_MOC_LITERAL(3, 21, 5), // "slot1"
0318 QT_MOC_LITERAL(4, 27, 8) // "privSlot"
0319
0320 },
0321 "WithNesting\0signal1\0\0slot1\0privSlot"
0322 };
0323 #undef QT_MOC_LITERAL
0324
0325 static const uint qt_meta_data_WithNesting[] = {
0326
0327 // content:
0328 7, // revision
0329 0, // classname
0330 0, 0, // classinfo
0331 3, 14, // methods
0332 0, 0, // properties
0333 0, 0, // enums/sets
0334 0, 0, // constructors
0335 0, // flags
0336 1, // signalCount
0337
0338 // signals: name, argc, parameters, tag, flags
0339 1, 0, 29, 2, 0x06 /* Public */,
0340
0341 // slots: name, argc, parameters, tag, flags
0342 3, 0, 30, 2, 0x0a /* Public */,
0343 4, 0, 31, 2, 0x08 /* Private */,
0344
0345 // signals: parameters
0346 QMetaType::Void,
0347
0348 // slots: parameters
0349 QMetaType::Void,
0350 QMetaType::Void,
0351
0352 0 // eod
0353 };
0354
0355 void WithNesting::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0356 {
0357 if (_c == QMetaObject::InvokeMetaMethod) {
0358 WithNesting *_t = static_cast<WithNesting *>(_o);
0359 Q_UNUSED(_t)
0360 switch (_id) {
0361 case 0: _t->signal1(); break;
0362 case 1: _t->slot1(); break;
0363 case 2: _t->privSlot(); break;
0364 default: ;
0365 }
0366 } else if (_c == QMetaObject::IndexOfMethod) {
0367 int *result = reinterpret_cast<int *>(_a[0]);
0368 void **func = reinterpret_cast<void **>(_a[1]);
0369 {
0370 typedef void (WithNesting::*_t)();
0371 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WithNesting::signal1)) {
0372 *result = 0;
0373 }
0374 }
0375 }
0376 Q_UNUSED(_a);
0377 }
0378
0379 const QMetaObject WithNesting::staticMetaObject = {
0380 { &QObject::staticMetaObject, qt_meta_stringdata_WithNesting.data,
0381 qt_meta_data_WithNesting, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
0382 };
0383
0384
0385 const QMetaObject *WithNesting::metaObject() const
0386 {
0387 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0388 }
0389
0390 void *WithNesting::qt_metacast(const char *_clname)
0391 {
0392 if (!_clname) return Q_NULLPTR;
0393 if (!strcmp(_clname, qt_meta_stringdata_WithNesting.stringdata0))
0394 return static_cast<void*>(const_cast< WithNesting*>(this));
0395 return QObject::qt_metacast(_clname);
0396 }
0397
0398 int WithNesting::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0399 {
0400 _id = QObject::qt_metacall(_c, _id, _a);
0401 if (_id < 0)
0402 return _id;
0403 if (_c == QMetaObject::InvokeMetaMethod) {
0404 if (_id < 3)
0405 qt_static_metacall(this, _c, _id, _a);
0406 _id -= 3;
0407 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
0408 if (_id < 3)
0409 *reinterpret_cast<int*>(_a[0]) = -1;
0410 _id -= 3;
0411 }
0412 return _id;
0413 }
0414
0415 // SIGNAL 0
0416 void WithNesting::signal1()
0417 {
0418 QMetaObject::activate(this, &staticMetaObject, 0, Q_NULLPTR);
0419 }
0420 struct qt_meta_stringdata_WithNesting__Private_t {
0421 QByteArrayData data[4];
0422 char stringdata0[37];
0423 };
0424 #define QT_MOC_LITERAL(idx, ofs, len) \
0425 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0426 qptrdiff(offsetof(qt_meta_stringdata_WithNesting__Private_t, stringdata0) + ofs \
0427 - idx * sizeof(QByteArrayData)) \
0428 )
0429 static const qt_meta_stringdata_WithNesting__Private_t qt_meta_stringdata_WithNesting__Private = {
0430 {
0431 QT_MOC_LITERAL(0, 0, 20), // "WithNesting::Private"
0432 QT_MOC_LITERAL(1, 21, 7), // "signal1"
0433 QT_MOC_LITERAL(2, 29, 0), // ""
0434 QT_MOC_LITERAL(3, 30, 6) // "pSlot1"
0435
0436 },
0437 "WithNesting::Private\0signal1\0\0pSlot1"
0438 };
0439 #undef QT_MOC_LITERAL
0440
0441 static const uint qt_meta_data_WithNesting__Private[] = {
0442
0443 // content:
0444 7, // revision
0445 0, // classname
0446 0, 0, // classinfo
0447 2, 14, // methods
0448 0, 0, // properties
0449 0, 0, // enums/sets
0450 0, 0, // constructors
0451 0, // flags
0452 1, // signalCount
0453
0454 // signals: name, argc, parameters, tag, flags
0455 1, 0, 24, 2, 0x06 /* Public */,
0456
0457 // slots: name, argc, parameters, tag, flags
0458 3, 0, 25, 2, 0x0a /* Public */,
0459
0460 // signals: parameters
0461 QMetaType::Void,
0462
0463 // slots: parameters
0464 QMetaType::Void,
0465
0466 0 // eod
0467 };
0468
0469 void WithNesting::Private::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0470 {
0471 if (_c == QMetaObject::InvokeMetaMethod) {
0472 Private *_t = static_cast<Private *>(_o);
0473 Q_UNUSED(_t)
0474 switch (_id) {
0475 case 0: _t->signal1(); break;
0476 case 1: _t->pSlot1(); break;
0477 default: ;
0478 }
0479 } else if (_c == QMetaObject::IndexOfMethod) {
0480 int *result = reinterpret_cast<int *>(_a[0]);
0481 void **func = reinterpret_cast<void **>(_a[1]);
0482 {
0483 typedef void (Private::*_t)();
0484 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Private::signal1)) {
0485 *result = 0;
0486 }
0487 }
0488 }
0489 Q_UNUSED(_a);
0490 }
0491
0492 const QMetaObject WithNesting::Private::staticMetaObject = {
0493 { &QObject::staticMetaObject, qt_meta_stringdata_WithNesting__Private.data,
0494 qt_meta_data_WithNesting__Private, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
0495 };
0496
0497
0498 const QMetaObject *WithNesting::Private::metaObject() const
0499 {
0500 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0501 }
0502
0503 void *WithNesting::Private::qt_metacast(const char *_clname)
0504 {
0505 if (!_clname) return Q_NULLPTR;
0506 if (!strcmp(_clname, qt_meta_stringdata_WithNesting__Private.stringdata0))
0507 return static_cast<void*>(const_cast< Private*>(this));
0508 return QObject::qt_metacast(_clname);
0509 }
0510
0511 int WithNesting::Private::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0512 {
0513 _id = QObject::qt_metacall(_c, _id, _a);
0514 if (_id < 0)
0515 return _id;
0516 if (_c == QMetaObject::InvokeMetaMethod) {
0517 if (_id < 2)
0518 qt_static_metacall(this, _c, _id, _a);
0519 _id -= 2;
0520 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
0521 if (_id < 2)
0522 *reinterpret_cast<int*>(_a[0]) = -1;
0523 _id -= 2;
0524 }
0525 return _id;
0526 }
0527
0528 // SIGNAL 0
0529 void WithNesting::Private::signal1()
0530 {
0531 QMetaObject::activate(this, &staticMetaObject, 0, Q_NULLPTR);
0532 }
0533 struct qt_meta_stringdata_TestingArgumentCounts_t {
0534 QByteArrayData data[9];
0535 char stringdata0[51];
0536 };
0537 #define QT_MOC_LITERAL(idx, ofs, len) \
0538 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0539 qptrdiff(offsetof(qt_meta_stringdata_TestingArgumentCounts_t, stringdata0) + ofs \
0540 - idx * sizeof(QByteArrayData)) \
0541 )
0542 static const qt_meta_stringdata_TestingArgumentCounts_t qt_meta_stringdata_TestingArgumentCounts = {
0543 {
0544 QT_MOC_LITERAL(0, 0, 21), // "TestingArgumentCounts"
0545 QT_MOC_LITERAL(1, 22, 3), // "si0"
0546 QT_MOC_LITERAL(2, 26, 0), // ""
0547 QT_MOC_LITERAL(3, 27, 3), // "si1"
0548 QT_MOC_LITERAL(4, 31, 3), // "si2"
0549 QT_MOC_LITERAL(5, 35, 3), // "si3"
0550 QT_MOC_LITERAL(6, 39, 3), // "sl0"
0551 QT_MOC_LITERAL(7, 43, 3), // "sl1"
0552 QT_MOC_LITERAL(8, 47, 3) // "sl2"
0553
0554 },
0555 "TestingArgumentCounts\0si0\0\0si1\0si2\0"
0556 "si3\0sl0\0sl1\0sl2"
0557 };
0558 #undef QT_MOC_LITERAL
0559
0560 static const uint qt_meta_data_TestingArgumentCounts[] = {
0561
0562 // content:
0563 7, // revision
0564 0, // classname
0565 0, 0, // classinfo
0566 8, 14, // methods
0567 0, 0, // properties
0568 0, 0, // enums/sets
0569 0, 0, // constructors
0570 0, // flags
0571 4, // signalCount
0572
0573 // signals: name, argc, parameters, tag, flags
0574 1, 0, 54, 2, 0x06 /* Public */,
0575 3, 1, 55, 2, 0x06 /* Public */,
0576 4, 2, 58, 2, 0x06 /* Public */,
0577 5, 3, 63, 2, 0x06 /* Public */,
0578
0579 // slots: name, argc, parameters, tag, flags
0580 6, 0, 70, 2, 0x0a /* Public */,
0581 7, 1, 71, 2, 0x0a /* Public */,
0582 8, 3, 74, 2, 0x0a /* Public */,
0583 8, 2, 81, 2, 0x2a /* Public | MethodCloned */,
0584
0585 // signals: parameters
0586 QMetaType::Void,
0587 QMetaType::Void, QMetaType::QString, 2,
0588 QMetaType::Void, QMetaType::QString, QMetaType::QString, 2, 2,
0589 QMetaType::Void, QMetaType::QString, QMetaType::QString, QMetaType::QString, 2, 2, 2,
0590
0591 // slots: parameters
0592 QMetaType::Void,
0593 QMetaType::Void, QMetaType::QString, 2,
0594 QMetaType::Void, QMetaType::QString, QMetaType::QString, QMetaType::QString, 2, 2, 2,
0595 QMetaType::Void, QMetaType::QString, QMetaType::QString, 2, 2,
0596
0597 0 // eod
0598 };
0599
0600 void TestingArgumentCounts::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0601 {
0602 if (_c == QMetaObject::InvokeMetaMethod) {
0603 TestingArgumentCounts *_t = static_cast<TestingArgumentCounts *>(_o);
0604 Q_UNUSED(_t)
0605 switch (_id) {
0606 case 0: _t->si0(); break;
0607 case 1: _t->si1((*reinterpret_cast< QString(*)>(_a[1]))); break;
0608 case 2: _t->si2((*reinterpret_cast< QString(*)>(_a[1])),(*reinterpret_cast< QString(*)>(_a[2]))); break;
0609 case 3: _t->si3((*reinterpret_cast< QString(*)>(_a[1])),(*reinterpret_cast< QString(*)>(_a[2])),(*reinterpret_cast< QString(*)>(_a[3]))); break;
0610 case 4: _t->sl0(); break;
0611 case 5: _t->sl1((*reinterpret_cast< QString(*)>(_a[1]))); break;
0612 case 6: _t->sl2((*reinterpret_cast< QString(*)>(_a[1])),(*reinterpret_cast< QString(*)>(_a[2])),(*reinterpret_cast< QString(*)>(_a[3]))); break;
0613 case 7: _t->sl2((*reinterpret_cast< QString(*)>(_a[1])),(*reinterpret_cast< QString(*)>(_a[2]))); break;
0614 default: ;
0615 }
0616 } else if (_c == QMetaObject::IndexOfMethod) {
0617 int *result = reinterpret_cast<int *>(_a[0]);
0618 void **func = reinterpret_cast<void **>(_a[1]);
0619 {
0620 typedef void (TestingArgumentCounts::*_t)();
0621 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestingArgumentCounts::si0)) {
0622 *result = 0;
0623 }
0624 }
0625 {
0626 typedef void (TestingArgumentCounts::*_t)(QString );
0627 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestingArgumentCounts::si1)) {
0628 *result = 1;
0629 }
0630 }
0631 {
0632 typedef void (TestingArgumentCounts::*_t)(QString , QString );
0633 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestingArgumentCounts::si2)) {
0634 *result = 2;
0635 }
0636 }
0637 {
0638 typedef void (TestingArgumentCounts::*_t)(QString , QString , QString );
0639 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestingArgumentCounts::si3)) {
0640 *result = 3;
0641 }
0642 }
0643 }
0644 }
0645
0646 const QMetaObject TestingArgumentCounts::staticMetaObject = {
0647 { &QObject::staticMetaObject, qt_meta_stringdata_TestingArgumentCounts.data,
0648 qt_meta_data_TestingArgumentCounts, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
0649 };
0650
0651
0652 const QMetaObject *TestingArgumentCounts::metaObject() const
0653 {
0654 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0655 }
0656
0657 void *TestingArgumentCounts::qt_metacast(const char *_clname)
0658 {
0659 if (!_clname) return Q_NULLPTR;
0660 if (!strcmp(_clname, qt_meta_stringdata_TestingArgumentCounts.stringdata0))
0661 return static_cast<void*>(const_cast< TestingArgumentCounts*>(this));
0662 return QObject::qt_metacast(_clname);
0663 }
0664
0665 int TestingArgumentCounts::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0666 {
0667 _id = QObject::qt_metacall(_c, _id, _a);
0668 if (_id < 0)
0669 return _id;
0670 if (_c == QMetaObject::InvokeMetaMethod) {
0671 if (_id < 8)
0672 qt_static_metacall(this, _c, _id, _a);
0673 _id -= 8;
0674 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
0675 if (_id < 8)
0676 *reinterpret_cast<int*>(_a[0]) = -1;
0677 _id -= 8;
0678 }
0679 return _id;
0680 }
0681
0682 // SIGNAL 0
0683 void TestingArgumentCounts::si0()
0684 {
0685 QMetaObject::activate(this, &staticMetaObject, 0, Q_NULLPTR);
0686 }
0687
0688 // SIGNAL 1
0689 void TestingArgumentCounts::si1(QString _t1)
0690 {
0691 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
0692 QMetaObject::activate(this, &staticMetaObject, 1, _a);
0693 }
0694
0695 // SIGNAL 2
0696 void TestingArgumentCounts::si2(QString _t1, QString _t2)
0697 {
0698 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
0699 QMetaObject::activate(this, &staticMetaObject, 2, _a);
0700 }
0701
0702 // SIGNAL 3
0703 void TestingArgumentCounts::si3(QString _t1, QString _t2, QString _t3)
0704 {
0705 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
0706 QMetaObject::activate(this, &staticMetaObject, 3, _a);
0707 }
0708 struct qt_meta_stringdata_TestingProtected_t {
0709 QByteArrayData data[1];
0710 char stringdata0[17];
0711 };
0712 #define QT_MOC_LITERAL(idx, ofs, len) \
0713 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0714 qptrdiff(offsetof(qt_meta_stringdata_TestingProtected_t, stringdata0) + ofs \
0715 - idx * sizeof(QByteArrayData)) \
0716 )
0717 static const qt_meta_stringdata_TestingProtected_t qt_meta_stringdata_TestingProtected = {
0718 {
0719 QT_MOC_LITERAL(0, 0, 16) // "TestingProtected"
0720
0721 },
0722 "TestingProtected"
0723 };
0724 #undef QT_MOC_LITERAL
0725
0726 static const uint qt_meta_data_TestingProtected[] = {
0727
0728 // content:
0729 7, // revision
0730 0, // classname
0731 0, 0, // classinfo
0732 0, 0, // methods
0733 0, 0, // properties
0734 0, 0, // enums/sets
0735 0, 0, // constructors
0736 0, // flags
0737 0, // signalCount
0738
0739 0 // eod
0740 };
0741
0742 void TestingProtected::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0743 {
0744 Q_UNUSED(_o);
0745 Q_UNUSED(_id);
0746 Q_UNUSED(_c);
0747 Q_UNUSED(_a);
0748 }
0749
0750 const QMetaObject TestingProtected::staticMetaObject = {
0751 { &QObject::staticMetaObject, qt_meta_stringdata_TestingProtected.data,
0752 qt_meta_data_TestingProtected, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
0753 };
0754
0755
0756 const QMetaObject *TestingProtected::metaObject() const
0757 {
0758 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0759 }
0760
0761 void *TestingProtected::qt_metacast(const char *_clname)
0762 {
0763 if (!_clname) return Q_NULLPTR;
0764 if (!strcmp(_clname, qt_meta_stringdata_TestingProtected.stringdata0))
0765 return static_cast<void*>(const_cast< TestingProtected*>(this));
0766 return QObject::qt_metacast(_clname);
0767 }
0768
0769 int TestingProtected::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0770 {
0771 _id = QObject::qt_metacall(_c, _id, _a);
0772 if (_id < 0)
0773 return _id;
0774 return _id;
0775 }
0776 struct qt_meta_stringdata_TestTypes_t {
0777 QByteArrayData data[57];
0778 char stringdata0[270];
0779 };
0780 #define QT_MOC_LITERAL(idx, ofs, len) \
0781 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0782 qptrdiff(offsetof(qt_meta_stringdata_TestTypes_t, stringdata0) + ofs \
0783 - idx * sizeof(QByteArrayData)) \
0784 )
0785 static const qt_meta_stringdata_TestTypes_t qt_meta_stringdata_TestTypes = {
0786 {
0787 QT_MOC_LITERAL(0, 0, 9), // "TestTypes"
0788 QT_MOC_LITERAL(1, 10, 2), // "s1"
0789 QT_MOC_LITERAL(2, 13, 0), // ""
0790 QT_MOC_LITERAL(3, 14, 2), // "s2"
0791 QT_MOC_LITERAL(4, 17, 2), // "s3"
0792 QT_MOC_LITERAL(5, 20, 4), // "int*"
0793 QT_MOC_LITERAL(6, 25, 2), // "s4"
0794 QT_MOC_LITERAL(7, 28, 5), // "bool*"
0795 QT_MOC_LITERAL(8, 34, 2), // "s5"
0796 QT_MOC_LITERAL(9, 37, 6), // "float*"
0797 QT_MOC_LITERAL(10, 44, 2), // "s6"
0798 QT_MOC_LITERAL(11, 47, 2), // "s7"
0799 QT_MOC_LITERAL(12, 50, 2), // "s8"
0800 QT_MOC_LITERAL(13, 53, 5), // "char*"
0801 QT_MOC_LITERAL(14, 59, 2), // "s9"
0802 QT_MOC_LITERAL(15, 62, 3), // "s10"
0803 QT_MOC_LITERAL(16, 66, 3), // "s11"
0804 QT_MOC_LITERAL(17, 70, 2), // "S1"
0805 QT_MOC_LITERAL(18, 73, 3), // "s12"
0806 QT_MOC_LITERAL(19, 77, 2), // "S2"
0807 QT_MOC_LITERAL(20, 80, 3), // "s13"
0808 QT_MOC_LITERAL(21, 84, 2), // "S3"
0809 QT_MOC_LITERAL(22, 87, 3), // "s14"
0810 QT_MOC_LITERAL(23, 91, 3), // "S1a"
0811 QT_MOC_LITERAL(24, 95, 3), // "s15"
0812 QT_MOC_LITERAL(25, 99, 3), // "S1*"
0813 QT_MOC_LITERAL(26, 103, 3), // "s16"
0814 QT_MOC_LITERAL(27, 107, 3), // "S2*"
0815 QT_MOC_LITERAL(28, 111, 3), // "s17"
0816 QT_MOC_LITERAL(29, 115, 3), // "S3*"
0817 QT_MOC_LITERAL(30, 119, 3), // "s18"
0818 QT_MOC_LITERAL(31, 123, 4), // "S1a*"
0819 QT_MOC_LITERAL(32, 128, 3), // "s19"
0820 QT_MOC_LITERAL(33, 132, 3), // "S1&"
0821 QT_MOC_LITERAL(34, 136, 3), // "s20"
0822 QT_MOC_LITERAL(35, 140, 3), // "S2&"
0823 QT_MOC_LITERAL(36, 144, 3), // "s21"
0824 QT_MOC_LITERAL(37, 148, 3), // "S3&"
0825 QT_MOC_LITERAL(38, 152, 3), // "s22"
0826 QT_MOC_LITERAL(39, 156, 4), // "S1a&"
0827 QT_MOC_LITERAL(40, 161, 3), // "s23"
0828 QT_MOC_LITERAL(41, 165, 3), // "s24"
0829 QT_MOC_LITERAL(42, 169, 3), // "s25"
0830 QT_MOC_LITERAL(43, 173, 3), // "s26"
0831 QT_MOC_LITERAL(44, 177, 3), // "s27"
0832 QT_MOC_LITERAL(45, 181, 9), // "const S1*"
0833 QT_MOC_LITERAL(46, 191, 3), // "s28"
0834 QT_MOC_LITERAL(47, 195, 9), // "const S2*"
0835 QT_MOC_LITERAL(48, 205, 3), // "s29"
0836 QT_MOC_LITERAL(49, 209, 9), // "const S3*"
0837 QT_MOC_LITERAL(50, 219, 3), // "s30"
0838 QT_MOC_LITERAL(51, 223, 10), // "const S1a*"
0839 QT_MOC_LITERAL(52, 234, 3), // "s31"
0840 QT_MOC_LITERAL(53, 238, 3), // "s32"
0841 QT_MOC_LITERAL(54, 242, 13), // "doubleClicked"
0842 QT_MOC_LITERAL(55, 256, 9), // "triggered"
0843 QT_MOC_LITERAL(56, 266, 3) // "yes"
0844
0845 },
0846 "TestTypes\0s1\0\0s2\0s3\0int*\0s4\0bool*\0s5\0"
0847 "float*\0s6\0s7\0s8\0char*\0s9\0s10\0s11\0S1\0"
0848 "s12\0S2\0s13\0S3\0s14\0S1a\0s15\0S1*\0s16\0S2*\0"
0849 "s17\0S3*\0s18\0S1a*\0s19\0S1&\0s20\0S2&\0s21\0"
0850 "S3&\0s22\0S1a&\0s23\0s24\0s25\0s26\0s27\0"
0851 "const S1*\0s28\0const S2*\0s29\0const S3*\0"
0852 "s30\0const S1a*\0s31\0s32\0doubleClicked\0"
0853 "triggered\0yes"
0854 };
0855 #undef QT_MOC_LITERAL
0856
0857 static const uint qt_meta_data_TestTypes[] = {
0858
0859 // content:
0860 7, // revision
0861 0, // classname
0862 0, 0, // classinfo
0863 35, 14, // methods
0864 0, 0, // properties
0865 0, 0, // enums/sets
0866 0, 0, // constructors
0867 0, // flags
0868 35, // signalCount
0869
0870 // signals: name, argc, parameters, tag, flags
0871 1, 1, 189, 2, 0x06 /* Public */,
0872 3, 1, 192, 2, 0x06 /* Public */,
0873 4, 1, 195, 2, 0x06 /* Public */,
0874 6, 1, 198, 2, 0x06 /* Public */,
0875 8, 1, 201, 2, 0x06 /* Public */,
0876 10, 1, 204, 2, 0x06 /* Public */,
0877 11, 1, 207, 2, 0x06 /* Public */,
0878 12, 1, 210, 2, 0x06 /* Public */,
0879 14, 1, 213, 2, 0x06 /* Public */,
0880 15, 1, 216, 2, 0x06 /* Public */,
0881 16, 1, 219, 2, 0x06 /* Public */,
0882 18, 1, 222, 2, 0x06 /* Public */,
0883 20, 1, 225, 2, 0x06 /* Public */,
0884 22, 1, 228, 2, 0x06 /* Public */,
0885 24, 1, 231, 2, 0x06 /* Public */,
0886 26, 1, 234, 2, 0x06 /* Public */,
0887 28, 1, 237, 2, 0x06 /* Public */,
0888 30, 1, 240, 2, 0x06 /* Public */,
0889 32, 1, 243, 2, 0x06 /* Public */,
0890 34, 1, 246, 2, 0x06 /* Public */,
0891 36, 1, 249, 2, 0x06 /* Public */,
0892 38, 1, 252, 2, 0x06 /* Public */,
0893 40, 1, 255, 2, 0x06 /* Public */,
0894 41, 1, 258, 2, 0x06 /* Public */,
0895 42, 1, 261, 2, 0x06 /* Public */,
0896 43, 1, 264, 2, 0x06 /* Public */,
0897 44, 1, 267, 2, 0x06 /* Public */,
0898 46, 1, 270, 2, 0x06 /* Public */,
0899 48, 1, 273, 2, 0x06 /* Public */,
0900 50, 1, 276, 2, 0x06 /* Public */,
0901 52, 1, 279, 2, 0x06 /* Public */,
0902 53, 1, 282, 2, 0x06 /* Public */,
0903 54, 1, 285, 2, 0x06 /* Public */,
0904 55, 1, 288, 2, 0x06 /* Public */,
0905 55, 0, 291, 2, 0x26 /* Public | MethodCloned */,
0906
0907 // signals: parameters
0908 QMetaType::Void, QMetaType::Bool, 2,
0909 QMetaType::Void, QMetaType::Int, 2,
0910 QMetaType::Void, 0x80000000 | 5, 2,
0911 QMetaType::Void, 0x80000000 | 7, 2,
0912 QMetaType::Void, 0x80000000 | 9, 2,
0913 QMetaType::Void, 0x80000000 | 9, 2,
0914 QMetaType::Void, QMetaType::Char, 2,
0915 QMetaType::Void, 0x80000000 | 13, 2,
0916 QMetaType::Void, QMetaType::Float, 2,
0917 QMetaType::Void, QMetaType::Double, 2,
0918 QMetaType::Void, 0x80000000 | 17, 2,
0919 QMetaType::Void, 0x80000000 | 19, 2,
0920 QMetaType::Void, 0x80000000 | 21, 2,
0921 QMetaType::Void, 0x80000000 | 23, 2,
0922 QMetaType::Void, 0x80000000 | 25, 2,
0923 QMetaType::Void, 0x80000000 | 27, 2,
0924 QMetaType::Void, 0x80000000 | 29, 2,
0925 QMetaType::Void, 0x80000000 | 31, 2,
0926 QMetaType::Void, 0x80000000 | 33, 2,
0927 QMetaType::Void, 0x80000000 | 35, 2,
0928 QMetaType::Void, 0x80000000 | 37, 2,
0929 QMetaType::Void, 0x80000000 | 39, 2,
0930 QMetaType::Void, 0x80000000 | 17, 2,
0931 QMetaType::Void, 0x80000000 | 19, 2,
0932 QMetaType::Void, 0x80000000 | 21, 2,
0933 QMetaType::Void, 0x80000000 | 23, 2,
0934 QMetaType::Void, 0x80000000 | 45, 2,
0935 QMetaType::Void, 0x80000000 | 47, 2,
0936 QMetaType::Void, 0x80000000 | 49, 2,
0937 QMetaType::Void, 0x80000000 | 51, 2,
0938 QMetaType::Void, 0x80000000 | 17, 2,
0939 QMetaType::Void, 0x80000000 | 33, 2,
0940 QMetaType::Void, QMetaType::QModelIndex, 2,
0941 QMetaType::Void, QMetaType::Bool, 56,
0942 QMetaType::Void,
0943
0944 0 // eod
0945 };
0946
0947 void TestTypes::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0948 {
0949 if (_c == QMetaObject::InvokeMetaMethod) {
0950 TestTypes *_t = static_cast<TestTypes *>(_o);
0951 Q_UNUSED(_t)
0952 switch (_id) {
0953 case 0: _t->s1((*reinterpret_cast< bool(*)>(_a[1]))); break;
0954 case 1: _t->s2((*reinterpret_cast< int(*)>(_a[1]))); break;
0955 case 2: _t->s3((*reinterpret_cast< int*(*)>(_a[1]))); break;
0956 case 3: _t->s4((*reinterpret_cast< bool*(*)>(_a[1]))); break;
0957 case 4: _t->s5((*reinterpret_cast< float*(*)>(_a[1]))); break;
0958 case 5: _t->s6((*reinterpret_cast< float*(*)>(_a[1]))); break;
0959 case 6: _t->s7((*reinterpret_cast< char(*)>(_a[1]))); break;
0960 case 7: _t->s8((*reinterpret_cast< char*(*)>(_a[1]))); break;
0961 case 8: _t->s9((*reinterpret_cast< float(*)>(_a[1]))); break;
0962 case 9: _t->s10((*reinterpret_cast< double(*)>(_a[1]))); break;
0963 case 10: _t->s11((*reinterpret_cast< S1(*)>(_a[1]))); break;
0964 case 11: _t->s12((*reinterpret_cast< S2(*)>(_a[1]))); break;
0965 case 12: _t->s13((*reinterpret_cast< S3(*)>(_a[1]))); break;
0966 case 13: _t->s14((*reinterpret_cast< S1a(*)>(_a[1]))); break;
0967 case 14: _t->s15((*reinterpret_cast< S1*(*)>(_a[1]))); break;
0968 case 15: _t->s16((*reinterpret_cast< S2*(*)>(_a[1]))); break;
0969 case 16: _t->s17((*reinterpret_cast< S3*(*)>(_a[1]))); break;
0970 case 17: _t->s18((*reinterpret_cast< S1a*(*)>(_a[1]))); break;
0971 case 18: _t->s19((*reinterpret_cast< S1(*)>(_a[1]))); break;
0972 case 19: _t->s20((*reinterpret_cast< S2(*)>(_a[1]))); break;
0973 case 20: _t->s21((*reinterpret_cast< S3(*)>(_a[1]))); break;
0974 case 21: _t->s22((*reinterpret_cast< S1a(*)>(_a[1]))); break;
0975 case 22: _t->s23((*reinterpret_cast< const S1(*)>(_a[1]))); break;
0976 case 23: _t->s24((*reinterpret_cast< const S2(*)>(_a[1]))); break;
0977 case 24: _t->s25((*reinterpret_cast< const S3(*)>(_a[1]))); break;
0978 case 25: _t->s26((*reinterpret_cast< const S1a(*)>(_a[1]))); break;
0979 case 26: _t->s27((*reinterpret_cast< const S1*(*)>(_a[1]))); break;
0980 case 27: _t->s28((*reinterpret_cast< const S2*(*)>(_a[1]))); break;
0981 case 28: _t->s29((*reinterpret_cast< const S3*(*)>(_a[1]))); break;
0982 case 29: _t->s30((*reinterpret_cast< const S1a*(*)>(_a[1]))); break;
0983 case 30: _t->s31((*reinterpret_cast< const S1(*)>(_a[1]))); break;
0984 case 31: _t->s32((*reinterpret_cast< S1(*)>(_a[1]))); break;
0985 case 32: _t->doubleClicked((*reinterpret_cast< const QModelIndex(*)>(_a[1]))); break;
0986 case 33: _t->triggered((*reinterpret_cast< bool(*)>(_a[1]))); break;
0987 case 34: _t->triggered(); break;
0988 default: ;
0989 }
0990 } else if (_c == QMetaObject::IndexOfMethod) {
0991 int *result = reinterpret_cast<int *>(_a[0]);
0992 void **func = reinterpret_cast<void **>(_a[1]);
0993 {
0994 typedef void (TestTypes::*_t)(bool );
0995 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s1)) {
0996 *result = 0;
0997 }
0998 }
0999 {
1000 typedef void (TestTypes::*_t)(int );
1001 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s2)) {
1002 *result = 1;
1003 }
1004 }
1005 {
1006 typedef void (TestTypes::*_t)(int * );
1007 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s3)) {
1008 *result = 2;
1009 }
1010 }
1011 {
1012 typedef void (TestTypes::*_t)(bool * );
1013 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s4)) {
1014 *result = 3;
1015 }
1016 }
1017 {
1018 typedef void (TestTypes::*_t)(float * );
1019 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s5)) {
1020 *result = 4;
1021 }
1022 }
1023 {
1024 typedef void (TestTypes::*_t)(float * );
1025 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s6)) {
1026 *result = 5;
1027 }
1028 }
1029 {
1030 typedef void (TestTypes::*_t)(char );
1031 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s7)) {
1032 *result = 6;
1033 }
1034 }
1035 {
1036 typedef void (TestTypes::*_t)(char * );
1037 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s8)) {
1038 *result = 7;
1039 }
1040 }
1041 {
1042 typedef void (TestTypes::*_t)(float );
1043 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s9)) {
1044 *result = 8;
1045 }
1046 }
1047 {
1048 typedef void (TestTypes::*_t)(double );
1049 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s10)) {
1050 *result = 9;
1051 }
1052 }
1053 {
1054 typedef void (TestTypes::*_t)(S1 );
1055 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s11)) {
1056 *result = 10;
1057 }
1058 }
1059 {
1060 typedef void (TestTypes::*_t)(S2 );
1061 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s12)) {
1062 *result = 11;
1063 }
1064 }
1065 {
1066 typedef void (TestTypes::*_t)(S3 );
1067 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s13)) {
1068 *result = 12;
1069 }
1070 }
1071 {
1072 typedef void (TestTypes::*_t)(S1a );
1073 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s14)) {
1074 *result = 13;
1075 }
1076 }
1077 {
1078 typedef void (TestTypes::*_t)(S1 * );
1079 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s15)) {
1080 *result = 14;
1081 }
1082 }
1083 {
1084 typedef void (TestTypes::*_t)(S2 * );
1085 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s16)) {
1086 *result = 15;
1087 }
1088 }
1089 {
1090 typedef void (TestTypes::*_t)(S3 * );
1091 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s17)) {
1092 *result = 16;
1093 }
1094 }
1095 {
1096 typedef void (TestTypes::*_t)(S1a * );
1097 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s18)) {
1098 *result = 17;
1099 }
1100 }
1101 {
1102 typedef void (TestTypes::*_t)(S1 & );
1103 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s19)) {
1104 *result = 18;
1105 }
1106 }
1107 {
1108 typedef void (TestTypes::*_t)(S2 & );
1109 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s20)) {
1110 *result = 19;
1111 }
1112 }
1113 {
1114 typedef void (TestTypes::*_t)(S3 & );
1115 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s21)) {
1116 *result = 20;
1117 }
1118 }
1119 {
1120 typedef void (TestTypes::*_t)(S1a & );
1121 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s22)) {
1122 *result = 21;
1123 }
1124 }
1125 {
1126 typedef void (TestTypes::*_t)(const S1 );
1127 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s23)) {
1128 *result = 22;
1129 }
1130 }
1131 {
1132 typedef void (TestTypes::*_t)(const S2 );
1133 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s24)) {
1134 *result = 23;
1135 }
1136 }
1137 {
1138 typedef void (TestTypes::*_t)(const S3 );
1139 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s25)) {
1140 *result = 24;
1141 }
1142 }
1143 {
1144 typedef void (TestTypes::*_t)(const S1a );
1145 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s26)) {
1146 *result = 25;
1147 }
1148 }
1149 {
1150 typedef void (TestTypes::*_t)(const S1 * );
1151 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s27)) {
1152 *result = 26;
1153 }
1154 }
1155 {
1156 typedef void (TestTypes::*_t)(const S2 * );
1157 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s28)) {
1158 *result = 27;
1159 }
1160 }
1161 {
1162 typedef void (TestTypes::*_t)(const S3 * );
1163 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s29)) {
1164 *result = 28;
1165 }
1166 }
1167 {
1168 typedef void (TestTypes::*_t)(const S1a * );
1169 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s30)) {
1170 *result = 29;
1171 }
1172 }
1173 {
1174 typedef void (TestTypes::*_t)(const S1 & );
1175 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s31)) {
1176 *result = 30;
1177 }
1178 }
1179 {
1180 typedef void (TestTypes::*_t)(S1 & );
1181 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::s32)) {
1182 *result = 31;
1183 }
1184 }
1185 {
1186 typedef void (TestTypes::*_t)(const QModelIndex & );
1187 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::doubleClicked)) {
1188 *result = 32;
1189 }
1190 }
1191 {
1192 typedef void (TestTypes::*_t)(bool );
1193 if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestTypes::triggered)) {
1194 *result = 33;
1195 }
1196 }
1197 }
1198 }
1199
1200 const QMetaObject TestTypes::staticMetaObject = {
1201 { &QObject::staticMetaObject, qt_meta_stringdata_TestTypes.data,
1202 qt_meta_data_TestTypes, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
1203 };
1204
1205
1206 const QMetaObject *TestTypes::metaObject() const
1207 {
1208 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
1209 }
1210
1211 void *TestTypes::qt_metacast(const char *_clname)
1212 {
1213 if (!_clname) return Q_NULLPTR;
1214 if (!strcmp(_clname, qt_meta_stringdata_TestTypes.stringdata0))
1215 return static_cast<void*>(const_cast< TestTypes*>(this));
1216 return QObject::qt_metacast(_clname);
1217 }
1218
1219 int TestTypes::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
1220 {
1221 _id = QObject::qt_metacall(_c, _id, _a);
1222 if (_id < 0)
1223 return _id;
1224 if (_c == QMetaObject::InvokeMetaMethod) {
1225 if (_id < 35)
1226 qt_static_metacall(this, _c, _id, _a);
1227 _id -= 35;
1228 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
1229 if (_id < 35)
1230 *reinterpret_cast<int*>(_a[0]) = -1;
1231 _id -= 35;
1232 }
1233 return _id;
1234 }
1235
1236 // SIGNAL 0
1237 void TestTypes::s1(bool _t1)
1238 {
1239 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1240 QMetaObject::activate(this, &staticMetaObject, 0, _a);
1241 }
1242
1243 // SIGNAL 1
1244 void TestTypes::s2(int _t1)
1245 {
1246 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1247 QMetaObject::activate(this, &staticMetaObject, 1, _a);
1248 }
1249
1250 // SIGNAL 2
1251 void TestTypes::s3(int * _t1)
1252 {
1253 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1254 QMetaObject::activate(this, &staticMetaObject, 2, _a);
1255 }
1256
1257 // SIGNAL 3
1258 void TestTypes::s4(bool * _t1)
1259 {
1260 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1261 QMetaObject::activate(this, &staticMetaObject, 3, _a);
1262 }
1263
1264 // SIGNAL 4
1265 void TestTypes::s5(float * _t1)
1266 {
1267 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1268 QMetaObject::activate(this, &staticMetaObject, 4, _a);
1269 }
1270
1271 // SIGNAL 5
1272 void TestTypes::s6(float * _t1)
1273 {
1274 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1275 QMetaObject::activate(this, &staticMetaObject, 5, _a);
1276 }
1277
1278 // SIGNAL 6
1279 void TestTypes::s7(char _t1)
1280 {
1281 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1282 QMetaObject::activate(this, &staticMetaObject, 6, _a);
1283 }
1284
1285 // SIGNAL 7
1286 void TestTypes::s8(char * _t1)
1287 {
1288 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1289 QMetaObject::activate(this, &staticMetaObject, 7, _a);
1290 }
1291
1292 // SIGNAL 8
1293 void TestTypes::s9(float _t1)
1294 {
1295 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1296 QMetaObject::activate(this, &staticMetaObject, 8, _a);
1297 }
1298
1299 // SIGNAL 9
1300 void TestTypes::s10(double _t1)
1301 {
1302 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1303 QMetaObject::activate(this, &staticMetaObject, 9, _a);
1304 }
1305
1306 // SIGNAL 10
1307 void TestTypes::s11(S1 _t1)
1308 {
1309 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1310 QMetaObject::activate(this, &staticMetaObject, 10, _a);
1311 }
1312
1313 // SIGNAL 11
1314 void TestTypes::s12(S2 _t1)
1315 {
1316 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1317 QMetaObject::activate(this, &staticMetaObject, 11, _a);
1318 }
1319
1320 // SIGNAL 12
1321 void TestTypes::s13(S3 _t1)
1322 {
1323 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1324 QMetaObject::activate(this, &staticMetaObject, 12, _a);
1325 }
1326
1327 // SIGNAL 13
1328 void TestTypes::s14(S1a _t1)
1329 {
1330 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1331 QMetaObject::activate(this, &staticMetaObject, 13, _a);
1332 }
1333
1334 // SIGNAL 14
1335 void TestTypes::s15(S1 * _t1)
1336 {
1337 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1338 QMetaObject::activate(this, &staticMetaObject, 14, _a);
1339 }
1340
1341 // SIGNAL 15
1342 void TestTypes::s16(S2 * _t1)
1343 {
1344 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1345 QMetaObject::activate(this, &staticMetaObject, 15, _a);
1346 }
1347
1348 // SIGNAL 16
1349 void TestTypes::s17(S3 * _t1)
1350 {
1351 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1352 QMetaObject::activate(this, &staticMetaObject, 16, _a);
1353 }
1354
1355 // SIGNAL 17
1356 void TestTypes::s18(S1a * _t1)
1357 {
1358 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1359 QMetaObject::activate(this, &staticMetaObject, 17, _a);
1360 }
1361
1362 // SIGNAL 18
1363 void TestTypes::s19(S1 & _t1)
1364 {
1365 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1366 QMetaObject::activate(this, &staticMetaObject, 18, _a);
1367 }
1368
1369 // SIGNAL 19
1370 void TestTypes::s20(S2 & _t1)
1371 {
1372 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1373 QMetaObject::activate(this, &staticMetaObject, 19, _a);
1374 }
1375
1376 // SIGNAL 20
1377 void TestTypes::s21(S3 & _t1)
1378 {
1379 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1380 QMetaObject::activate(this, &staticMetaObject, 20, _a);
1381 }
1382
1383 // SIGNAL 21
1384 void TestTypes::s22(S1a & _t1)
1385 {
1386 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1387 QMetaObject::activate(this, &staticMetaObject, 21, _a);
1388 }
1389
1390 // SIGNAL 22
1391 void TestTypes::s23(const S1 _t1)
1392 {
1393 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1394 QMetaObject::activate(this, &staticMetaObject, 22, _a);
1395 }
1396
1397 // SIGNAL 23
1398 void TestTypes::s24(const S2 _t1)
1399 {
1400 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1401 QMetaObject::activate(this, &staticMetaObject, 23, _a);
1402 }
1403
1404 // SIGNAL 24
1405 void TestTypes::s25(const S3 _t1)
1406 {
1407 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1408 QMetaObject::activate(this, &staticMetaObject, 24, _a);
1409 }
1410
1411 // SIGNAL 25
1412 void TestTypes::s26(const S1a _t1)
1413 {
1414 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1415 QMetaObject::activate(this, &staticMetaObject, 25, _a);
1416 }
1417
1418 // SIGNAL 26
1419 void TestTypes::s27(const S1 * _t1)
1420 {
1421 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1422 QMetaObject::activate(this, &staticMetaObject, 26, _a);
1423 }
1424
1425 // SIGNAL 27
1426 void TestTypes::s28(const S2 * _t1)
1427 {
1428 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1429 QMetaObject::activate(this, &staticMetaObject, 27, _a);
1430 }
1431
1432 // SIGNAL 28
1433 void TestTypes::s29(const S3 * _t1)
1434 {
1435 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1436 QMetaObject::activate(this, &staticMetaObject, 28, _a);
1437 }
1438
1439 // SIGNAL 29
1440 void TestTypes::s30(const S1a * _t1)
1441 {
1442 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1443 QMetaObject::activate(this, &staticMetaObject, 29, _a);
1444 }
1445
1446 // SIGNAL 30
1447 void TestTypes::s31(const S1 & _t1)
1448 {
1449 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1450 QMetaObject::activate(this, &staticMetaObject, 30, _a);
1451 }
1452
1453 // SIGNAL 31
1454 void TestTypes::s32(S1 & _t1)
1455 {
1456 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1457 QMetaObject::activate(this, &staticMetaObject, 31, _a);
1458 }
1459
1460 // SIGNAL 32
1461 void TestTypes::doubleClicked(const QModelIndex & _t1)
1462 {
1463 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1464 QMetaObject::activate(this, &staticMetaObject, 32, _a);
1465 }
1466
1467 // SIGNAL 33
1468 void TestTypes::triggered(bool _t1)
1469 {
1470 void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1471 QMetaObject::activate(this, &staticMetaObject, 33, _a);
1472 }
1473 struct qt_meta_stringdata_Kleo__ProgressDialog_t {
1474 QByteArrayData data[1];
1475 char stringdata0[21];
1476 };
1477 #define QT_MOC_LITERAL(idx, ofs, len) \
1478 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
1479 qptrdiff(offsetof(qt_meta_stringdata_Kleo__ProgressDialog_t, stringdata0) + ofs \
1480 - idx * sizeof(QByteArrayData)) \
1481 )
1482 static const qt_meta_stringdata_Kleo__ProgressDialog_t qt_meta_stringdata_Kleo__ProgressDialog = {
1483 {
1484 QT_MOC_LITERAL(0, 0, 20) // "Kleo::ProgressDialog"
1485
1486 },
1487 "Kleo::ProgressDialog"
1488 };
1489 #undef QT_MOC_LITERAL
1490
1491 static const uint qt_meta_data_Kleo__ProgressDialog[] = {
1492
1493 // content:
1494 7, // revision
1495 0, // classname
1496 0, 0, // classinfo
1497 0, 0, // methods
1498 0, 0, // properties
1499 0, 0, // enums/sets
1500 0, 0, // constructors
1501 0, // flags
1502 0, // signalCount
1503
1504 0 // eod
1505 };
1506
1507 void Kleo::ProgressDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
1508 {
1509 Q_UNUSED(_o);
1510 Q_UNUSED(_id);
1511 Q_UNUSED(_c);
1512 Q_UNUSED(_a);
1513 }
1514
1515 const QMetaObject Kleo::ProgressDialog::staticMetaObject = {
1516 { &QProgressDialog::staticMetaObject, qt_meta_stringdata_Kleo__ProgressDialog.data,
1517 qt_meta_data_Kleo__ProgressDialog, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
1518 };
1519
1520
1521 const QMetaObject *Kleo::ProgressDialog::metaObject() const
1522 {
1523 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
1524 }
1525
1526 void *Kleo::ProgressDialog::qt_metacast(const char *_clname)
1527 {
1528 if (!_clname) return Q_NULLPTR;
1529 if (!strcmp(_clname, qt_meta_stringdata_Kleo__ProgressDialog.stringdata0))
1530 return static_cast<void*>(const_cast< ProgressDialog*>(this));
1531 return QProgressDialog::qt_metacast(_clname);
1532 }
1533
1534 int Kleo::ProgressDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
1535 {
1536 _id = QProgressDialog::qt_metacall(_c, _id, _a);
1537 if (_id < 0)
1538 return _id;
1539 return _id;
1540 }
1541 struct qt_meta_stringdata_TestQPointerMember_t {
1542 QByteArrayData data[3];
1543 char stringdata0[26];
1544 };
1545 #define QT_MOC_LITERAL(idx, ofs, len) \
1546 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
1547 qptrdiff(offsetof(qt_meta_stringdata_TestQPointerMember_t, stringdata0) + ofs \
1548 - idx * sizeof(QByteArrayData)) \
1549 )
1550 static const qt_meta_stringdata_TestQPointerMember_t qt_meta_stringdata_TestQPointerMember = {
1551 {
1552 QT_MOC_LITERAL(0, 0, 18), // "TestQPointerMember"
1553 QT_MOC_LITERAL(1, 19, 5), // "slot1"
1554 QT_MOC_LITERAL(2, 25, 0) // ""
1555
1556 },
1557 "TestQPointerMember\0slot1\0"
1558 };
1559 #undef QT_MOC_LITERAL
1560
1561 static const uint qt_meta_data_TestQPointerMember[] = {
1562
1563 // content:
1564 7, // revision
1565 0, // classname
1566 0, 0, // classinfo
1567 1, 14, // methods
1568 0, 0, // properties
1569 0, 0, // enums/sets
1570 0, 0, // constructors
1571 0, // flags
1572 0, // signalCount
1573
1574 // slots: name, argc, parameters, tag, flags
1575 1, 0, 19, 2, 0x0a /* Public */,
1576
1577 // slots: parameters
1578 QMetaType::Void,
1579
1580 0 // eod
1581 };
1582
1583 void TestQPointerMember::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
1584 {
1585 if (_c == QMetaObject::InvokeMetaMethod) {
1586 TestQPointerMember *_t = static_cast<TestQPointerMember *>(_o);
1587 Q_UNUSED(_t)
1588 switch (_id) {
1589 case 0: _t->slot1(); break;
1590 default: ;
1591 }
1592 }
1593 Q_UNUSED(_a);
1594 }
1595
1596 const QMetaObject TestQPointerMember::staticMetaObject = {
1597 { &QObject::staticMetaObject, qt_meta_stringdata_TestQPointerMember.data,
1598 qt_meta_data_TestQPointerMember, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
1599 };
1600
1601
1602 const QMetaObject *TestQPointerMember::metaObject() const
1603 {
1604 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
1605 }
1606
1607 void *TestQPointerMember::qt_metacast(const char *_clname)
1608 {
1609 if (!_clname) return Q_NULLPTR;
1610 if (!strcmp(_clname, qt_meta_stringdata_TestQPointerMember.stringdata0))
1611 return static_cast<void*>(const_cast< TestQPointerMember*>(this));
1612 return QObject::qt_metacast(_clname);
1613 }
1614
1615 int TestQPointerMember::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
1616 {
1617 _id = QObject::qt_metacall(_c, _id, _a);
1618 if (_id < 0)
1619 return _id;
1620 if (_c == QMetaObject::InvokeMetaMethod) {
1621 if (_id < 1)
1622 qt_static_metacall(this, _c, _id, _a);
1623 _id -= 1;
1624 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
1625 if (_id < 1)
1626 *reinterpret_cast<int*>(_a[0]) = -1;
1627 _id -= 1;
1628 }
1629 return _id;
1630 }
1631 QT_END_MOC_NAMESPACE