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 69 (Qt 6.9.0)
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#include <QtCore/qtmochelpers.h>
14
15#include <memory>
16
17
18#include <QtCore/qxptype_traits.h>
19#if !defined(Q_MOC_OUTPUT_REVISION)
20#error "The header file 'qmlmetadata.h' doesn't include <QObject>."
21#elif Q_MOC_OUTPUT_REVISION != 69
22#error "This file was generated using the moc from 6.9.0. It"
23#error "cannot be used with the include files from this version of Qt."
24#error "(The moc has changed too much.)"
25#endif
26
27#ifndef Q_CONSTINIT
28#define Q_CONSTINIT
29#endif
30
31QT_WARNING_PUSH
32QT_WARNING_DISABLE_DEPRECATED
33QT_WARNING_DISABLE_GCC("-Wuseless-cast")
34namespace {
35struct qt_meta_tag_ZN21QmlKeyframesParameterE_t {};
36} // unnamed namespace
37
38template <> constexpr inline auto QmlKeyframesParameter::qt_create_metaobjectdata<qt_meta_tag_ZN21QmlKeyframesParameterE_t>()
39{
40 namespace QMC = QtMocConstants;
41 QtMocHelpers::StringRefStorage qt_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
60 QtMocHelpers::UintData qt_methods {
61 // Signal 'changed'
62 QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
63 };
64 QtMocHelpers::UintData qt_properties {
65 // property 'rangeType'
66 QtMocHelpers::PropertyData<RangeType>(3, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 0),
67 // property 'name'
68 QtMocHelpers::PropertyData<QString>(5, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 0),
69 // property 'property'
70 QtMocHelpers::PropertyData<QString>(6, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 0),
71 // property 'gangedProperties'
72 QtMocHelpers::PropertyData<QStringList>(7, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Writable, 0),
73 // property 'isCurve'
74 QtMocHelpers::PropertyData<bool>(8, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
75 // property 'minimum'
76 QtMocHelpers::PropertyData<double>(9, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable, 0),
77 // property 'maximum'
78 QtMocHelpers::PropertyData<double>(10, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable, 0),
79 // property 'units'
80 QtMocHelpers::PropertyData<QString>(11, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 0),
81 // property 'isRectangle'
82 QtMocHelpers::PropertyData<bool>(12, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
83 // property 'isColor'
84 QtMocHelpers::PropertyData<bool>(13, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
85 };
86 QtMocHelpers::UintData qt_enums {
87 // enum 'RangeType'
88 QtMocHelpers::EnumData<RangeType>(4, 4, QMC::EnumFlags{}).add({
89 { 14, RangeType::MinMax },
90 { 15, RangeType::ClipLength },
91 }),
92 };
93 return QtMocHelpers::metaObjectData<QmlKeyframesParameter, qt_meta_tag_ZN21QmlKeyframesParameterE_t>(QMC::MetaObjectFlag{}, qt_stringData,
94 qt_methods, qt_properties, qt_enums);
95}
96Q_CONSTINIT const QMetaObject QmlKeyframesParameter::staticMetaObject = { {
97 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
98 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QmlKeyframesParameterE_t>.stringdata,
99 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QmlKeyframesParameterE_t>.data,
100 qt_static_metacall,
101 nullptr,
102 qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QmlKeyframesParameterE_t>.metaTypes,
103 nullptr
104} };
105
106void QmlKeyframesParameter::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
107{
108 auto *_t = static_cast<QmlKeyframesParameter *>(_o);
109 if (_c == QMetaObject::InvokeMetaMethod) {
110 switch (_id) {
111 case 0: _t->changed(); break;
112 default: ;
113 }
114 }
115 if (_c == QMetaObject::IndexOfMethod) {
116 if (QtMocHelpers::indexOfMethod<void (QmlKeyframesParameter::*)()>(_a, &QmlKeyframesParameter::changed, 0))
117 return;
118 }
119 if (_c == QMetaObject::ReadProperty) {
120 void *_v = _a[0];
121 switch (_id) {
122 case 0: *reinterpret_cast<RangeType*>(_v) = _t->m_rangeType; break;
123 case 1: *reinterpret_cast<QString*>(_v) = _t->m_name; break;
124 case 2: *reinterpret_cast<QString*>(_v) = _t->m_property; break;
125 case 3: *reinterpret_cast<QStringList*>(_v) = _t->m_gangedProperties; break;
126 case 4: *reinterpret_cast<bool*>(_v) = _t->m_isCurve; break;
127 case 5: *reinterpret_cast<double*>(_v) = _t->m_minimum; break;
128 case 6: *reinterpret_cast<double*>(_v) = _t->m_maximum; break;
129 case 7: *reinterpret_cast<QString*>(_v) = _t->m_units; break;
130 case 8: *reinterpret_cast<bool*>(_v) = _t->m_isRectangle; break;
131 case 9: *reinterpret_cast<bool*>(_v) = _t->m_isColor; break;
132 default: break;
133 }
134 }
135 if (_c == QMetaObject::WriteProperty) {
136 void *_v = _a[0];
137 switch (_id) {
138 case 0:
139 if (QtMocHelpers::setProperty(_t->m_rangeType, *reinterpret_cast<RangeType*>(_v)))
140 Q_EMIT _t->changed();
141 break;
142 case 1:
143 if (QtMocHelpers::setProperty(_t->m_name, *reinterpret_cast<QString*>(_v)))
144 Q_EMIT _t->changed();
145 break;
146 case 2:
147 if (QtMocHelpers::setProperty(_t->m_property, *reinterpret_cast<QString*>(_v)))
148 Q_EMIT _t->changed();
149 break;
150 case 3:
151 if (QtMocHelpers::setProperty(_t->m_gangedProperties, *reinterpret_cast<QStringList*>(_v)))
152 Q_EMIT _t->changed();
153 break;
154 case 4:
155 if (QtMocHelpers::setProperty(_t->m_isCurve, *reinterpret_cast<bool*>(_v)))
156 Q_EMIT _t->changed();
157 break;
158 case 5:
159 if (QtMocHelpers::setProperty(_t->m_minimum, *reinterpret_cast<double*>(_v)))
160 Q_EMIT _t->changed();
161 break;
162 case 6:
163 if (QtMocHelpers::setProperty(_t->m_maximum, *reinterpret_cast<double*>(_v)))
164 Q_EMIT _t->changed();
165 break;
166 case 7:
167 if (QtMocHelpers::setProperty(_t->m_units, *reinterpret_cast<QString*>(_v)))
168 Q_EMIT _t->changed();
169 break;
170 case 8:
171 if (QtMocHelpers::setProperty(_t->m_isRectangle, *reinterpret_cast<bool*>(_v)))
172 Q_EMIT _t->changed();
173 break;
174 case 9:
175 if (QtMocHelpers::setProperty(_t->m_isColor, *reinterpret_cast<bool*>(_v)))
176 Q_EMIT _t->changed();
177 break;
178 default: break;
179 }
180 }
181}
182
183const QMetaObject *QmlKeyframesParameter::metaObject() const
184{
185 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
186}
187
188void *QmlKeyframesParameter::qt_metacast(const char *_clname)
189{
190 if (!_clname) return nullptr;
191 if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QmlKeyframesParameterE_t>.strings))
192 return static_cast<void*>(this);
193 return QObject::qt_metacast(_clname);
194}
195
196int QmlKeyframesParameter::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
197{
198 _id = QObject::qt_metacall(_c, _id, _a);
199 if (_id < 0)
200 return _id;
201 if (_c == QMetaObject::InvokeMetaMethod) {
202 if (_id < 1)
203 qt_static_metacall(this, _c, _id, _a);
204 _id -= 1;
205 }
206 if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
207 if (_id < 1)
208 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
209 _id -= 1;
210 }
211 if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
212 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
213 || _c == QMetaObject::RegisterPropertyMetaType) {
214 qt_static_metacall(this, _c, _id, _a);
215 _id -= 10;
216 }
217 return _id;
218}
219
220// SIGNAL 0
221void QmlKeyframesParameter::changed()
222{
223 QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
224}
225namespace {
226struct qt_meta_tag_ZN20QmlKeyframesMetadataE_t {};
227} // unnamed namespace
228
229template <> constexpr inline auto QmlKeyframesMetadata::qt_create_metaobjectdata<qt_meta_tag_ZN20QmlKeyframesMetadataE_t>()
230{
231 namespace QMC = QtMocConstants;
232 QtMocHelpers::StringRefStorage qt_stringData {
233 "QmlKeyframesMetadata",
234 "changed",
235 "",
236 "parameter",
237 "QmlKeyframesParameter*",
238 "propertyName",
239 "allowTrim",
240 "allowAnimateIn",
241 "allowAnimateOut",
242 "parameters",
243 "QQmlListProperty<QmlKeyframesParameter>",
244 "simpleProperties",
245 "minimumVersion",
246 "enabled",
247 "allowOvershoot"
248 };
249
250 QtMocHelpers::UintData qt_methods {
251 // Signal 'changed'
252 QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
253 // Method 'parameter'
254 QtMocHelpers::MethodData<QmlKeyframesParameter *(const QString &) const>(3, 2, QMC::AccessPublic, 0x80000000 | 4, {{
255 { QMetaType::QString, 5 },
256 }}),
257 };
258 QtMocHelpers::UintData qt_properties {
259 // property 'allowTrim'
260 QtMocHelpers::PropertyData<bool>(6, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
261 // property 'allowAnimateIn'
262 QtMocHelpers::PropertyData<bool>(7, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
263 // property 'allowAnimateOut'
264 QtMocHelpers::PropertyData<bool>(8, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
265 // property 'parameters'
266 QtMocHelpers::PropertyData<QQmlListProperty<QmlKeyframesParameter>>(9, 0x80000000 | 10, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
267 // property 'simpleProperties'
268 QtMocHelpers::PropertyData<QList<QString>>(11, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Writable, 0),
269 // property 'minimumVersion'
270 QtMocHelpers::PropertyData<QString>(12, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 0),
271 // property 'enabled'
272 QtMocHelpers::PropertyData<bool>(13, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
273 // property 'allowOvershoot'
274 QtMocHelpers::PropertyData<bool>(14, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
275 };
276 QtMocHelpers::UintData qt_enums {
277 };
278 return QtMocHelpers::metaObjectData<QmlKeyframesMetadata, qt_meta_tag_ZN20QmlKeyframesMetadataE_t>(QMC::MetaObjectFlag{}, qt_stringData,
279 qt_methods, qt_properties, qt_enums);
280}
281Q_CONSTINIT const QMetaObject QmlKeyframesMetadata::staticMetaObject = { {
282 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
283 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QmlKeyframesMetadataE_t>.stringdata,
284 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QmlKeyframesMetadataE_t>.data,
285 qt_static_metacall,
286 nullptr,
287 qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20QmlKeyframesMetadataE_t>.metaTypes,
288 nullptr
289} };
290
291void QmlKeyframesMetadata::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
292{
293 auto *_t = static_cast<QmlKeyframesMetadata *>(_o);
294 if (_c == QMetaObject::InvokeMetaMethod) {
295 switch (_id) {
296 case 0: _t->changed(); break;
297 case 1: { QmlKeyframesParameter* _r = _t->parameter((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1])));
298 if (_a[0]) *reinterpret_cast< QmlKeyframesParameter**>(_a[0]) = std::move(_r); } break;
299 default: ;
300 }
301 }
302 if (_c == QMetaObject::IndexOfMethod) {
303 if (QtMocHelpers::indexOfMethod<void (QmlKeyframesMetadata::*)()>(_a, &QmlKeyframesMetadata::changed, 0))
304 return;
305 }
306 if (_c == QMetaObject::ReadProperty) {
307 void *_v = _a[0];
308 switch (_id) {
309 case 0: *reinterpret_cast<bool*>(_v) = _t->m_allowTrim; break;
310 case 1: *reinterpret_cast<bool*>(_v) = _t->m_allowAnimateIn; break;
311 case 2: *reinterpret_cast<bool*>(_v) = _t->m_allowAnimateOut; break;
312 case 3: *reinterpret_cast<QQmlListProperty<QmlKeyframesParameter>*>(_v) = _t->parameters(); break;
313 case 4: *reinterpret_cast<QList<QString>*>(_v) = _t->m_simpleProperties; break;
314 case 5: *reinterpret_cast<QString*>(_v) = _t->m_minimumVersion; break;
315 case 6: *reinterpret_cast<bool*>(_v) = _t->m_enabled; break;
316 case 7: *reinterpret_cast<bool*>(_v) = _t->m_allowOvershoot; break;
317 default: break;
318 }
319 }
320 if (_c == QMetaObject::WriteProperty) {
321 void *_v = _a[0];
322 switch (_id) {
323 case 0:
324 if (QtMocHelpers::setProperty(_t->m_allowTrim, *reinterpret_cast<bool*>(_v)))
325 Q_EMIT _t->changed();
326 break;
327 case 1:
328 if (QtMocHelpers::setProperty(_t->m_allowAnimateIn, *reinterpret_cast<bool*>(_v)))
329 Q_EMIT _t->changed();
330 break;
331 case 2:
332 if (QtMocHelpers::setProperty(_t->m_allowAnimateOut, *reinterpret_cast<bool*>(_v)))
333 Q_EMIT _t->changed();
334 break;
335 case 4:
336 if (QtMocHelpers::setProperty(_t->m_simpleProperties, *reinterpret_cast<QList<QString>*>(_v)))
337 Q_EMIT _t->changed();
338 break;
339 case 5:
340 if (QtMocHelpers::setProperty(_t->m_minimumVersion, *reinterpret_cast<QString*>(_v)))
341 Q_EMIT _t->changed();
342 break;
343 case 6:
344 if (QtMocHelpers::setProperty(_t->m_enabled, *reinterpret_cast<bool*>(_v)))
345 Q_EMIT _t->changed();
346 break;
347 case 7:
348 if (QtMocHelpers::setProperty(_t->m_allowOvershoot, *reinterpret_cast<bool*>(_v)))
349 Q_EMIT _t->changed();
350 break;
351 default: break;
352 }
353 }
354}
355
356const QMetaObject *QmlKeyframesMetadata::metaObject() const
357{
358 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
359}
360
361void *QmlKeyframesMetadata::qt_metacast(const char *_clname)
362{
363 if (!_clname) return nullptr;
364 if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QmlKeyframesMetadataE_t>.strings))
365 return static_cast<void*>(this);
366 return QObject::qt_metacast(_clname);
367}
368
369int QmlKeyframesMetadata::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
370{
371 _id = QObject::qt_metacall(_c, _id, _a);
372 if (_id < 0)
373 return _id;
374 if (_c == QMetaObject::InvokeMetaMethod) {
375 if (_id < 2)
376 qt_static_metacall(this, _c, _id, _a);
377 _id -= 2;
378 }
379 if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
380 if (_id < 2)
381 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
382 _id -= 2;
383 }
384 if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
385 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
386 || _c == QMetaObject::RegisterPropertyMetaType) {
387 qt_static_metacall(this, _c, _id, _a);
388 _id -= 8;
389 }
390 return _id;
391}
392
393// SIGNAL 0
394void QmlKeyframesMetadata::changed()
395{
396 QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
397}
398namespace {
399struct qt_meta_tag_ZN11QmlMetadataE_t {};
400} // unnamed namespace
401
402template <> constexpr inline auto QmlMetadata::qt_create_metaobjectdata<qt_meta_tag_ZN11QmlMetadataE_t>()
403{
404 namespace QMC = QtMocConstants;
405 QtMocHelpers::StringRefStorage qt_stringData {
406 "QmlMetadata",
407 "changed",
408 "",
409 "type",
410 "PluginType",
411 "name",
412 "mlt_service",
413 "needsGPU",
414 "qml",
415 "vui",
416 "qmlFilePath",
417 "vuiFilePath",
418 "isAudio",
419 "isHidden",
420 "isFavorite",
421 "gpuAlt",
422 "allowMultiple",
423 "isClipOnly",
424 "isTrackOnly",
425 "isOutputOnly",
426 "isGpuCompatible",
427 "keyframes",
428 "QmlKeyframesMetadata*",
429 "isDeprecated",
430 "minimumVersion",
431 "keywords",
432 "icon",
433 "seekReverse",
434 "Filter",
435 "Producer",
436 "Transition",
437 "Link",
438 "FilterSet"
439 };
440
441 QtMocHelpers::UintData qt_methods {
442 // Signal 'changed'
443 QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
444 };
445 QtMocHelpers::UintData qt_properties {
446 // property 'type'
447 QtMocHelpers::PropertyData<PluginType>(3, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 0),
448 // property 'name'
449 QtMocHelpers::PropertyData<QString>(5, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
450 // property 'mlt_service'
451 QtMocHelpers::PropertyData<QString>(6, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 0),
452 // property 'needsGPU'
453 QtMocHelpers::PropertyData<bool>(7, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
454 // property 'qml'
455 QtMocHelpers::PropertyData<QString>(8, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 0),
456 // property 'vui'
457 QtMocHelpers::PropertyData<QString>(9, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 0),
458 // property 'qmlFilePath'
459 QtMocHelpers::PropertyData<QUrl>(10, QMetaType::QUrl, QMC::DefaultPropertyFlags, 0),
460 // property 'vuiFilePath'
461 QtMocHelpers::PropertyData<QUrl>(11, QMetaType::QUrl, QMC::DefaultPropertyFlags, 0),
462 // property 'isAudio'
463 QtMocHelpers::PropertyData<bool>(12, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
464 // property 'isHidden'
465 QtMocHelpers::PropertyData<bool>(13, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
466 // property 'isFavorite'
467 QtMocHelpers::PropertyData<bool>(14, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
468 // property 'gpuAlt'
469 QtMocHelpers::PropertyData<QString>(15, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
470 // property 'allowMultiple'
471 QtMocHelpers::PropertyData<bool>(16, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
472 // property 'isClipOnly'
473 QtMocHelpers::PropertyData<bool>(17, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
474 // property 'isTrackOnly'
475 QtMocHelpers::PropertyData<bool>(18, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
476 // property 'isOutputOnly'
477 QtMocHelpers::PropertyData<bool>(19, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
478 // property 'isGpuCompatible'
479 QtMocHelpers::PropertyData<bool>(20, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
480 // property 'keyframes'
481 QtMocHelpers::PropertyData<QmlKeyframesMetadata*>(21, 0x80000000 | 22, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
482 // property 'isDeprecated'
483 QtMocHelpers::PropertyData<bool>(23, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
484 // property 'minimumVersion'
485 QtMocHelpers::PropertyData<QString>(24, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 0),
486 // property 'keywords'
487 QtMocHelpers::PropertyData<QString>(25, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 0),
488 // property 'icon'
489 QtMocHelpers::PropertyData<QString>(26, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 0),
490 // property 'seekReverse'
491 QtMocHelpers::PropertyData<bool>(27, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
492 };
493 QtMocHelpers::UintData qt_enums {
494 // enum 'PluginType'
495 QtMocHelpers::EnumData<PluginType>(4, 4, QMC::EnumFlags{}).add({
496 { 28, PluginType::Filter },
497 { 29, PluginType::Producer },
498 { 30, PluginType::Transition },
499 { 31, PluginType::Link },
500 { 32, PluginType::FilterSet },
501 }),
502 };
503 return QtMocHelpers::metaObjectData<QmlMetadata, qt_meta_tag_ZN11QmlMetadataE_t>(QMC::MetaObjectFlag{}, qt_stringData,
504 qt_methods, qt_properties, qt_enums);
505}
506Q_CONSTINIT const QMetaObject QmlMetadata::staticMetaObject = { {
507 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
508 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QmlMetadataE_t>.stringdata,
509 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QmlMetadataE_t>.data,
510 qt_static_metacall,
511 nullptr,
512 qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11QmlMetadataE_t>.metaTypes,
513 nullptr
514} };
515
516void QmlMetadata::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
517{
518 auto *_t = static_cast<QmlMetadata *>(_o);
519 if (_c == QMetaObject::InvokeMetaMethod) {
520 switch (_id) {
521 case 0: _t->changed(); break;
522 default: ;
523 }
524 }
525 if (_c == QMetaObject::IndexOfMethod) {
526 if (QtMocHelpers::indexOfMethod<void (QmlMetadata::*)()>(_a, &QmlMetadata::changed, 0))
527 return;
528 }
529 if (_c == QMetaObject::RegisterPropertyMetaType) {
530 switch (_id) {
531 default: *reinterpret_cast<int*>(_a[0]) = -1; break;
532 case 17:
533 *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QmlKeyframesMetadata* >(); break;
534 }
535 }
536 if (_c == QMetaObject::ReadProperty) {
537 void *_v = _a[0];
538 switch (_id) {
539 case 0: *reinterpret_cast<PluginType*>(_v) = _t->type(); break;
540 case 1: *reinterpret_cast<QString*>(_v) = _t->name(); break;
541 case 2: *reinterpret_cast<QString*>(_v) = _t->mlt_service(); break;
542 case 3: *reinterpret_cast<bool*>(_v) = _t->needsGPU(); break;
543 case 4: *reinterpret_cast<QString*>(_v) = _t->qmlFileName(); break;
544 case 5: *reinterpret_cast<QString*>(_v) = _t->vuiFileName(); break;
545 case 6: *reinterpret_cast<QUrl*>(_v) = _t->qmlFilePath(); break;
546 case 7: *reinterpret_cast<QUrl*>(_v) = _t->vuiFilePath(); break;
547 case 8: *reinterpret_cast<bool*>(_v) = _t->isAudio(); break;
548 case 9: *reinterpret_cast<bool*>(_v) = _t->isHidden(); break;
549 case 10: *reinterpret_cast<bool*>(_v) = _t->isFavorite(); break;
550 case 11: *reinterpret_cast<QString*>(_v) = _t->gpuAlt(); break;
551 case 12: *reinterpret_cast<bool*>(_v) = _t->allowMultiple(); break;
552 case 13: *reinterpret_cast<bool*>(_v) = _t->isClipOnly(); break;
553 case 14: *reinterpret_cast<bool*>(_v) = _t->isTrackOnly(); break;
554 case 15: *reinterpret_cast<bool*>(_v) = _t->isOutputOnly(); break;
555 case 16: *reinterpret_cast<bool*>(_v) = _t->isGpuCompatible(); break;
556 case 17: *reinterpret_cast<QmlKeyframesMetadata**>(_v) = _t->keyframes(); break;
557 case 18: *reinterpret_cast<bool*>(_v) = _t->isDeprecated(); break;
558 case 19: *reinterpret_cast<QString*>(_v) = _t->m_minimumVersion; break;
559 case 20: *reinterpret_cast<QString*>(_v) = _t->m_keywords; break;
560 case 21: *reinterpret_cast<QString*>(_v) = _t->iconFilePath(); break;
561 case 22: *reinterpret_cast<bool*>(_v) = _t->m_seekReverse; break;
562 default: break;
563 }
564 }
565 if (_c == QMetaObject::WriteProperty) {
566 void *_v = _a[0];
567 switch (_id) {
568 case 0: _t->setType(*reinterpret_cast<PluginType*>(_v)); break;
569 case 1: _t->setName(*reinterpret_cast<QString*>(_v)); break;
570 case 2: _t->set_mlt_service(*reinterpret_cast<QString*>(_v)); break;
571 case 3: _t->setNeedsGPU(*reinterpret_cast<bool*>(_v)); break;
572 case 4: _t->setQmlFileName(*reinterpret_cast<QString*>(_v)); break;
573 case 5: _t->setVuiFileName(*reinterpret_cast<QString*>(_v)); break;
574 case 8: _t->setIsAudio(*reinterpret_cast<bool*>(_v)); break;
575 case 9: _t->setIsHidden(*reinterpret_cast<bool*>(_v)); break;
576 case 10: _t->setIsFavorite(*reinterpret_cast<bool*>(_v)); break;
577 case 11: _t->setGpuAlt(*reinterpret_cast<QString*>(_v)); break;
578 case 12: _t->setAllowMultiple(*reinterpret_cast<bool*>(_v)); break;
579 case 13: _t->setIsClipOnly(*reinterpret_cast<bool*>(_v)); break;
580 case 14: _t->setIsTrackOnly(*reinterpret_cast<bool*>(_v)); break;
581 case 15: _t->setIsOutputOnly(*reinterpret_cast<bool*>(_v)); break;
582 case 16: _t->setIsGpuCompatible(*reinterpret_cast<bool*>(_v)); break;
583 case 18: _t->setIsDeprecated(*reinterpret_cast<bool*>(_v)); break;
584 case 19:
585 if (QtMocHelpers::setProperty(_t->m_minimumVersion, *reinterpret_cast<QString*>(_v)))
586 Q_EMIT _t->changed();
587 break;
588 case 20:
589 if (QtMocHelpers::setProperty(_t->m_keywords, *reinterpret_cast<QString*>(_v)))
590 Q_EMIT _t->changed();
591 break;
592 case 21: _t->setIconFileName(*reinterpret_cast<QString*>(_v)); break;
593 case 22:
594 if (QtMocHelpers::setProperty(_t->m_seekReverse, *reinterpret_cast<bool*>(_v)))
595 Q_EMIT _t->changed();
596 break;
597 default: break;
598 }
599 }
600}
601
602const QMetaObject *QmlMetadata::metaObject() const
603{
604 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
605}
606
607void *QmlMetadata::qt_metacast(const char *_clname)
608{
609 if (!_clname) return nullptr;
610 if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QmlMetadataE_t>.strings))
611 return static_cast<void*>(this);
612 return QObject::qt_metacast(_clname);
613}
614
615int QmlMetadata::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
616{
617 _id = QObject::qt_metacall(_c, _id, _a);
618 if (_id < 0)
619 return _id;
620 if (_c == QMetaObject::InvokeMetaMethod) {
621 if (_id < 1)
622 qt_static_metacall(this, _c, _id, _a);
623 _id -= 1;
624 }
625 if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
626 if (_id < 1)
627 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
628 _id -= 1;
629 }
630 if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
631 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
632 || _c == QMetaObject::RegisterPropertyMetaType) {
633 qt_static_metacall(this, _c, _id, _a);
634 _id -= 23;
635 }
636 return _id;
637}
638
639// SIGNAL 0
640void QmlMetadata::changed()
641{
642 QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
643}
644QT_WARNING_POP