CuteLogger
Fast and simple logging solution for Qt based applications
moc_qmlmetadata.cpp
1/****************************************************************************
2** Meta object code from reading C++ file 'qmlmetadata.h'
3**
4** Created by: The Qt Meta Object Compiler version 68 (Qt 6.6.2)
5**
6** WARNING! All changes made in this file will be lost!
7*****************************************************************************/
8
9#include "../../../../src/qmltypes/qmlmetadata.h"
10#include <QtCore/qmetatype.h>
11#include <QtCore/QList>
12
13#if __has_include(<QtCore/qtmochelpers.h>)
14#include <QtCore/qtmochelpers.h>
15#else
16QT_BEGIN_MOC_NAMESPACE
17#endif
18
19
20#include <memory>
21
22#if !defined(Q_MOC_OUTPUT_REVISION)
23#error "The header file 'qmlmetadata.h' doesn't include <QObject>."
24#elif Q_MOC_OUTPUT_REVISION != 68
25#error "This file was generated using the moc from 6.6.2. It"
26#error "cannot be used with the include files from this version of Qt."
27#error "(The moc has changed too much.)"
28#endif
29
30#ifndef Q_CONSTINIT
31#define Q_CONSTINIT
32#endif
33
34QT_WARNING_PUSH
35QT_WARNING_DISABLE_DEPRECATED
36QT_WARNING_DISABLE_GCC("-Wuseless-cast")
37namespace {
38
39#ifdef QT_MOC_HAS_STRINGDATA
40struct qt_meta_stringdata_CLASSQmlKeyframesParameterENDCLASS_t {};
41constexpr auto qt_meta_stringdata_CLASSQmlKeyframesParameterENDCLASS = QtMocHelpers::stringData(
42 "QmlKeyframesParameter",
43 "changed",
44 "",
45 "rangeType",
46 "RangeType",
47 "name",
48 "property",
49 "gangedProperties",
50 "isCurve",
51 "minimum",
52 "maximum",
53 "units",
54 "isRectangle",
55 "isColor",
56 "MinMax",
57 "ClipLength"
58);
59#else // !QT_MOC_HAS_STRING_DATA
60struct qt_meta_stringdata_CLASSQmlKeyframesParameterENDCLASS_t {
61 uint offsetsAndSizes[32];
62 char stringdata0[22];
63 char stringdata1[8];
64 char stringdata2[1];
65 char stringdata3[10];
66 char stringdata4[10];
67 char stringdata5[5];
68 char stringdata6[9];
69 char stringdata7[17];
70 char stringdata8[8];
71 char stringdata9[8];
72 char stringdata10[8];
73 char stringdata11[6];
74 char stringdata12[12];
75 char stringdata13[8];
76 char stringdata14[7];
77 char stringdata15[11];
78};
79#define QT_MOC_LITERAL(ofs, len) \
80 uint(sizeof(qt_meta_stringdata_CLASSQmlKeyframesParameterENDCLASS_t::offsetsAndSizes) + ofs), len
81Q_CONSTINIT static const qt_meta_stringdata_CLASSQmlKeyframesParameterENDCLASS_t qt_meta_stringdata_CLASSQmlKeyframesParameterENDCLASS = {
82 {
83 QT_MOC_LITERAL(0, 21), // "QmlKeyframesParameter"
84 QT_MOC_LITERAL(22, 7), // "changed"
85 QT_MOC_LITERAL(30, 0), // ""
86 QT_MOC_LITERAL(31, 9), // "rangeType"
87 QT_MOC_LITERAL(41, 9), // "RangeType"
88 QT_MOC_LITERAL(51, 4), // "name"
89 QT_MOC_LITERAL(56, 8), // "property"
90 QT_MOC_LITERAL(65, 16), // "gangedProperties"
91 QT_MOC_LITERAL(82, 7), // "isCurve"
92 QT_MOC_LITERAL(90, 7), // "minimum"
93 QT_MOC_LITERAL(98, 7), // "maximum"
94 QT_MOC_LITERAL(106, 5), // "units"
95 QT_MOC_LITERAL(112, 11), // "isRectangle"
96 QT_MOC_LITERAL(124, 7), // "isColor"
97 QT_MOC_LITERAL(132, 6), // "MinMax"
98 QT_MOC_LITERAL(139, 10) // "ClipLength"
99 },
100 "QmlKeyframesParameter",
101 "changed",
102 "",
103 "rangeType",
104 "RangeType",
105 "name",
106 "property",
107 "gangedProperties",
108 "isCurve",
109 "minimum",
110 "maximum",
111 "units",
112 "isRectangle",
113 "isColor",
114 "MinMax",
115 "ClipLength"
116};
117#undef QT_MOC_LITERAL
118#endif // !QT_MOC_HAS_STRING_DATA
119} // unnamed namespace
120
121Q_CONSTINIT static const uint qt_meta_data_CLASSQmlKeyframesParameterENDCLASS[] = {
122
123 // content:
124 12, // revision
125 0, // classname
126 0, 0, // classinfo
127 1, 14, // methods
128 10, 21, // properties
129 1, 71, // enums/sets
130 0, 0, // constructors
131 0, // flags
132 1, // signalCount
133
134 // signals: name, argc, parameters, tag, flags, initial metatype offsets
135 1, 0, 20, 2, 0x06, 12 /* Public */,
136
137 // signals: parameters
138 QMetaType::Void,
139
140 // properties: name, type, flags
141 3, 0x80000000 | 4, 0x0001500b, uint(0), 0,
142 5, QMetaType::QString, 0x00015003, uint(0), 0,
143 6, QMetaType::QString, 0x00015003, uint(0), 0,
144 7, QMetaType::QStringList, 0x00015003, uint(0), 0,
145 8, QMetaType::Bool, 0x00015003, uint(0), 0,
146 9, QMetaType::Double, 0x00015003, uint(0), 0,
147 10, QMetaType::Double, 0x00015003, uint(0), 0,
148 11, QMetaType::QString, 0x00015003, uint(0), 0,
149 12, QMetaType::Bool, 0x00015003, uint(0), 0,
150 13, QMetaType::Bool, 0x00015003, uint(0), 0,
151
152 // enums: name, alias, flags, count, data
153 4, 4, 0x0, 2, 76,
154
155 // enum data: key, value
156 14, uint(QmlKeyframesParameter::MinMax),
157 15, uint(QmlKeyframesParameter::ClipLength),
158
159 0 // eod
160};
161
162Q_CONSTINIT const QMetaObject QmlKeyframesParameter::staticMetaObject = { {
163 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
164 qt_meta_stringdata_CLASSQmlKeyframesParameterENDCLASS.offsetsAndSizes,
165 qt_meta_data_CLASSQmlKeyframesParameterENDCLASS,
166 qt_static_metacall,
167 nullptr,
168 qt_incomplete_metaTypeArray<qt_meta_stringdata_CLASSQmlKeyframesParameterENDCLASS_t,
169 // property 'rangeType'
170 QtPrivate::TypeAndForceComplete<RangeType, std::true_type>,
171 // property 'name'
172 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
173 // property 'property'
174 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
175 // property 'gangedProperties'
176 QtPrivate::TypeAndForceComplete<QStringList, std::true_type>,
177 // property 'isCurve'
178 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
179 // property 'minimum'
180 QtPrivate::TypeAndForceComplete<double, std::true_type>,
181 // property 'maximum'
182 QtPrivate::TypeAndForceComplete<double, std::true_type>,
183 // property 'units'
184 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
185 // property 'isRectangle'
186 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
187 // property 'isColor'
188 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
189 // enum 'RangeType'
190 QtPrivate::TypeAndForceComplete<QmlKeyframesParameter::RangeType, std::true_type>,
191 // Q_OBJECT / Q_GADGET
192 QtPrivate::TypeAndForceComplete<QmlKeyframesParameter, std::true_type>,
193 // method 'changed'
194 QtPrivate::TypeAndForceComplete<void, std::false_type>
195 >,
196 nullptr
197} };
198
199void QmlKeyframesParameter::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
200{
201 if (_c == QMetaObject::InvokeMetaMethod) {
202 auto *_t = static_cast<QmlKeyframesParameter *>(_o);
203 (void)_t;
204 switch (_id) {
205 case 0: _t->changed(); break;
206 default: ;
207 }
208 } else if (_c == QMetaObject::IndexOfMethod) {
209 int *result = reinterpret_cast<int *>(_a[0]);
210 {
211 using _t = void (QmlKeyframesParameter::*)();
212 if (_t _q_method = &QmlKeyframesParameter::changed; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
213 *result = 0;
214 return;
215 }
216 }
217 } else if (_c == QMetaObject::ReadProperty) {
218 auto *_t = static_cast<QmlKeyframesParameter *>(_o);
219 (void)_t;
220 void *_v = _a[0];
221 switch (_id) {
222 case 0: *reinterpret_cast< RangeType*>(_v) = _t->m_rangeType; break;
223 case 1: *reinterpret_cast< QString*>(_v) = _t->m_name; break;
224 case 2: *reinterpret_cast< QString*>(_v) = _t->m_property; break;
225 case 3: *reinterpret_cast< QStringList*>(_v) = _t->m_gangedProperties; break;
226 case 4: *reinterpret_cast< bool*>(_v) = _t->m_isCurve; break;
227 case 5: *reinterpret_cast< double*>(_v) = _t->m_minimum; break;
228 case 6: *reinterpret_cast< double*>(_v) = _t->m_maximum; break;
229 case 7: *reinterpret_cast< QString*>(_v) = _t->m_units; break;
230 case 8: *reinterpret_cast< bool*>(_v) = _t->m_isRectangle; break;
231 case 9: *reinterpret_cast< bool*>(_v) = _t->m_isColor; break;
232 default: break;
233 }
234 } else if (_c == QMetaObject::WriteProperty) {
235 auto *_t = static_cast<QmlKeyframesParameter *>(_o);
236 (void)_t;
237 void *_v = _a[0];
238 switch (_id) {
239 case 0:
240 if (_t->m_rangeType != *reinterpret_cast< RangeType*>(_v)) {
241 _t->m_rangeType = *reinterpret_cast< RangeType*>(_v);
242 Q_EMIT _t->changed();
243 }
244 break;
245 case 1:
246 if (_t->m_name != *reinterpret_cast< QString*>(_v)) {
247 _t->m_name = *reinterpret_cast< QString*>(_v);
248 Q_EMIT _t->changed();
249 }
250 break;
251 case 2:
252 if (_t->m_property != *reinterpret_cast< QString*>(_v)) {
253 _t->m_property = *reinterpret_cast< QString*>(_v);
254 Q_EMIT _t->changed();
255 }
256 break;
257 case 3:
258 if (_t->m_gangedProperties != *reinterpret_cast< QStringList*>(_v)) {
259 _t->m_gangedProperties = *reinterpret_cast< QStringList*>(_v);
260 Q_EMIT _t->changed();
261 }
262 break;
263 case 4:
264 if (_t->m_isCurve != *reinterpret_cast< bool*>(_v)) {
265 _t->m_isCurve = *reinterpret_cast< bool*>(_v);
266 Q_EMIT _t->changed();
267 }
268 break;
269 case 5:
270 if (_t->m_minimum != *reinterpret_cast< double*>(_v)) {
271 _t->m_minimum = *reinterpret_cast< double*>(_v);
272 Q_EMIT _t->changed();
273 }
274 break;
275 case 6:
276 if (_t->m_maximum != *reinterpret_cast< double*>(_v)) {
277 _t->m_maximum = *reinterpret_cast< double*>(_v);
278 Q_EMIT _t->changed();
279 }
280 break;
281 case 7:
282 if (_t->m_units != *reinterpret_cast< QString*>(_v)) {
283 _t->m_units = *reinterpret_cast< QString*>(_v);
284 Q_EMIT _t->changed();
285 }
286 break;
287 case 8:
288 if (_t->m_isRectangle != *reinterpret_cast< bool*>(_v)) {
289 _t->m_isRectangle = *reinterpret_cast< bool*>(_v);
290 Q_EMIT _t->changed();
291 }
292 break;
293 case 9:
294 if (_t->m_isColor != *reinterpret_cast< bool*>(_v)) {
295 _t->m_isColor = *reinterpret_cast< bool*>(_v);
296 Q_EMIT _t->changed();
297 }
298 break;
299 default: break;
300 }
301 } else if (_c == QMetaObject::ResetProperty) {
302 } else if (_c == QMetaObject::BindableProperty) {
303 }
304 (void)_a;
305}
306
307const QMetaObject *QmlKeyframesParameter::metaObject() const
308{
309 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
310}
311
312void *QmlKeyframesParameter::qt_metacast(const char *_clname)
313{
314 if (!_clname) return nullptr;
315 if (!strcmp(_clname, qt_meta_stringdata_CLASSQmlKeyframesParameterENDCLASS.stringdata0))
316 return static_cast<void*>(this);
317 return QObject::qt_metacast(_clname);
318}
319
320int QmlKeyframesParameter::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
321{
322 _id = QObject::qt_metacall(_c, _id, _a);
323 if (_id < 0)
324 return _id;
325 if (_c == QMetaObject::InvokeMetaMethod) {
326 if (_id < 1)
327 qt_static_metacall(this, _c, _id, _a);
328 _id -= 1;
329 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
330 if (_id < 1)
331 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
332 _id -= 1;
333 }else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
334 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
335 || _c == QMetaObject::RegisterPropertyMetaType) {
336 qt_static_metacall(this, _c, _id, _a);
337 _id -= 10;
338 }
339 return _id;
340}
341
342// SIGNAL 0
343void QmlKeyframesParameter::changed()
344{
345 QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
346}
347namespace {
348
349#ifdef QT_MOC_HAS_STRINGDATA
350struct qt_meta_stringdata_CLASSQmlKeyframesMetadataENDCLASS_t {};
351constexpr auto qt_meta_stringdata_CLASSQmlKeyframesMetadataENDCLASS = QtMocHelpers::stringData(
352 "QmlKeyframesMetadata",
353 "changed",
354 "",
355 "parameter",
356 "QmlKeyframesParameter*",
357 "propertyName",
358 "allowTrim",
359 "allowAnimateIn",
360 "allowAnimateOut",
361 "parameters",
362 "QQmlListProperty<QmlKeyframesParameter>",
363 "simpleProperties",
364 "minimumVersion",
365 "enabled",
366 "allowOvershoot"
367);
368#else // !QT_MOC_HAS_STRING_DATA
369struct qt_meta_stringdata_CLASSQmlKeyframesMetadataENDCLASS_t {
370 uint offsetsAndSizes[30];
371 char stringdata0[21];
372 char stringdata1[8];
373 char stringdata2[1];
374 char stringdata3[10];
375 char stringdata4[23];
376 char stringdata5[13];
377 char stringdata6[10];
378 char stringdata7[15];
379 char stringdata8[16];
380 char stringdata9[11];
381 char stringdata10[40];
382 char stringdata11[17];
383 char stringdata12[15];
384 char stringdata13[8];
385 char stringdata14[15];
386};
387#define QT_MOC_LITERAL(ofs, len) \
388 uint(sizeof(qt_meta_stringdata_CLASSQmlKeyframesMetadataENDCLASS_t::offsetsAndSizes) + ofs), len
389Q_CONSTINIT static const qt_meta_stringdata_CLASSQmlKeyframesMetadataENDCLASS_t qt_meta_stringdata_CLASSQmlKeyframesMetadataENDCLASS = {
390 {
391 QT_MOC_LITERAL(0, 20), // "QmlKeyframesMetadata"
392 QT_MOC_LITERAL(21, 7), // "changed"
393 QT_MOC_LITERAL(29, 0), // ""
394 QT_MOC_LITERAL(30, 9), // "parameter"
395 QT_MOC_LITERAL(40, 22), // "QmlKeyframesParameter*"
396 QT_MOC_LITERAL(63, 12), // "propertyName"
397 QT_MOC_LITERAL(76, 9), // "allowTrim"
398 QT_MOC_LITERAL(86, 14), // "allowAnimateIn"
399 QT_MOC_LITERAL(101, 15), // "allowAnimateOut"
400 QT_MOC_LITERAL(117, 10), // "parameters"
401 QT_MOC_LITERAL(128, 39), // "QQmlListProperty<QmlKeyframes..."
402 QT_MOC_LITERAL(168, 16), // "simpleProperties"
403 QT_MOC_LITERAL(185, 14), // "minimumVersion"
404 QT_MOC_LITERAL(200, 7), // "enabled"
405 QT_MOC_LITERAL(208, 14) // "allowOvershoot"
406 },
407 "QmlKeyframesMetadata",
408 "changed",
409 "",
410 "parameter",
411 "QmlKeyframesParameter*",
412 "propertyName",
413 "allowTrim",
414 "allowAnimateIn",
415 "allowAnimateOut",
416 "parameters",
417 "QQmlListProperty<QmlKeyframesParameter>",
418 "simpleProperties",
419 "minimumVersion",
420 "enabled",
421 "allowOvershoot"
422};
423#undef QT_MOC_LITERAL
424#endif // !QT_MOC_HAS_STRING_DATA
425} // unnamed namespace
426
427Q_CONSTINIT static const uint qt_meta_data_CLASSQmlKeyframesMetadataENDCLASS[] = {
428
429 // content:
430 12, // revision
431 0, // classname
432 0, 0, // classinfo
433 2, 14, // methods
434 8, 30, // properties
435 0, 0, // enums/sets
436 0, 0, // constructors
437 0, // flags
438 1, // signalCount
439
440 // signals: name, argc, parameters, tag, flags, initial metatype offsets
441 1, 0, 26, 2, 0x06, 9 /* Public */,
442
443 // methods: name, argc, parameters, tag, flags, initial metatype offsets
444 3, 1, 27, 2, 0x102, 10 /* Public | MethodIsConst */,
445
446 // signals: parameters
447 QMetaType::Void,
448
449 // methods: parameters
450 0x80000000 | 4, QMetaType::QString, 5,
451
452 // properties: name, type, flags
453 6, QMetaType::Bool, 0x00015003, uint(0), 0,
454 7, QMetaType::Bool, 0x00015003, uint(0), 0,
455 8, QMetaType::Bool, 0x00015003, uint(0), 0,
456 9, 0x80000000 | 10, 0x00015009, uint(0), 0,
457 11, QMetaType::QStringList, 0x00015003, uint(0), 0,
458 12, QMetaType::QString, 0x00015003, uint(0), 0,
459 13, QMetaType::Bool, 0x00015003, uint(0), 0,
460 14, QMetaType::Bool, 0x00015003, uint(0), 0,
461
462 0 // eod
463};
464
465Q_CONSTINIT const QMetaObject QmlKeyframesMetadata::staticMetaObject = { {
466 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
467 qt_meta_stringdata_CLASSQmlKeyframesMetadataENDCLASS.offsetsAndSizes,
468 qt_meta_data_CLASSQmlKeyframesMetadataENDCLASS,
469 qt_static_metacall,
470 nullptr,
471 qt_incomplete_metaTypeArray<qt_meta_stringdata_CLASSQmlKeyframesMetadataENDCLASS_t,
472 // property 'allowTrim'
473 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
474 // property 'allowAnimateIn'
475 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
476 // property 'allowAnimateOut'
477 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
478 // property 'parameters'
479 QtPrivate::TypeAndForceComplete<QQmlListProperty<QmlKeyframesParameter>, std::true_type>,
480 // property 'simpleProperties'
481 QtPrivate::TypeAndForceComplete<QList<QString>, std::true_type>,
482 // property 'minimumVersion'
483 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
484 // property 'enabled'
485 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
486 // property 'allowOvershoot'
487 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
488 // Q_OBJECT / Q_GADGET
489 QtPrivate::TypeAndForceComplete<QmlKeyframesMetadata, std::true_type>,
490 // method 'changed'
491 QtPrivate::TypeAndForceComplete<void, std::false_type>,
492 // method 'parameter'
493 QtPrivate::TypeAndForceComplete<QmlKeyframesParameter *, std::false_type>,
494 QtPrivate::TypeAndForceComplete<const QString &, std::false_type>
495 >,
496 nullptr
497} };
498
499void QmlKeyframesMetadata::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
500{
501 if (_c == QMetaObject::InvokeMetaMethod) {
502 auto *_t = static_cast<QmlKeyframesMetadata *>(_o);
503 (void)_t;
504 switch (_id) {
505 case 0: _t->changed(); break;
506 case 1: { QmlKeyframesParameter* _r = _t->parameter((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1])));
507 if (_a[0]) *reinterpret_cast< QmlKeyframesParameter**>(_a[0]) = std::move(_r); } break;
508 default: ;
509 }
510 } else if (_c == QMetaObject::IndexOfMethod) {
511 int *result = reinterpret_cast<int *>(_a[0]);
512 {
513 using _t = void (QmlKeyframesMetadata::*)();
514 if (_t _q_method = &QmlKeyframesMetadata::changed; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
515 *result = 0;
516 return;
517 }
518 }
519 } else if (_c == QMetaObject::ReadProperty) {
520 auto *_t = static_cast<QmlKeyframesMetadata *>(_o);
521 (void)_t;
522 void *_v = _a[0];
523 switch (_id) {
524 case 0: *reinterpret_cast< bool*>(_v) = _t->m_allowTrim; break;
525 case 1: *reinterpret_cast< bool*>(_v) = _t->m_allowAnimateIn; break;
526 case 2: *reinterpret_cast< bool*>(_v) = _t->m_allowAnimateOut; break;
527 case 3: *reinterpret_cast< QQmlListProperty<QmlKeyframesParameter>*>(_v) = _t->parameters(); break;
528 case 4: *reinterpret_cast< QList<QString>*>(_v) = _t->m_simpleProperties; break;
529 case 5: *reinterpret_cast< QString*>(_v) = _t->m_minimumVersion; break;
530 case 6: *reinterpret_cast< bool*>(_v) = _t->m_enabled; break;
531 case 7: *reinterpret_cast< bool*>(_v) = _t->m_allowOvershoot; break;
532 default: break;
533 }
534 } else if (_c == QMetaObject::WriteProperty) {
535 auto *_t = static_cast<QmlKeyframesMetadata *>(_o);
536 (void)_t;
537 void *_v = _a[0];
538 switch (_id) {
539 case 0:
540 if (_t->m_allowTrim != *reinterpret_cast< bool*>(_v)) {
541 _t->m_allowTrim = *reinterpret_cast< bool*>(_v);
542 Q_EMIT _t->changed();
543 }
544 break;
545 case 1:
546 if (_t->m_allowAnimateIn != *reinterpret_cast< bool*>(_v)) {
547 _t->m_allowAnimateIn = *reinterpret_cast< bool*>(_v);
548 Q_EMIT _t->changed();
549 }
550 break;
551 case 2:
552 if (_t->m_allowAnimateOut != *reinterpret_cast< bool*>(_v)) {
553 _t->m_allowAnimateOut = *reinterpret_cast< bool*>(_v);
554 Q_EMIT _t->changed();
555 }
556 break;
557 case 4:
558 if (_t->m_simpleProperties != *reinterpret_cast< QList<QString>*>(_v)) {
559 _t->m_simpleProperties = *reinterpret_cast< QList<QString>*>(_v);
560 Q_EMIT _t->changed();
561 }
562 break;
563 case 5:
564 if (_t->m_minimumVersion != *reinterpret_cast< QString*>(_v)) {
565 _t->m_minimumVersion = *reinterpret_cast< QString*>(_v);
566 Q_EMIT _t->changed();
567 }
568 break;
569 case 6:
570 if (_t->m_enabled != *reinterpret_cast< bool*>(_v)) {
571 _t->m_enabled = *reinterpret_cast< bool*>(_v);
572 Q_EMIT _t->changed();
573 }
574 break;
575 case 7:
576 if (_t->m_allowOvershoot != *reinterpret_cast< bool*>(_v)) {
577 _t->m_allowOvershoot = *reinterpret_cast< bool*>(_v);
578 Q_EMIT _t->changed();
579 }
580 break;
581 default: break;
582 }
583 } else if (_c == QMetaObject::ResetProperty) {
584 } else if (_c == QMetaObject::BindableProperty) {
585 }
586}
587
588const QMetaObject *QmlKeyframesMetadata::metaObject() const
589{
590 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
591}
592
593void *QmlKeyframesMetadata::qt_metacast(const char *_clname)
594{
595 if (!_clname) return nullptr;
596 if (!strcmp(_clname, qt_meta_stringdata_CLASSQmlKeyframesMetadataENDCLASS.stringdata0))
597 return static_cast<void*>(this);
598 return QObject::qt_metacast(_clname);
599}
600
601int QmlKeyframesMetadata::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
602{
603 _id = QObject::qt_metacall(_c, _id, _a);
604 if (_id < 0)
605 return _id;
606 if (_c == QMetaObject::InvokeMetaMethod) {
607 if (_id < 2)
608 qt_static_metacall(this, _c, _id, _a);
609 _id -= 2;
610 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
611 if (_id < 2)
612 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
613 _id -= 2;
614 }else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
615 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
616 || _c == QMetaObject::RegisterPropertyMetaType) {
617 qt_static_metacall(this, _c, _id, _a);
618 _id -= 8;
619 }
620 return _id;
621}
622
623// SIGNAL 0
624void QmlKeyframesMetadata::changed()
625{
626 QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
627}
628namespace {
629
630#ifdef QT_MOC_HAS_STRINGDATA
631struct qt_meta_stringdata_CLASSQmlMetadataENDCLASS_t {};
632constexpr auto qt_meta_stringdata_CLASSQmlMetadataENDCLASS = QtMocHelpers::stringData(
633 "QmlMetadata",
634 "changed",
635 "",
636 "type",
637 "PluginType",
638 "name",
639 "mlt_service",
640 "needsGPU",
641 "qml",
642 "vui",
643 "qmlFilePath",
644 "vuiFilePath",
645 "isAudio",
646 "isHidden",
647 "isFavorite",
648 "gpuAlt",
649 "allowMultiple",
650 "isClipOnly",
651 "isTrackOnly",
652 "isOutputOnly",
653 "isGpuCompatible",
654 "keyframes",
655 "QmlKeyframesMetadata*",
656 "isDeprecated",
657 "minimumVersion",
658 "keywords",
659 "icon",
660 "seekReverse",
661 "Filter",
662 "Producer",
663 "Transition",
664 "Link",
665 "FilterSet"
666);
667#else // !QT_MOC_HAS_STRING_DATA
668struct qt_meta_stringdata_CLASSQmlMetadataENDCLASS_t {
669 uint offsetsAndSizes[66];
670 char stringdata0[12];
671 char stringdata1[8];
672 char stringdata2[1];
673 char stringdata3[5];
674 char stringdata4[11];
675 char stringdata5[5];
676 char stringdata6[12];
677 char stringdata7[9];
678 char stringdata8[4];
679 char stringdata9[4];
680 char stringdata10[12];
681 char stringdata11[12];
682 char stringdata12[8];
683 char stringdata13[9];
684 char stringdata14[11];
685 char stringdata15[7];
686 char stringdata16[14];
687 char stringdata17[11];
688 char stringdata18[12];
689 char stringdata19[13];
690 char stringdata20[16];
691 char stringdata21[10];
692 char stringdata22[22];
693 char stringdata23[13];
694 char stringdata24[15];
695 char stringdata25[9];
696 char stringdata26[5];
697 char stringdata27[12];
698 char stringdata28[7];
699 char stringdata29[9];
700 char stringdata30[11];
701 char stringdata31[5];
702 char stringdata32[10];
703};
704#define QT_MOC_LITERAL(ofs, len) \
705 uint(sizeof(qt_meta_stringdata_CLASSQmlMetadataENDCLASS_t::offsetsAndSizes) + ofs), len
706Q_CONSTINIT static const qt_meta_stringdata_CLASSQmlMetadataENDCLASS_t qt_meta_stringdata_CLASSQmlMetadataENDCLASS = {
707 {
708 QT_MOC_LITERAL(0, 11), // "QmlMetadata"
709 QT_MOC_LITERAL(12, 7), // "changed"
710 QT_MOC_LITERAL(20, 0), // ""
711 QT_MOC_LITERAL(21, 4), // "type"
712 QT_MOC_LITERAL(26, 10), // "PluginType"
713 QT_MOC_LITERAL(37, 4), // "name"
714 QT_MOC_LITERAL(42, 11), // "mlt_service"
715 QT_MOC_LITERAL(54, 8), // "needsGPU"
716 QT_MOC_LITERAL(63, 3), // "qml"
717 QT_MOC_LITERAL(67, 3), // "vui"
718 QT_MOC_LITERAL(71, 11), // "qmlFilePath"
719 QT_MOC_LITERAL(83, 11), // "vuiFilePath"
720 QT_MOC_LITERAL(95, 7), // "isAudio"
721 QT_MOC_LITERAL(103, 8), // "isHidden"
722 QT_MOC_LITERAL(112, 10), // "isFavorite"
723 QT_MOC_LITERAL(123, 6), // "gpuAlt"
724 QT_MOC_LITERAL(130, 13), // "allowMultiple"
725 QT_MOC_LITERAL(144, 10), // "isClipOnly"
726 QT_MOC_LITERAL(155, 11), // "isTrackOnly"
727 QT_MOC_LITERAL(167, 12), // "isOutputOnly"
728 QT_MOC_LITERAL(180, 15), // "isGpuCompatible"
729 QT_MOC_LITERAL(196, 9), // "keyframes"
730 QT_MOC_LITERAL(206, 21), // "QmlKeyframesMetadata*"
731 QT_MOC_LITERAL(228, 12), // "isDeprecated"
732 QT_MOC_LITERAL(241, 14), // "minimumVersion"
733 QT_MOC_LITERAL(256, 8), // "keywords"
734 QT_MOC_LITERAL(265, 4), // "icon"
735 QT_MOC_LITERAL(270, 11), // "seekReverse"
736 QT_MOC_LITERAL(282, 6), // "Filter"
737 QT_MOC_LITERAL(289, 8), // "Producer"
738 QT_MOC_LITERAL(298, 10), // "Transition"
739 QT_MOC_LITERAL(309, 4), // "Link"
740 QT_MOC_LITERAL(314, 9) // "FilterSet"
741 },
742 "QmlMetadata",
743 "changed",
744 "",
745 "type",
746 "PluginType",
747 "name",
748 "mlt_service",
749 "needsGPU",
750 "qml",
751 "vui",
752 "qmlFilePath",
753 "vuiFilePath",
754 "isAudio",
755 "isHidden",
756 "isFavorite",
757 "gpuAlt",
758 "allowMultiple",
759 "isClipOnly",
760 "isTrackOnly",
761 "isOutputOnly",
762 "isGpuCompatible",
763 "keyframes",
764 "QmlKeyframesMetadata*",
765 "isDeprecated",
766 "minimumVersion",
767 "keywords",
768 "icon",
769 "seekReverse",
770 "Filter",
771 "Producer",
772 "Transition",
773 "Link",
774 "FilterSet"
775};
776#undef QT_MOC_LITERAL
777#endif // !QT_MOC_HAS_STRING_DATA
778} // unnamed namespace
779
780Q_CONSTINIT static const uint qt_meta_data_CLASSQmlMetadataENDCLASS[] = {
781
782 // content:
783 12, // revision
784 0, // classname
785 0, 0, // classinfo
786 1, 14, // methods
787 23, 21, // properties
788 1, 136, // enums/sets
789 0, 0, // constructors
790 0, // flags
791 1, // signalCount
792
793 // signals: name, argc, parameters, tag, flags, initial metatype offsets
794 1, 0, 20, 2, 0x06, 25 /* Public */,
795
796 // signals: parameters
797 QMetaType::Void,
798
799 // properties: name, type, flags
800 3, 0x80000000 | 4, 0x0001510b, uint(0), 0,
801 5, QMetaType::QString, 0x00015103, uint(0), 0,
802 6, QMetaType::QString, 0x00015003, uint(0), 0,
803 7, QMetaType::Bool, 0x00015103, uint(0), 0,
804 8, QMetaType::QString, 0x00015003, uint(0), 0,
805 9, QMetaType::QString, 0x00015003, uint(0), 0,
806 10, QMetaType::QUrl, 0x00015001, uint(0), 0,
807 11, QMetaType::QUrl, 0x00015001, uint(0), 0,
808 12, QMetaType::Bool, 0x00015103, uint(0), 0,
809 13, QMetaType::Bool, 0x00015103, uint(0), 0,
810 14, QMetaType::Bool, 0x00015103, uint(0), 0,
811 15, QMetaType::QString, 0x00015103, uint(0), 0,
812 16, QMetaType::Bool, 0x00015103, uint(0), 0,
813 17, QMetaType::Bool, 0x00015103, uint(0), 0,
814 18, QMetaType::Bool, 0x00015103, uint(0), 0,
815 19, QMetaType::Bool, 0x00015103, uint(0), 0,
816 20, QMetaType::Bool, 0x00015103, uint(0), 0,
817 21, 0x80000000 | 22, 0x00015009, uint(0), 0,
818 23, QMetaType::Bool, 0x00015103, uint(0), 0,
819 24, QMetaType::QString, 0x00015003, uint(0), 0,
820 25, QMetaType::QString, 0x00015003, uint(0), 0,
821 26, QMetaType::QString, 0x00015003, uint(0), 0,
822 27, QMetaType::Bool, 0x00015003, uint(0), 0,
823
824 // enums: name, alias, flags, count, data
825 4, 4, 0x0, 5, 141,
826
827 // enum data: key, value
828 28, uint(QmlMetadata::Filter),
829 29, uint(QmlMetadata::Producer),
830 30, uint(QmlMetadata::Transition),
831 31, uint(QmlMetadata::Link),
832 32, uint(QmlMetadata::FilterSet),
833
834 0 // eod
835};
836
837Q_CONSTINIT const QMetaObject QmlMetadata::staticMetaObject = { {
838 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
839 qt_meta_stringdata_CLASSQmlMetadataENDCLASS.offsetsAndSizes,
840 qt_meta_data_CLASSQmlMetadataENDCLASS,
841 qt_static_metacall,
842 nullptr,
843 qt_incomplete_metaTypeArray<qt_meta_stringdata_CLASSQmlMetadataENDCLASS_t,
844 // property 'type'
845 QtPrivate::TypeAndForceComplete<PluginType, std::true_type>,
846 // property 'name'
847 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
848 // property 'mlt_service'
849 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
850 // property 'needsGPU'
851 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
852 // property 'qml'
853 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
854 // property 'vui'
855 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
856 // property 'qmlFilePath'
857 QtPrivate::TypeAndForceComplete<QUrl, std::true_type>,
858 // property 'vuiFilePath'
859 QtPrivate::TypeAndForceComplete<QUrl, std::true_type>,
860 // property 'isAudio'
861 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
862 // property 'isHidden'
863 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
864 // property 'isFavorite'
865 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
866 // property 'gpuAlt'
867 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
868 // property 'allowMultiple'
869 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
870 // property 'isClipOnly'
871 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
872 // property 'isTrackOnly'
873 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
874 // property 'isOutputOnly'
875 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
876 // property 'isGpuCompatible'
877 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
878 // property 'keyframes'
879 QtPrivate::TypeAndForceComplete<QmlKeyframesMetadata*, std::true_type>,
880 // property 'isDeprecated'
881 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
882 // property 'minimumVersion'
883 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
884 // property 'keywords'
885 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
886 // property 'icon'
887 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
888 // property 'seekReverse'
889 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
890 // enum 'PluginType'
891 QtPrivate::TypeAndForceComplete<QmlMetadata::PluginType, std::true_type>,
892 // Q_OBJECT / Q_GADGET
893 QtPrivate::TypeAndForceComplete<QmlMetadata, std::true_type>,
894 // method 'changed'
895 QtPrivate::TypeAndForceComplete<void, std::false_type>
896 >,
897 nullptr
898} };
899
900void QmlMetadata::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
901{
902 if (_c == QMetaObject::InvokeMetaMethod) {
903 auto *_t = static_cast<QmlMetadata *>(_o);
904 (void)_t;
905 switch (_id) {
906 case 0: _t->changed(); break;
907 default: ;
908 }
909 } else if (_c == QMetaObject::IndexOfMethod) {
910 int *result = reinterpret_cast<int *>(_a[0]);
911 {
912 using _t = void (QmlMetadata::*)();
913 if (_t _q_method = &QmlMetadata::changed; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
914 *result = 0;
915 return;
916 }
917 }
918 } else if (_c == QMetaObject::RegisterPropertyMetaType) {
919 switch (_id) {
920 default: *reinterpret_cast<int*>(_a[0]) = -1; break;
921 case 17:
922 *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QmlKeyframesMetadata* >(); break;
923 }
924 } else if (_c == QMetaObject::ReadProperty) {
925 auto *_t = static_cast<QmlMetadata *>(_o);
926 (void)_t;
927 void *_v = _a[0];
928 switch (_id) {
929 case 0: *reinterpret_cast< PluginType*>(_v) = _t->type(); break;
930 case 1: *reinterpret_cast< QString*>(_v) = _t->name(); break;
931 case 2: *reinterpret_cast< QString*>(_v) = _t->mlt_service(); break;
932 case 3: *reinterpret_cast< bool*>(_v) = _t->needsGPU(); break;
933 case 4: *reinterpret_cast< QString*>(_v) = _t->qmlFileName(); break;
934 case 5: *reinterpret_cast< QString*>(_v) = _t->vuiFileName(); break;
935 case 6: *reinterpret_cast< QUrl*>(_v) = _t->qmlFilePath(); break;
936 case 7: *reinterpret_cast< QUrl*>(_v) = _t->vuiFilePath(); break;
937 case 8: *reinterpret_cast< bool*>(_v) = _t->isAudio(); break;
938 case 9: *reinterpret_cast< bool*>(_v) = _t->isHidden(); break;
939 case 10: *reinterpret_cast< bool*>(_v) = _t->isFavorite(); break;
940 case 11: *reinterpret_cast< QString*>(_v) = _t->gpuAlt(); break;
941 case 12: *reinterpret_cast< bool*>(_v) = _t->allowMultiple(); break;
942 case 13: *reinterpret_cast< bool*>(_v) = _t->isClipOnly(); break;
943 case 14: *reinterpret_cast< bool*>(_v) = _t->isTrackOnly(); break;
944 case 15: *reinterpret_cast< bool*>(_v) = _t->isOutputOnly(); break;
945 case 16: *reinterpret_cast< bool*>(_v) = _t->isGpuCompatible(); break;
946 case 17: *reinterpret_cast< QmlKeyframesMetadata**>(_v) = _t->keyframes(); break;
947 case 18: *reinterpret_cast< bool*>(_v) = _t->isDeprecated(); break;
948 case 19: *reinterpret_cast< QString*>(_v) = _t->m_minimumVersion; break;
949 case 20: *reinterpret_cast< QString*>(_v) = _t->m_keywords; break;
950 case 21: *reinterpret_cast< QString*>(_v) = _t->iconFilePath(); break;
951 case 22: *reinterpret_cast< bool*>(_v) = _t->m_seekReverse; break;
952 default: break;
953 }
954 } else if (_c == QMetaObject::WriteProperty) {
955 auto *_t = static_cast<QmlMetadata *>(_o);
956 (void)_t;
957 void *_v = _a[0];
958 switch (_id) {
959 case 0: _t->setType(*reinterpret_cast< PluginType*>(_v)); break;
960 case 1: _t->setName(*reinterpret_cast< QString*>(_v)); break;
961 case 2: _t->set_mlt_service(*reinterpret_cast< QString*>(_v)); break;
962 case 3: _t->setNeedsGPU(*reinterpret_cast< bool*>(_v)); break;
963 case 4: _t->setQmlFileName(*reinterpret_cast< QString*>(_v)); break;
964 case 5: _t->setVuiFileName(*reinterpret_cast< QString*>(_v)); break;
965 case 8: _t->setIsAudio(*reinterpret_cast< bool*>(_v)); break;
966 case 9: _t->setIsHidden(*reinterpret_cast< bool*>(_v)); break;
967 case 10: _t->setIsFavorite(*reinterpret_cast< bool*>(_v)); break;
968 case 11: _t->setGpuAlt(*reinterpret_cast< QString*>(_v)); break;
969 case 12: _t->setAllowMultiple(*reinterpret_cast< bool*>(_v)); break;
970 case 13: _t->setIsClipOnly(*reinterpret_cast< bool*>(_v)); break;
971 case 14: _t->setIsTrackOnly(*reinterpret_cast< bool*>(_v)); break;
972 case 15: _t->setIsOutputOnly(*reinterpret_cast< bool*>(_v)); break;
973 case 16: _t->setIsGpuCompatible(*reinterpret_cast< bool*>(_v)); break;
974 case 18: _t->setIsDeprecated(*reinterpret_cast< bool*>(_v)); break;
975 case 19:
976 if (_t->m_minimumVersion != *reinterpret_cast< QString*>(_v)) {
977 _t->m_minimumVersion = *reinterpret_cast< QString*>(_v);
978 Q_EMIT _t->changed();
979 }
980 break;
981 case 20:
982 if (_t->m_keywords != *reinterpret_cast< QString*>(_v)) {
983 _t->m_keywords = *reinterpret_cast< QString*>(_v);
984 Q_EMIT _t->changed();
985 }
986 break;
987 case 21: _t->setIconFileName(*reinterpret_cast< QString*>(_v)); break;
988 case 22:
989 if (_t->m_seekReverse != *reinterpret_cast< bool*>(_v)) {
990 _t->m_seekReverse = *reinterpret_cast< bool*>(_v);
991 Q_EMIT _t->changed();
992 }
993 break;
994 default: break;
995 }
996 } else if (_c == QMetaObject::ResetProperty) {
997 } else if (_c == QMetaObject::BindableProperty) {
998 }
999}
1000
1001const QMetaObject *QmlMetadata::metaObject() const
1002{
1003 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
1004}
1005
1006void *QmlMetadata::qt_metacast(const char *_clname)
1007{
1008 if (!_clname) return nullptr;
1009 if (!strcmp(_clname, qt_meta_stringdata_CLASSQmlMetadataENDCLASS.stringdata0))
1010 return static_cast<void*>(this);
1011 return QObject::qt_metacast(_clname);
1012}
1013
1014int QmlMetadata::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
1015{
1016 _id = QObject::qt_metacall(_c, _id, _a);
1017 if (_id < 0)
1018 return _id;
1019 if (_c == QMetaObject::InvokeMetaMethod) {
1020 if (_id < 1)
1021 qt_static_metacall(this, _c, _id, _a);
1022 _id -= 1;
1023 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
1024 if (_id < 1)
1025 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
1026 _id -= 1;
1027 }else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
1028 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
1029 || _c == QMetaObject::RegisterPropertyMetaType) {
1030 qt_static_metacall(this, _c, _id, _a);
1031 _id -= 23;
1032 }
1033 return _id;
1034}
1035
1036// SIGNAL 0
1037void QmlMetadata::changed()
1038{
1039 QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
1040}
1041QT_WARNING_POP