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