GitBucket
Newer
/****************************************************************************
** Meta object code from reading C++ file 'qtpropertymanager.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.2.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../src/qtpropertymanager.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'qtpropertymanager.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.2.1. 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
struct qt_meta_stringdata_QtGroupPropertyManager_t {
QByteArrayData data[1];
char stringdata[24];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtGroupPropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtGroupPropertyManager_t qt_meta_stringdata_QtGroupPropertyManager = {
{
QT_MOC_LITERAL(0, 0, 22)
},
"QtGroupPropertyManager\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtGroupPropertyManager[] = {
// content:
7, // 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
};
void QtGroupPropertyManager::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 QMetaObject QtGroupPropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtGroupPropertyManager.data,
qt_meta_data_QtGroupPropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtGroupPropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtGroupPropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtGroupPropertyManager.stringdata))
return static_cast<void*>(const_cast< QtGroupPropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtGroupPropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
return _id;
}
struct qt_meta_stringdata_QtIntPropertyManager_t {
QByteArrayData data[19];
char stringdata[202];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtIntPropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtIntPropertyManager_t qt_meta_stringdata_QtIntPropertyManager = {
{
QT_MOC_LITERAL(0, 0, 20),
QT_MOC_LITERAL(1, 21, 12),
QT_MOC_LITERAL(2, 34, 0),
QT_MOC_LITERAL(3, 35, 11),
QT_MOC_LITERAL(4, 47, 8),
QT_MOC_LITERAL(5, 56, 3),
QT_MOC_LITERAL(6, 60, 12),
QT_MOC_LITERAL(7, 73, 6),
QT_MOC_LITERAL(8, 80, 6),
QT_MOC_LITERAL(9, 87, 17),
QT_MOC_LITERAL(10, 105, 4),
QT_MOC_LITERAL(11, 110, 15),
QT_MOC_LITERAL(12, 126, 8),
QT_MOC_LITERAL(13, 135, 8),
QT_MOC_LITERAL(14, 144, 10),
QT_MOC_LITERAL(15, 155, 10),
QT_MOC_LITERAL(16, 166, 8),
QT_MOC_LITERAL(17, 175, 13),
QT_MOC_LITERAL(18, 189, 11)
},
"QtIntPropertyManager\0valueChanged\0\0"
"QtProperty*\0property\0val\0rangeChanged\0"
"minVal\0maxVal\0singleStepChanged\0step\0"
"readOnlyChanged\0readOnly\0setValue\0"
"setMinimum\0setMaximum\0setRange\0"
"setSingleStep\0setReadOnly\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtIntPropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
10, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
4, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 64, 2, 0x06,
6, 3, 69, 2, 0x06,
9, 2, 76, 2, 0x06,
11, 2, 81, 2, 0x06,
// slots: name, argc, parameters, tag, flags
13, 2, 86, 2, 0x0a,
14, 2, 91, 2, 0x0a,
15, 2, 96, 2, 0x0a,
16, 3, 101, 2, 0x0a,
17, 2, 108, 2, 0x0a,
18, 2, 113, 2, 0x0a,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, QMetaType::Int, 4, 7, 8,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 10,
QMetaType::Void, 0x80000000 | 3, QMetaType::Bool, 4, 12,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 7,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 8,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, QMetaType::Int, 4, 7, 8,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 10,
QMetaType::Void, 0x80000000 | 3, QMetaType::Bool, 4, 12,
0 // eod
};
void QtIntPropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtIntPropertyManager *_t = static_cast<QtIntPropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 1: _t->rangeChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3]))); break;
case 2: _t->singleStepChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 3: _t->readOnlyChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
case 4: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 5: _t->setMinimum((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 6: _t->setMaximum((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 7: _t->setRange((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3]))); break;
case 8: _t->setSingleStep((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 9: _t->setReadOnly((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtIntPropertyManager::*_t)(QtProperty * , int );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtIntPropertyManager::valueChanged)) {
*result = 0;
}
}
{
typedef void (QtIntPropertyManager::*_t)(QtProperty * , int , int );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtIntPropertyManager::rangeChanged)) {
*result = 1;
}
}
{
typedef void (QtIntPropertyManager::*_t)(QtProperty * , int );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtIntPropertyManager::singleStepChanged)) {
*result = 2;
}
}
{
typedef void (QtIntPropertyManager::*_t)(QtProperty * , bool );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtIntPropertyManager::readOnlyChanged)) {
*result = 3;
}
}
}
}
const QMetaObject QtIntPropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtIntPropertyManager.data,
qt_meta_data_QtIntPropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtIntPropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtIntPropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtIntPropertyManager.stringdata))
return static_cast<void*>(const_cast< QtIntPropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtIntPropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 10)
qt_static_metacall(this, _c, _id, _a);
_id -= 10;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 10)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 10;
}
return _id;
}
// SIGNAL 0
void QtIntPropertyManager::valueChanged(QtProperty * _t1, int _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
// SIGNAL 1
void QtIntPropertyManager::rangeChanged(QtProperty * _t1, int _t2, int _t3)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
// SIGNAL 2
void QtIntPropertyManager::singleStepChanged(QtProperty * _t1, int _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 2, _a);
}
// SIGNAL 3
void QtIntPropertyManager::readOnlyChanged(QtProperty * _t1, bool _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 3, _a);
}
struct qt_meta_stringdata_QtBoolPropertyManager_t {
QByteArrayData data[10];
char stringdata[117];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtBoolPropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtBoolPropertyManager_t qt_meta_stringdata_QtBoolPropertyManager = {
{
QT_MOC_LITERAL(0, 0, 21),
QT_MOC_LITERAL(1, 22, 12),
QT_MOC_LITERAL(2, 35, 0),
QT_MOC_LITERAL(3, 36, 11),
QT_MOC_LITERAL(4, 48, 8),
QT_MOC_LITERAL(5, 57, 3),
QT_MOC_LITERAL(6, 61, 18),
QT_MOC_LITERAL(7, 80, 8),
QT_MOC_LITERAL(8, 89, 14),
QT_MOC_LITERAL(9, 104, 11)
},
"QtBoolPropertyManager\0valueChanged\0\0"
"QtProperty*\0property\0val\0textVisibleChanged\0"
"setValue\0setTextVisible\0textVisible\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtBoolPropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
4, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
2, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 34, 2, 0x06,
6, 2, 39, 2, 0x06,
// slots: name, argc, parameters, tag, flags
7, 2, 44, 2, 0x0a,
8, 2, 49, 2, 0x0a,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::Bool, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::Bool, 4, 2,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::Bool, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::Bool, 4, 9,
0 // eod
};
void QtBoolPropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtBoolPropertyManager *_t = static_cast<QtBoolPropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
case 1: _t->textVisibleChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
case 2: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
case 3: _t->setTextVisible((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtBoolPropertyManager::*_t)(QtProperty * , bool );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtBoolPropertyManager::valueChanged)) {
*result = 0;
}
}
{
typedef void (QtBoolPropertyManager::*_t)(QtProperty * , bool );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtBoolPropertyManager::textVisibleChanged)) {
*result = 1;
}
}
}
}
const QMetaObject QtBoolPropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtBoolPropertyManager.data,
qt_meta_data_QtBoolPropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtBoolPropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtBoolPropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtBoolPropertyManager.stringdata))
return static_cast<void*>(const_cast< QtBoolPropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtBoolPropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 4)
qt_static_metacall(this, _c, _id, _a);
_id -= 4;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 4)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 4;
}
return _id;
}
// SIGNAL 0
void QtBoolPropertyManager::valueChanged(QtProperty * _t1, bool _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
// SIGNAL 1
void QtBoolPropertyManager::textVisibleChanged(QtProperty * _t1, bool _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
struct qt_meta_stringdata_QtDoublePropertyManager_t {
QByteArrayData data[22];
char stringdata[238];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtDoublePropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtDoublePropertyManager_t qt_meta_stringdata_QtDoublePropertyManager = {
{
QT_MOC_LITERAL(0, 0, 23),
QT_MOC_LITERAL(1, 24, 12),
QT_MOC_LITERAL(2, 37, 0),
QT_MOC_LITERAL(3, 38, 11),
QT_MOC_LITERAL(4, 50, 8),
QT_MOC_LITERAL(5, 59, 3),
QT_MOC_LITERAL(6, 63, 12),
QT_MOC_LITERAL(7, 76, 6),
QT_MOC_LITERAL(8, 83, 6),
QT_MOC_LITERAL(9, 90, 17),
QT_MOC_LITERAL(10, 108, 4),
QT_MOC_LITERAL(11, 113, 15),
QT_MOC_LITERAL(12, 129, 4),
QT_MOC_LITERAL(13, 134, 15),
QT_MOC_LITERAL(14, 150, 8),
QT_MOC_LITERAL(15, 159, 8),
QT_MOC_LITERAL(16, 168, 10),
QT_MOC_LITERAL(17, 179, 10),
QT_MOC_LITERAL(18, 190, 8),
QT_MOC_LITERAL(19, 199, 13),
QT_MOC_LITERAL(20, 213, 11),
QT_MOC_LITERAL(21, 225, 11)
},
"QtDoublePropertyManager\0valueChanged\0"
"\0QtProperty*\0property\0val\0rangeChanged\0"
"minVal\0maxVal\0singleStepChanged\0step\0"
"decimalsChanged\0prec\0readOnlyChanged\0"
"readOnly\0setValue\0setMinimum\0setMaximum\0"
"setRange\0setSingleStep\0setDecimals\0"
"setReadOnly\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtDoublePropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
12, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
5, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 74, 2, 0x06,
6, 3, 79, 2, 0x06,
9, 2, 86, 2, 0x06,
11, 2, 91, 2, 0x06,
13, 2, 96, 2, 0x06,
// slots: name, argc, parameters, tag, flags
15, 2, 101, 2, 0x0a,
16, 2, 106, 2, 0x0a,
17, 2, 111, 2, 0x0a,
18, 3, 116, 2, 0x0a,
19, 2, 123, 2, 0x0a,
20, 2, 128, 2, 0x0a,
21, 2, 133, 2, 0x0a,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::Double, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::Double, QMetaType::Double, 4, 7, 8,
QMetaType::Void, 0x80000000 | 3, QMetaType::Double, 4, 10,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 12,
QMetaType::Void, 0x80000000 | 3, QMetaType::Bool, 4, 14,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::Double, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::Double, 4, 7,
QMetaType::Void, 0x80000000 | 3, QMetaType::Double, 4, 8,
QMetaType::Void, 0x80000000 | 3, QMetaType::Double, QMetaType::Double, 4, 7, 8,
QMetaType::Void, 0x80000000 | 3, QMetaType::Double, 4, 10,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 12,
QMetaType::Void, 0x80000000 | 3, QMetaType::Bool, 4, 14,
0 // eod
};
void QtDoublePropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtDoublePropertyManager *_t = static_cast<QtDoublePropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< double(*)>(_a[2]))); break;
case 1: _t->rangeChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< double(*)>(_a[2])),(*reinterpret_cast< double(*)>(_a[3]))); break;
case 2: _t->singleStepChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< double(*)>(_a[2]))); break;
case 3: _t->decimalsChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 4: _t->readOnlyChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
case 5: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< double(*)>(_a[2]))); break;
case 6: _t->setMinimum((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< double(*)>(_a[2]))); break;
case 7: _t->setMaximum((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< double(*)>(_a[2]))); break;
case 8: _t->setRange((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< double(*)>(_a[2])),(*reinterpret_cast< double(*)>(_a[3]))); break;
case 9: _t->setSingleStep((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< double(*)>(_a[2]))); break;
case 10: _t->setDecimals((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 11: _t->setReadOnly((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtDoublePropertyManager::*_t)(QtProperty * , double );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtDoublePropertyManager::valueChanged)) {
*result = 0;
}
}
{
typedef void (QtDoublePropertyManager::*_t)(QtProperty * , double , double );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtDoublePropertyManager::rangeChanged)) {
*result = 1;
}
}
{
typedef void (QtDoublePropertyManager::*_t)(QtProperty * , double );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtDoublePropertyManager::singleStepChanged)) {
*result = 2;
}
}
{
typedef void (QtDoublePropertyManager::*_t)(QtProperty * , int );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtDoublePropertyManager::decimalsChanged)) {
*result = 3;
}
}
{
typedef void (QtDoublePropertyManager::*_t)(QtProperty * , bool );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtDoublePropertyManager::readOnlyChanged)) {
*result = 4;
}
}
}
}
const QMetaObject QtDoublePropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtDoublePropertyManager.data,
qt_meta_data_QtDoublePropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtDoublePropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtDoublePropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtDoublePropertyManager.stringdata))
return static_cast<void*>(const_cast< QtDoublePropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtDoublePropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 12)
qt_static_metacall(this, _c, _id, _a);
_id -= 12;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 12)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 12;
}
return _id;
}
// SIGNAL 0
void QtDoublePropertyManager::valueChanged(QtProperty * _t1, double _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
// SIGNAL 1
void QtDoublePropertyManager::rangeChanged(QtProperty * _t1, double _t2, double _t3)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
// SIGNAL 2
void QtDoublePropertyManager::singleStepChanged(QtProperty * _t1, double _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 2, _a);
}
// SIGNAL 3
void QtDoublePropertyManager::decimalsChanged(QtProperty * _t1, int _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 3, _a);
}
// SIGNAL 4
void QtDoublePropertyManager::readOnlyChanged(QtProperty * _t1, bool _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 4, _a);
}
struct qt_meta_stringdata_QtStringPropertyManager_t {
QByteArrayData data[17];
char stringdata[187];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtStringPropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtStringPropertyManager_t qt_meta_stringdata_QtStringPropertyManager = {
{
QT_MOC_LITERAL(0, 0, 23),
QT_MOC_LITERAL(1, 24, 12),
QT_MOC_LITERAL(2, 37, 0),
QT_MOC_LITERAL(3, 38, 11),
QT_MOC_LITERAL(4, 50, 8),
QT_MOC_LITERAL(5, 59, 3),
QT_MOC_LITERAL(6, 63, 13),
QT_MOC_LITERAL(7, 77, 6),
QT_MOC_LITERAL(8, 84, 15),
QT_MOC_LITERAL(9, 100, 15),
QT_MOC_LITERAL(10, 116, 8),
QT_MOC_LITERAL(11, 125, 9),
QT_MOC_LITERAL(12, 135, 11),
QT_MOC_LITERAL(13, 147, 8),
QT_MOC_LITERAL(14, 156, 8),
QT_MOC_LITERAL(15, 165, 11),
QT_MOC_LITERAL(16, 177, 8)
},
"QtStringPropertyManager\0valueChanged\0"
"\0QtProperty*\0property\0val\0regExpChanged\0"
"regExp\0echoModeChanged\0readOnlyChanged\0"
"setValue\0setRegExp\0setEchoMode\0EchoMode\0"
"echoMode\0setReadOnly\0readOnly\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtStringPropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
8, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
4, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 54, 2, 0x06,
6, 2, 59, 2, 0x06,
8, 2, 64, 2, 0x06,
9, 2, 69, 2, 0x06,
// slots: name, argc, parameters, tag, flags
10, 2, 74, 2, 0x0a,
11, 2, 79, 2, 0x0a,
12, 2, 84, 2, 0x0a,
15, 2, 89, 2, 0x0a,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QString, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::QRegExp, 4, 7,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 2,
QMetaType::Void, 0x80000000 | 3, QMetaType::Bool, 4, 2,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QString, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::QRegExp, 4, 7,
QMetaType::Void, 0x80000000 | 3, 0x80000000 | 13, 4, 14,
QMetaType::Void, 0x80000000 | 3, QMetaType::Bool, 4, 16,
0 // eod
};
void QtStringPropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtStringPropertyManager *_t = static_cast<QtStringPropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2]))); break;
case 1: _t->regExpChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QRegExp(*)>(_a[2]))); break;
case 2: _t->echoModeChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const int(*)>(_a[2]))); break;
case 3: _t->readOnlyChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
case 4: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2]))); break;
case 5: _t->setRegExp((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QRegExp(*)>(_a[2]))); break;
case 6: _t->setEchoMode((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< EchoMode(*)>(_a[2]))); break;
case 7: _t->setReadOnly((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtStringPropertyManager::*_t)(QtProperty * , const QString & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtStringPropertyManager::valueChanged)) {
*result = 0;
}
}
{
typedef void (QtStringPropertyManager::*_t)(QtProperty * , const QRegExp & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtStringPropertyManager::regExpChanged)) {
*result = 1;
}
}
{
typedef void (QtStringPropertyManager::*_t)(QtProperty * , const int );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtStringPropertyManager::echoModeChanged)) {
*result = 2;
}
}
{
typedef void (QtStringPropertyManager::*_t)(QtProperty * , bool );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtStringPropertyManager::readOnlyChanged)) {
*result = 3;
}
}
}
}
const QMetaObject QtStringPropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtStringPropertyManager.data,
qt_meta_data_QtStringPropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtStringPropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtStringPropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtStringPropertyManager.stringdata))
return static_cast<void*>(const_cast< QtStringPropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtStringPropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 8)
qt_static_metacall(this, _c, _id, _a);
_id -= 8;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 8)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 8;
}
return _id;
}
// SIGNAL 0
void QtStringPropertyManager::valueChanged(QtProperty * _t1, const QString & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
// SIGNAL 1
void QtStringPropertyManager::regExpChanged(QtProperty * _t1, const QRegExp & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
// SIGNAL 2
void QtStringPropertyManager::echoModeChanged(QtProperty * _t1, const int _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 2, _a);
}
// SIGNAL 3
void QtStringPropertyManager::readOnlyChanged(QtProperty * _t1, bool _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 3, _a);
}
struct qt_meta_stringdata_QtDatePropertyManager_t {
QByteArrayData data[13];
char stringdata[129];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtDatePropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtDatePropertyManager_t qt_meta_stringdata_QtDatePropertyManager = {
{
QT_MOC_LITERAL(0, 0, 21),
QT_MOC_LITERAL(1, 22, 12),
QT_MOC_LITERAL(2, 35, 0),
QT_MOC_LITERAL(3, 36, 11),
QT_MOC_LITERAL(4, 48, 8),
QT_MOC_LITERAL(5, 57, 3),
QT_MOC_LITERAL(6, 61, 12),
QT_MOC_LITERAL(7, 74, 6),
QT_MOC_LITERAL(8, 81, 6),
QT_MOC_LITERAL(9, 88, 8),
QT_MOC_LITERAL(10, 97, 10),
QT_MOC_LITERAL(11, 108, 10),
QT_MOC_LITERAL(12, 119, 8)
},
"QtDatePropertyManager\0valueChanged\0\0"
"QtProperty*\0property\0val\0rangeChanged\0"
"minVal\0maxVal\0setValue\0setMinimum\0"
"setMaximum\0setRange\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtDatePropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
6, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
2, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 44, 2, 0x06,
6, 3, 49, 2, 0x06,
// slots: name, argc, parameters, tag, flags
9, 2, 56, 2, 0x0a,
10, 2, 61, 2, 0x0a,
11, 2, 66, 2, 0x0a,
12, 3, 71, 2, 0x0a,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QDate, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::QDate, QMetaType::QDate, 4, 7, 8,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QDate, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::QDate, 4, 7,
QMetaType::Void, 0x80000000 | 3, QMetaType::QDate, 4, 8,
QMetaType::Void, 0x80000000 | 3, QMetaType::QDate, QMetaType::QDate, 4, 7, 8,
0 // eod
};
void QtDatePropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtDatePropertyManager *_t = static_cast<QtDatePropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QDate(*)>(_a[2]))); break;
case 1: _t->rangeChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QDate(*)>(_a[2])),(*reinterpret_cast< const QDate(*)>(_a[3]))); break;
case 2: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QDate(*)>(_a[2]))); break;
case 3: _t->setMinimum((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QDate(*)>(_a[2]))); break;
case 4: _t->setMaximum((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QDate(*)>(_a[2]))); break;
case 5: _t->setRange((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QDate(*)>(_a[2])),(*reinterpret_cast< const QDate(*)>(_a[3]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtDatePropertyManager::*_t)(QtProperty * , const QDate & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtDatePropertyManager::valueChanged)) {
*result = 0;
}
}
{
typedef void (QtDatePropertyManager::*_t)(QtProperty * , const QDate & , const QDate & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtDatePropertyManager::rangeChanged)) {
*result = 1;
}
}
}
}
const QMetaObject QtDatePropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtDatePropertyManager.data,
qt_meta_data_QtDatePropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtDatePropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtDatePropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtDatePropertyManager.stringdata))
return static_cast<void*>(const_cast< QtDatePropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtDatePropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 6)
qt_static_metacall(this, _c, _id, _a);
_id -= 6;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 6)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 6;
}
return _id;
}
// SIGNAL 0
void QtDatePropertyManager::valueChanged(QtProperty * _t1, const QDate & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
// SIGNAL 1
void QtDatePropertyManager::rangeChanged(QtProperty * _t1, const QDate & _t2, const QDate & _t3)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
struct qt_meta_stringdata_QtTimePropertyManager_t {
QByteArrayData data[7];
char stringdata[71];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtTimePropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtTimePropertyManager_t qt_meta_stringdata_QtTimePropertyManager = {
{
QT_MOC_LITERAL(0, 0, 21),
QT_MOC_LITERAL(1, 22, 12),
QT_MOC_LITERAL(2, 35, 0),
QT_MOC_LITERAL(3, 36, 11),
QT_MOC_LITERAL(4, 48, 8),
QT_MOC_LITERAL(5, 57, 3),
QT_MOC_LITERAL(6, 61, 8)
},
"QtTimePropertyManager\0valueChanged\0\0"
"QtProperty*\0property\0val\0setValue\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtTimePropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
2, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
1, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 24, 2, 0x06,
// slots: name, argc, parameters, tag, flags
6, 2, 29, 2, 0x0a,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QTime, 4, 5,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QTime, 4, 5,
0 // eod
};
void QtTimePropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtTimePropertyManager *_t = static_cast<QtTimePropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QTime(*)>(_a[2]))); break;
case 1: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QTime(*)>(_a[2]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtTimePropertyManager::*_t)(QtProperty * , const QTime & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtTimePropertyManager::valueChanged)) {
*result = 0;
}
}
}
}
const QMetaObject QtTimePropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtTimePropertyManager.data,
qt_meta_data_QtTimePropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtTimePropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtTimePropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtTimePropertyManager.stringdata))
return static_cast<void*>(const_cast< QtTimePropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtTimePropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::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;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 2)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 2;
}
return _id;
}
// SIGNAL 0
void QtTimePropertyManager::valueChanged(QtProperty * _t1, const QTime & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_QtDateTimePropertyManager_t {
QByteArrayData data[7];
char stringdata[75];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtDateTimePropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtDateTimePropertyManager_t qt_meta_stringdata_QtDateTimePropertyManager = {
{
QT_MOC_LITERAL(0, 0, 25),
QT_MOC_LITERAL(1, 26, 12),
QT_MOC_LITERAL(2, 39, 0),
QT_MOC_LITERAL(3, 40, 11),
QT_MOC_LITERAL(4, 52, 8),
QT_MOC_LITERAL(5, 61, 3),
QT_MOC_LITERAL(6, 65, 8)
},
"QtDateTimePropertyManager\0valueChanged\0"
"\0QtProperty*\0property\0val\0setValue\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtDateTimePropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
2, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
1, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 24, 2, 0x06,
// slots: name, argc, parameters, tag, flags
6, 2, 29, 2, 0x0a,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QDateTime, 4, 5,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QDateTime, 4, 5,
0 // eod
};
void QtDateTimePropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtDateTimePropertyManager *_t = static_cast<QtDateTimePropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QDateTime(*)>(_a[2]))); break;
case 1: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QDateTime(*)>(_a[2]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtDateTimePropertyManager::*_t)(QtProperty * , const QDateTime & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtDateTimePropertyManager::valueChanged)) {
*result = 0;
}
}
}
}
const QMetaObject QtDateTimePropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtDateTimePropertyManager.data,
qt_meta_data_QtDateTimePropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtDateTimePropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtDateTimePropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtDateTimePropertyManager.stringdata))
return static_cast<void*>(const_cast< QtDateTimePropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtDateTimePropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::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;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 2)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 2;
}
return _id;
}
// SIGNAL 0
void QtDateTimePropertyManager::valueChanged(QtProperty * _t1, const QDateTime & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_QtKeySequencePropertyManager_t {
QByteArrayData data[7];
char stringdata[78];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtKeySequencePropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtKeySequencePropertyManager_t qt_meta_stringdata_QtKeySequencePropertyManager = {
{
QT_MOC_LITERAL(0, 0, 28),
QT_MOC_LITERAL(1, 29, 12),
QT_MOC_LITERAL(2, 42, 0),
QT_MOC_LITERAL(3, 43, 11),
QT_MOC_LITERAL(4, 55, 8),
QT_MOC_LITERAL(5, 64, 3),
QT_MOC_LITERAL(6, 68, 8)
},
"QtKeySequencePropertyManager\0valueChanged\0"
"\0QtProperty*\0property\0val\0setValue\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtKeySequencePropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
2, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
1, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 24, 2, 0x06,
// slots: name, argc, parameters, tag, flags
6, 2, 29, 2, 0x0a,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QKeySequence, 4, 5,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QKeySequence, 4, 5,
0 // eod
};
void QtKeySequencePropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtKeySequencePropertyManager *_t = static_cast<QtKeySequencePropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QKeySequence(*)>(_a[2]))); break;
case 1: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QKeySequence(*)>(_a[2]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtKeySequencePropertyManager::*_t)(QtProperty * , const QKeySequence & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtKeySequencePropertyManager::valueChanged)) {
*result = 0;
}
}
}
}
const QMetaObject QtKeySequencePropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtKeySequencePropertyManager.data,
qt_meta_data_QtKeySequencePropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtKeySequencePropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtKeySequencePropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtKeySequencePropertyManager.stringdata))
return static_cast<void*>(const_cast< QtKeySequencePropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtKeySequencePropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::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;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 2)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 2;
}
return _id;
}
// SIGNAL 0
void QtKeySequencePropertyManager::valueChanged(QtProperty * _t1, const QKeySequence & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_QtCharPropertyManager_t {
QByteArrayData data[7];
char stringdata[71];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtCharPropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtCharPropertyManager_t qt_meta_stringdata_QtCharPropertyManager = {
{
QT_MOC_LITERAL(0, 0, 21),
QT_MOC_LITERAL(1, 22, 12),
QT_MOC_LITERAL(2, 35, 0),
QT_MOC_LITERAL(3, 36, 11),
QT_MOC_LITERAL(4, 48, 8),
QT_MOC_LITERAL(5, 57, 3),
QT_MOC_LITERAL(6, 61, 8)
},
"QtCharPropertyManager\0valueChanged\0\0"
"QtProperty*\0property\0val\0setValue\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtCharPropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
2, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
1, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 24, 2, 0x06,
// slots: name, argc, parameters, tag, flags
6, 2, 29, 2, 0x0a,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QChar, 4, 5,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QChar, 4, 5,
0 // eod
};
void QtCharPropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtCharPropertyManager *_t = static_cast<QtCharPropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QChar(*)>(_a[2]))); break;
case 1: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QChar(*)>(_a[2]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtCharPropertyManager::*_t)(QtProperty * , const QChar & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtCharPropertyManager::valueChanged)) {
*result = 0;
}
}
}
}
const QMetaObject QtCharPropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtCharPropertyManager.data,
qt_meta_data_QtCharPropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtCharPropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtCharPropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtCharPropertyManager.stringdata))
return static_cast<void*>(const_cast< QtCharPropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtCharPropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::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;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 2)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 2;
}
return _id;
}
// SIGNAL 0
void QtCharPropertyManager::valueChanged(QtProperty * _t1, const QChar & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_QtLocalePropertyManager_t {
QByteArrayData data[9];
char stringdata[111];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtLocalePropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtLocalePropertyManager_t qt_meta_stringdata_QtLocalePropertyManager = {
{
QT_MOC_LITERAL(0, 0, 23),
QT_MOC_LITERAL(1, 24, 12),
QT_MOC_LITERAL(2, 37, 0),
QT_MOC_LITERAL(3, 38, 11),
QT_MOC_LITERAL(4, 50, 8),
QT_MOC_LITERAL(5, 59, 3),
QT_MOC_LITERAL(6, 63, 8),
QT_MOC_LITERAL(7, 72, 15),
QT_MOC_LITERAL(8, 88, 21)
},
"QtLocalePropertyManager\0valueChanged\0"
"\0QtProperty*\0property\0val\0setValue\0"
"slotEnumChanged\0slotPropertyDestroyed\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtLocalePropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
4, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
1, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 34, 2, 0x06,
// slots: name, argc, parameters, tag, flags
6, 2, 39, 2, 0x0a,
7, 2, 44, 2, 0x08,
8, 1, 49, 2, 0x08,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QLocale, 4, 5,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QLocale, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 2, 2,
QMetaType::Void, 0x80000000 | 3, 2,
0 // eod
};
void QtLocalePropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtLocalePropertyManager *_t = static_cast<QtLocalePropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QLocale(*)>(_a[2]))); break;
case 1: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QLocale(*)>(_a[2]))); break;
case 2: _t->d_func()->slotEnumChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 3: _t->d_func()->slotPropertyDestroyed((*reinterpret_cast< QtProperty*(*)>(_a[1]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtLocalePropertyManager::*_t)(QtProperty * , const QLocale & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtLocalePropertyManager::valueChanged)) {
*result = 0;
}
}
}
}
const QMetaObject QtLocalePropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtLocalePropertyManager.data,
qt_meta_data_QtLocalePropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtLocalePropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtLocalePropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtLocalePropertyManager.stringdata))
return static_cast<void*>(const_cast< QtLocalePropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtLocalePropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 4)
qt_static_metacall(this, _c, _id, _a);
_id -= 4;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 4)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 4;
}
return _id;
}
// SIGNAL 0
void QtLocalePropertyManager::valueChanged(QtProperty * _t1, const QLocale & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_QtPointPropertyManager_t {
QByteArrayData data[9];
char stringdata[109];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtPointPropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtPointPropertyManager_t qt_meta_stringdata_QtPointPropertyManager = {
{
QT_MOC_LITERAL(0, 0, 22),
QT_MOC_LITERAL(1, 23, 12),
QT_MOC_LITERAL(2, 36, 0),
QT_MOC_LITERAL(3, 37, 11),
QT_MOC_LITERAL(4, 49, 8),
QT_MOC_LITERAL(5, 58, 3),
QT_MOC_LITERAL(6, 62, 8),
QT_MOC_LITERAL(7, 71, 14),
QT_MOC_LITERAL(8, 86, 21)
},
"QtPointPropertyManager\0valueChanged\0"
"\0QtProperty*\0property\0val\0setValue\0"
"slotIntChanged\0slotPropertyDestroyed\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtPointPropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
4, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
1, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 34, 2, 0x06,
// slots: name, argc, parameters, tag, flags
6, 2, 39, 2, 0x0a,
7, 2, 44, 2, 0x08,
8, 1, 49, 2, 0x08,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QPoint, 4, 5,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QPoint, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 2, 2,
QMetaType::Void, 0x80000000 | 3, 2,
0 // eod
};
void QtPointPropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtPointPropertyManager *_t = static_cast<QtPointPropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QPoint(*)>(_a[2]))); break;
case 1: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QPoint(*)>(_a[2]))); break;
case 2: _t->d_func()->slotIntChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 3: _t->d_func()->slotPropertyDestroyed((*reinterpret_cast< QtProperty*(*)>(_a[1]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtPointPropertyManager::*_t)(QtProperty * , const QPoint & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtPointPropertyManager::valueChanged)) {
*result = 0;
}
}
}
}
const QMetaObject QtPointPropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtPointPropertyManager.data,
qt_meta_data_QtPointPropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtPointPropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtPointPropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtPointPropertyManager.stringdata))
return static_cast<void*>(const_cast< QtPointPropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtPointPropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 4)
qt_static_metacall(this, _c, _id, _a);
_id -= 4;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 4)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 4;
}
return _id;
}
// SIGNAL 0
void QtPointPropertyManager::valueChanged(QtProperty * _t1, const QPoint & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_QtPointFPropertyManager_t {
QByteArrayData data[12];
char stringdata[146];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtPointFPropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtPointFPropertyManager_t qt_meta_stringdata_QtPointFPropertyManager = {
{
QT_MOC_LITERAL(0, 0, 23),
QT_MOC_LITERAL(1, 24, 12),
QT_MOC_LITERAL(2, 37, 0),
QT_MOC_LITERAL(3, 38, 11),
QT_MOC_LITERAL(4, 50, 8),
QT_MOC_LITERAL(5, 59, 3),
QT_MOC_LITERAL(6, 63, 15),
QT_MOC_LITERAL(7, 79, 4),
QT_MOC_LITERAL(8, 84, 8),
QT_MOC_LITERAL(9, 93, 11),
QT_MOC_LITERAL(10, 105, 17),
QT_MOC_LITERAL(11, 123, 21)
},
"QtPointFPropertyManager\0valueChanged\0"
"\0QtProperty*\0property\0val\0decimalsChanged\0"
"prec\0setValue\0setDecimals\0slotDoubleChanged\0"
"slotPropertyDestroyed\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtPointFPropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
6, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
2, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 44, 2, 0x06,
6, 2, 49, 2, 0x06,
// slots: name, argc, parameters, tag, flags
8, 2, 54, 2, 0x0a,
9, 2, 59, 2, 0x0a,
10, 2, 64, 2, 0x08,
11, 1, 69, 2, 0x08,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QPointF, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 7,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QPointF, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 7,
QMetaType::Void, 0x80000000 | 3, QMetaType::Double, 2, 2,
QMetaType::Void, 0x80000000 | 3, 2,
0 // eod
};
void QtPointFPropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtPointFPropertyManager *_t = static_cast<QtPointFPropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QPointF(*)>(_a[2]))); break;
case 1: _t->decimalsChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 2: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QPointF(*)>(_a[2]))); break;
case 3: _t->setDecimals((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 4: _t->d_func()->slotDoubleChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< double(*)>(_a[2]))); break;
case 5: _t->d_func()->slotPropertyDestroyed((*reinterpret_cast< QtProperty*(*)>(_a[1]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtPointFPropertyManager::*_t)(QtProperty * , const QPointF & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtPointFPropertyManager::valueChanged)) {
*result = 0;
}
}
{
typedef void (QtPointFPropertyManager::*_t)(QtProperty * , int );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtPointFPropertyManager::decimalsChanged)) {
*result = 1;
}
}
}
}
const QMetaObject QtPointFPropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtPointFPropertyManager.data,
qt_meta_data_QtPointFPropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtPointFPropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtPointFPropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtPointFPropertyManager.stringdata))
return static_cast<void*>(const_cast< QtPointFPropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtPointFPropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 6)
qt_static_metacall(this, _c, _id, _a);
_id -= 6;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 6)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 6;
}
return _id;
}
// SIGNAL 0
void QtPointFPropertyManager::valueChanged(QtProperty * _t1, const QPointF & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
// SIGNAL 1
void QtPointFPropertyManager::decimalsChanged(QtProperty * _t1, int _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
struct qt_meta_stringdata_QtSizePropertyManager_t {
QByteArrayData data[15];
char stringdata[166];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtSizePropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtSizePropertyManager_t qt_meta_stringdata_QtSizePropertyManager = {
{
QT_MOC_LITERAL(0, 0, 21),
QT_MOC_LITERAL(1, 22, 12),
QT_MOC_LITERAL(2, 35, 0),
QT_MOC_LITERAL(3, 36, 11),
QT_MOC_LITERAL(4, 48, 8),
QT_MOC_LITERAL(5, 57, 3),
QT_MOC_LITERAL(6, 61, 12),
QT_MOC_LITERAL(7, 74, 6),
QT_MOC_LITERAL(8, 81, 6),
QT_MOC_LITERAL(9, 88, 8),
QT_MOC_LITERAL(10, 97, 10),
QT_MOC_LITERAL(11, 108, 10),
QT_MOC_LITERAL(12, 119, 8),
QT_MOC_LITERAL(13, 128, 14),
QT_MOC_LITERAL(14, 143, 21)
},
"QtSizePropertyManager\0valueChanged\0\0"
"QtProperty*\0property\0val\0rangeChanged\0"
"minVal\0maxVal\0setValue\0setMinimum\0"
"setMaximum\0setRange\0slotIntChanged\0"
"slotPropertyDestroyed\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtSizePropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
8, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
2, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 54, 2, 0x06,
6, 3, 59, 2, 0x06,
// slots: name, argc, parameters, tag, flags
9, 2, 66, 2, 0x0a,
10, 2, 71, 2, 0x0a,
11, 2, 76, 2, 0x0a,
12, 3, 81, 2, 0x0a,
13, 2, 88, 2, 0x08,
14, 1, 93, 2, 0x08,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QSize, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::QSize, QMetaType::QSize, 4, 7, 8,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QSize, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::QSize, 4, 7,
QMetaType::Void, 0x80000000 | 3, QMetaType::QSize, 4, 8,
QMetaType::Void, 0x80000000 | 3, QMetaType::QSize, QMetaType::QSize, 4, 7, 8,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 2, 2,
QMetaType::Void, 0x80000000 | 3, 2,
0 // eod
};
void QtSizePropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtSizePropertyManager *_t = static_cast<QtSizePropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QSize(*)>(_a[2]))); break;
case 1: _t->rangeChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QSize(*)>(_a[2])),(*reinterpret_cast< const QSize(*)>(_a[3]))); break;
case 2: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QSize(*)>(_a[2]))); break;
case 3: _t->setMinimum((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QSize(*)>(_a[2]))); break;
case 4: _t->setMaximum((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QSize(*)>(_a[2]))); break;
case 5: _t->setRange((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QSize(*)>(_a[2])),(*reinterpret_cast< const QSize(*)>(_a[3]))); break;
case 6: _t->d_func()->slotIntChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 7: _t->d_func()->slotPropertyDestroyed((*reinterpret_cast< QtProperty*(*)>(_a[1]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtSizePropertyManager::*_t)(QtProperty * , const QSize & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtSizePropertyManager::valueChanged)) {
*result = 0;
}
}
{
typedef void (QtSizePropertyManager::*_t)(QtProperty * , const QSize & , const QSize & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtSizePropertyManager::rangeChanged)) {
*result = 1;
}
}
}
}
const QMetaObject QtSizePropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtSizePropertyManager.data,
qt_meta_data_QtSizePropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtSizePropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtSizePropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtSizePropertyManager.stringdata))
return static_cast<void*>(const_cast< QtSizePropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtSizePropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 8)
qt_static_metacall(this, _c, _id, _a);
_id -= 8;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 8)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 8;
}
return _id;
}
// SIGNAL 0
void QtSizePropertyManager::valueChanged(QtProperty * _t1, const QSize & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
// SIGNAL 1
void QtSizePropertyManager::rangeChanged(QtProperty * _t1, const QSize & _t2, const QSize & _t3)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
struct qt_meta_stringdata_QtSizeFPropertyManager_t {
QByteArrayData data[18];
char stringdata[203];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtSizeFPropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtSizeFPropertyManager_t qt_meta_stringdata_QtSizeFPropertyManager = {
{
QT_MOC_LITERAL(0, 0, 22),
QT_MOC_LITERAL(1, 23, 12),
QT_MOC_LITERAL(2, 36, 0),
QT_MOC_LITERAL(3, 37, 11),
QT_MOC_LITERAL(4, 49, 8),
QT_MOC_LITERAL(5, 58, 3),
QT_MOC_LITERAL(6, 62, 12),
QT_MOC_LITERAL(7, 75, 6),
QT_MOC_LITERAL(8, 82, 6),
QT_MOC_LITERAL(9, 89, 15),
QT_MOC_LITERAL(10, 105, 4),
QT_MOC_LITERAL(11, 110, 8),
QT_MOC_LITERAL(12, 119, 10),
QT_MOC_LITERAL(13, 130, 10),
QT_MOC_LITERAL(14, 141, 8),
QT_MOC_LITERAL(15, 150, 11),
QT_MOC_LITERAL(16, 162, 17),
QT_MOC_LITERAL(17, 180, 21)
},
"QtSizeFPropertyManager\0valueChanged\0"
"\0QtProperty*\0property\0val\0rangeChanged\0"
"minVal\0maxVal\0decimalsChanged\0prec\0"
"setValue\0setMinimum\0setMaximum\0setRange\0"
"setDecimals\0slotDoubleChanged\0"
"slotPropertyDestroyed\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtSizeFPropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
10, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
3, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 64, 2, 0x06,
6, 3, 69, 2, 0x06,
9, 2, 76, 2, 0x06,
// slots: name, argc, parameters, tag, flags
11, 2, 81, 2, 0x0a,
12, 2, 86, 2, 0x0a,
13, 2, 91, 2, 0x0a,
14, 3, 96, 2, 0x0a,
15, 2, 103, 2, 0x0a,
16, 2, 108, 2, 0x08,
17, 1, 113, 2, 0x08,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QSizeF, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::QSizeF, QMetaType::QSizeF, 4, 7, 8,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 10,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QSizeF, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::QSizeF, 4, 7,
QMetaType::Void, 0x80000000 | 3, QMetaType::QSizeF, 4, 8,
QMetaType::Void, 0x80000000 | 3, QMetaType::QSizeF, QMetaType::QSizeF, 4, 7, 8,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 10,
QMetaType::Void, 0x80000000 | 3, QMetaType::Double, 2, 2,
QMetaType::Void, 0x80000000 | 3, 2,
0 // eod
};
void QtSizeFPropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtSizeFPropertyManager *_t = static_cast<QtSizeFPropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QSizeF(*)>(_a[2]))); break;
case 1: _t->rangeChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QSizeF(*)>(_a[2])),(*reinterpret_cast< const QSizeF(*)>(_a[3]))); break;
case 2: _t->decimalsChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 3: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QSizeF(*)>(_a[2]))); break;
case 4: _t->setMinimum((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QSizeF(*)>(_a[2]))); break;
case 5: _t->setMaximum((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QSizeF(*)>(_a[2]))); break;
case 6: _t->setRange((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QSizeF(*)>(_a[2])),(*reinterpret_cast< const QSizeF(*)>(_a[3]))); break;
case 7: _t->setDecimals((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 8: _t->d_func()->slotDoubleChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< double(*)>(_a[2]))); break;
case 9: _t->d_func()->slotPropertyDestroyed((*reinterpret_cast< QtProperty*(*)>(_a[1]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtSizeFPropertyManager::*_t)(QtProperty * , const QSizeF & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtSizeFPropertyManager::valueChanged)) {
*result = 0;
}
}
{
typedef void (QtSizeFPropertyManager::*_t)(QtProperty * , const QSizeF & , const QSizeF & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtSizeFPropertyManager::rangeChanged)) {
*result = 1;
}
}
{
typedef void (QtSizeFPropertyManager::*_t)(QtProperty * , int );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtSizeFPropertyManager::decimalsChanged)) {
*result = 2;
}
}
}
}
const QMetaObject QtSizeFPropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtSizeFPropertyManager.data,
qt_meta_data_QtSizeFPropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtSizeFPropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtSizeFPropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtSizeFPropertyManager.stringdata))
return static_cast<void*>(const_cast< QtSizeFPropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtSizeFPropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 10)
qt_static_metacall(this, _c, _id, _a);
_id -= 10;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 10)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 10;
}
return _id;
}
// SIGNAL 0
void QtSizeFPropertyManager::valueChanged(QtProperty * _t1, const QSizeF & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
// SIGNAL 1
void QtSizeFPropertyManager::rangeChanged(QtProperty * _t1, const QSizeF & _t2, const QSizeF & _t3)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
// SIGNAL 2
void QtSizeFPropertyManager::decimalsChanged(QtProperty * _t1, int _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 2, _a);
}
struct qt_meta_stringdata_QtRectPropertyManager_t {
QByteArrayData data[12];
char stringdata[151];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtRectPropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtRectPropertyManager_t qt_meta_stringdata_QtRectPropertyManager = {
{
QT_MOC_LITERAL(0, 0, 21),
QT_MOC_LITERAL(1, 22, 12),
QT_MOC_LITERAL(2, 35, 0),
QT_MOC_LITERAL(3, 36, 11),
QT_MOC_LITERAL(4, 48, 8),
QT_MOC_LITERAL(5, 57, 3),
QT_MOC_LITERAL(6, 61, 17),
QT_MOC_LITERAL(7, 79, 10),
QT_MOC_LITERAL(8, 90, 8),
QT_MOC_LITERAL(9, 99, 13),
QT_MOC_LITERAL(10, 113, 14),
QT_MOC_LITERAL(11, 128, 21)
},
"QtRectPropertyManager\0valueChanged\0\0"
"QtProperty*\0property\0val\0constraintChanged\0"
"constraint\0setValue\0setConstraint\0"
"slotIntChanged\0slotPropertyDestroyed\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtRectPropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
6, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
2, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 44, 2, 0x06,
6, 2, 49, 2, 0x06,
// slots: name, argc, parameters, tag, flags
8, 2, 54, 2, 0x0a,
9, 2, 59, 2, 0x0a,
10, 2, 64, 2, 0x08,
11, 1, 69, 2, 0x08,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QRect, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::QRect, 4, 7,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QRect, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::QRect, 4, 7,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 2, 2,
QMetaType::Void, 0x80000000 | 3, 2,
0 // eod
};
void QtRectPropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtRectPropertyManager *_t = static_cast<QtRectPropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QRect(*)>(_a[2]))); break;
case 1: _t->constraintChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QRect(*)>(_a[2]))); break;
case 2: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QRect(*)>(_a[2]))); break;
case 3: _t->setConstraint((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QRect(*)>(_a[2]))); break;
case 4: _t->d_func()->slotIntChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 5: _t->d_func()->slotPropertyDestroyed((*reinterpret_cast< QtProperty*(*)>(_a[1]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtRectPropertyManager::*_t)(QtProperty * , const QRect & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtRectPropertyManager::valueChanged)) {
*result = 0;
}
}
{
typedef void (QtRectPropertyManager::*_t)(QtProperty * , const QRect & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtRectPropertyManager::constraintChanged)) {
*result = 1;
}
}
}
}
const QMetaObject QtRectPropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtRectPropertyManager.data,
qt_meta_data_QtRectPropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtRectPropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtRectPropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtRectPropertyManager.stringdata))
return static_cast<void*>(const_cast< QtRectPropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtRectPropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 6)
qt_static_metacall(this, _c, _id, _a);
_id -= 6;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 6)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 6;
}
return _id;
}
// SIGNAL 0
void QtRectPropertyManager::valueChanged(QtProperty * _t1, const QRect & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
// SIGNAL 1
void QtRectPropertyManager::constraintChanged(QtProperty * _t1, const QRect & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
struct qt_meta_stringdata_QtRectFPropertyManager_t {
QByteArrayData data[15];
char stringdata[188];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtRectFPropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtRectFPropertyManager_t qt_meta_stringdata_QtRectFPropertyManager = {
{
QT_MOC_LITERAL(0, 0, 22),
QT_MOC_LITERAL(1, 23, 12),
QT_MOC_LITERAL(2, 36, 0),
QT_MOC_LITERAL(3, 37, 11),
QT_MOC_LITERAL(4, 49, 8),
QT_MOC_LITERAL(5, 58, 3),
QT_MOC_LITERAL(6, 62, 17),
QT_MOC_LITERAL(7, 80, 10),
QT_MOC_LITERAL(8, 91, 15),
QT_MOC_LITERAL(9, 107, 4),
QT_MOC_LITERAL(10, 112, 8),
QT_MOC_LITERAL(11, 121, 13),
QT_MOC_LITERAL(12, 135, 11),
QT_MOC_LITERAL(13, 147, 17),
QT_MOC_LITERAL(14, 165, 21)
},
"QtRectFPropertyManager\0valueChanged\0"
"\0QtProperty*\0property\0val\0constraintChanged\0"
"constraint\0decimalsChanged\0prec\0"
"setValue\0setConstraint\0setDecimals\0"
"slotDoubleChanged\0slotPropertyDestroyed\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtRectFPropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
8, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
3, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 54, 2, 0x06,
6, 2, 59, 2, 0x06,
8, 2, 64, 2, 0x06,
// slots: name, argc, parameters, tag, flags
10, 2, 69, 2, 0x0a,
11, 2, 74, 2, 0x0a,
12, 2, 79, 2, 0x0a,
13, 2, 84, 2, 0x08,
14, 1, 89, 2, 0x08,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QRectF, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::QRectF, 4, 7,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 9,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QRectF, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::QRectF, 4, 7,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 9,
QMetaType::Void, 0x80000000 | 3, QMetaType::Double, 2, 2,
QMetaType::Void, 0x80000000 | 3, 2,
0 // eod
};
void QtRectFPropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtRectFPropertyManager *_t = static_cast<QtRectFPropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QRectF(*)>(_a[2]))); break;
case 1: _t->constraintChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QRectF(*)>(_a[2]))); break;
case 2: _t->decimalsChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 3: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QRectF(*)>(_a[2]))); break;
case 4: _t->setConstraint((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QRectF(*)>(_a[2]))); break;
case 5: _t->setDecimals((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 6: _t->d_func()->slotDoubleChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< double(*)>(_a[2]))); break;
case 7: _t->d_func()->slotPropertyDestroyed((*reinterpret_cast< QtProperty*(*)>(_a[1]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtRectFPropertyManager::*_t)(QtProperty * , const QRectF & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtRectFPropertyManager::valueChanged)) {
*result = 0;
}
}
{
typedef void (QtRectFPropertyManager::*_t)(QtProperty * , const QRectF & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtRectFPropertyManager::constraintChanged)) {
*result = 1;
}
}
{
typedef void (QtRectFPropertyManager::*_t)(QtProperty * , int );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtRectFPropertyManager::decimalsChanged)) {
*result = 2;
}
}
}
}
const QMetaObject QtRectFPropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtRectFPropertyManager.data,
qt_meta_data_QtRectFPropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtRectFPropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtRectFPropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtRectFPropertyManager.stringdata))
return static_cast<void*>(const_cast< QtRectFPropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtRectFPropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 8)
qt_static_metacall(this, _c, _id, _a);
_id -= 8;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 8)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 8;
}
return _id;
}
// SIGNAL 0
void QtRectFPropertyManager::valueChanged(QtProperty * _t1, const QRectF & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
// SIGNAL 1
void QtRectFPropertyManager::constraintChanged(QtProperty * _t1, const QRectF & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
// SIGNAL 2
void QtRectFPropertyManager::decimalsChanged(QtProperty * _t1, int _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 2, _a);
}
struct qt_meta_stringdata_QtEnumPropertyManager_t {
QByteArrayData data[14];
char stringdata[159];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtEnumPropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtEnumPropertyManager_t qt_meta_stringdata_QtEnumPropertyManager = {
{
QT_MOC_LITERAL(0, 0, 21),
QT_MOC_LITERAL(1, 22, 12),
QT_MOC_LITERAL(2, 35, 0),
QT_MOC_LITERAL(3, 36, 11),
QT_MOC_LITERAL(4, 48, 8),
QT_MOC_LITERAL(5, 57, 3),
QT_MOC_LITERAL(6, 61, 16),
QT_MOC_LITERAL(7, 78, 5),
QT_MOC_LITERAL(8, 84, 16),
QT_MOC_LITERAL(9, 101, 15),
QT_MOC_LITERAL(10, 117, 5),
QT_MOC_LITERAL(11, 123, 8),
QT_MOC_LITERAL(12, 132, 12),
QT_MOC_LITERAL(13, 145, 12)
},
"QtEnumPropertyManager\0valueChanged\0\0"
"QtProperty*\0property\0val\0enumNamesChanged\0"
"names\0enumIconsChanged\0QMap<int,QIcon>\0"
"icons\0setValue\0setEnumNames\0setEnumIcons\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtEnumPropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
6, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
3, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 44, 2, 0x06,
6, 2, 49, 2, 0x06,
8, 2, 54, 2, 0x06,
// slots: name, argc, parameters, tag, flags
11, 2, 59, 2, 0x0a,
12, 2, 64, 2, 0x0a,
13, 2, 69, 2, 0x0a,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::QStringList, 4, 7,
QMetaType::Void, 0x80000000 | 3, 0x80000000 | 9, 4, 10,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::QStringList, 4, 7,
QMetaType::Void, 0x80000000 | 3, 0x80000000 | 9, 4, 10,
0 // eod
};
void QtEnumPropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtEnumPropertyManager *_t = static_cast<QtEnumPropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 1: _t->enumNamesChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QStringList(*)>(_a[2]))); break;
case 2: _t->enumIconsChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QMap<int,QIcon>(*)>(_a[2]))); break;
case 3: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 4: _t->setEnumNames((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QStringList(*)>(_a[2]))); break;
case 5: _t->setEnumIcons((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QMap<int,QIcon>(*)>(_a[2]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtEnumPropertyManager::*_t)(QtProperty * , int );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtEnumPropertyManager::valueChanged)) {
*result = 0;
}
}
{
typedef void (QtEnumPropertyManager::*_t)(QtProperty * , const QStringList & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtEnumPropertyManager::enumNamesChanged)) {
*result = 1;
}
}
{
typedef void (QtEnumPropertyManager::*_t)(QtProperty * , const QMap<int,QIcon> & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtEnumPropertyManager::enumIconsChanged)) {
*result = 2;
}
}
}
}
const QMetaObject QtEnumPropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtEnumPropertyManager.data,
qt_meta_data_QtEnumPropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtEnumPropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtEnumPropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtEnumPropertyManager.stringdata))
return static_cast<void*>(const_cast< QtEnumPropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtEnumPropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 6)
qt_static_metacall(this, _c, _id, _a);
_id -= 6;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 6)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 6;
}
return _id;
}
// SIGNAL 0
void QtEnumPropertyManager::valueChanged(QtProperty * _t1, int _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
// SIGNAL 1
void QtEnumPropertyManager::enumNamesChanged(QtProperty * _t1, const QStringList & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
// SIGNAL 2
void QtEnumPropertyManager::enumIconsChanged(QtProperty * _t1, const QMap<int,QIcon> & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 2, _a);
}
struct qt_meta_stringdata_QtFlagPropertyManager_t {
QByteArrayData data[12];
char stringdata[145];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtFlagPropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtFlagPropertyManager_t qt_meta_stringdata_QtFlagPropertyManager = {
{
QT_MOC_LITERAL(0, 0, 21),
QT_MOC_LITERAL(1, 22, 12),
QT_MOC_LITERAL(2, 35, 0),
QT_MOC_LITERAL(3, 36, 11),
QT_MOC_LITERAL(4, 48, 8),
QT_MOC_LITERAL(5, 57, 3),
QT_MOC_LITERAL(6, 61, 16),
QT_MOC_LITERAL(7, 78, 5),
QT_MOC_LITERAL(8, 84, 8),
QT_MOC_LITERAL(9, 93, 12),
QT_MOC_LITERAL(10, 106, 15),
QT_MOC_LITERAL(11, 122, 21)
},
"QtFlagPropertyManager\0valueChanged\0\0"
"QtProperty*\0property\0val\0flagNamesChanged\0"
"names\0setValue\0setFlagNames\0slotBoolChanged\0"
"slotPropertyDestroyed\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtFlagPropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
6, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
2, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 44, 2, 0x06,
6, 2, 49, 2, 0x06,
// slots: name, argc, parameters, tag, flags
8, 2, 54, 2, 0x0a,
9, 2, 59, 2, 0x0a,
10, 2, 64, 2, 0x08,
11, 1, 69, 2, 0x08,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::QStringList, 4, 7,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::QStringList, 4, 7,
QMetaType::Void, 0x80000000 | 3, QMetaType::Bool, 2, 2,
QMetaType::Void, 0x80000000 | 3, 2,
0 // eod
};
void QtFlagPropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtFlagPropertyManager *_t = static_cast<QtFlagPropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 1: _t->flagNamesChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QStringList(*)>(_a[2]))); break;
case 2: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 3: _t->setFlagNames((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QStringList(*)>(_a[2]))); break;
case 4: _t->d_func()->slotBoolChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
case 5: _t->d_func()->slotPropertyDestroyed((*reinterpret_cast< QtProperty*(*)>(_a[1]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtFlagPropertyManager::*_t)(QtProperty * , int );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtFlagPropertyManager::valueChanged)) {
*result = 0;
}
}
{
typedef void (QtFlagPropertyManager::*_t)(QtProperty * , const QStringList & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtFlagPropertyManager::flagNamesChanged)) {
*result = 1;
}
}
}
}
const QMetaObject QtFlagPropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtFlagPropertyManager.data,
qt_meta_data_QtFlagPropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtFlagPropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtFlagPropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtFlagPropertyManager.stringdata))
return static_cast<void*>(const_cast< QtFlagPropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtFlagPropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 6)
qt_static_metacall(this, _c, _id, _a);
_id -= 6;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 6)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 6;
}
return _id;
}
// SIGNAL 0
void QtFlagPropertyManager::valueChanged(QtProperty * _t1, int _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
// SIGNAL 1
void QtFlagPropertyManager::flagNamesChanged(QtProperty * _t1, const QStringList & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
struct qt_meta_stringdata_QtSizePolicyPropertyManager_t {
QByteArrayData data[10];
char stringdata[130];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtSizePolicyPropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtSizePolicyPropertyManager_t qt_meta_stringdata_QtSizePolicyPropertyManager = {
{
QT_MOC_LITERAL(0, 0, 27),
QT_MOC_LITERAL(1, 28, 12),
QT_MOC_LITERAL(2, 41, 0),
QT_MOC_LITERAL(3, 42, 11),
QT_MOC_LITERAL(4, 54, 8),
QT_MOC_LITERAL(5, 63, 3),
QT_MOC_LITERAL(6, 67, 8),
QT_MOC_LITERAL(7, 76, 14),
QT_MOC_LITERAL(8, 91, 15),
QT_MOC_LITERAL(9, 107, 21)
},
"QtSizePolicyPropertyManager\0valueChanged\0"
"\0QtProperty*\0property\0val\0setValue\0"
"slotIntChanged\0slotEnumChanged\0"
"slotPropertyDestroyed\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtSizePolicyPropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
5, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
1, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 39, 2, 0x06,
// slots: name, argc, parameters, tag, flags
6, 2, 44, 2, 0x0a,
7, 2, 49, 2, 0x08,
8, 2, 54, 2, 0x08,
9, 1, 59, 2, 0x08,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QSizePolicy, 4, 5,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QSizePolicy, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 2, 2,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 2, 2,
QMetaType::Void, 0x80000000 | 3, 2,
0 // eod
};
void QtSizePolicyPropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtSizePolicyPropertyManager *_t = static_cast<QtSizePolicyPropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QSizePolicy(*)>(_a[2]))); break;
case 1: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QSizePolicy(*)>(_a[2]))); break;
case 2: _t->d_func()->slotIntChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 3: _t->d_func()->slotEnumChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 4: _t->d_func()->slotPropertyDestroyed((*reinterpret_cast< QtProperty*(*)>(_a[1]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtSizePolicyPropertyManager::*_t)(QtProperty * , const QSizePolicy & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtSizePolicyPropertyManager::valueChanged)) {
*result = 0;
}
}
}
}
const QMetaObject QtSizePolicyPropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtSizePolicyPropertyManager.data,
qt_meta_data_QtSizePolicyPropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtSizePolicyPropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtSizePolicyPropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtSizePolicyPropertyManager.stringdata))
return static_cast<void*>(const_cast< QtSizePolicyPropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtSizePolicyPropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 5)
qt_static_metacall(this, _c, _id, _a);
_id -= 5;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 5)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 5;
}
return _id;
}
// SIGNAL 0
void QtSizePolicyPropertyManager::valueChanged(QtProperty * _t1, const QSizePolicy & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_QtFontPropertyManager_t {
QByteArrayData data[13];
char stringdata[194];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtFontPropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtFontPropertyManager_t qt_meta_stringdata_QtFontPropertyManager = {
{
QT_MOC_LITERAL(0, 0, 21),
QT_MOC_LITERAL(1, 22, 12),
QT_MOC_LITERAL(2, 35, 0),
QT_MOC_LITERAL(3, 36, 11),
QT_MOC_LITERAL(4, 48, 8),
QT_MOC_LITERAL(5, 57, 3),
QT_MOC_LITERAL(6, 61, 8),
QT_MOC_LITERAL(7, 70, 14),
QT_MOC_LITERAL(8, 85, 15),
QT_MOC_LITERAL(9, 101, 15),
QT_MOC_LITERAL(10, 117, 21),
QT_MOC_LITERAL(11, 139, 23),
QT_MOC_LITERAL(12, 163, 29)
},
"QtFontPropertyManager\0valueChanged\0\0"
"QtProperty*\0property\0val\0setValue\0"
"slotIntChanged\0slotEnumChanged\0"
"slotBoolChanged\0slotPropertyDestroyed\0"
"slotFontDatabaseChanged\0"
"slotFontDatabaseDelayedChange\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtFontPropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
8, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
1, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 54, 2, 0x06,
// slots: name, argc, parameters, tag, flags
6, 2, 59, 2, 0x0a,
7, 2, 64, 2, 0x08,
8, 2, 69, 2, 0x08,
9, 2, 74, 2, 0x08,
10, 1, 79, 2, 0x08,
11, 0, 82, 2, 0x08,
12, 0, 83, 2, 0x08,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QFont, 4, 5,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QFont, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 2, 2,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 2, 2,
QMetaType::Void, 0x80000000 | 3, QMetaType::Bool, 2, 2,
QMetaType::Void, 0x80000000 | 3, 2,
QMetaType::Void,
QMetaType::Void,
0 // eod
};
void QtFontPropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtFontPropertyManager *_t = static_cast<QtFontPropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QFont(*)>(_a[2]))); break;
case 1: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QFont(*)>(_a[2]))); break;
case 2: _t->d_func()->slotIntChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 3: _t->d_func()->slotEnumChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 4: _t->d_func()->slotBoolChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
case 5: _t->d_func()->slotPropertyDestroyed((*reinterpret_cast< QtProperty*(*)>(_a[1]))); break;
case 6: _t->d_func()->slotFontDatabaseChanged(); break;
case 7: _t->d_func()->slotFontDatabaseDelayedChange(); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtFontPropertyManager::*_t)(QtProperty * , const QFont & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtFontPropertyManager::valueChanged)) {
*result = 0;
}
}
}
}
const QMetaObject QtFontPropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtFontPropertyManager.data,
qt_meta_data_QtFontPropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtFontPropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtFontPropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtFontPropertyManager.stringdata))
return static_cast<void*>(const_cast< QtFontPropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtFontPropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 8)
qt_static_metacall(this, _c, _id, _a);
_id -= 8;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 8)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 8;
}
return _id;
}
// SIGNAL 0
void QtFontPropertyManager::valueChanged(QtProperty * _t1, const QFont & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_QtColorPropertyManager_t {
QByteArrayData data[9];
char stringdata[109];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtColorPropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtColorPropertyManager_t qt_meta_stringdata_QtColorPropertyManager = {
{
QT_MOC_LITERAL(0, 0, 22),
QT_MOC_LITERAL(1, 23, 12),
QT_MOC_LITERAL(2, 36, 0),
QT_MOC_LITERAL(3, 37, 11),
QT_MOC_LITERAL(4, 49, 8),
QT_MOC_LITERAL(5, 58, 3),
QT_MOC_LITERAL(6, 62, 8),
QT_MOC_LITERAL(7, 71, 14),
QT_MOC_LITERAL(8, 86, 21)
},
"QtColorPropertyManager\0valueChanged\0"
"\0QtProperty*\0property\0val\0setValue\0"
"slotIntChanged\0slotPropertyDestroyed\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtColorPropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
4, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
1, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 34, 2, 0x06,
// slots: name, argc, parameters, tag, flags
6, 2, 39, 2, 0x0a,
7, 2, 44, 2, 0x08,
8, 1, 49, 2, 0x08,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QColor, 4, 5,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QColor, 4, 5,
QMetaType::Void, 0x80000000 | 3, QMetaType::Int, 2, 2,
QMetaType::Void, 0x80000000 | 3, 2,
0 // eod
};
void QtColorPropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtColorPropertyManager *_t = static_cast<QtColorPropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QColor(*)>(_a[2]))); break;
case 1: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QColor(*)>(_a[2]))); break;
case 2: _t->d_func()->slotIntChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 3: _t->d_func()->slotPropertyDestroyed((*reinterpret_cast< QtProperty*(*)>(_a[1]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtColorPropertyManager::*_t)(QtProperty * , const QColor & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtColorPropertyManager::valueChanged)) {
*result = 0;
}
}
}
}
const QMetaObject QtColorPropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtColorPropertyManager.data,
qt_meta_data_QtColorPropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtColorPropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtColorPropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtColorPropertyManager.stringdata))
return static_cast<void*>(const_cast< QtColorPropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtColorPropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 4)
qt_static_metacall(this, _c, _id, _a);
_id -= 4;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 4)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 4;
}
return _id;
}
// SIGNAL 0
void QtColorPropertyManager::valueChanged(QtProperty * _t1, const QColor & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_QtCursorPropertyManager_t {
QByteArrayData data[7];
char stringdata[73];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_QtCursorPropertyManager_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_QtCursorPropertyManager_t qt_meta_stringdata_QtCursorPropertyManager = {
{
QT_MOC_LITERAL(0, 0, 23),
QT_MOC_LITERAL(1, 24, 12),
QT_MOC_LITERAL(2, 37, 0),
QT_MOC_LITERAL(3, 38, 11),
QT_MOC_LITERAL(4, 50, 8),
QT_MOC_LITERAL(5, 59, 3),
QT_MOC_LITERAL(6, 63, 8)
},
"QtCursorPropertyManager\0valueChanged\0"
"\0QtProperty*\0property\0val\0setValue\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_QtCursorPropertyManager[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
2, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
1, // signalCount
// signals: name, argc, parameters, tag, flags
1, 2, 24, 2, 0x06,
// slots: name, argc, parameters, tag, flags
6, 2, 29, 2, 0x0a,
// signals: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QCursor, 4, 5,
// slots: parameters
QMetaType::Void, 0x80000000 | 3, QMetaType::QCursor, 4, 5,
0 // eod
};
void QtCursorPropertyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
QtCursorPropertyManager *_t = static_cast<QtCursorPropertyManager *>(_o);
switch (_id) {
case 0: _t->valueChanged((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QCursor(*)>(_a[2]))); break;
case 1: _t->setValue((*reinterpret_cast< QtProperty*(*)>(_a[1])),(*reinterpret_cast< const QCursor(*)>(_a[2]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (QtCursorPropertyManager::*_t)(QtProperty * , const QCursor & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&QtCursorPropertyManager::valueChanged)) {
*result = 0;
}
}
}
}
const QMetaObject QtCursorPropertyManager::staticMetaObject = {
{ &QtAbstractPropertyManager::staticMetaObject, qt_meta_stringdata_QtCursorPropertyManager.data,
qt_meta_data_QtCursorPropertyManager, qt_static_metacall, 0, 0}
};
const QMetaObject *QtCursorPropertyManager::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QtCursorPropertyManager::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QtCursorPropertyManager.stringdata))
return static_cast<void*>(const_cast< QtCursorPropertyManager*>(this));
return QtAbstractPropertyManager::qt_metacast(_clname);
}
int QtCursorPropertyManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QtAbstractPropertyManager::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;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 2)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 2;
}
return _id;
}
// SIGNAL 0
void QtCursorPropertyManager::valueChanged(QtProperty * _t1, const QCursor & _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
QT_END_MOC_NAMESPACE