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 "isGpuCompatible",
653 "keyframes",
654 "QmlKeyframesMetadata*",
655 "isDeprecated",
656 "minimumVersion",
657 "keywords",
658 "icon",
659 "seekReverse",
660 "Filter",
661 "Producer",
662 "Transition",
663 "Link",
664 "FilterSet"
665);
666#else // !QT_MOC_HAS_STRING_DATA
667struct qt_meta_stringdata_CLASSQmlMetadataENDCLASS_t {
668 uint offsetsAndSizes[64];
669 char stringdata0[12];
670 char stringdata1[8];
671 char stringdata2[1];
672 char stringdata3[5];
673 char stringdata4[11];
674 char stringdata5[5];
675 char stringdata6[12];
676 char stringdata7[9];
677 char stringdata8[4];
678 char stringdata9[4];
679 char stringdata10[12];
680 char stringdata11[12];
681 char stringdata12[8];
682 char stringdata13[9];
683 char stringdata14[11];
684 char stringdata15[7];
685 char stringdata16[14];
686 char stringdata17[11];
687 char stringdata18[12];
688 char stringdata19[16];
689 char stringdata20[10];
690 char stringdata21[22];
691 char stringdata22[13];
692 char stringdata23[15];
693 char stringdata24[9];
694 char stringdata25[5];
695 char stringdata26[12];
696 char stringdata27[7];
697 char stringdata28[9];
698 char stringdata29[11];
699 char stringdata30[5];
700 char stringdata31[10];
701};
702#define QT_MOC_LITERAL(ofs, len) \
703 uint(sizeof(qt_meta_stringdata_CLASSQmlMetadataENDCLASS_t::offsetsAndSizes) + ofs), len
704Q_CONSTINIT static const qt_meta_stringdata_CLASSQmlMetadataENDCLASS_t qt_meta_stringdata_CLASSQmlMetadataENDCLASS = {
705 {
706 QT_MOC_LITERAL(0, 11), // "QmlMetadata"
707 QT_MOC_LITERAL(12, 7), // "changed"
708 QT_MOC_LITERAL(20, 0), // ""
709 QT_MOC_LITERAL(21, 4), // "type"
710 QT_MOC_LITERAL(26, 10), // "PluginType"
711 QT_MOC_LITERAL(37, 4), // "name"
712 QT_MOC_LITERAL(42, 11), // "mlt_service"
713 QT_MOC_LITERAL(54, 8), // "needsGPU"
714 QT_MOC_LITERAL(63, 3), // "qml"
715 QT_MOC_LITERAL(67, 3), // "vui"
716 QT_MOC_LITERAL(71, 11), // "qmlFilePath"
717 QT_MOC_LITERAL(83, 11), // "vuiFilePath"
718 QT_MOC_LITERAL(95, 7), // "isAudio"
719 QT_MOC_LITERAL(103, 8), // "isHidden"
720 QT_MOC_LITERAL(112, 10), // "isFavorite"
721 QT_MOC_LITERAL(123, 6), // "gpuAlt"
722 QT_MOC_LITERAL(130, 13), // "allowMultiple"
723 QT_MOC_LITERAL(144, 10), // "isClipOnly"
724 QT_MOC_LITERAL(155, 11), // "isTrackOnly"
725 QT_MOC_LITERAL(167, 15), // "isGpuCompatible"
726 QT_MOC_LITERAL(183, 9), // "keyframes"
727 QT_MOC_LITERAL(193, 21), // "QmlKeyframesMetadata*"
728 QT_MOC_LITERAL(215, 12), // "isDeprecated"
729 QT_MOC_LITERAL(228, 14), // "minimumVersion"
730 QT_MOC_LITERAL(243, 8), // "keywords"
731 QT_MOC_LITERAL(252, 4), // "icon"
732 QT_MOC_LITERAL(257, 11), // "seekReverse"
733 QT_MOC_LITERAL(269, 6), // "Filter"
734 QT_MOC_LITERAL(276, 8), // "Producer"
735 QT_MOC_LITERAL(285, 10), // "Transition"
736 QT_MOC_LITERAL(296, 4), // "Link"
737 QT_MOC_LITERAL(301, 9) // "FilterSet"
738 },
739 "QmlMetadata",
740 "changed",
741 "",
742 "type",
743 "PluginType",
744 "name",
745 "mlt_service",
746 "needsGPU",
747 "qml",
748 "vui",
749 "qmlFilePath",
750 "vuiFilePath",
751 "isAudio",
752 "isHidden",
753 "isFavorite",
754 "gpuAlt",
755 "allowMultiple",
756 "isClipOnly",
757 "isTrackOnly",
758 "isGpuCompatible",
759 "keyframes",
760 "QmlKeyframesMetadata*",
761 "isDeprecated",
762 "minimumVersion",
763 "keywords",
764 "icon",
765 "seekReverse",
766 "Filter",
767 "Producer",
768 "Transition",
769 "Link",
770 "FilterSet"
771};
772#undef QT_MOC_LITERAL
773#endif // !QT_MOC_HAS_STRING_DATA
774} // unnamed namespace
775
776Q_CONSTINIT static const uint qt_meta_data_CLASSQmlMetadataENDCLASS[] = {
777
778 // content:
779 12, // revision
780 0, // classname
781 0, 0, // classinfo
782 1, 14, // methods
783 22, 21, // properties
784 1, 131, // enums/sets
785 0, 0, // constructors
786 0, // flags
787 1, // signalCount
788
789 // signals: name, argc, parameters, tag, flags, initial metatype offsets
790 1, 0, 20, 2, 0x06, 24 /* Public */,
791
792 // signals: parameters
793 QMetaType::Void,
794
795 // properties: name, type, flags
796 3, 0x80000000 | 4, 0x0001510b, uint(0), 0,
797 5, QMetaType::QString, 0x00015103, uint(0), 0,
798 6, QMetaType::QString, 0x00015003, uint(0), 0,
799 7, QMetaType::Bool, 0x00015103, uint(0), 0,
800 8, QMetaType::QString, 0x00015003, uint(0), 0,
801 9, QMetaType::QString, 0x00015003, uint(0), 0,
802 10, QMetaType::QUrl, 0x00015001, uint(0), 0,
803 11, QMetaType::QUrl, 0x00015001, uint(0), 0,
804 12, QMetaType::Bool, 0x00015103, uint(0), 0,
805 13, QMetaType::Bool, 0x00015103, uint(0), 0,
806 14, QMetaType::Bool, 0x00015103, uint(0), 0,
807 15, QMetaType::QString, 0x00015103, uint(0), 0,
808 16, QMetaType::Bool, 0x00015103, uint(0), 0,
809 17, QMetaType::Bool, 0x00015103, uint(0), 0,
810 18, QMetaType::Bool, 0x00015103, uint(0), 0,
811 19, QMetaType::Bool, 0x00015103, uint(0), 0,
812 20, 0x80000000 | 21, 0x00015009, uint(0), 0,
813 22, QMetaType::Bool, 0x00015103, uint(0), 0,
814 23, QMetaType::QString, 0x00015003, uint(0), 0,
815 24, QMetaType::QString, 0x00015003, uint(0), 0,
816 25, QMetaType::QString, 0x00015003, uint(0), 0,
817 26, QMetaType::Bool, 0x00015003, uint(0), 0,
818
819 // enums: name, alias, flags, count, data
820 4, 4, 0x0, 5, 136,
821
822 // enum data: key, value
823 27, uint(QmlMetadata::Filter),
824 28, uint(QmlMetadata::Producer),
825 29, uint(QmlMetadata::Transition),
826 30, uint(QmlMetadata::Link),
827 31, uint(QmlMetadata::FilterSet),
828
829 0 // eod
830};
831
832Q_CONSTINIT const QMetaObject QmlMetadata::staticMetaObject = { {
833 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
834 qt_meta_stringdata_CLASSQmlMetadataENDCLASS.offsetsAndSizes,
835 qt_meta_data_CLASSQmlMetadataENDCLASS,
836 qt_static_metacall,
837 nullptr,
838 qt_incomplete_metaTypeArray<qt_meta_stringdata_CLASSQmlMetadataENDCLASS_t,
839 // property 'type'
840 QtPrivate::TypeAndForceComplete<PluginType, std::true_type>,
841 // property 'name'
842 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
843 // property 'mlt_service'
844 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
845 // property 'needsGPU'
846 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
847 // property 'qml'
848 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
849 // property 'vui'
850 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
851 // property 'qmlFilePath'
852 QtPrivate::TypeAndForceComplete<QUrl, std::true_type>,
853 // property 'vuiFilePath'
854 QtPrivate::TypeAndForceComplete<QUrl, std::true_type>,
855 // property 'isAudio'
856 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
857 // property 'isHidden'
858 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
859 // property 'isFavorite'
860 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
861 // property 'gpuAlt'
862 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
863 // property 'allowMultiple'
864 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
865 // property 'isClipOnly'
866 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
867 // property 'isTrackOnly'
868 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
869 // property 'isGpuCompatible'
870 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
871 // property 'keyframes'
872 QtPrivate::TypeAndForceComplete<QmlKeyframesMetadata*, std::true_type>,
873 // property 'isDeprecated'
874 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
875 // property 'minimumVersion'
876 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
877 // property 'keywords'
878 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
879 // property 'icon'
880 QtPrivate::TypeAndForceComplete<QString, std::true_type>,
881 // property 'seekReverse'
882 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
883 // enum 'PluginType'
884 QtPrivate::TypeAndForceComplete<QmlMetadata::PluginType, std::true_type>,
885 // Q_OBJECT / Q_GADGET
886 QtPrivate::TypeAndForceComplete<QmlMetadata, std::true_type>,
887 // method 'changed'
888 QtPrivate::TypeAndForceComplete<void, std::false_type>
889 >,
890 nullptr
891} };
892
893void QmlMetadata::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
894{
895 if (_c == QMetaObject::InvokeMetaMethod) {
896 auto *_t = static_cast<QmlMetadata *>(_o);
897 (void)_t;
898 switch (_id) {
899 case 0: _t->changed(); break;
900 default: ;
901 }
902 } else if (_c == QMetaObject::IndexOfMethod) {
903 int *result = reinterpret_cast<int *>(_a[0]);
904 {
905 using _t = void (QmlMetadata::*)();
906 if (_t _q_method = &QmlMetadata::changed; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
907 *result = 0;
908 return;
909 }
910 }
911 } else if (_c == QMetaObject::RegisterPropertyMetaType) {
912 switch (_id) {
913 default: *reinterpret_cast<int*>(_a[0]) = -1; break;
914 case 16:
915 *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QmlKeyframesMetadata* >(); break;
916 }
917 } else if (_c == QMetaObject::ReadProperty) {
918 auto *_t = static_cast<QmlMetadata *>(_o);
919 (void)_t;
920 void *_v = _a[0];
921 switch (_id) {
922 case 0: *reinterpret_cast< PluginType*>(_v) = _t->type(); break;
923 case 1: *reinterpret_cast< QString*>(_v) = _t->name(); break;
924 case 2: *reinterpret_cast< QString*>(_v) = _t->mlt_service(); break;
925 case 3: *reinterpret_cast< bool*>(_v) = _t->needsGPU(); break;
926 case 4: *reinterpret_cast< QString*>(_v) = _t->qmlFileName(); break;
927 case 5: *reinterpret_cast< QString*>(_v) = _t->vuiFileName(); break;
928 case 6: *reinterpret_cast< QUrl*>(_v) = _t->qmlFilePath(); break;
929 case 7: *reinterpret_cast< QUrl*>(_v) = _t->vuiFilePath(); break;
930 case 8: *reinterpret_cast< bool*>(_v) = _t->isAudio(); break;
931 case 9: *reinterpret_cast< bool*>(_v) = _t->isHidden(); break;
932 case 10: *reinterpret_cast< bool*>(_v) = _t->isFavorite(); break;
933 case 11: *reinterpret_cast< QString*>(_v) = _t->gpuAlt(); break;
934 case 12: *reinterpret_cast< bool*>(_v) = _t->allowMultiple(); break;
935 case 13: *reinterpret_cast< bool*>(_v) = _t->isClipOnly(); break;
936 case 14: *reinterpret_cast< bool*>(_v) = _t->isTrackOnly(); break;
937 case 15: *reinterpret_cast< bool*>(_v) = _t->isGpuCompatible(); break;
938 case 16: *reinterpret_cast< QmlKeyframesMetadata**>(_v) = _t->keyframes(); break;
939 case 17: *reinterpret_cast< bool*>(_v) = _t->isDeprecated(); break;
940 case 18: *reinterpret_cast< QString*>(_v) = _t->m_minimumVersion; break;
941 case 19: *reinterpret_cast< QString*>(_v) = _t->m_keywords; break;
942 case 20: *reinterpret_cast< QString*>(_v) = _t->iconFilePath(); break;
943 case 21: *reinterpret_cast< bool*>(_v) = _t->m_seekReverse; break;
944 default: break;
945 }
946 } else if (_c == QMetaObject::WriteProperty) {
947 auto *_t = static_cast<QmlMetadata *>(_o);
948 (void)_t;
949 void *_v = _a[0];
950 switch (_id) {
951 case 0: _t->setType(*reinterpret_cast< PluginType*>(_v)); break;
952 case 1: _t->setName(*reinterpret_cast< QString*>(_v)); break;
953 case 2: _t->set_mlt_service(*reinterpret_cast< QString*>(_v)); break;
954 case 3: _t->setNeedsGPU(*reinterpret_cast< bool*>(_v)); break;
955 case 4: _t->setQmlFileName(*reinterpret_cast< QString*>(_v)); break;
956 case 5: _t->setVuiFileName(*reinterpret_cast< QString*>(_v)); break;
957 case 8: _t->setIsAudio(*reinterpret_cast< bool*>(_v)); break;
958 case 9: _t->setIsHidden(*reinterpret_cast< bool*>(_v)); break;
959 case 10: _t->setIsFavorite(*reinterpret_cast< bool*>(_v)); break;
960 case 11: _t->setGpuAlt(*reinterpret_cast< QString*>(_v)); break;
961 case 12: _t->setAllowMultiple(*reinterpret_cast< bool*>(_v)); break;
962 case 13: _t->setIsClipOnly(*reinterpret_cast< bool*>(_v)); break;
963 case 14: _t->setIsTrackOnly(*reinterpret_cast< bool*>(_v)); break;
964 case 15: _t->setIsGpuCompatible(*reinterpret_cast< bool*>(_v)); break;
965 case 17: _t->setIsDeprecated(*reinterpret_cast< bool*>(_v)); break;
966 case 18:
967 if (_t->m_minimumVersion != *reinterpret_cast< QString*>(_v)) {
968 _t->m_minimumVersion = *reinterpret_cast< QString*>(_v);
969 Q_EMIT _t->changed();
970 }
971 break;
972 case 19:
973 if (_t->m_keywords != *reinterpret_cast< QString*>(_v)) {
974 _t->m_keywords = *reinterpret_cast< QString*>(_v);
975 Q_EMIT _t->changed();
976 }
977 break;
978 case 20: _t->setIconFileName(*reinterpret_cast< QString*>(_v)); break;
979 case 21:
980 if (_t->m_seekReverse != *reinterpret_cast< bool*>(_v)) {
981 _t->m_seekReverse = *reinterpret_cast< bool*>(_v);
982 Q_EMIT _t->changed();
983 }
984 break;
985 default: break;
986 }
987 } else if (_c == QMetaObject::ResetProperty) {
988 } else if (_c == QMetaObject::BindableProperty) {
989 }
990}
991
992const QMetaObject *QmlMetadata::metaObject() const
993{
994 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
995}
996
997void *QmlMetadata::qt_metacast(const char *_clname)
998{
999 if (!_clname) return nullptr;
1000 if (!strcmp(_clname, qt_meta_stringdata_CLASSQmlMetadataENDCLASS.stringdata0))
1001 return static_cast<void*>(this);
1002 return QObject::qt_metacast(_clname);
1003}
1004
1005int QmlMetadata::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
1006{
1007 _id = QObject::qt_metacall(_c, _id, _a);
1008 if (_id < 0)
1009 return _id;
1010 if (_c == QMetaObject::InvokeMetaMethod) {
1011 if (_id < 1)
1012 qt_static_metacall(this, _c, _id, _a);
1013 _id -= 1;
1014 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
1015 if (_id < 1)
1016 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
1017 _id -= 1;
1018 }else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
1019 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
1020 || _c == QMetaObject::RegisterPropertyMetaType) {
1021 qt_static_metacall(this, _c, _id, _a);
1022 _id -= 22;
1023 }
1024 return _id;
1025}
1026
1027// SIGNAL 0
1028void QmlMetadata::changed()
1029{
1030 QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
1031}
1032QT_WARNING_POP