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

#include "../../../../../qtmultimedia/src/multimedia/camera/qcamera.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'qcamera.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.12.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_ZN7QCameraE_t {};
} // unnamed namespace

template <> constexpr inline auto QCamera::qt_create_metaobjectdata<qt_meta_tag_ZN7QCameraE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCamera",
        "activeChanged",
        "",
        "errorChanged",
        "errorOccurred",
        "QCamera::Error",
        "error",
        "errorString",
        "cameraDeviceChanged",
        "cameraFormatChanged",
        "supportedFeaturesChanged",
        "focusModeChanged",
        "zoomFactorChanged",
        "minimumZoomFactorChanged",
        "maximumZoomFactorChanged",
        "focusDistanceChanged",
        "focusPointChanged",
        "customFocusPointChanged",
        "flashReady",
        "flashModeChanged",
        "torchModeChanged",
        "exposureTimeChanged",
        "speed",
        "manualExposureTimeChanged",
        "isoSensitivityChanged",
        "manualIsoSensitivityChanged",
        "exposureCompensationChanged",
        "exposureModeChanged",
        "whiteBalanceModeChanged",
        "colorTemperatureChanged",
        "brightnessChanged",
        "contrastChanged",
        "saturationChanged",
        "hueChanged",
        "setActive",
        "active",
        "start",
        "stop",
        "zoomTo",
        "zoom",
        "rate",
        "setFlashMode",
        "FlashMode",
        "mode",
        "setTorchMode",
        "TorchMode",
        "setExposureMode",
        "ExposureMode",
        "setExposureCompensation",
        "ev",
        "setManualIsoSensitivity",
        "iso",
        "setAutoIsoSensitivity",
        "setManualExposureTime",
        "seconds",
        "setAutoExposureTime",
        "setWhiteBalanceMode",
        "WhiteBalanceMode",
        "setColorTemperature",
        "colorTemperature",
        "isFocusModeSupported",
        "FocusMode",
        "isFlashModeSupported",
        "isFlashReady",
        "isTorchModeSupported",
        "isExposureModeSupported",
        "isWhiteBalanceModeSupported",
        "cameraDevice",
        "QCameraDevice",
        "Error",
        "cameraFormat",
        "QCameraFormat",
        "focusMode",
        "focusPoint",
        "QPointF",
        "customFocusPoint",
        "focusDistance",
        "minimumZoomFactor",
        "maximumZoomFactor",
        "zoomFactor",
        "exposureTime",
        "manualExposureTime",
        "isoSensitivity",
        "manualIsoSensitivity",
        "exposureCompensation",
        "exposureMode",
        "QCamera::ExposureMode",
        "flashMode",
        "QCamera::FlashMode",
        "torchMode",
        "QCamera::TorchMode",
        "whiteBalanceMode",
        "supportedFeatures",
        "Features",
        "NoError",
        "CameraError",
        "FocusModeAuto",
        "FocusModeAutoNear",
        "FocusModeAutoFar",
        "FocusModeHyperfocal",
        "FocusModeInfinity",
        "FocusModeManual",
        "FlashOff",
        "FlashOn",
        "FlashAuto",
        "TorchOff",
        "TorchOn",
        "TorchAuto",
        "ExposureAuto",
        "ExposureManual",
        "ExposurePortrait",
        "ExposureNight",
        "ExposureSports",
        "ExposureSnow",
        "ExposureBeach",
        "ExposureAction",
        "ExposureLandscape",
        "ExposureNightPortrait",
        "ExposureTheatre",
        "ExposureSunset",
        "ExposureSteadyPhoto",
        "ExposureFireworks",
        "ExposureParty",
        "ExposureCandlelight",
        "ExposureBarcode",
        "WhiteBalanceAuto",
        "WhiteBalanceManual",
        "WhiteBalanceSunlight",
        "WhiteBalanceCloudy",
        "WhiteBalanceShade",
        "WhiteBalanceTungsten",
        "WhiteBalanceFluorescent",
        "WhiteBalanceFlash",
        "WhiteBalanceSunset",
        "Feature",
        "ColorTemperature",
        "ExposureCompensation",
        "IsoSensitivity",
        "ManualExposureTime",
        "CustomFocusPoint",
        "FocusDistance"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'activeChanged'
        QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'errorChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'errorOccurred'
        QtMocHelpers::SignalData<void(QCamera::Error, const QString &)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 }, { QMetaType::QString, 7 },
        }}),
        // Signal 'cameraDeviceChanged'
        QtMocHelpers::SignalData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'cameraFormatChanged'
        QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'supportedFeaturesChanged'
        QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'focusModeChanged'
        QtMocHelpers::SignalData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'zoomFactorChanged'
        QtMocHelpers::SignalData<void(float)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 2 },
        }}),
        // Signal 'minimumZoomFactorChanged'
        QtMocHelpers::SignalData<void(float)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 2 },
        }}),
        // Signal 'maximumZoomFactorChanged'
        QtMocHelpers::SignalData<void(float)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 2 },
        }}),
        // Signal 'focusDistanceChanged'
        QtMocHelpers::SignalData<void(float)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 2 },
        }}),
        // Signal 'focusPointChanged'
        QtMocHelpers::SignalData<void()>(16, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'customFocusPointChanged'
        QtMocHelpers::SignalData<void()>(17, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'flashReady'
        QtMocHelpers::SignalData<void(bool)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'flashModeChanged'
        QtMocHelpers::SignalData<void()>(19, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'torchModeChanged'
        QtMocHelpers::SignalData<void()>(20, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'exposureTimeChanged'
        QtMocHelpers::SignalData<void(float)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 22 },
        }}),
        // Signal 'manualExposureTimeChanged'
        QtMocHelpers::SignalData<void(float)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 22 },
        }}),
        // Signal 'isoSensitivityChanged'
        QtMocHelpers::SignalData<void(int)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Signal 'manualIsoSensitivityChanged'
        QtMocHelpers::SignalData<void(int)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Signal 'exposureCompensationChanged'
        QtMocHelpers::SignalData<void(float)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 2 },
        }}),
        // Signal 'exposureModeChanged'
        QtMocHelpers::SignalData<void()>(27, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'whiteBalanceModeChanged'
        QtMocHelpers::SignalData<void() const>(28, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'colorTemperatureChanged'
        QtMocHelpers::SignalData<void() const>(29, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'brightnessChanged'
        QtMocHelpers::SignalData<void()>(30, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'contrastChanged'
        QtMocHelpers::SignalData<void()>(31, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'saturationChanged'
        QtMocHelpers::SignalData<void()>(32, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'hueChanged'
        QtMocHelpers::SignalData<void()>(33, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setActive'
        QtMocHelpers::SlotData<void(bool)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 35 },
        }}),
        // Slot 'start'
        QtMocHelpers::SlotData<void()>(36, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'stop'
        QtMocHelpers::SlotData<void()>(37, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'zoomTo'
        QtMocHelpers::SlotData<void(float, float)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 39 }, { QMetaType::Float, 40 },
        }}),
        // Slot 'setFlashMode'
        QtMocHelpers::SlotData<void(enum FlashMode)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 42, 43 },
        }}),
        // Slot 'setTorchMode'
        QtMocHelpers::SlotData<void(enum TorchMode)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 45, 43 },
        }}),
        // Slot 'setExposureMode'
        QtMocHelpers::SlotData<void(enum ExposureMode)>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 47, 43 },
        }}),
        // Slot 'setExposureCompensation'
        QtMocHelpers::SlotData<void(float)>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 49 },
        }}),
        // Slot 'setManualIsoSensitivity'
        QtMocHelpers::SlotData<void(int)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 51 },
        }}),
        // Slot 'setAutoIsoSensitivity'
        QtMocHelpers::SlotData<void()>(52, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setManualExposureTime'
        QtMocHelpers::SlotData<void(float)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 54 },
        }}),
        // Slot 'setAutoExposureTime'
        QtMocHelpers::SlotData<void()>(55, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setWhiteBalanceMode'
        QtMocHelpers::SlotData<void(enum WhiteBalanceMode)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 57, 43 },
        }}),
        // Slot 'setColorTemperature'
        QtMocHelpers::SlotData<void(int)>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 59 },
        }}),
        // Method 'isFocusModeSupported'
        QtMocHelpers::MethodData<bool(enum FocusMode) const>(60, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 61, 43 },
        }}),
        // Method 'isFlashModeSupported'
        QtMocHelpers::MethodData<bool(enum FlashMode) const>(62, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 42, 43 },
        }}),
        // Method 'isFlashReady'
        QtMocHelpers::MethodData<bool() const>(63, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'isTorchModeSupported'
        QtMocHelpers::MethodData<bool(enum TorchMode) const>(64, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 45, 43 },
        }}),
        // Method 'isExposureModeSupported'
        QtMocHelpers::MethodData<bool(enum ExposureMode) const>(65, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 47, 43 },
        }}),
        // Method 'isWhiteBalanceModeSupported'
        QtMocHelpers::MethodData<bool(enum WhiteBalanceMode) const>(66, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 57, 43 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'active'
        QtMocHelpers::PropertyData<bool>(35, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
        // property 'cameraDevice'
        QtMocHelpers::PropertyData<QCameraDevice>(67, 0x80000000 | 68, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 3),
        // property 'error'
        QtMocHelpers::PropertyData<enum Error>(6, 0x80000000 | 69, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 1),
        // property 'errorString'
        QtMocHelpers::PropertyData<QString>(7, QMetaType::QString, QMC::DefaultPropertyFlags, 1),
        // property 'cameraFormat'
        QtMocHelpers::PropertyData<QCameraFormat>(70, 0x80000000 | 71, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 4),
        // property 'focusMode'
        QtMocHelpers::PropertyData<enum FocusMode>(72, 0x80000000 | 61, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 6),
        // property 'focusPoint'
        QtMocHelpers::PropertyData<QPointF>(73, 0x80000000 | 74, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 11),
        // property 'customFocusPoint'
        QtMocHelpers::PropertyData<QPointF>(75, 0x80000000 | 74, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 12),
        // property 'focusDistance'
        QtMocHelpers::PropertyData<float>(76, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 10),
        // property 'minimumZoomFactor'
        QtMocHelpers::PropertyData<float>(77, QMetaType::Float, QMC::DefaultPropertyFlags, 8),
        // property 'maximumZoomFactor'
        QtMocHelpers::PropertyData<float>(78, QMetaType::Float, QMC::DefaultPropertyFlags, 9),
        // property 'zoomFactor'
        QtMocHelpers::PropertyData<float>(79, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 7),
        // property 'exposureTime'
        QtMocHelpers::PropertyData<float>(80, QMetaType::Float, QMC::DefaultPropertyFlags, 16),
        // property 'manualExposureTime'
        QtMocHelpers::PropertyData<float>(81, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 17),
        // property 'isoSensitivity'
        QtMocHelpers::PropertyData<int>(82, QMetaType::Int, QMC::DefaultPropertyFlags, 18),
        // property 'manualIsoSensitivity'
        QtMocHelpers::PropertyData<int>(83, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 19),
        // property 'exposureCompensation'
        QtMocHelpers::PropertyData<float>(84, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 20),
        // property 'exposureMode'
        QtMocHelpers::PropertyData<QCamera::ExposureMode>(85, 0x80000000 | 86, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 21),
        // property 'flashReady'
        QtMocHelpers::PropertyData<bool>(18, QMetaType::Bool, QMC::DefaultPropertyFlags, 13),
        // property 'flashMode'
        QtMocHelpers::PropertyData<QCamera::FlashMode>(87, 0x80000000 | 88, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 14),
        // property 'torchMode'
        QtMocHelpers::PropertyData<QCamera::TorchMode>(89, 0x80000000 | 90, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 15),
        // property 'whiteBalanceMode'
        QtMocHelpers::PropertyData<enum WhiteBalanceMode>(91, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 22),
        // property 'colorTemperature'
        QtMocHelpers::PropertyData<int>(59, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 23),
        // property 'supportedFeatures'
        QtMocHelpers::PropertyData<Features>(92, 0x80000000 | 93, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 5),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Error'
        QtMocHelpers::EnumData<enum Error>(69, 69, QMC::EnumFlags{}).add({
            {   94, Error::NoError },
            {   95, Error::CameraError },
        }),
        // enum 'FocusMode'
        QtMocHelpers::EnumData<enum FocusMode>(61, 61, QMC::EnumFlags{}).add({
            {   96, FocusMode::FocusModeAuto },
            {   97, FocusMode::FocusModeAutoNear },
            {   98, FocusMode::FocusModeAutoFar },
            {   99, FocusMode::FocusModeHyperfocal },
            {  100, FocusMode::FocusModeInfinity },
            {  101, FocusMode::FocusModeManual },
        }),
        // enum 'FlashMode'
        QtMocHelpers::EnumData<enum FlashMode>(42, 42, QMC::EnumFlags{}).add({
            {  102, FlashMode::FlashOff },
            {  103, FlashMode::FlashOn },
            {  104, FlashMode::FlashAuto },
        }),
        // enum 'TorchMode'
        QtMocHelpers::EnumData<enum TorchMode>(45, 45, QMC::EnumFlags{}).add({
            {  105, TorchMode::TorchOff },
            {  106, TorchMode::TorchOn },
            {  107, TorchMode::TorchAuto },
        }),
        // enum 'ExposureMode'
        QtMocHelpers::EnumData<enum ExposureMode>(47, 47, QMC::EnumFlags{}).add({
            {  108, ExposureMode::ExposureAuto },
            {  109, ExposureMode::ExposureManual },
            {  110, ExposureMode::ExposurePortrait },
            {  111, ExposureMode::ExposureNight },
            {  112, ExposureMode::ExposureSports },
            {  113, ExposureMode::ExposureSnow },
            {  114, ExposureMode::ExposureBeach },
            {  115, ExposureMode::ExposureAction },
            {  116, ExposureMode::ExposureLandscape },
            {  117, ExposureMode::ExposureNightPortrait },
            {  118, ExposureMode::ExposureTheatre },
            {  119, ExposureMode::ExposureSunset },
            {  120, ExposureMode::ExposureSteadyPhoto },
            {  121, ExposureMode::ExposureFireworks },
            {  122, ExposureMode::ExposureParty },
            {  123, ExposureMode::ExposureCandlelight },
            {  124, ExposureMode::ExposureBarcode },
        }),
        // enum 'WhiteBalanceMode'
        QtMocHelpers::EnumData<enum WhiteBalanceMode>(57, 57, QMC::EnumFlags{}).add({
            {  125, WhiteBalanceMode::WhiteBalanceAuto },
            {  126, WhiteBalanceMode::WhiteBalanceManual },
            {  127, WhiteBalanceMode::WhiteBalanceSunlight },
            {  128, WhiteBalanceMode::WhiteBalanceCloudy },
            {  129, WhiteBalanceMode::WhiteBalanceShade },
            {  130, WhiteBalanceMode::WhiteBalanceTungsten },
            {  131, WhiteBalanceMode::WhiteBalanceFluorescent },
            {  132, WhiteBalanceMode::WhiteBalanceFlash },
            {  133, WhiteBalanceMode::WhiteBalanceSunset },
        }),
        // flag 'Features'
        QtMocHelpers::EnumData<Features>(93, 134, QMC::EnumIsFlag | QMC::EnumIsScoped).add({
            {  135, Feature::ColorTemperature },
            {  136, Feature::ExposureCompensation },
            {  137, Feature::IsoSensitivity },
            {  138, Feature::ManualExposureTime },
            {  139, Feature::CustomFocusPoint },
            {  140, Feature::FocusDistance },
        }),
    };
    return QtMocHelpers::metaObjectData<QCamera, qt_meta_tag_ZN7QCameraE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCamera::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7QCameraE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7QCameraE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN7QCameraE_t>.metaTypes,
    nullptr
} };

void QCamera::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QCamera *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->activeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 1: _t->errorChanged(); break;
        case 2: _t->errorOccurred((*reinterpret_cast<std::add_pointer_t<QCamera::Error>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 3: _t->cameraDeviceChanged(); break;
        case 4: _t->cameraFormatChanged(); break;
        case 5: _t->supportedFeaturesChanged(); break;
        case 6: _t->focusModeChanged(); break;
        case 7: _t->zoomFactorChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 8: _t->minimumZoomFactorChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 9: _t->maximumZoomFactorChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 10: _t->focusDistanceChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 11: _t->focusPointChanged(); break;
        case 12: _t->customFocusPointChanged(); break;
        case 13: _t->flashReady((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 14: _t->flashModeChanged(); break;
        case 15: _t->torchModeChanged(); break;
        case 16: _t->exposureTimeChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 17: _t->manualExposureTimeChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 18: _t->isoSensitivityChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 19: _t->manualIsoSensitivityChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 20: _t->exposureCompensationChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 21: _t->exposureModeChanged(); break;
        case 22: _t->whiteBalanceModeChanged(); break;
        case 23: _t->colorTemperatureChanged(); break;
        case 24: _t->brightnessChanged(); break;
        case 25: _t->contrastChanged(); break;
        case 26: _t->saturationChanged(); break;
        case 27: _t->hueChanged(); break;
        case 28: _t->setActive((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 29: _t->start(); break;
        case 30: _t->stop(); break;
        case 31: _t->zoomTo((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2]))); break;
        case 32: _t->setFlashMode((*reinterpret_cast<std::add_pointer_t<enum FlashMode>>(_a[1]))); break;
        case 33: _t->setTorchMode((*reinterpret_cast<std::add_pointer_t<enum TorchMode>>(_a[1]))); break;
        case 34: _t->setExposureMode((*reinterpret_cast<std::add_pointer_t<enum ExposureMode>>(_a[1]))); break;
        case 35: _t->setExposureCompensation((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 36: _t->setManualIsoSensitivity((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 37: _t->setAutoIsoSensitivity(); break;
        case 38: _t->setManualExposureTime((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 39: _t->setAutoExposureTime(); break;
        case 40: _t->setWhiteBalanceMode((*reinterpret_cast<std::add_pointer_t<enum WhiteBalanceMode>>(_a[1]))); break;
        case 41: _t->setColorTemperature((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 42: { bool _r = _t->isFocusModeSupported((*reinterpret_cast<std::add_pointer_t<enum FocusMode>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 43: { bool _r = _t->isFlashModeSupported((*reinterpret_cast<std::add_pointer_t<enum FlashMode>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 44: { bool _r = _t->isFlashReady();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 45: { bool _r = _t->isTorchModeSupported((*reinterpret_cast<std::add_pointer_t<enum TorchMode>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 46: { bool _r = _t->isExposureModeSupported((*reinterpret_cast<std::add_pointer_t<enum ExposureMode>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 47: { bool _r = _t->isWhiteBalanceModeSupported((*reinterpret_cast<std::add_pointer_t<enum WhiteBalanceMode>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)(bool )>(_a, &QCamera::activeChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)()>(_a, &QCamera::errorChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)(QCamera::Error , const QString & )>(_a, &QCamera::errorOccurred, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)()>(_a, &QCamera::cameraDeviceChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)()>(_a, &QCamera::cameraFormatChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)()>(_a, &QCamera::supportedFeaturesChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)()>(_a, &QCamera::focusModeChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)(float )>(_a, &QCamera::zoomFactorChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)(float )>(_a, &QCamera::minimumZoomFactorChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)(float )>(_a, &QCamera::maximumZoomFactorChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)(float )>(_a, &QCamera::focusDistanceChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)()>(_a, &QCamera::focusPointChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)()>(_a, &QCamera::customFocusPointChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)(bool )>(_a, &QCamera::flashReady, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)()>(_a, &QCamera::flashModeChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)()>(_a, &QCamera::torchModeChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)(float )>(_a, &QCamera::exposureTimeChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)(float )>(_a, &QCamera::manualExposureTimeChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)(int )>(_a, &QCamera::isoSensitivityChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)(int )>(_a, &QCamera::manualIsoSensitivityChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)(float )>(_a, &QCamera::exposureCompensationChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)()>(_a, &QCamera::exposureModeChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)() const>(_a, &QCamera::whiteBalanceModeChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)() const>(_a, &QCamera::colorTemperatureChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)()>(_a, &QCamera::brightnessChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)()>(_a, &QCamera::contrastChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)()>(_a, &QCamera::saturationChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (QCamera::*)()>(_a, &QCamera::hueChanged, 27))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->isActive(); break;
        case 1: *reinterpret_cast<QCameraDevice*>(_v) = _t->cameraDevice(); break;
        case 2: *reinterpret_cast<enum Error*>(_v) = _t->error(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->errorString(); break;
        case 4: *reinterpret_cast<QCameraFormat*>(_v) = _t->cameraFormat(); break;
        case 5: *reinterpret_cast<enum FocusMode*>(_v) = _t->focusMode(); break;
        case 6: *reinterpret_cast<QPointF*>(_v) = _t->focusPoint(); break;
        case 7: *reinterpret_cast<QPointF*>(_v) = _t->customFocusPoint(); break;
        case 8: *reinterpret_cast<float*>(_v) = _t->focusDistance(); break;
        case 9: *reinterpret_cast<float*>(_v) = _t->minimumZoomFactor(); break;
        case 10: *reinterpret_cast<float*>(_v) = _t->maximumZoomFactor(); break;
        case 11: *reinterpret_cast<float*>(_v) = _t->zoomFactor(); break;
        case 12: *reinterpret_cast<float*>(_v) = _t->exposureTime(); break;
        case 13: *reinterpret_cast<float*>(_v) = _t->manualExposureTime(); break;
        case 14: *reinterpret_cast<int*>(_v) = _t->isoSensitivity(); break;
        case 15: *reinterpret_cast<int*>(_v) = _t->manualIsoSensitivity(); break;
        case 16: *reinterpret_cast<float*>(_v) = _t->exposureCompensation(); break;
        case 17: *reinterpret_cast<QCamera::ExposureMode*>(_v) = _t->exposureMode(); break;
        case 18: *reinterpret_cast<bool*>(_v) = _t->isFlashReady(); break;
        case 19: *reinterpret_cast<QCamera::FlashMode*>(_v) = _t->flashMode(); break;
        case 20: *reinterpret_cast<QCamera::TorchMode*>(_v) = _t->torchMode(); break;
        case 21: *reinterpret_cast<enum WhiteBalanceMode*>(_v) = _t->whiteBalanceMode(); break;
        case 22: *reinterpret_cast<int*>(_v) = _t->colorTemperature(); break;
        case 23: QtMocHelpers::assignFlags<Features>(_v, _t->supportedFeatures()); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setActive(*reinterpret_cast<bool*>(_v)); break;
        case 1: _t->setCameraDevice(*reinterpret_cast<QCameraDevice*>(_v)); break;
        case 4: _t->setCameraFormat(*reinterpret_cast<QCameraFormat*>(_v)); break;
        case 5: _t->setFocusMode(*reinterpret_cast<enum FocusMode*>(_v)); break;
        case 7: _t->setCustomFocusPoint(*reinterpret_cast<QPointF*>(_v)); break;
        case 8: _t->setFocusDistance(*reinterpret_cast<float*>(_v)); break;
        case 11: _t->setZoomFactor(*reinterpret_cast<float*>(_v)); break;
        case 13: _t->setManualExposureTime(*reinterpret_cast<float*>(_v)); break;
        case 15: _t->setManualIsoSensitivity(*reinterpret_cast<int*>(_v)); break;
        case 16: _t->setExposureCompensation(*reinterpret_cast<float*>(_v)); break;
        case 17: _t->setExposureMode(*reinterpret_cast<QCamera::ExposureMode*>(_v)); break;
        case 19: _t->setFlashMode(*reinterpret_cast<QCamera::FlashMode*>(_v)); break;
        case 20: _t->setTorchMode(*reinterpret_cast<QCamera::TorchMode*>(_v)); break;
        case 21: _t->setWhiteBalanceMode(*reinterpret_cast<enum WhiteBalanceMode*>(_v)); break;
        case 22: _t->setColorTemperature(*reinterpret_cast<int*>(_v)); break;
        default: break;
        }
    }
}

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

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

int QCamera::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 < 48)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 48;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 48)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 48;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 24;
    }
    return _id;
}

// SIGNAL 0
void QCamera::activeChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

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

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

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

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

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

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

// SIGNAL 7
void QCamera::zoomFactorChanged(float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void QCamera::minimumZoomFactorChanged(float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void QCamera::maximumZoomFactorChanged(float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void QCamera::focusDistanceChanged(float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

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

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

// SIGNAL 13
void QCamera::flashReady(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

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

// SIGNAL 15
void QCamera::torchModeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
}

// SIGNAL 16
void QCamera::exposureTimeChanged(float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
}

// SIGNAL 17
void QCamera::manualExposureTimeChanged(float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

// SIGNAL 18
void QCamera::isoSensitivityChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 19
void QCamera::manualIsoSensitivityChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1);
}

// SIGNAL 20
void QCamera::exposureCompensationChanged(float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

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

// SIGNAL 22
void QCamera::whiteBalanceModeChanged()const
{
    QMetaObject::activate(const_cast< QCamera *>(this), &staticMetaObject, 22, nullptr);
}

// SIGNAL 23
void QCamera::colorTemperatureChanged()const
{
    QMetaObject::activate(const_cast< QCamera *>(this), &staticMetaObject, 23, nullptr);
}

// SIGNAL 24
void QCamera::brightnessChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 24, nullptr);
}

// SIGNAL 25
void QCamera::contrastChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 25, nullptr);
}

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

// SIGNAL 27
void QCamera::hueChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 27, nullptr);
}
QT_WARNING_POP
