/****************************************************************************
** Meta object code from reading C++ file 'plasmacameramanager.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 "../../../../plasma-camera-26.04.0/src/plasmacameramanager.h"
#include <QtGui/qtextcursor.h>
#include <QtGui/qscreen.h>
#include <QtNetwork/QSslPreSharedKeyAuthenticator>
#include <QtNetwork/QSslError>
#include <QtCore/qmetatype.h>
#include <QtCore/QList>
#include <QtCore/QQueue>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'plasmacameramanager.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_ZN19PlasmaCameraManagerE_t {};
} // unnamed namespace

template <> constexpr inline auto PlasmaCameraManager::qt_create_metaobjectdata<qt_meta_tag_ZN19PlasmaCameraManagerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "PlasmaCameraManager",
        "errorChanged",
        "",
        "errorOccurred",
        "id",
        "Error",
        "error",
        "errorString",
        "readyForCaptureChanged",
        "ready",
        "metaDataChanged",
        "fileFormatChanged",
        "filenamePatternChanged",
        "outputPathChanged",
        "qualityChanged",
        "plasmaCameraChanged",
        "videoSinkChanged",
        "recorderChanged",
        "audioInputChanged",
        "videoRecordingFpsChanged",
        "fps",
        "videoResolutionChanged",
        "videoCodecChanged",
        "imageSaved",
        "fileName",
        "audioRecordingEnabledChanged",
        "isRecordingVideoChanged",
        "isSavingVideoChanged",
        "framesDropped",
        "captureImage",
        "captureImageToFile",
        "location",
        "setReadyForCapture",
        "setFileFormat",
        "FileFormat",
        "fileFormat",
        "setFilenamePattern",
        "FilenamePattern",
        "filenamePattern",
        "setOutputPath",
        "OutputPath",
        "outputPath",
        "setQuality",
        "Quality",
        "quality",
        "setPlasmaCamera",
        "PlasmaCamera*",
        "plasmaCamera",
        "setVideoSink",
        "QVideoSink*",
        "videoSink",
        "setRecorder",
        "QMediaRecorder*",
        "recorder",
        "setAudioInput",
        "QAudioInput*",
        "audioInput",
        "setVideoRecordingFps",
        "setVideoResolution",
        "Resolution",
        "resolution",
        "setVideoCodec",
        "VideoCodec",
        "codec",
        "setError",
        "unsetError",
        "updateRecorderSettings",
        "setSettings",
        "Settings",
        "settings",
        "processViewfinderFrame",
        "QImage",
        "image",
        "processCaptureImage",
        "QQueue<QImage>",
        "frames",
        "processVideoFrame",
        "updateFromOrientationSensor",
        "setIsSavingVideo",
        "isSavingVideo",
        "startRecordingVideo",
        "stopRecordingVideo",
        "readyForCapture",
        "supportedFileFormats",
        "QList<FileFormat>",
        "audioRecordingEnabled",
        "videoRecordingFps",
        "videoResolution",
        "videoCodec",
        "isRecordingVideo",
        "NoError",
        "NotReadyError",
        "ResourceError",
        "OutOfSpaceError",
        "NotSupportedFeatureError",
        "FormatError",
        "VeryLowQuality",
        "LowQuality",
        "NormalQuality",
        "HighQuality",
        "VeryHighQuality",
        "UnspecifiedFormat",
        "JPEG",
        "PNG",
        "WebP",
        "Tiff",
        "ResolutionAuto",
        "Resolution540p",
        "Resolution720p",
        "Resolution1080p",
        "Resolution1440p",
        "Resolution2160p",
        "H264",
        "H265",
        "MPEG2",
        "FilenameNumericSequential",
        "FilenameDateShort",
        "FilenameDateUnderscore",
        "OutputPathDefault",
        "OutputPathDCIM"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'errorChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'errorOccurred'
        QtMocHelpers::SignalData<void(int, enum Error, const QString &)>(3, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 4 }, { 0x80000000 | 5, 6 }, { QMetaType::QString, 7 },
        }}),
        // Signal 'readyForCaptureChanged'
        QtMocHelpers::SignalData<void(bool)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 9 },
        }}),
        // Signal 'metaDataChanged'
        QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fileFormatChanged'
        QtMocHelpers::SignalData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'filenamePatternChanged'
        QtMocHelpers::SignalData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'outputPathChanged'
        QtMocHelpers::SignalData<void()>(13, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'qualityChanged'
        QtMocHelpers::SignalData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'plasmaCameraChanged'
        QtMocHelpers::SignalData<void()>(15, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'videoSinkChanged'
        QtMocHelpers::SignalData<void()>(16, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'recorderChanged'
        QtMocHelpers::SignalData<void()>(17, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'audioInputChanged'
        QtMocHelpers::SignalData<void()>(18, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'videoRecordingFpsChanged'
        QtMocHelpers::SignalData<void(float)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 20 },
        }}),
        // Signal 'videoResolutionChanged'
        QtMocHelpers::SignalData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'videoCodecChanged'
        QtMocHelpers::SignalData<void()>(22, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'imageSaved'
        QtMocHelpers::SignalData<void(int, const QString &)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 4 }, { QMetaType::QString, 24 },
        }}),
        // Signal 'audioRecordingEnabledChanged'
        QtMocHelpers::SignalData<void()>(25, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'isRecordingVideoChanged'
        QtMocHelpers::SignalData<void()>(26, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'isSavingVideoChanged'
        QtMocHelpers::SignalData<void()>(27, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'framesDropped'
        QtMocHelpers::SignalData<void()>(28, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'captureImage'
        QtMocHelpers::SlotData<int()>(29, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'captureImageToFile'
        QtMocHelpers::SlotData<int(const QString &)>(30, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::QString, 31 },
        }}),
        // Slot 'captureImageToFile'
        QtMocHelpers::SlotData<int()>(30, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Int),
        // Slot 'setReadyForCapture'
        QtMocHelpers::SlotData<void(bool)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 9 },
        }}),
        // Slot 'setFileFormat'
        QtMocHelpers::SlotData<void(enum FileFormat)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 34, 35 },
        }}),
        // Slot 'setFilenamePattern'
        QtMocHelpers::SlotData<void(enum FilenamePattern)>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 37, 38 },
        }}),
        // Slot 'setOutputPath'
        QtMocHelpers::SlotData<void(enum OutputPath)>(39, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 40, 41 },
        }}),
        // Slot 'setQuality'
        QtMocHelpers::SlotData<void(enum Quality)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 43, 44 },
        }}),
        // Slot 'setPlasmaCamera'
        QtMocHelpers::SlotData<void(PlasmaCamera *)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 46, 47 },
        }}),
        // Slot 'setVideoSink'
        QtMocHelpers::SlotData<void(QVideoSink *)>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 49, 50 },
        }}),
        // Slot 'setRecorder'
        QtMocHelpers::SlotData<void(QMediaRecorder *)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 52, 53 },
        }}),
        // Slot 'setAudioInput'
        QtMocHelpers::SlotData<void(QAudioInput *)>(54, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 55, 56 },
        }}),
        // Slot 'setVideoRecordingFps'
        QtMocHelpers::SlotData<void(float)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 20 },
        }}),
        // Slot 'setVideoResolution'
        QtMocHelpers::SlotData<void(enum Resolution)>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 59, 60 },
        }}),
        // Slot 'setVideoCodec'
        QtMocHelpers::SlotData<void(enum VideoCodec)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 62, 63 },
        }}),
        // Slot 'setError'
        QtMocHelpers::SlotData<void(int, enum Error, const QString &)>(64, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 4 }, { 0x80000000 | 5, 6 }, { QMetaType::QString, 7 },
        }}),
        // Slot 'unsetError'
        QtMocHelpers::SlotData<void()>(65, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateRecorderSettings'
        QtMocHelpers::SlotData<void()>(66, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'setSettings'
        QtMocHelpers::SlotData<void(const Settings &)>(67, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 68, 69 },
        }}),
        // Slot 'processViewfinderFrame'
        QtMocHelpers::SlotData<void(const QImage &)>(70, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 71, 72 },
        }}),
        // Slot 'processCaptureImage'
        QtMocHelpers::SlotData<void(const QQueue<QImage> &)>(73, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 74, 75 },
        }}),
        // Slot 'processVideoFrame'
        QtMocHelpers::SlotData<void()>(76, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateFromOrientationSensor'
        QtMocHelpers::SlotData<void()>(77, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'setIsSavingVideo'
        QtMocHelpers::SlotData<void(bool)>(78, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 79 },
        }}),
        // Method 'startRecordingVideo'
        QtMocHelpers::MethodData<void()>(80, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'stopRecordingVideo'
        QtMocHelpers::MethodData<void()>(81, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'error'
        QtMocHelpers::PropertyData<enum Error>(6, 0x80000000 | 5, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
        // property 'errorString'
        QtMocHelpers::PropertyData<QString>(7, QMetaType::QString, QMC::DefaultPropertyFlags, 0),
        // property 'readyForCapture'
        QtMocHelpers::PropertyData<bool>(82, QMetaType::Bool, QMC::DefaultPropertyFlags, 2),
        // property 'supportedFileFormats'
        QtMocHelpers::PropertyData<QList<FileFormat>>(83, 0x80000000 | 84, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'fileFormat'
        QtMocHelpers::PropertyData<enum FileFormat>(35, 0x80000000 | 34, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 4),
        // property 'filenamePattern'
        QtMocHelpers::PropertyData<enum FilenamePattern>(38, 0x80000000 | 37, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 5),
        // property 'outputPath'
        QtMocHelpers::PropertyData<enum OutputPath>(41, 0x80000000 | 40, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 6),
        // property 'quality'
        QtMocHelpers::PropertyData<enum Quality>(44, 0x80000000 | 43, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 7),
        // property 'plasmaCamera'
        QtMocHelpers::PropertyData<PlasmaCamera*>(47, 0x80000000 | 46, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 8),
        // property 'videoSink'
        QtMocHelpers::PropertyData<QVideoSink*>(50, 0x80000000 | 49, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 9),
        // property 'recorder'
        QtMocHelpers::PropertyData<QMediaRecorder*>(53, 0x80000000 | 52, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 10),
        // property 'audioRecordingEnabled'
        QtMocHelpers::PropertyData<bool>(85, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'audioInput'
        QtMocHelpers::PropertyData<QAudioInput*>(56, 0x80000000 | 55, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 11),
        // property 'videoRecordingFps'
        QtMocHelpers::PropertyData<float>(86, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 12),
        // property 'videoResolution'
        QtMocHelpers::PropertyData<enum Resolution>(87, 0x80000000 | 59, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 13),
        // property 'videoCodec'
        QtMocHelpers::PropertyData<enum VideoCodec>(88, 0x80000000 | 62, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 14),
        // property 'isRecordingVideo'
        QtMocHelpers::PropertyData<bool>(89, QMetaType::Bool, QMC::DefaultPropertyFlags, 17),
        // property 'isSavingVideo'
        QtMocHelpers::PropertyData<bool>(79, QMetaType::Bool, QMC::DefaultPropertyFlags, 18),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Error'
        QtMocHelpers::EnumData<enum Error>(5, 5, QMC::EnumFlags{}).add({
            {   90, Error::NoError },
            {   91, Error::NotReadyError },
            {   92, Error::ResourceError },
            {   93, Error::OutOfSpaceError },
            {   94, Error::NotSupportedFeatureError },
            {   95, Error::FormatError },
        }),
        // enum 'Quality'
        QtMocHelpers::EnumData<enum Quality>(43, 43, QMC::EnumFlags{}).add({
            {   96, Quality::VeryLowQuality },
            {   97, Quality::LowQuality },
            {   98, Quality::NormalQuality },
            {   99, Quality::HighQuality },
            {  100, Quality::VeryHighQuality },
        }),
        // enum 'FileFormat'
        QtMocHelpers::EnumData<enum FileFormat>(34, 34, QMC::EnumFlags{}).add({
            {  101, FileFormat::UnspecifiedFormat },
            {  102, FileFormat::JPEG },
            {  103, FileFormat::PNG },
            {  104, FileFormat::WebP },
            {  105, FileFormat::Tiff },
        }),
        // enum 'Resolution'
        QtMocHelpers::EnumData<enum Resolution>(59, 59, QMC::EnumFlags{}).add({
            {  106, Resolution::ResolutionAuto },
            {  107, Resolution::Resolution540p },
            {  108, Resolution::Resolution720p },
            {  109, Resolution::Resolution1080p },
            {  110, Resolution::Resolution1440p },
            {  111, Resolution::Resolution2160p },
        }),
        // enum 'VideoCodec'
        QtMocHelpers::EnumData<enum VideoCodec>(62, 62, QMC::EnumFlags{}).add({
            {  112, VideoCodec::H264 },
            {  113, VideoCodec::H265 },
            {  114, VideoCodec::MPEG2 },
        }),
        // enum 'FilenamePattern'
        QtMocHelpers::EnumData<enum FilenamePattern>(37, 37, QMC::EnumFlags{}).add({
            {  115, FilenamePattern::FilenameNumericSequential },
            {  116, FilenamePattern::FilenameDateShort },
            {  117, FilenamePattern::FilenameDateUnderscore },
        }),
        // enum 'OutputPath'
        QtMocHelpers::EnumData<enum OutputPath>(40, 40, QMC::EnumFlags{}).add({
            {  118, OutputPath::OutputPathDefault },
            {  119, OutputPath::OutputPathDCIM },
        }),
    };
    return QtMocHelpers::metaObjectData<PlasmaCameraManager, qt_meta_tag_ZN19PlasmaCameraManagerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject PlasmaCameraManager::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19PlasmaCameraManagerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19PlasmaCameraManagerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19PlasmaCameraManagerE_t>.metaTypes,
    nullptr
} };

void PlasmaCameraManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PlasmaCameraManager *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->errorChanged(); break;
        case 1: _t->errorOccurred((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<enum Error>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 2: _t->readyForCaptureChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 3: _t->metaDataChanged(); break;
        case 4: _t->fileFormatChanged(); break;
        case 5: _t->filenamePatternChanged(); break;
        case 6: _t->outputPathChanged(); break;
        case 7: _t->qualityChanged(); break;
        case 8: _t->plasmaCameraChanged(); break;
        case 9: _t->videoSinkChanged(); break;
        case 10: _t->recorderChanged(); break;
        case 11: _t->audioInputChanged(); break;
        case 12: _t->videoRecordingFpsChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 13: _t->videoResolutionChanged(); break;
        case 14: _t->videoCodecChanged(); break;
        case 15: _t->imageSaved((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 16: _t->audioRecordingEnabledChanged(); break;
        case 17: _t->isRecordingVideoChanged(); break;
        case 18: _t->isSavingVideoChanged(); break;
        case 19: _t->framesDropped(); break;
        case 20: { int _r = _t->captureImage();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 21: { int _r = _t->captureImageToFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 22: { int _r = _t->captureImageToFile();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 23: _t->setReadyForCapture((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 24: _t->setFileFormat((*reinterpret_cast<std::add_pointer_t<enum FileFormat>>(_a[1]))); break;
        case 25: _t->setFilenamePattern((*reinterpret_cast<std::add_pointer_t<enum FilenamePattern>>(_a[1]))); break;
        case 26: _t->setOutputPath((*reinterpret_cast<std::add_pointer_t<enum OutputPath>>(_a[1]))); break;
        case 27: _t->setQuality((*reinterpret_cast<std::add_pointer_t<enum Quality>>(_a[1]))); break;
        case 28: _t->setPlasmaCamera((*reinterpret_cast<std::add_pointer_t<PlasmaCamera*>>(_a[1]))); break;
        case 29: _t->setVideoSink((*reinterpret_cast<std::add_pointer_t<QVideoSink*>>(_a[1]))); break;
        case 30: _t->setRecorder((*reinterpret_cast<std::add_pointer_t<QMediaRecorder*>>(_a[1]))); break;
        case 31: _t->setAudioInput((*reinterpret_cast<std::add_pointer_t<QAudioInput*>>(_a[1]))); break;
        case 32: _t->setVideoRecordingFps((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 33: _t->setVideoResolution((*reinterpret_cast<std::add_pointer_t<enum Resolution>>(_a[1]))); break;
        case 34: _t->setVideoCodec((*reinterpret_cast<std::add_pointer_t<enum VideoCodec>>(_a[1]))); break;
        case 35: _t->setError((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<enum Error>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 36: _t->unsetError(); break;
        case 37: _t->updateRecorderSettings(); break;
        case 38: _t->setSettings((*reinterpret_cast<std::add_pointer_t<Settings>>(_a[1]))); break;
        case 39: _t->processViewfinderFrame((*reinterpret_cast<std::add_pointer_t<QImage>>(_a[1]))); break;
        case 40: _t->processCaptureImage((*reinterpret_cast<std::add_pointer_t<QQueue<QImage>>>(_a[1]))); break;
        case 41: _t->processVideoFrame(); break;
        case 42: _t->updateFromOrientationSensor(); break;
        case 43: _t->setIsSavingVideo((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 44: _t->startRecordingVideo(); break;
        case 45: _t->stopRecordingVideo(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 28:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< PlasmaCamera* >(); break;
            }
            break;
        case 29:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QVideoSink* >(); break;
            }
            break;
        case 30:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QMediaRecorder* >(); break;
            }
            break;
        case 31:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QAudioInput* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)()>(_a, &PlasmaCameraManager::errorChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)(int , Error , const QString & )>(_a, &PlasmaCameraManager::errorOccurred, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)(bool )>(_a, &PlasmaCameraManager::readyForCaptureChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)()>(_a, &PlasmaCameraManager::metaDataChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)()>(_a, &PlasmaCameraManager::fileFormatChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)()>(_a, &PlasmaCameraManager::filenamePatternChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)()>(_a, &PlasmaCameraManager::outputPathChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)()>(_a, &PlasmaCameraManager::qualityChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)()>(_a, &PlasmaCameraManager::plasmaCameraChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)()>(_a, &PlasmaCameraManager::videoSinkChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)()>(_a, &PlasmaCameraManager::recorderChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)()>(_a, &PlasmaCameraManager::audioInputChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)(float )>(_a, &PlasmaCameraManager::videoRecordingFpsChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)()>(_a, &PlasmaCameraManager::videoResolutionChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)()>(_a, &PlasmaCameraManager::videoCodecChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)(int , const QString & )>(_a, &PlasmaCameraManager::imageSaved, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)()>(_a, &PlasmaCameraManager::audioRecordingEnabledChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)()>(_a, &PlasmaCameraManager::isRecordingVideoChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)()>(_a, &PlasmaCameraManager::isSavingVideoChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (PlasmaCameraManager::*)()>(_a, &PlasmaCameraManager::framesDropped, 19))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 8:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< PlasmaCamera* >(); break;
        case 12:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QAudioInput* >(); break;
        case 10:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QMediaRecorder* >(); break;
        case 9:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QVideoSink* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<enum Error*>(_v) = _t->error(); break;
        case 1: *reinterpret_cast<QString*>(_v) = _t->errorString(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->isReadyForCapture(); break;
        case 3: *reinterpret_cast<QList<FileFormat>*>(_v) = _t->supportedFileFormats(); break;
        case 4: *reinterpret_cast<enum FileFormat*>(_v) = _t->fileFormat(); break;
        case 5: *reinterpret_cast<enum FilenamePattern*>(_v) = _t->filenamePattern(); break;
        case 6: *reinterpret_cast<enum OutputPath*>(_v) = _t->outputPath(); break;
        case 7: *reinterpret_cast<enum Quality*>(_v) = _t->quality(); break;
        case 8: *reinterpret_cast<PlasmaCamera**>(_v) = _t->plasmaCamera(); break;
        case 9: *reinterpret_cast<QVideoSink**>(_v) = _t->videoSink(); break;
        case 10: *reinterpret_cast<QMediaRecorder**>(_v) = _t->recorder(); break;
        case 11: *reinterpret_cast<bool*>(_v) = _t->audioRecordingEnabled(); break;
        case 12: *reinterpret_cast<QAudioInput**>(_v) = _t->audioInput(); break;
        case 13: *reinterpret_cast<float*>(_v) = _t->videoRecordingFps(); break;
        case 14: *reinterpret_cast<enum Resolution*>(_v) = _t->videoResolution(); break;
        case 15: *reinterpret_cast<enum VideoCodec*>(_v) = _t->videoCodec(); break;
        case 16: *reinterpret_cast<bool*>(_v) = _t->isRecordingVideo(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->isSavingVideo(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 4: _t->setFileFormat(*reinterpret_cast<enum FileFormat*>(_v)); break;
        case 5: _t->setFilenamePattern(*reinterpret_cast<enum FilenamePattern*>(_v)); break;
        case 6: _t->setOutputPath(*reinterpret_cast<enum OutputPath*>(_v)); break;
        case 7: _t->setQuality(*reinterpret_cast<enum Quality*>(_v)); break;
        case 8: _t->setPlasmaCamera(*reinterpret_cast<PlasmaCamera**>(_v)); break;
        case 9: _t->setVideoSink(*reinterpret_cast<QVideoSink**>(_v)); break;
        case 10: _t->setRecorder(*reinterpret_cast<QMediaRecorder**>(_v)); break;
        case 11: _t->setAudioRecordingEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 12: _t->setAudioInput(*reinterpret_cast<QAudioInput**>(_v)); break;
        case 13: _t->setVideoRecordingFps(*reinterpret_cast<float*>(_v)); break;
        case 14: _t->setVideoResolution(*reinterpret_cast<enum Resolution*>(_v)); break;
        case 15: _t->setVideoCodec(*reinterpret_cast<enum VideoCodec*>(_v)); break;
        default: break;
        }
    }
}

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

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

int PlasmaCameraManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 46)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 46;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 46)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 46;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 18;
    }
    return _id;
}

// SIGNAL 0
void PlasmaCameraManager::errorChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void PlasmaCameraManager::errorOccurred(int _t1, Error _t2, const QString & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2, _t3);
}

// SIGNAL 2
void PlasmaCameraManager::readyForCaptureChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

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

// SIGNAL 4
void PlasmaCameraManager::fileFormatChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void PlasmaCameraManager::filenamePatternChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

// SIGNAL 6
void PlasmaCameraManager::outputPathChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void PlasmaCameraManager::qualityChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void PlasmaCameraManager::plasmaCameraChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void PlasmaCameraManager::videoSinkChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
}

// SIGNAL 10
void PlasmaCameraManager::recorderChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}

// SIGNAL 11
void PlasmaCameraManager::audioInputChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 11, nullptr);
}

// SIGNAL 12
void PlasmaCameraManager::videoRecordingFpsChanged(float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void PlasmaCameraManager::videoResolutionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}

// SIGNAL 14
void PlasmaCameraManager::videoCodecChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 14, nullptr);
}

// SIGNAL 15
void PlasmaCameraManager::imageSaved(int _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1, _t2);
}

// SIGNAL 16
void PlasmaCameraManager::audioRecordingEnabledChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

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

// SIGNAL 18
void PlasmaCameraManager::isSavingVideoChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 18, nullptr);
}

// SIGNAL 19
void PlasmaCameraManager::framesDropped()
{
    QMetaObject::activate(this, &staticMetaObject, 19, nullptr);
}
QT_WARNING_POP
