CuteLogger
Fast and simple logging solution for Qt based applications
moc_videowidget.cpp
1/****************************************************************************
2** Meta object code from reading C++ file 'videowidget.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/videowidget.h"
10#include <QtCore/qmetatype.h>
11
12#include <QtCore/qtmochelpers.h>
13
14#include <memory>
15
16
17#include <QtCore/qxptype_traits.h>
18#if !defined(Q_MOC_OUTPUT_REVISION)
19#error "The header file 'videowidget.h' doesn't include <QObject>."
20#elif Q_MOC_OUTPUT_REVISION != 69
21#error "This file was generated using the moc from 6.10.2. It"
22#error "cannot be used with the include files from this version of Qt."
23#error "(The moc has changed too much.)"
24#endif
25
26#ifndef Q_CONSTINIT
27#define Q_CONSTINIT
28#endif
29
30QT_WARNING_PUSH
31QT_WARNING_DISABLE_DEPRECATED
32QT_WARNING_DISABLE_GCC("-Wuseless-cast")
33namespace {
34struct qt_meta_tag_ZN3Mlt11VideoWidgetE_t {};
35} // unnamed namespace
36
37template <> constexpr inline auto Mlt::VideoWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3Mlt11VideoWidgetE_t>()
38{
39 namespace QMC = QtMocConstants;
40 QtMocHelpers::StringRefStorage qt_stringData {
41 "Mlt::VideoWidget",
42 "frameDisplayed",
43 "",
44 "SharedFrame",
45 "frame",
46 "dragStarted",
47 "seekTo",
48 "x",
49 "gpuNotSupported",
50 "started",
51 "paused",
52 "playing",
53 "rectChanged",
54 "gridChanged",
55 "zoomChanged",
56 "offsetChanged",
57 "QPoint",
58 "offset",
59 "imageReady",
60 "snapToGridChanged",
61 "toggleZoom",
62 "stepZoom",
63 "setGrid",
64 "grid",
65 "setZoom",
66 "zoom",
67 "setOffsetX",
68 "setOffsetY",
69 "y",
70 "setBlankScene",
71 "setCurrentFilter",
72 "QmlFilter*",
73 "filter",
74 "QmlMetadata*",
75 "meta",
76 "setSnapToGrid",
77 "snap",
78 "initialize",
79 "beforeRendering",
80 "renderVideo",
81 "onFrameDisplayed",
82 "resizeVideo",
83 "width",
84 "height",
85 "onRefreshTimeout",
86 "rect",
87 "QRectF",
88 "snapToGrid"
89 };
90
91 QtMocHelpers::UintData qt_methods {
92 // Signal 'frameDisplayed'
93 QtMocHelpers::SignalData<void(const SharedFrame &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
94 { 0x80000000 | 3, 4 },
95 }}),
96 // Signal 'dragStarted'
97 QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
98 // Signal 'seekTo'
99 QtMocHelpers::SignalData<void(int)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
100 { QMetaType::Int, 7 },
101 }}),
102 // Signal 'gpuNotSupported'
103 QtMocHelpers::SignalData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
104 // Signal 'started'
105 QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
106 // Signal 'paused'
107 QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
108 // Signal 'playing'
109 QtMocHelpers::SignalData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
110 // Signal 'rectChanged'
111 QtMocHelpers::SignalData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
112 // Signal 'gridChanged'
113 QtMocHelpers::SignalData<void()>(13, 2, QMC::AccessPublic, QMetaType::Void),
114 // Signal 'zoomChanged'
115 QtMocHelpers::SignalData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
116 // Signal 'offsetChanged'
117 QtMocHelpers::SignalData<void(const QPoint &)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
118 { 0x80000000 | 16, 17 },
119 }}),
120 // Signal 'offsetChanged'
121 QtMocHelpers::SignalData<void()>(15, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
122 // Signal 'imageReady'
123 QtMocHelpers::SignalData<void()>(18, 2, QMC::AccessPublic, QMetaType::Void),
124 // Signal 'snapToGridChanged'
125 QtMocHelpers::SignalData<void()>(19, 2, QMC::AccessPublic, QMetaType::Void),
126 // Signal 'toggleZoom'
127 QtMocHelpers::SignalData<void(bool)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
128 { QMetaType::Bool, 2 },
129 }}),
130 // Signal 'stepZoom'
131 QtMocHelpers::SignalData<void(float, float)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
132 { QMetaType::Float, 2 }, { QMetaType::Float, 2 },
133 }}),
134 // Slot 'setGrid'
135 QtMocHelpers::SlotData<void(int)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
136 { QMetaType::Int, 23 },
137 }}),
138 // Slot 'setZoom'
139 QtMocHelpers::SlotData<void(float)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
140 { QMetaType::Float, 25 },
141 }}),
142 // Slot 'setOffsetX'
143 QtMocHelpers::SlotData<void(int)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
144 { QMetaType::Int, 7 },
145 }}),
146 // Slot 'setOffsetY'
147 QtMocHelpers::SlotData<void(int)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
148 { QMetaType::Int, 28 },
149 }}),
150 // Slot 'setBlankScene'
151 QtMocHelpers::SlotData<void()>(29, 2, QMC::AccessPublic, QMetaType::Void),
152 // Slot 'setCurrentFilter'
153 QtMocHelpers::SlotData<void(QmlFilter *, QmlMetadata *)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
154 { 0x80000000 | 31, 32 }, { 0x80000000 | 33, 34 },
155 }}),
156 // Slot 'setSnapToGrid'
157 QtMocHelpers::SlotData<void(bool)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
158 { QMetaType::Bool, 36 },
159 }}),
160 // Slot 'initialize'
161 QtMocHelpers::SlotData<void()>(37, 2, QMC::AccessPublic, QMetaType::Void),
162 // Slot 'beforeRendering'
163 QtMocHelpers::SlotData<void()>(38, 2, QMC::AccessPublic, QMetaType::Void),
164 // Slot 'renderVideo'
165 QtMocHelpers::SlotData<void()>(39, 2, QMC::AccessPublic, QMetaType::Void),
166 // Slot 'onFrameDisplayed'
167 QtMocHelpers::SlotData<void(const SharedFrame &)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
168 { 0x80000000 | 3, 4 },
169 }}),
170 // Slot 'resizeVideo'
171 QtMocHelpers::SlotData<void(int, int)>(41, 2, QMC::AccessPrivate, QMetaType::Void, {{
172 { QMetaType::Int, 42 }, { QMetaType::Int, 43 },
173 }}),
174 // Slot 'onRefreshTimeout'
175 QtMocHelpers::SlotData<void()>(44, 2, QMC::AccessPrivate, QMetaType::Void),
176 };
177 QtMocHelpers::UintData qt_properties {
178 // property 'rect'
179 QtMocHelpers::PropertyData<QRectF>(45, 0x80000000 | 46, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 7),
180 // property 'grid'
181 QtMocHelpers::PropertyData<int>(23, QMetaType::Int, QMC::DefaultPropertyFlags, 8),
182 // property 'snapToGrid'
183 QtMocHelpers::PropertyData<bool>(47, QMetaType::Bool, QMC::DefaultPropertyFlags, 13),
184 // property 'zoom'
185 QtMocHelpers::PropertyData<float>(25, QMetaType::Float, QMC::DefaultPropertyFlags, 9),
186 // property 'offset'
187 QtMocHelpers::PropertyData<QPoint>(17, 0x80000000 | 16, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 10),
188 };
189 QtMocHelpers::UintData qt_enums {
190 };
191 return QtMocHelpers::metaObjectData<VideoWidget, qt_meta_tag_ZN3Mlt11VideoWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
192 qt_methods, qt_properties, qt_enums);
193}
194Q_CONSTINIT const QMetaObject Mlt::VideoWidget::staticMetaObject = { {
195 QMetaObject::SuperData::link<QQuickWidget::staticMetaObject>(),
196 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt11VideoWidgetE_t>.stringdata,
197 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt11VideoWidgetE_t>.data,
198 qt_static_metacall,
199 nullptr,
200 qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3Mlt11VideoWidgetE_t>.metaTypes,
201 nullptr
202} };
203
204void Mlt::VideoWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
205{
206 auto *_t = static_cast<VideoWidget *>(_o);
207 if (_c == QMetaObject::InvokeMetaMethod) {
208 switch (_id) {
209 case 0: _t->frameDisplayed((*reinterpret_cast<std::add_pointer_t<SharedFrame>>(_a[1]))); break;
210 case 1: _t->dragStarted(); break;
211 case 2: _t->seekTo((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
212 case 3: _t->gpuNotSupported(); break;
213 case 4: _t->started(); break;
214 case 5: _t->paused(); break;
215 case 6: _t->playing(); break;
216 case 7: _t->rectChanged(); break;
217 case 8: _t->gridChanged(); break;
218 case 9: _t->zoomChanged(); break;
219 case 10: _t->offsetChanged((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
220 case 11: _t->offsetChanged(); break;
221 case 12: _t->imageReady(); break;
222 case 13: _t->snapToGridChanged(); break;
223 case 14: _t->toggleZoom((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
224 case 15: _t->stepZoom((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2]))); break;
225 case 16: _t->setGrid((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
226 case 17: _t->setZoom((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
227 case 18: _t->setOffsetX((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
228 case 19: _t->setOffsetY((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
229 case 20: _t->setBlankScene(); break;
230 case 21: _t->setCurrentFilter((*reinterpret_cast<std::add_pointer_t<QmlFilter*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QmlMetadata*>>(_a[2]))); break;
231 case 22: _t->setSnapToGrid((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
232 case 23: _t->initialize(); break;
233 case 24: _t->beforeRendering(); break;
234 case 25: _t->renderVideo(); break;
235 case 26: _t->onFrameDisplayed((*reinterpret_cast<std::add_pointer_t<SharedFrame>>(_a[1]))); break;
236 case 27: _t->resizeVideo((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
237 case 28: _t->onRefreshTimeout(); break;
238 default: ;
239 }
240 }
241 if (_c == QMetaObject::IndexOfMethod) {
242 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)(const SharedFrame & )>(_a, &VideoWidget::frameDisplayed, 0))
243 return;
244 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::dragStarted, 1))
245 return;
246 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)(int )>(_a, &VideoWidget::seekTo, 2))
247 return;
248 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::gpuNotSupported, 3))
249 return;
250 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::started, 4))
251 return;
252 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::paused, 5))
253 return;
254 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::playing, 6))
255 return;
256 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::rectChanged, 7))
257 return;
258 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::gridChanged, 8))
259 return;
260 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::zoomChanged, 9))
261 return;
262 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)(const QPoint & )>(_a, &VideoWidget::offsetChanged, 10))
263 return;
264 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::imageReady, 12))
265 return;
266 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::snapToGridChanged, 13))
267 return;
268 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)(bool )>(_a, &VideoWidget::toggleZoom, 14))
269 return;
270 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)(float , float )>(_a, &VideoWidget::stepZoom, 15))
271 return;
272 }
273 if (_c == QMetaObject::ReadProperty) {
274 void *_v = _a[0];
275 switch (_id) {
276 case 0: *reinterpret_cast<QRectF*>(_v) = _t->rect(); break;
277 case 1: *reinterpret_cast<int*>(_v) = _t->grid(); break;
278 case 2: *reinterpret_cast<bool*>(_v) = _t->snapToGrid(); break;
279 case 3: *reinterpret_cast<float*>(_v) = _t->zoom(); break;
280 case 4: *reinterpret_cast<QPoint*>(_v) = _t->offset(); break;
281 default: break;
282 }
283 }
284}
285
286const QMetaObject *Mlt::VideoWidget::metaObject() const
287{
288 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
289}
290
291void *Mlt::VideoWidget::qt_metacast(const char *_clname)
292{
293 if (!_clname) return nullptr;
294 if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt11VideoWidgetE_t>.strings))
295 return static_cast<void*>(this);
296 if (!strcmp(_clname, "Controller"))
297 return static_cast< Controller*>(this);
298 return QQuickWidget::qt_metacast(_clname);
299}
300
301int Mlt::VideoWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
302{
303 _id = QQuickWidget::qt_metacall(_c, _id, _a);
304 if (_id < 0)
305 return _id;
306 if (_c == QMetaObject::InvokeMetaMethod) {
307 if (_id < 29)
308 qt_static_metacall(this, _c, _id, _a);
309 _id -= 29;
310 }
311 if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
312 if (_id < 29)
313 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
314 _id -= 29;
315 }
316 if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
317 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
318 || _c == QMetaObject::RegisterPropertyMetaType) {
319 qt_static_metacall(this, _c, _id, _a);
320 _id -= 5;
321 }
322 return _id;
323}
324
325// SIGNAL 0
326void Mlt::VideoWidget::frameDisplayed(const SharedFrame & _t1)
327{
328 QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
329}
330
331// SIGNAL 1
332void Mlt::VideoWidget::dragStarted()
333{
334 QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
335}
336
337// SIGNAL 2
338void Mlt::VideoWidget::seekTo(int _t1)
339{
340 QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
341}
342
343// SIGNAL 3
344void Mlt::VideoWidget::gpuNotSupported()
345{
346 QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
347}
348
349// SIGNAL 4
350void Mlt::VideoWidget::started()
351{
352 QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
353}
354
355// SIGNAL 5
356void Mlt::VideoWidget::paused()
357{
358 QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
359}
360
361// SIGNAL 6
362void Mlt::VideoWidget::playing()
363{
364 QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
365}
366
367// SIGNAL 7
368void Mlt::VideoWidget::rectChanged()
369{
370 QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
371}
372
373// SIGNAL 8
374void Mlt::VideoWidget::gridChanged()
375{
376 QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
377}
378
379// SIGNAL 9
380void Mlt::VideoWidget::zoomChanged()
381{
382 QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
383}
384
385// SIGNAL 10
386void Mlt::VideoWidget::offsetChanged(const QPoint & _t1)
387{
388 QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
389}
390
391// SIGNAL 12
392void Mlt::VideoWidget::imageReady()
393{
394 QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
395}
396
397// SIGNAL 13
398void Mlt::VideoWidget::snapToGridChanged()
399{
400 QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
401}
402
403// SIGNAL 14
404void Mlt::VideoWidget::toggleZoom(bool _t1)
405{
406 QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
407}
408
409// SIGNAL 15
410void Mlt::VideoWidget::stepZoom(float _t1, float _t2)
411{
412 QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1, _t2);
413}
414namespace {
415struct qt_meta_tag_ZN3Mlt12RenderThreadE_t {};
416} // unnamed namespace
417
418template <> constexpr inline auto Mlt::RenderThread::qt_create_metaobjectdata<qt_meta_tag_ZN3Mlt12RenderThreadE_t>()
419{
420 namespace QMC = QtMocConstants;
421 QtMocHelpers::StringRefStorage qt_stringData {
422 "Mlt::RenderThread"
423 };
424
425 QtMocHelpers::UintData qt_methods {
426 };
427 QtMocHelpers::UintData qt_properties {
428 };
429 QtMocHelpers::UintData qt_enums {
430 };
431 return QtMocHelpers::metaObjectData<RenderThread, qt_meta_tag_ZN3Mlt12RenderThreadE_t>(QMC::MetaObjectFlag{}, qt_stringData,
432 qt_methods, qt_properties, qt_enums);
433}
434Q_CONSTINIT const QMetaObject Mlt::RenderThread::staticMetaObject = { {
435 QMetaObject::SuperData::link<QThread::staticMetaObject>(),
436 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt12RenderThreadE_t>.stringdata,
437 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt12RenderThreadE_t>.data,
438 qt_static_metacall,
439 nullptr,
440 qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3Mlt12RenderThreadE_t>.metaTypes,
441 nullptr
442} };
443
444void Mlt::RenderThread::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
445{
446 auto *_t = static_cast<RenderThread *>(_o);
447 (void)_t;
448 (void)_c;
449 (void)_id;
450 (void)_a;
451}
452
453const QMetaObject *Mlt::RenderThread::metaObject() const
454{
455 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
456}
457
458void *Mlt::RenderThread::qt_metacast(const char *_clname)
459{
460 if (!_clname) return nullptr;
461 if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt12RenderThreadE_t>.strings))
462 return static_cast<void*>(this);
463 return QThread::qt_metacast(_clname);
464}
465
466int Mlt::RenderThread::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
467{
468 _id = QThread::qt_metacall(_c, _id, _a);
469 return _id;
470}
471namespace {
472struct qt_meta_tag_ZN3Mlt13FrameRendererE_t {};
473} // unnamed namespace
474
475template <> constexpr inline auto Mlt::FrameRenderer::qt_create_metaobjectdata<qt_meta_tag_ZN3Mlt13FrameRendererE_t>()
476{
477 namespace QMC = QtMocConstants;
478 QtMocHelpers::StringRefStorage qt_stringData {
479 "Mlt::FrameRenderer",
480 "frameDisplayed",
481 "",
482 "SharedFrame",
483 "frame",
484 "imageReady",
485 "showFrame",
486 "Mlt::Frame"
487 };
488
489 QtMocHelpers::UintData qt_methods {
490 // Signal 'frameDisplayed'
491 QtMocHelpers::SignalData<void(const SharedFrame &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
492 { 0x80000000 | 3, 4 },
493 }}),
494 // Signal 'imageReady'
495 QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
496 // Method 'showFrame'
497 QtMocHelpers::MethodData<void(Mlt::Frame)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
498 { 0x80000000 | 7, 4 },
499 }}),
500 };
501 QtMocHelpers::UintData qt_properties {
502 };
503 QtMocHelpers::UintData qt_enums {
504 };
505 return QtMocHelpers::metaObjectData<FrameRenderer, qt_meta_tag_ZN3Mlt13FrameRendererE_t>(QMC::MetaObjectFlag{}, qt_stringData,
506 qt_methods, qt_properties, qt_enums);
507}
508Q_CONSTINIT const QMetaObject Mlt::FrameRenderer::staticMetaObject = { {
509 QMetaObject::SuperData::link<QThread::staticMetaObject>(),
510 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt13FrameRendererE_t>.stringdata,
511 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt13FrameRendererE_t>.data,
512 qt_static_metacall,
513 nullptr,
514 qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3Mlt13FrameRendererE_t>.metaTypes,
515 nullptr
516} };
517
518void Mlt::FrameRenderer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
519{
520 auto *_t = static_cast<FrameRenderer *>(_o);
521 if (_c == QMetaObject::InvokeMetaMethod) {
522 switch (_id) {
523 case 0: _t->frameDisplayed((*reinterpret_cast<std::add_pointer_t<SharedFrame>>(_a[1]))); break;
524 case 1: _t->imageReady(); break;
525 case 2: _t->showFrame((*reinterpret_cast<std::add_pointer_t<Mlt::Frame>>(_a[1]))); break;
526 default: ;
527 }
528 }
529 if (_c == QMetaObject::IndexOfMethod) {
530 if (QtMocHelpers::indexOfMethod<void (FrameRenderer::*)(const SharedFrame & )>(_a, &FrameRenderer::frameDisplayed, 0))
531 return;
532 if (QtMocHelpers::indexOfMethod<void (FrameRenderer::*)()>(_a, &FrameRenderer::imageReady, 1))
533 return;
534 }
535}
536
537const QMetaObject *Mlt::FrameRenderer::metaObject() const
538{
539 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
540}
541
542void *Mlt::FrameRenderer::qt_metacast(const char *_clname)
543{
544 if (!_clname) return nullptr;
545 if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt13FrameRendererE_t>.strings))
546 return static_cast<void*>(this);
547 return QThread::qt_metacast(_clname);
548}
549
550int Mlt::FrameRenderer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
551{
552 _id = QThread::qt_metacall(_c, _id, _a);
553 if (_id < 0)
554 return _id;
555 if (_c == QMetaObject::InvokeMetaMethod) {
556 if (_id < 3)
557 qt_static_metacall(this, _c, _id, _a);
558 _id -= 3;
559 }
560 if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
561 if (_id < 3)
562 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
563 _id -= 3;
564 }
565 return _id;
566}
567
568// SIGNAL 0
569void Mlt::FrameRenderer::frameDisplayed(const SharedFrame & _t1)
570{
571 QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
572}
573
574// SIGNAL 1
575void Mlt::FrameRenderer::imageReady()
576{
577 QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
578}
579QT_WARNING_POP
Generated on for CuteLogger by doxygen 1.14.0