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