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