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.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.10.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<enum 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<enum 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<enum 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<enum 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 "QUrl",
418 "vuiFilePath",
419 "isAudio",
420 "isHidden",
421 "isFavorite",
422 "gpuAlt",
423 "allowMultiple",
424 "isClipOnly",
425 "isTrackOnly",
426 "isOutputOnly",
427 "isGpuCompatible",
428 "keyframes",
429 "QmlKeyframesMetadata*",
430 "isDeprecated",
431 "minimumVersion",
432 "keywords",
433 "icon",
434 "seekReverse",
435 "Filter",
436 "Producer",
437 "Transition",
438 "Link",
439 "FilterSet"
440 };
441
442 QtMocHelpers::UintData qt_methods {
443 // Signal 'changed'
444 QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
445 };
446 QtMocHelpers::UintData qt_properties {
447 // property 'type'
448 QtMocHelpers::PropertyData<enum PluginType>(3, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 0),
449 // property 'name'
450 QtMocHelpers::PropertyData<QString>(5, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
451 // property 'mlt_service'
452 QtMocHelpers::PropertyData<QString>(6, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 0),
453 // property 'needsGPU'
454 QtMocHelpers::PropertyData<bool>(7, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
455 // property 'qml'
456 QtMocHelpers::PropertyData<QString>(8, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 0),
457 // property 'vui'
458 QtMocHelpers::PropertyData<QString>(9, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 0),
459 // property 'qmlFilePath'
460 QtMocHelpers::PropertyData<QUrl>(10, 0x80000000 | 11, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
461 // property 'vuiFilePath'
462 QtMocHelpers::PropertyData<QUrl>(12, 0x80000000 | 11, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
463 // property 'isAudio'
464 QtMocHelpers::PropertyData<bool>(13, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
465 // property 'isHidden'
466 QtMocHelpers::PropertyData<bool>(14, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
467 // property 'isFavorite'
468 QtMocHelpers::PropertyData<bool>(15, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
469 // property 'gpuAlt'
470 QtMocHelpers::PropertyData<QString>(16, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
471 // property 'allowMultiple'
472 QtMocHelpers::PropertyData<bool>(17, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
473 // property 'isClipOnly'
474 QtMocHelpers::PropertyData<bool>(18, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
475 // property 'isTrackOnly'
476 QtMocHelpers::PropertyData<bool>(19, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
477 // property 'isOutputOnly'
478 QtMocHelpers::PropertyData<bool>(20, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
479 // property 'isGpuCompatible'
480 QtMocHelpers::PropertyData<bool>(21, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
481 // property 'keyframes'
482 QtMocHelpers::PropertyData<QmlKeyframesMetadata*>(22, 0x80000000 | 23, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
483 // property 'isDeprecated'
484 QtMocHelpers::PropertyData<bool>(24, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
485 // property 'minimumVersion'
486 QtMocHelpers::PropertyData<QString>(25, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 0),
487 // property 'keywords'
488 QtMocHelpers::PropertyData<QString>(26, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 0),
489 // property 'icon'
490 QtMocHelpers::PropertyData<QString>(27, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 0),
491 // property 'seekReverse'
492 QtMocHelpers::PropertyData<bool>(28, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
493 };
494 QtMocHelpers::UintData qt_enums {
495 // enum 'PluginType'
496 QtMocHelpers::EnumData<enum PluginType>(4, 4, QMC::EnumFlags{}).add({
497 { 29, PluginType::Filter },
498 { 30, PluginType::Producer },
499 { 31, PluginType::Transition },
500 { 32, PluginType::Link },
501 { 33, PluginType::FilterSet },
502 }),
503 };
504 return QtMocHelpers::metaObjectData<QmlMetadata, qt_meta_tag_ZN11QmlMetadataE_t>(QMC::MetaObjectFlag{}, qt_stringData,
505 qt_methods, qt_properties, qt_enums);
506}
507Q_CONSTINIT const QMetaObject QmlMetadata::staticMetaObject = { {
508 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
509 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QmlMetadataE_t>.stringdata,
510 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QmlMetadataE_t>.data,
511 qt_static_metacall,
512 nullptr,
513 qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11QmlMetadataE_t>.metaTypes,
514 nullptr
515} };
516
517void QmlMetadata::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
518{
519 auto *_t = static_cast<QmlMetadata *>(_o);
520 if (_c == QMetaObject::InvokeMetaMethod) {
521 switch (_id) {
522 case 0: _t->changed(); break;
523 default: ;
524 }
525 }
526 if (_c == QMetaObject::IndexOfMethod) {
527 if (QtMocHelpers::indexOfMethod<void (QmlMetadata::*)()>(_a, &QmlMetadata::changed, 0))
528 return;
529 }
530 if (_c == QMetaObject::RegisterPropertyMetaType) {
531 switch (_id) {
532 default: *reinterpret_cast<int*>(_a[0]) = -1; break;
533 case 17:
534 *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QmlKeyframesMetadata* >(); break;
535 }
536 }
537 if (_c == QMetaObject::ReadProperty) {
538 void *_v = _a[0];
539 switch (_id) {
540 case 0: *reinterpret_cast<enum PluginType*>(_v) = _t->type(); break;
541 case 1: *reinterpret_cast<QString*>(_v) = _t->name(); break;
542 case 2: *reinterpret_cast<QString*>(_v) = _t->mlt_service(); break;
543 case 3: *reinterpret_cast<bool*>(_v) = _t->needsGPU(); break;
544 case 4: *reinterpret_cast<QString*>(_v) = _t->qmlFileName(); break;
545 case 5: *reinterpret_cast<QString*>(_v) = _t->vuiFileName(); break;
546 case 6: *reinterpret_cast<QUrl*>(_v) = _t->qmlFilePath(); break;
547 case 7: *reinterpret_cast<QUrl*>(_v) = _t->vuiFilePath(); break;
548 case 8: *reinterpret_cast<bool*>(_v) = _t->isAudio(); break;
549 case 9: *reinterpret_cast<bool*>(_v) = _t->isHidden(); break;
550 case 10: *reinterpret_cast<bool*>(_v) = _t->isFavorite(); break;
551 case 11: *reinterpret_cast<QString*>(_v) = _t->gpuAlt(); break;
552 case 12: *reinterpret_cast<bool*>(_v) = _t->allowMultiple(); break;
553 case 13: *reinterpret_cast<bool*>(_v) = _t->isClipOnly(); break;
554 case 14: *reinterpret_cast<bool*>(_v) = _t->isTrackOnly(); break;
555 case 15: *reinterpret_cast<bool*>(_v) = _t->isOutputOnly(); break;
556 case 16: *reinterpret_cast<bool*>(_v) = _t->isGpuCompatible(); break;
557 case 17: *reinterpret_cast<QmlKeyframesMetadata**>(_v) = _t->keyframes(); break;
558 case 18: *reinterpret_cast<bool*>(_v) = _t->isDeprecated(); break;
559 case 19: *reinterpret_cast<QString*>(_v) = _t->m_minimumVersion; break;
560 case 20: *reinterpret_cast<QString*>(_v) = _t->m_keywords; break;
561 case 21: *reinterpret_cast<QString*>(_v) = _t->iconFilePath(); break;
562 case 22: *reinterpret_cast<bool*>(_v) = _t->m_seekReverse; break;
563 default: break;
564 }
565 }
566 if (_c == QMetaObject::WriteProperty) {
567 void *_v = _a[0];
568 switch (_id) {
569 case 0: _t->setType(*reinterpret_cast<enum PluginType*>(_v)); break;
570 case 1: _t->setName(*reinterpret_cast<QString*>(_v)); break;
571 case 2: _t->set_mlt_service(*reinterpret_cast<QString*>(_v)); break;
572 case 3: _t->setNeedsGPU(*reinterpret_cast<bool*>(_v)); break;
573 case 4: _t->setQmlFileName(*reinterpret_cast<QString*>(_v)); break;
574 case 5: _t->setVuiFileName(*reinterpret_cast<QString*>(_v)); break;
575 case 8: _t->setIsAudio(*reinterpret_cast<bool*>(_v)); break;
576 case 9: _t->setIsHidden(*reinterpret_cast<bool*>(_v)); break;
577 case 10: _t->setIsFavorite(*reinterpret_cast<bool*>(_v)); break;
578 case 11: _t->setGpuAlt(*reinterpret_cast<QString*>(_v)); break;
579 case 12: _t->setAllowMultiple(*reinterpret_cast<bool*>(_v)); break;
580 case 13: _t->setIsClipOnly(*reinterpret_cast<bool*>(_v)); break;
581 case 14: _t->setIsTrackOnly(*reinterpret_cast<bool*>(_v)); break;
582 case 15: _t->setIsOutputOnly(*reinterpret_cast<bool*>(_v)); break;
583 case 16: _t->setIsGpuCompatible(*reinterpret_cast<bool*>(_v)); break;
584 case 18: _t->setIsDeprecated(*reinterpret_cast<bool*>(_v)); break;
585 case 19:
586 if (QtMocHelpers::setProperty(_t->m_minimumVersion, *reinterpret_cast<QString*>(_v)))
587 Q_EMIT _t->changed();
588 break;
589 case 20:
590 if (QtMocHelpers::setProperty(_t->m_keywords, *reinterpret_cast<QString*>(_v)))
591 Q_EMIT _t->changed();
592 break;
593 case 21: _t->setIconFileName(*reinterpret_cast<QString*>(_v)); break;
594 case 22:
595 if (QtMocHelpers::setProperty(_t->m_seekReverse, *reinterpret_cast<bool*>(_v)))
596 Q_EMIT _t->changed();
597 break;
598 default: break;
599 }
600 }
601}
602
603const QMetaObject *QmlMetadata::metaObject() const
604{
605 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
606}
607
608void *QmlMetadata::qt_metacast(const char *_clname)
609{
610 if (!_clname) return nullptr;
611 if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QmlMetadataE_t>.strings))
612 return static_cast<void*>(this);
613 return QObject::qt_metacast(_clname);
614}
615
616int QmlMetadata::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
617{
618 _id = QObject::qt_metacall(_c, _id, _a);
619 if (_id < 0)
620 return _id;
621 if (_c == QMetaObject::InvokeMetaMethod) {
622 if (_id < 1)
623 qt_static_metacall(this, _c, _id, _a);
624 _id -= 1;
625 }
626 if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
627 if (_id < 1)
628 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
629 _id -= 1;
630 }
631 if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
632 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
633 || _c == QMetaObject::RegisterPropertyMetaType) {
634 qt_static_metacall(this, _c, _id, _a);
635 _id -= 23;
636 }
637 return _id;
638}
639
640// SIGNAL 0
641void QmlMetadata::changed()
642{
643 QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
644}
645QT_WARNING_POP
Generated on for CuteLogger by doxygen 1.14.0