/****************************************************************************
** Meta object code from reading C++ file 'monitor.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.0)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../../../../kdenlive-26.04.1/src/monitor/monitor.h"
#include <QtNetwork/QSslPreSharedKeyAuthenticator>
#include <QtNetwork/QSslError>
#include <QtGui/qtextcursor.h>
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'monitor.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.0. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN12VolumeActionE_t {};
} // unnamed namespace

template <> constexpr inline auto VolumeAction::qt_create_metaobjectdata<qt_meta_tag_ZN12VolumeActionE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "VolumeAction",
        "volumeChanged",
        "",
        "volume"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'volumeChanged'
        QtMocHelpers::SignalData<void(int)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<VolumeAction, qt_meta_tag_ZN12VolumeActionE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject VolumeAction::staticMetaObject = { {
    QMetaObject::SuperData::link<QWidgetAction::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12VolumeActionE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12VolumeActionE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12VolumeActionE_t>.metaTypes,
    nullptr
} };

void VolumeAction::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<VolumeAction *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->volumeChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (VolumeAction::*)(int )>(_a, &VolumeAction::volumeChanged, 0))
            return;
    }
}

const QMetaObject *VolumeAction::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *VolumeAction::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12VolumeActionE_t>.strings))
        return static_cast<void*>(this);
    return QWidgetAction::qt_metacast(_clname);
}

int VolumeAction::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QWidgetAction::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void VolumeAction::volumeChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN7MonitorE_t {};
} // unnamed namespace

template <> constexpr inline auto Monitor::qt_create_metaobjectdata<qt_meta_tag_ZN7MonitorE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Monitor",
        "screenChanged",
        "",
        "screenIndex",
        "seekPosition",
        "pos",
        "seekRemap",
        "updateScene",
        "durationChanged",
        "zoneUpdated",
        "QPoint",
        "zoneUpdatedWithUndo",
        "effectChanged",
        "QRectF",
        "effectPointsChanged",
        "QVariantList",
        "addRemoveKeyframe",
        "addOnly",
        "seekToKeyframe",
        "ix",
        "offset",
        "addClipToProject",
        "QUrl",
        "refreshCurrentClip",
        "addTimelineEffect",
        "passKeyPress",
        "QKeyEvent*",
        "multitrackView",
        "timeCodeUpdated",
        "addMarker",
        "deleteMarker",
        "deleteGuide",
        "seekToPreviousSnap",
        "seekToNextSnap",
        "createSplitOverlay",
        "std::shared_ptr<Mlt::Filter>",
        "removeSplitOverlay",
        "activateTrack",
        "notesMode",
        "autoKeyframeChanged",
        "zoneDurationChanged",
        "blockSceneChange",
        "addMonitorControlPoint",
        "position",
        "QSize",
        "frameSize",
        "xPos",
        "yPos",
        "extend",
        "exclude",
        "moveMonitorControlPoint",
        "addMonitorControlRect",
        "QRect",
        "rect",
        "generateMask",
        "disablePreviewMask",
        "sceneChanged",
        "MonitorSceneType",
        "sceneType",
        "effectRotationChanged",
        "rotation",
        "profileUpdated",
        "slotSetThumbFrame",
        "slotSeek",
        "updateClipZone",
        "zone",
        "slotGoToMarker",
        "QAction*",
        "action",
        "slotSetVolume",
        "volume",
        "slotEditMarker",
        "slotExtractCurrentZone",
        "onFrameDisplayed",
        "SharedFrame",
        "frame",
        "slotStartDrag",
        "setZoom",
        "zoomRatio",
        "slotAdjustEffectCompare",
        "slotShowMenu",
        "slotForceSize",
        "a",
        "buildBackgroundedProducer",
        "slotLockMonitor",
        "lock",
        "slotSwitchPlay",
        "slotEditInlineMarker",
        "doKeyPressEvent",
        "gpuError",
        "setOffsetX",
        "x",
        "setOffsetY",
        "y",
        "panView",
        "diff",
        "slotSeekPosition",
        "addSnapPoint",
        "removeSnapPoint",
        "processSeek",
        "noAudioScrub",
        "checkDrops",
        "addControlPoint",
        "moveControlPoint",
        "addControlRect",
        "width",
        "height",
        "updatePowerManagement",
        "rebuildAudio",
        "cid",
        "slotCreateRangeMarkerFromZone",
        "slotCreateRangeMarkerFromZoneQuick",
        "updateTimelineProducer",
        "setProducer",
        "QUuid",
        "std::shared_ptr<Mlt::Producer>",
        "producer",
        "slotSetScreen",
        "slotPreviewResource",
        "path",
        "title",
        "updateClipProducer",
        "prod",
        "playlist",
        "slotOpenClip",
        "std::shared_ptr<ProjectClip>",
        "controller",
        "in",
        "out",
        "sequenceUuid",
        "slotRefreshMonitor",
        "visible",
        "stop",
        "start",
        "switchPlay",
        "play",
        "updatePlayAction",
        "slotPlay",
        "pause",
        "slotPlayZone",
        "startFromIn",
        "slotLoopZone",
        "slotLoopClip",
        "std::pair<int,int>",
        "inOut",
        "slotForward",
        "speed",
        "allowNormalPlay",
        "slotRewind",
        "slotRewindOneFrame",
        "slotForwardOneFrame",
        "warningMessage",
        "text",
        "timeout",
        "QList<QAction*>",
        "actions",
        "slotStart",
        "slotTrimmingPos",
        "frames1",
        "frames2",
        "slotEnd",
        "slotSetZoneStart",
        "slotSetZoneEnd",
        "slotZoneStart",
        "slotZoneEnd",
        "slotSetZone",
        "slotLoadClipZone",
        "slotSeekToNextSnap",
        "slotSeekToPreviousSnap",
        "adjustRulerSize",
        "length",
        "std::shared_ptr<MarkerSortModel>",
        "markerModel",
        "setTimePos",
        "slotShowEffectScene",
        "temporary",
        "QVariant",
        "sceneData",
        "effectSceneDisplayed",
        "effectType",
        "slotSwitchCompare",
        "enable",
        "slotMouseSeek",
        "eventDelta",
        "modifiers",
        "slotSwitchFullScreen",
        "minimizeOnly",
        "slotSwitchRec",
        "slotSwitchTrimming",
        "slotGetCurrentImage",
        "request",
        "slotSwitchAudioMonitor",
        "slotSwitchRecTimecode",
        "requestSeek",
        "requestSeekIfVisible",
        "checkOverlay",
        "refreshMonitorIfActive",
        "directUpdate",
        "refreshMonitor",
        "slowRefresh",
        "forceMonitorRefresh",
        "purgeCache",
        "abortPreviewMask",
        "rebuildProducer"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'screenChanged'
        QtMocHelpers::SignalData<void(int)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
        // Signal 'seekPosition'
        QtMocHelpers::SignalData<void(int)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
        // Signal 'seekRemap'
        QtMocHelpers::SignalData<void(int)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
        // Signal 'updateScene'
        QtMocHelpers::SignalData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'durationChanged'
        QtMocHelpers::SignalData<void(int)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Signal 'zoneUpdated'
        QtMocHelpers::SignalData<void(const QPoint &)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 10, 2 },
        }}),
        // Signal 'zoneUpdatedWithUndo'
        QtMocHelpers::SignalData<void(const QPoint &, const QPoint &)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 10, 2 }, { 0x80000000 | 10, 2 },
        }}),
        // Signal 'effectChanged'
        QtMocHelpers::SignalData<void(const QRectF &)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 13, 2 },
        }}),
        // Signal 'effectPointsChanged'
        QtMocHelpers::SignalData<void(const QVariantList &)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 15, 2 },
        }}),
        // Signal 'addRemoveKeyframe'
        QtMocHelpers::SignalData<void(bool)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'seekToKeyframe'
        QtMocHelpers::SignalData<void(int, int)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 19 }, { QMetaType::Int, 20 },
        }}),
        // Signal 'addClipToProject'
        QtMocHelpers::SignalData<void(const QUrl &)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 22, 2 },
        }}),
        // Signal 'refreshCurrentClip'
        QtMocHelpers::SignalData<void()>(23, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'addTimelineEffect'
        QtMocHelpers::SignalData<void(const QStringList &)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 2 },
        }}),
        // Signal 'passKeyPress'
        QtMocHelpers::SignalData<void(QKeyEvent *)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 26, 2 },
        }}),
        // Signal 'multitrackView'
        QtMocHelpers::SignalData<void(bool, bool)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 }, { QMetaType::Bool, 2 },
        }}),
        // Signal 'timeCodeUpdated'
        QtMocHelpers::SignalData<void(const QString &)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Signal 'addMarker'
        QtMocHelpers::SignalData<void()>(29, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'deleteMarker'
        QtMocHelpers::SignalData<void(bool)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 31 },
        }}),
        // Signal 'deleteMarker'
        QtMocHelpers::SignalData<void()>(30, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Signal 'seekToPreviousSnap'
        QtMocHelpers::SignalData<void()>(32, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'seekToNextSnap'
        QtMocHelpers::SignalData<void()>(33, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'createSplitOverlay'
        QtMocHelpers::SignalData<void(std::shared_ptr<Mlt::Filter>)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 35, 2 },
        }}),
        // Signal 'removeSplitOverlay'
        QtMocHelpers::SignalData<void()>(36, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'activateTrack'
        QtMocHelpers::SignalData<void(int, bool)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 }, { QMetaType::Bool, 38 },
        }}),
        // Signal 'activateTrack'
        QtMocHelpers::SignalData<void(int)>(37, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Signal 'autoKeyframeChanged'
        QtMocHelpers::SignalData<void()>(39, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'zoneDurationChanged'
        QtMocHelpers::SignalData<void()>(40, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'blockSceneChange'
        QtMocHelpers::SignalData<void(bool)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'addMonitorControlPoint'
        QtMocHelpers::SignalData<void(int, const QSize, int, int, bool, bool)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 43 }, { 0x80000000 | 44, 45 }, { QMetaType::Int, 46 }, { QMetaType::Int, 47 },
            { QMetaType::Bool, 48 }, { QMetaType::Bool, 49 },
        }}),
        // Signal 'moveMonitorControlPoint'
        QtMocHelpers::SignalData<void(int, int, const QSize, int, int)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 19 }, { QMetaType::Int, 43 }, { 0x80000000 | 44, 45 }, { QMetaType::Int, 46 },
            { QMetaType::Int, 47 },
        }}),
        // Signal 'addMonitorControlRect'
        QtMocHelpers::SignalData<void(int, const QSize, const QRect, bool)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 43 }, { 0x80000000 | 44, 45 }, { 0x80000000 | 52, 53 }, { QMetaType::Bool, 48 },
        }}),
        // Signal 'generateMask'
        QtMocHelpers::SignalData<void()>(54, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'disablePreviewMask'
        QtMocHelpers::SignalData<void()>(55, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sceneChanged'
        QtMocHelpers::SignalData<void(MonitorSceneType)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 57, 58 },
        }}),
        // Signal 'effectRotationChanged'
        QtMocHelpers::SignalData<void(double)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 60 },
        }}),
        // Signal 'profileUpdated'
        QtMocHelpers::SignalData<void()>(61, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSetThumbFrame'
        QtMocHelpers::SlotData<void()>(62, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'slotSeek'
        QtMocHelpers::SlotData<void()>(63, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateClipZone'
        QtMocHelpers::SlotData<void(const QPoint)>(64, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 10, 65 },
        }}),
        // Slot 'slotGoToMarker'
        QtMocHelpers::SlotData<void(QAction *)>(66, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Slot 'slotSetVolume'
        QtMocHelpers::SlotData<void(int)>(69, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 70 },
        }}),
        // Slot 'slotEditMarker'
        QtMocHelpers::SlotData<void()>(71, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'slotExtractCurrentZone'
        QtMocHelpers::SlotData<void()>(72, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'onFrameDisplayed'
        QtMocHelpers::SlotData<void(const SharedFrame &)>(73, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 74, 75 },
        }}),
        // Slot 'slotStartDrag'
        QtMocHelpers::SlotData<void()>(76, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'setZoom'
        QtMocHelpers::SlotData<void(float)>(77, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Float, 78 },
        }}),
        // Slot 'slotAdjustEffectCompare'
        QtMocHelpers::SlotData<void()>(79, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'slotShowMenu'
        QtMocHelpers::SlotData<void(const QPoint)>(80, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 10, 5 },
        }}),
        // Slot 'slotForceSize'
        QtMocHelpers::SlotData<void(QAction *)>(81, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 67, 82 },
        }}),
        // Slot 'buildBackgroundedProducer'
        QtMocHelpers::SlotData<void(int)>(83, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
        // Slot 'slotLockMonitor'
        QtMocHelpers::SlotData<void(bool)>(84, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 85 },
        }}),
        // Slot 'slotSwitchPlay'
        QtMocHelpers::SlotData<void()>(86, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'slotEditInlineMarker'
        QtMocHelpers::SlotData<void()>(87, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'doKeyPressEvent'
        QtMocHelpers::SlotData<void(QKeyEvent *)>(88, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 26, 2 },
        }}),
        // Slot 'gpuError'
        QtMocHelpers::SlotData<void()>(89, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'setOffsetX'
        QtMocHelpers::SlotData<void(int)>(90, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 91 },
        }}),
        // Slot 'setOffsetY'
        QtMocHelpers::SlotData<void(int)>(92, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 93 },
        }}),
        // Slot 'panView'
        QtMocHelpers::SlotData<void(QPoint)>(94, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 10, 95 },
        }}),
        // Slot 'slotSeekPosition'
        QtMocHelpers::SlotData<void(int)>(96, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Slot 'addSnapPoint'
        QtMocHelpers::SlotData<void(int)>(97, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
        // Slot 'removeSnapPoint'
        QtMocHelpers::SlotData<void(int)>(98, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
        // Slot 'processSeek'
        QtMocHelpers::SlotData<void(int, bool)>(99, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 5 }, { QMetaType::Bool, 100 },
        }}),
        // Slot 'processSeek'
        QtMocHelpers::SlotData<void(int)>(99, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
        // Slot 'checkDrops'
        QtMocHelpers::SlotData<void()>(101, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addControlPoint'
        QtMocHelpers::SlotData<void(double, double, bool, bool)>(102, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Double, 91 }, { QMetaType::Double, 93 }, { QMetaType::Bool, 48 }, { QMetaType::Bool, 49 },
        }}),
        // Slot 'moveControlPoint'
        QtMocHelpers::SlotData<void(int, double, double)>(103, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 19 }, { QMetaType::Double, 91 }, { QMetaType::Double, 93 },
        }}),
        // Slot 'addControlRect'
        QtMocHelpers::SlotData<void(double, double, double, double, bool)>(104, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Double, 91 }, { QMetaType::Double, 93 }, { QMetaType::Double, 105 }, { QMetaType::Double, 106 },
            { QMetaType::Bool, 48 },
        }}),
        // Slot 'updatePowerManagement'
        QtMocHelpers::SlotData<void()>(107, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'rebuildAudio'
        QtMocHelpers::SlotData<void(int)>(108, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 109 },
        }}),
        // Slot 'slotCreateRangeMarkerFromZone'
        QtMocHelpers::SlotData<void()>(110, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotCreateRangeMarkerFromZoneQuick'
        QtMocHelpers::SlotData<void()>(111, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateTimelineProducer'
        QtMocHelpers::SlotData<void()>(112, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setProducer'
        QtMocHelpers::SlotData<void(const QUuid, std::shared_ptr<Mlt::Producer>, int)>(113, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 114, 2 }, { 0x80000000 | 115, 116 }, { QMetaType::Int, 5 },
        }}),
        // Slot 'setProducer'
        QtMocHelpers::SlotData<void(const QUuid, std::shared_ptr<Mlt::Producer>)>(113, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 114, 2 }, { 0x80000000 | 115, 116 },
        }}),
        // Slot 'slotSetScreen'
        QtMocHelpers::SlotData<void(int)>(117, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
        // Slot 'slotPreviewResource'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(118, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 119 }, { QMetaType::QString, 120 },
        }}),
        // Slot 'updateClipProducer'
        QtMocHelpers::SlotData<void(const std::shared_ptr<Mlt::Producer> &)>(121, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 115, 122 },
        }}),
        // Slot 'updateClipProducer'
        QtMocHelpers::SlotData<void(const QString &)>(121, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 123 },
        }}),
        // Slot 'slotOpenClip'
        QtMocHelpers::SlotData<bool(const std::shared_ptr<ProjectClip> &, int, int, const QUuid &)>(124, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 125, 126 }, { QMetaType::Int, 127 }, { QMetaType::Int, 128 }, { 0x80000000 | 114, 129 },
        }}),
        // Slot 'slotOpenClip'
        QtMocHelpers::SlotData<bool(const std::shared_ptr<ProjectClip> &, int, int)>(124, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { 0x80000000 | 125, 126 }, { QMetaType::Int, 127 }, { QMetaType::Int, 128 },
        }}),
        // Slot 'slotOpenClip'
        QtMocHelpers::SlotData<bool(const std::shared_ptr<ProjectClip> &, int)>(124, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { 0x80000000 | 125, 126 }, { QMetaType::Int, 127 },
        }}),
        // Slot 'slotOpenClip'
        QtMocHelpers::SlotData<bool(const std::shared_ptr<ProjectClip> &)>(124, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { 0x80000000 | 125, 126 },
        }}),
        // Slot 'slotRefreshMonitor'
        QtMocHelpers::SlotData<void(bool)>(130, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 131 },
        }}),
        // Slot 'slotSeek'
        QtMocHelpers::SlotData<void(int)>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
        // Slot 'stop'
        QtMocHelpers::SlotData<void()>(132, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'start'
        QtMocHelpers::SlotData<void()>(133, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'switchPlay'
        QtMocHelpers::SlotData<void(bool)>(134, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 135 },
        }}),
        // Slot 'updatePlayAction'
        QtMocHelpers::SlotData<void(bool)>(136, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 135 },
        }}),
        // Slot 'slotPlay'
        QtMocHelpers::SlotData<void()>(137, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'pause'
        QtMocHelpers::SlotData<void()>(138, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotPlayZone'
        QtMocHelpers::SlotData<void(bool)>(139, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 140 },
        }}),
        // Slot 'slotPlayZone'
        QtMocHelpers::SlotData<void()>(139, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'slotLoopZone'
        QtMocHelpers::SlotData<void()>(141, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotLoopClip'
        QtMocHelpers::SlotData<void(std::pair<int,int>)>(142, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 143, 144 },
        }}),
        // Slot 'slotForward'
        QtMocHelpers::SlotData<void(double, bool)>(145, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 146 }, { QMetaType::Bool, 147 },
        }}),
        // Slot 'slotForward'
        QtMocHelpers::SlotData<void(double)>(145, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Double, 146 },
        }}),
        // Slot 'slotForward'
        QtMocHelpers::SlotData<void()>(145, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'slotRewind'
        QtMocHelpers::SlotData<void(double)>(148, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 146 },
        }}),
        // Slot 'slotRewind'
        QtMocHelpers::SlotData<void()>(148, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'slotRewindOneFrame'
        QtMocHelpers::SlotData<void(int)>(149, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 95 },
        }}),
        // Slot 'slotRewindOneFrame'
        QtMocHelpers::SlotData<void()>(149, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'slotForwardOneFrame'
        QtMocHelpers::SlotData<void(int)>(150, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 95 },
        }}),
        // Slot 'slotForwardOneFrame'
        QtMocHelpers::SlotData<void()>(150, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'warningMessage'
        QtMocHelpers::SlotData<void(const QString &, int, const QList<QAction*> &)>(151, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 152 }, { QMetaType::Int, 153 }, { 0x80000000 | 154, 155 },
        }}),
        // Slot 'warningMessage'
        QtMocHelpers::SlotData<void(const QString &, int)>(151, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 152 }, { QMetaType::Int, 153 },
        }}),
        // Slot 'warningMessage'
        QtMocHelpers::SlotData<void(const QString &)>(151, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 152 },
        }}),
        // Slot 'slotStart'
        QtMocHelpers::SlotData<void()>(156, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotTrimmingPos'
        QtMocHelpers::SlotData<void(int, int, int, int)>(157, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 5 }, { QMetaType::Int, 20 }, { QMetaType::Int, 158 }, { QMetaType::Int, 159 },
        }}),
        // Slot 'slotTrimmingPos'
        QtMocHelpers::SlotData<void(int)>(157, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 20 },
        }}),
        // Slot 'slotEnd'
        QtMocHelpers::SlotData<void()>(160, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSetZoneStart'
        QtMocHelpers::SlotData<void()>(161, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSetZoneEnd'
        QtMocHelpers::SlotData<void()>(162, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotZoneStart'
        QtMocHelpers::SlotData<void()>(163, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotZoneEnd'
        QtMocHelpers::SlotData<void()>(164, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSetZone'
        QtMocHelpers::SlotData<void(const QPoint)>(165, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 10, 65 },
        }}),
        // Slot 'slotLoadClipZone'
        QtMocHelpers::SlotData<void(const QPoint &)>(166, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 10, 65 },
        }}),
        // Slot 'slotSeekToNextSnap'
        QtMocHelpers::SlotData<void()>(167, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSeekToPreviousSnap'
        QtMocHelpers::SlotData<void()>(168, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'adjustRulerSize'
        QtMocHelpers::SlotData<void(int, const std::shared_ptr<MarkerSortModel> &)>(169, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 170 }, { 0x80000000 | 171, 172 },
        }}),
        // Slot 'adjustRulerSize'
        QtMocHelpers::SlotData<void(int)>(169, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 170 },
        }}),
        // Slot 'setTimePos'
        QtMocHelpers::SlotData<void(const QString &)>(173, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Slot 'slotShowEffectScene'
        QtMocHelpers::SlotData<void(MonitorSceneType, bool, const QVariant &)>(174, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 57, 58 }, { QMetaType::Bool, 175 }, { 0x80000000 | 176, 177 },
        }}),
        // Slot 'slotShowEffectScene'
        QtMocHelpers::SlotData<void(MonitorSceneType, bool)>(174, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 57, 58 }, { QMetaType::Bool, 175 },
        }}),
        // Slot 'slotShowEffectScene'
        QtMocHelpers::SlotData<void(MonitorSceneType)>(174, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 57, 58 },
        }}),
        // Slot 'effectSceneDisplayed'
        QtMocHelpers::SlotData<bool(MonitorSceneType)>(178, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 57, 179 },
        }}),
        // Slot 'slotSwitchCompare'
        QtMocHelpers::SlotData<void(bool)>(180, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 181 },
        }}),
        // Slot 'slotMouseSeek'
        QtMocHelpers::SlotData<void(int, uint)>(182, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 183 }, { QMetaType::UInt, 184 },
        }}),
        // Slot 'slotSwitchFullScreen'
        QtMocHelpers::SlotData<void(bool)>(185, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 186 },
        }}),
        // Slot 'slotSwitchFullScreen'
        QtMocHelpers::SlotData<void()>(185, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'slotSwitchRec'
        QtMocHelpers::SlotData<void(bool)>(187, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 181 },
        }}),
        // Slot 'slotSwitchTrimming'
        QtMocHelpers::SlotData<void(bool)>(188, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 181 },
        }}),
        // Slot 'slotGetCurrentImage'
        QtMocHelpers::SlotData<void(bool)>(189, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 190 },
        }}),
        // Slot 'slotSwitchAudioMonitor'
        QtMocHelpers::SlotData<void()>(191, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSwitchRecTimecode'
        QtMocHelpers::SlotData<void(bool)>(192, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 181 },
        }}),
        // Slot 'requestSeek'
        QtMocHelpers::SlotData<void(int)>(193, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
        // Slot 'requestSeekIfVisible'
        QtMocHelpers::SlotData<void(int)>(194, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
        // Slot 'checkOverlay'
        QtMocHelpers::SlotData<void(int)>(195, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
        // Slot 'checkOverlay'
        QtMocHelpers::SlotData<void()>(195, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'refreshMonitorIfActive'
        QtMocHelpers::SlotData<void(bool)>(196, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 197 },
        }}),
        // Slot 'refreshMonitorIfActive'
        QtMocHelpers::SlotData<void()>(196, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'refreshMonitor'
        QtMocHelpers::SlotData<void(bool, bool)>(198, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 197 }, { QMetaType::Bool, 199 },
        }}),
        // Slot 'refreshMonitor'
        QtMocHelpers::SlotData<void(bool)>(198, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 197 },
        }}),
        // Slot 'refreshMonitor'
        QtMocHelpers::SlotData<void()>(198, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'forceMonitorRefresh'
        QtMocHelpers::SlotData<void()>(200, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'purgeCache'
        QtMocHelpers::SlotData<void()>(201, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'abortPreviewMask'
        QtMocHelpers::SlotData<void(bool)>(202, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 203 },
        }}),
        // Slot 'abortPreviewMask'
        QtMocHelpers::SlotData<void()>(202, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Monitor, qt_meta_tag_ZN7MonitorE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Monitor::staticMetaObject = { {
    QMetaObject::SuperData::link<AbstractMonitor::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7MonitorE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7MonitorE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN7MonitorE_t>.metaTypes,
    nullptr
} };

void Monitor::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Monitor *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->screenChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 1: _t->seekPosition((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 2: _t->seekRemap((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 3: _t->updateScene(); break;
        case 4: _t->durationChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 5: _t->zoneUpdated((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 6: _t->zoneUpdatedWithUndo((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[2]))); break;
        case 7: _t->effectChanged((*reinterpret_cast<std::add_pointer_t<QRectF>>(_a[1]))); break;
        case 8: _t->effectPointsChanged((*reinterpret_cast<std::add_pointer_t<QVariantList>>(_a[1]))); break;
        case 9: _t->addRemoveKeyframe((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 10: _t->seekToKeyframe((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 11: _t->addClipToProject((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1]))); break;
        case 12: _t->refreshCurrentClip(); break;
        case 13: _t->addTimelineEffect((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 14: _t->passKeyPress((*reinterpret_cast<std::add_pointer_t<QKeyEvent*>>(_a[1]))); break;
        case 15: _t->multitrackView((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 16: _t->timeCodeUpdated((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 17: _t->addMarker(); break;
        case 18: _t->deleteMarker((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 19: _t->deleteMarker(); break;
        case 20: _t->seekToPreviousSnap(); break;
        case 21: _t->seekToNextSnap(); break;
        case 22: _t->createSplitOverlay((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<Mlt::Filter>>>(_a[1]))); break;
        case 23: _t->removeSplitOverlay(); break;
        case 24: _t->activateTrack((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 25: _t->activateTrack((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 26: _t->autoKeyframeChanged(); break;
        case 27: _t->zoneDurationChanged(); break;
        case 28: _t->blockSceneChange((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 29: _t->addMonitorControlPoint((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QSize>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[6]))); break;
        case 30: _t->moveMonitorControlPoint((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QSize>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[5]))); break;
        case 31: _t->addMonitorControlRect((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QSize>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QRect>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4]))); break;
        case 32: _t->generateMask(); break;
        case 33: _t->disablePreviewMask(); break;
        case 34: _t->sceneChanged((*reinterpret_cast<std::add_pointer_t<MonitorSceneType>>(_a[1]))); break;
        case 35: _t->effectRotationChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 36: _t->profileUpdated(); break;
        case 37: _t->slotSetThumbFrame(); break;
        case 38: _t->slotSeek(); break;
        case 39: _t->updateClipZone((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 40: _t->slotGoToMarker((*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[1]))); break;
        case 41: _t->slotSetVolume((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 42: _t->slotEditMarker(); break;
        case 43: _t->slotExtractCurrentZone(); break;
        case 44: _t->onFrameDisplayed((*reinterpret_cast<std::add_pointer_t<SharedFrame>>(_a[1]))); break;
        case 45: _t->slotStartDrag(); break;
        case 46: _t->setZoom((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 47: _t->slotAdjustEffectCompare(); break;
        case 48: _t->slotShowMenu((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 49: _t->slotForceSize((*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[1]))); break;
        case 50: _t->buildBackgroundedProducer((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 51: _t->slotLockMonitor((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 52: _t->slotSwitchPlay(); break;
        case 53: _t->slotEditInlineMarker(); break;
        case 54: _t->doKeyPressEvent((*reinterpret_cast<std::add_pointer_t<QKeyEvent*>>(_a[1]))); break;
        case 55: _t->gpuError(); break;
        case 56: _t->setOffsetX((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 57: _t->setOffsetY((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 58: _t->panView((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 59: _t->slotSeekPosition((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 60: _t->addSnapPoint((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 61: _t->removeSnapPoint((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 62: _t->processSeek((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 63: _t->processSeek((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 64: _t->checkDrops(); break;
        case 65: _t->addControlPoint((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4]))); break;
        case 66: _t->moveControlPoint((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[3]))); break;
        case 67: _t->addControlRect((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5]))); break;
        case 68: _t->updatePowerManagement(); break;
        case 69: _t->rebuildAudio((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 70: _t->slotCreateRangeMarkerFromZone(); break;
        case 71: _t->slotCreateRangeMarkerFromZoneQuick(); break;
        case 72: _t->updateTimelineProducer(); break;
        case 73: _t->setProducer((*reinterpret_cast<std::add_pointer_t<QUuid>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<std::shared_ptr<Mlt::Producer>>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 74: _t->setProducer((*reinterpret_cast<std::add_pointer_t<QUuid>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<std::shared_ptr<Mlt::Producer>>>(_a[2]))); break;
        case 75: _t->slotSetScreen((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 76: _t->slotPreviewResource((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 77: _t->updateClipProducer((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<Mlt::Producer>>>(_a[1]))); break;
        case 78: _t->updateClipProducer((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 79: { bool _r = _t->slotOpenClip((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<ProjectClip>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QUuid>>(_a[4])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 80: { bool _r = _t->slotOpenClip((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<ProjectClip>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 81: { bool _r = _t->slotOpenClip((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<ProjectClip>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 82: { bool _r = _t->slotOpenClip((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<ProjectClip>>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 83: _t->slotRefreshMonitor((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 84: _t->slotSeek((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 85: _t->stop(); break;
        case 86: _t->start(); break;
        case 87: _t->switchPlay((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 88: _t->updatePlayAction((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 89: _t->slotPlay(); break;
        case 90: _t->pause(); break;
        case 91: _t->slotPlayZone((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 92: _t->slotPlayZone(); break;
        case 93: _t->slotLoopZone(); break;
        case 94: _t->slotLoopClip((*reinterpret_cast<std::add_pointer_t<std::pair<int,int>>>(_a[1]))); break;
        case 95: _t->slotForward((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 96: _t->slotForward((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 97: _t->slotForward(); break;
        case 98: _t->slotRewind((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 99: _t->slotRewind(); break;
        case 100: _t->slotRewindOneFrame((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 101: _t->slotRewindOneFrame(); break;
        case 102: _t->slotForwardOneFrame((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 103: _t->slotForwardOneFrame(); break;
        case 104: _t->warningMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QList<QAction*>>>(_a[3]))); break;
        case 105: _t->warningMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 106: _t->warningMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 107: _t->slotStart(); break;
        case 108: _t->slotTrimmingPos((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 109: _t->slotTrimmingPos((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 110: _t->slotEnd(); break;
        case 111: _t->slotSetZoneStart(); break;
        case 112: _t->slotSetZoneEnd(); break;
        case 113: _t->slotZoneStart(); break;
        case 114: _t->slotZoneEnd(); break;
        case 115: _t->slotSetZone((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 116: _t->slotLoadClipZone((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 117: _t->slotSeekToNextSnap(); break;
        case 118: _t->slotSeekToPreviousSnap(); break;
        case 119: _t->adjustRulerSize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<std::shared_ptr<MarkerSortModel>>>(_a[2]))); break;
        case 120: _t->adjustRulerSize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 121: _t->setTimePos((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 122: _t->slotShowEffectScene((*reinterpret_cast<std::add_pointer_t<MonitorSceneType>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[3]))); break;
        case 123: _t->slotShowEffectScene((*reinterpret_cast<std::add_pointer_t<MonitorSceneType>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 124: _t->slotShowEffectScene((*reinterpret_cast<std::add_pointer_t<MonitorSceneType>>(_a[1]))); break;
        case 125: { bool _r = _t->effectSceneDisplayed((*reinterpret_cast<std::add_pointer_t<MonitorSceneType>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 126: _t->slotSwitchCompare((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 127: _t->slotMouseSeek((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<uint>>(_a[2]))); break;
        case 128: _t->slotSwitchFullScreen((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 129: _t->slotSwitchFullScreen(); break;
        case 130: _t->slotSwitchRec((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 131: _t->slotSwitchTrimming((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 132: _t->slotGetCurrentImage((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 133: _t->slotSwitchAudioMonitor(); break;
        case 134: _t->slotSwitchRecTimecode((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 135: _t->requestSeek((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 136: _t->requestSeekIfVisible((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 137: _t->checkOverlay((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 138: _t->checkOverlay(); break;
        case 139: _t->refreshMonitorIfActive((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 140: _t->refreshMonitorIfActive(); break;
        case 141: _t->refreshMonitor((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 142: _t->refreshMonitor((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 143: _t->refreshMonitor(); break;
        case 144: _t->forceMonitorRefresh(); break;
        case 145: _t->purgeCache(); break;
        case 146: _t->abortPreviewMask((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 147: _t->abortPreviewMask(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 40:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QAction* >(); break;
            }
            break;
        case 49:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QAction* >(); break;
            }
            break;
        case 104:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<QAction*> >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(int )>(_a, &Monitor::screenChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(int )>(_a, &Monitor::seekPosition, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(int )>(_a, &Monitor::seekRemap, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)()>(_a, &Monitor::updateScene, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(int )>(_a, &Monitor::durationChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(const QPoint & )>(_a, &Monitor::zoneUpdated, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(const QPoint & , const QPoint & )>(_a, &Monitor::zoneUpdatedWithUndo, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(const QRectF & )>(_a, &Monitor::effectChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(const QVariantList & )>(_a, &Monitor::effectPointsChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(bool )>(_a, &Monitor::addRemoveKeyframe, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(int , int )>(_a, &Monitor::seekToKeyframe, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(const QUrl & )>(_a, &Monitor::addClipToProject, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)()>(_a, &Monitor::refreshCurrentClip, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(const QStringList & )>(_a, &Monitor::addTimelineEffect, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(QKeyEvent * )>(_a, &Monitor::passKeyPress, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(bool , bool )>(_a, &Monitor::multitrackView, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(const QString & )>(_a, &Monitor::timeCodeUpdated, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)()>(_a, &Monitor::addMarker, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(bool )>(_a, &Monitor::deleteMarker, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)()>(_a, &Monitor::seekToPreviousSnap, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)()>(_a, &Monitor::seekToNextSnap, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(std::shared_ptr<Mlt::Filter> )>(_a, &Monitor::createSplitOverlay, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)()>(_a, &Monitor::removeSplitOverlay, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(int , bool )>(_a, &Monitor::activateTrack, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)()>(_a, &Monitor::autoKeyframeChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)()>(_a, &Monitor::zoneDurationChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(bool )>(_a, &Monitor::blockSceneChange, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(int , const QSize , int , int , bool , bool )>(_a, &Monitor::addMonitorControlPoint, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(int , int , const QSize , int , int )>(_a, &Monitor::moveMonitorControlPoint, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(int , const QSize , const QRect , bool )>(_a, &Monitor::addMonitorControlRect, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)()>(_a, &Monitor::generateMask, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)()>(_a, &Monitor::disablePreviewMask, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(MonitorSceneType )>(_a, &Monitor::sceneChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)(double )>(_a, &Monitor::effectRotationChanged, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (Monitor::*)()>(_a, &Monitor::profileUpdated, 36))
            return;
    }
}

const QMetaObject *Monitor::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Monitor::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7MonitorE_t>.strings))
        return static_cast<void*>(this);
    return AbstractMonitor::qt_metacast(_clname);
}

int Monitor::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractMonitor::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 148)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 148;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 148)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 148;
    }
    return _id;
}

// SIGNAL 0
void Monitor::screenChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void Monitor::seekPosition(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void Monitor::seekRemap(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void Monitor::updateScene()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void Monitor::durationChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void Monitor::zoneUpdated(const QPoint & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void Monitor::zoneUpdatedWithUndo(const QPoint & _t1, const QPoint & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1, _t2);
}

// SIGNAL 7
void Monitor::effectChanged(const QRectF & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void Monitor::effectPointsChanged(const QVariantList & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void Monitor::addRemoveKeyframe(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void Monitor::seekToKeyframe(int _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1, _t2);
}

// SIGNAL 11
void Monitor::addClipToProject(const QUrl & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void Monitor::refreshCurrentClip()
{
    QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
}

// SIGNAL 13
void Monitor::addTimelineEffect(const QStringList & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void Monitor::passKeyPress(QKeyEvent * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void Monitor::multitrackView(bool _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1, _t2);
}

// SIGNAL 16
void Monitor::timeCodeUpdated(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
}

// SIGNAL 17
void Monitor::addMarker()
{
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
}

// SIGNAL 18
void Monitor::deleteMarker(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 20
void Monitor::seekToPreviousSnap()
{
    QMetaObject::activate(this, &staticMetaObject, 20, nullptr);
}

// SIGNAL 21
void Monitor::seekToNextSnap()
{
    QMetaObject::activate(this, &staticMetaObject, 21, nullptr);
}

// SIGNAL 22
void Monitor::createSplitOverlay(std::shared_ptr<Mlt::Filter> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void Monitor::removeSplitOverlay()
{
    QMetaObject::activate(this, &staticMetaObject, 23, nullptr);
}

// SIGNAL 24
void Monitor::activateTrack(int _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1, _t2);
}

// SIGNAL 26
void Monitor::autoKeyframeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 26, nullptr);
}

// SIGNAL 27
void Monitor::zoneDurationChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 27, nullptr);
}

// SIGNAL 28
void Monitor::blockSceneChange(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1);
}

// SIGNAL 29
void Monitor::addMonitorControlPoint(int _t1, const QSize _t2, int _t3, int _t4, bool _t5, bool _t6)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 29, nullptr, _t1, _t2, _t3, _t4, _t5, _t6);
}

// SIGNAL 30
void Monitor::moveMonitorControlPoint(int _t1, int _t2, const QSize _t3, int _t4, int _t5)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 30, nullptr, _t1, _t2, _t3, _t4, _t5);
}

// SIGNAL 31
void Monitor::addMonitorControlRect(int _t1, const QSize _t2, const QRect _t3, bool _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 32
void Monitor::generateMask()
{
    QMetaObject::activate(this, &staticMetaObject, 32, nullptr);
}

// SIGNAL 33
void Monitor::disablePreviewMask()
{
    QMetaObject::activate(this, &staticMetaObject, 33, nullptr);
}

// SIGNAL 34
void Monitor::sceneChanged(MonitorSceneType _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 34, nullptr, _t1);
}

// SIGNAL 35
void Monitor::effectRotationChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 35, nullptr, _t1);
}

// SIGNAL 36
void Monitor::profileUpdated()
{
    QMetaObject::activate(this, &staticMetaObject, 36, nullptr);
}
QT_WARNING_POP
