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

#include "../../../../../dde-control-center/src/plugin-power/operation/powerworker.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 'powerworker.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.2. 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_ZN11PowerWorkerE_t {};
} // unnamed namespace

template <> constexpr inline auto PowerWorker::qt_create_metaobjectdata<qt_meta_tag_ZN11PowerWorkerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "PowerWorker",
        "setScreenBlackLock",
        "",
        "lock",
        "setScheduledShutdownState",
        "state",
        "setShutdownTime",
        "time",
        "setShutdownRepetition",
        "repetition",
        "setCustomShutdownWeekDays",
        "weekdays",
        "setSleepLock",
        "setSleepOnLidOnPowerClosed",
        "sleep",
        "setSleepDelayOnPower",
        "delay",
        "setSleepDelayOnBattery",
        "setScreenBlackDelayOnPower",
        "setScreenBlackDelayOnBattery",
        "setSleepDelayToModelOnPower",
        "setScreenBlackDelayToModelOnPower",
        "setSleepDelayToModelOnBattery",
        "setScreenBlackDelayToModelOnBattery",
        "setLockScreenDelayOnBattery",
        "setLockScreenDelayOnPower",
        "setResponseBatteryLockScreenDelay",
        "setResponsePowerLockScreenDelay",
        "setHighPerformanceSupported",
        "setBalancePerformanceSupported",
        "setPowerSavingModeAutoWhenQuantifyLow",
        "bLowBatteryAutoIntoSaveEnergyMode",
        "setPowerSavingModeAuto",
        "bAutoIntoSaveEnergyMode",
        "setPowerSavingModeLowerBrightnessThreshold",
        "dPowerSavingModeLowerBrightnessThreshold",
        "setPowerSavingModeAutoBatteryPercentage",
        "dPowerSavingModebatteryPentage",
        "setLinePowerPressPowerBtnAction",
        "nLinePowerPressPowerBtnAction",
        "setLinePowerLidClosedAction",
        "nLinePowerLidClosedAction",
        "setBatteryPressPowerBtnAction",
        "nBatteryPressPowerBtnAction",
        "setBatteryLidClosedAction",
        "nBatteryLidClosedAction",
        "setLowPowerNotifyEnable",
        "bLowPowerNotifyEnable",
        "setLowPowerNotifyThreshold",
        "dLowPowerNotifyThreshold",
        "setLowPowerAutoSleepThreshold",
        "dLowPowerAutoSleepThreshold",
        "setLowPowerAction",
        "action",
        "setPowerPlan",
        "powerPlan",
        "setShowBatteryTimeToFull",
        "value",
        "getCurCanSuspend",
        "getCurCanHibernate",
        "setEnablePowerSave",
        "isEnable",
        "getMaxBacklightBrightness",
        "onCustomShutdownWeekDaysChanged"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'setScreenBlackLock'
        QtMocHelpers::SlotData<void(const bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'setScheduledShutdownState'
        QtMocHelpers::SlotData<void(const bool)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 5 },
        }}),
        // Slot 'setShutdownTime'
        QtMocHelpers::SlotData<void(const QString &)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 7 },
        }}),
        // Slot 'setShutdownRepetition'
        QtMocHelpers::SlotData<void(int)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 9 },
        }}),
        // Slot 'setCustomShutdownWeekDays'
        QtMocHelpers::SlotData<void(const QString &)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 11 },
        }}),
        // Slot 'setSleepLock'
        QtMocHelpers::SlotData<void(const bool)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'setSleepOnLidOnPowerClosed'
        QtMocHelpers::SlotData<void(const bool)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 14 },
        }}),
        // Slot 'setSleepDelayOnPower'
        QtMocHelpers::SlotData<void(const int)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 16 },
        }}),
        // Slot 'setSleepDelayOnBattery'
        QtMocHelpers::SlotData<void(const int)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 16 },
        }}),
        // Slot 'setScreenBlackDelayOnPower'
        QtMocHelpers::SlotData<void(const int)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 16 },
        }}),
        // Slot 'setScreenBlackDelayOnBattery'
        QtMocHelpers::SlotData<void(const int)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 16 },
        }}),
        // Slot 'setSleepDelayToModelOnPower'
        QtMocHelpers::SlotData<void(const int)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 16 },
        }}),
        // Slot 'setScreenBlackDelayToModelOnPower'
        QtMocHelpers::SlotData<void(const int)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 16 },
        }}),
        // Slot 'setSleepDelayToModelOnBattery'
        QtMocHelpers::SlotData<void(const int)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 16 },
        }}),
        // Slot 'setScreenBlackDelayToModelOnBattery'
        QtMocHelpers::SlotData<void(const int)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 16 },
        }}),
        // Slot 'setLockScreenDelayOnBattery'
        QtMocHelpers::SlotData<void(const int)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 16 },
        }}),
        // Slot 'setLockScreenDelayOnPower'
        QtMocHelpers::SlotData<void(const int)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 16 },
        }}),
        // Slot 'setResponseBatteryLockScreenDelay'
        QtMocHelpers::SlotData<void(const int)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 16 },
        }}),
        // Slot 'setResponsePowerLockScreenDelay'
        QtMocHelpers::SlotData<void(const int)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 16 },
        }}),
        // Slot 'setHighPerformanceSupported'
        QtMocHelpers::SlotData<void(bool)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 5 },
        }}),
        // Slot 'setBalancePerformanceSupported'
        QtMocHelpers::SlotData<void(bool)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 5 },
        }}),
        // Slot 'setPowerSavingModeAutoWhenQuantifyLow'
        QtMocHelpers::SlotData<void(bool)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 31 },
        }}),
        // Slot 'setPowerSavingModeAuto'
        QtMocHelpers::SlotData<void(bool)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 33 },
        }}),
        // Slot 'setPowerSavingModeLowerBrightnessThreshold'
        QtMocHelpers::SlotData<void(uint)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 35 },
        }}),
        // Slot 'setPowerSavingModeAutoBatteryPercentage'
        QtMocHelpers::SlotData<void(uint)>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 37 },
        }}),
        // Slot 'setLinePowerPressPowerBtnAction'
        QtMocHelpers::SlotData<void(int)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 },
        }}),
        // Slot 'setLinePowerLidClosedAction'
        QtMocHelpers::SlotData<void(int)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 41 },
        }}),
        // Slot 'setBatteryPressPowerBtnAction'
        QtMocHelpers::SlotData<void(int)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 43 },
        }}),
        // Slot 'setBatteryLidClosedAction'
        QtMocHelpers::SlotData<void(int)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 45 },
        }}),
        // Slot 'setLowPowerNotifyEnable'
        QtMocHelpers::SlotData<void(bool)>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 47 },
        }}),
        // Slot 'setLowPowerNotifyThreshold'
        QtMocHelpers::SlotData<void(int)>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 49 },
        }}),
        // Slot 'setLowPowerAutoSleepThreshold'
        QtMocHelpers::SlotData<void(int)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 51 },
        }}),
        // Slot 'setLowPowerAction'
        QtMocHelpers::SlotData<void(int)>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 53 },
        }}),
        // Slot 'setPowerPlan'
        QtMocHelpers::SlotData<void(const QString &)>(54, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 55 },
        }}),
        // Slot 'setShowBatteryTimeToFull'
        QtMocHelpers::SlotData<void(bool)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 57 },
        }}),
        // Slot 'getCurCanSuspend'
        QtMocHelpers::SlotData<bool()>(58, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getCurCanHibernate'
        QtMocHelpers::SlotData<bool()>(59, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setEnablePowerSave'
        QtMocHelpers::SlotData<void(const bool)>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 61 },
        }}),
        // Slot 'getMaxBacklightBrightness'
        QtMocHelpers::SlotData<int()>(62, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'onCustomShutdownWeekDaysChanged'
        QtMocHelpers::SlotData<void(const QByteArray &)>(63, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QByteArray, 57 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PowerWorker, qt_meta_tag_ZN11PowerWorkerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject PowerWorker::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11PowerWorkerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11PowerWorkerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11PowerWorkerE_t>.metaTypes,
    nullptr
} };

void PowerWorker::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PowerWorker *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->setScreenBlackLock((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 1: _t->setScheduledShutdownState((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 2: _t->setShutdownTime((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->setShutdownRepetition((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 4: _t->setCustomShutdownWeekDays((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 5: _t->setSleepLock((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 6: _t->setSleepOnLidOnPowerClosed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->setSleepDelayOnPower((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 8: _t->setSleepDelayOnBattery((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 9: _t->setScreenBlackDelayOnPower((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 10: _t->setScreenBlackDelayOnBattery((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 11: _t->setSleepDelayToModelOnPower((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 12: _t->setScreenBlackDelayToModelOnPower((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 13: _t->setSleepDelayToModelOnBattery((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 14: _t->setScreenBlackDelayToModelOnBattery((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 15: _t->setLockScreenDelayOnBattery((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 16: _t->setLockScreenDelayOnPower((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 17: _t->setResponseBatteryLockScreenDelay((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 18: _t->setResponsePowerLockScreenDelay((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 19: _t->setHighPerformanceSupported((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 20: _t->setBalancePerformanceSupported((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 21: _t->setPowerSavingModeAutoWhenQuantifyLow((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 22: _t->setPowerSavingModeAuto((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 23: _t->setPowerSavingModeLowerBrightnessThreshold((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 24: _t->setPowerSavingModeAutoBatteryPercentage((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 25: _t->setLinePowerPressPowerBtnAction((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 26: _t->setLinePowerLidClosedAction((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 27: _t->setBatteryPressPowerBtnAction((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 28: _t->setBatteryLidClosedAction((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 29: _t->setLowPowerNotifyEnable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 30: _t->setLowPowerNotifyThreshold((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 31: _t->setLowPowerAutoSleepThreshold((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 32: _t->setLowPowerAction((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 33: _t->setPowerPlan((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 34: _t->setShowBatteryTimeToFull((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 35: { bool _r = _t->getCurCanSuspend();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 36: { bool _r = _t->getCurCanHibernate();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 37: _t->setEnablePowerSave((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 38: { int _r = _t->getMaxBacklightBrightness();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 39: _t->onCustomShutdownWeekDaysChanged((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
        default: ;
        }
    }
}

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

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

int PowerWorker::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 < 40)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 40;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 40)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 40;
    }
    return _id;
}
QT_WARNING_POP
