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

#include "../../annotationconfig.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 'annotationconfig.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.10.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_ZN16AnnotationConfigE_t {};
} // unnamed namespace

template <> constexpr inline auto AnnotationConfig::qt_create_metaobjectdata<qt_meta_tag_ZN16AnnotationConfigE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "AnnotationConfig",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "annotationToolTypeChanged",
        "",
        "freehandStrokeWidthChanged",
        "highlighterStrokeWidthChanged",
        "lineStrokeWidthChanged",
        "arrowStrokeWidthChanged",
        "rectangleStrokeWidthChanged",
        "ellipseStrokeWidthChanged",
        "freehandStrokeColorChanged",
        "highlighterStrokeColorChanged",
        "lineStrokeColorChanged",
        "arrowStrokeColorChanged",
        "rectangleStrokeColorChanged",
        "ellipseStrokeColorChanged",
        "rectangleFillColorChanged",
        "ellipseFillColorChanged",
        "numberFillColorChanged",
        "blurStrengthChanged",
        "pixelateStrengthChanged",
        "textFontChanged",
        "numberFontChanged",
        "textFontColorChanged",
        "numberFontColorChanged",
        "freehandShadowChanged",
        "lineShadowChanged",
        "arrowShadowChanged",
        "rectangleShadowChanged",
        "ellipseShadowChanged",
        "textShadowChanged",
        "numberShadowChanged",
        "annotationToolType",
        "isAnnotationToolTypeImmutable",
        "defaultAnnotationToolTypeValue",
        "freehandStrokeWidth",
        "isFreehandStrokeWidthImmutable",
        "defaultFreehandStrokeWidthValue",
        "highlighterStrokeWidth",
        "isHighlighterStrokeWidthImmutable",
        "defaultHighlighterStrokeWidthValue",
        "lineStrokeWidth",
        "isLineStrokeWidthImmutable",
        "defaultLineStrokeWidthValue",
        "arrowStrokeWidth",
        "isArrowStrokeWidthImmutable",
        "defaultArrowStrokeWidthValue",
        "rectangleStrokeWidth",
        "isRectangleStrokeWidthImmutable",
        "defaultRectangleStrokeWidthValue",
        "ellipseStrokeWidth",
        "isEllipseStrokeWidthImmutable",
        "defaultEllipseStrokeWidthValue",
        "freehandStrokeColor",
        "QColor",
        "isFreehandStrokeColorImmutable",
        "defaultFreehandStrokeColorValue",
        "highlighterStrokeColor",
        "isHighlighterStrokeColorImmutable",
        "defaultHighlighterStrokeColorValue",
        "lineStrokeColor",
        "isLineStrokeColorImmutable",
        "defaultLineStrokeColorValue",
        "arrowStrokeColor",
        "isArrowStrokeColorImmutable",
        "defaultArrowStrokeColorValue",
        "rectangleStrokeColor",
        "isRectangleStrokeColorImmutable",
        "defaultRectangleStrokeColorValue",
        "ellipseStrokeColor",
        "isEllipseStrokeColorImmutable",
        "defaultEllipseStrokeColorValue",
        "rectangleFillColor",
        "isRectangleFillColorImmutable",
        "defaultRectangleFillColorValue",
        "ellipseFillColor",
        "isEllipseFillColorImmutable",
        "defaultEllipseFillColorValue",
        "numberFillColor",
        "isNumberFillColorImmutable",
        "defaultNumberFillColorValue",
        "blurStrength",
        "isBlurStrengthImmutable",
        "defaultBlurStrengthValue",
        "pixelateStrength",
        "isPixelateStrengthImmutable",
        "defaultPixelateStrengthValue",
        "textFont",
        "QFont",
        "isTextFontImmutable",
        "numberFont",
        "isNumberFontImmutable",
        "textFontColor",
        "isTextFontColorImmutable",
        "defaultTextFontColorValue",
        "numberFontColor",
        "isNumberFontColorImmutable",
        "defaultNumberFontColorValue",
        "freehandShadow",
        "isFreehandShadowImmutable",
        "defaultFreehandShadowValue",
        "lineShadow",
        "isLineShadowImmutable",
        "defaultLineShadowValue",
        "arrowShadow",
        "isArrowShadowImmutable",
        "defaultArrowShadowValue",
        "rectangleShadow",
        "isRectangleShadowImmutable",
        "defaultRectangleShadowValue",
        "ellipseShadow",
        "isEllipseShadowImmutable",
        "defaultEllipseShadowValue",
        "textShadow",
        "isTextShadowImmutable",
        "defaultTextShadowValue",
        "numberShadow",
        "isNumberShadowImmutable",
        "defaultNumberShadowValue"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'annotationToolTypeChanged'
        QtMocHelpers::SignalData<void()>(5, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'freehandStrokeWidthChanged'
        QtMocHelpers::SignalData<void()>(7, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'highlighterStrokeWidthChanged'
        QtMocHelpers::SignalData<void()>(8, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lineStrokeWidthChanged'
        QtMocHelpers::SignalData<void()>(9, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'arrowStrokeWidthChanged'
        QtMocHelpers::SignalData<void()>(10, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'rectangleStrokeWidthChanged'
        QtMocHelpers::SignalData<void()>(11, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'ellipseStrokeWidthChanged'
        QtMocHelpers::SignalData<void()>(12, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'freehandStrokeColorChanged'
        QtMocHelpers::SignalData<void()>(13, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'highlighterStrokeColorChanged'
        QtMocHelpers::SignalData<void()>(14, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lineStrokeColorChanged'
        QtMocHelpers::SignalData<void()>(15, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'arrowStrokeColorChanged'
        QtMocHelpers::SignalData<void()>(16, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'rectangleStrokeColorChanged'
        QtMocHelpers::SignalData<void()>(17, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'ellipseStrokeColorChanged'
        QtMocHelpers::SignalData<void()>(18, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'rectangleFillColorChanged'
        QtMocHelpers::SignalData<void()>(19, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'ellipseFillColorChanged'
        QtMocHelpers::SignalData<void()>(20, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'numberFillColorChanged'
        QtMocHelpers::SignalData<void()>(21, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'blurStrengthChanged'
        QtMocHelpers::SignalData<void()>(22, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'pixelateStrengthChanged'
        QtMocHelpers::SignalData<void()>(23, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'textFontChanged'
        QtMocHelpers::SignalData<void()>(24, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'numberFontChanged'
        QtMocHelpers::SignalData<void()>(25, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'textFontColorChanged'
        QtMocHelpers::SignalData<void()>(26, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'numberFontColorChanged'
        QtMocHelpers::SignalData<void()>(27, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'freehandShadowChanged'
        QtMocHelpers::SignalData<void()>(28, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lineShadowChanged'
        QtMocHelpers::SignalData<void()>(29, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'arrowShadowChanged'
        QtMocHelpers::SignalData<void()>(30, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'rectangleShadowChanged'
        QtMocHelpers::SignalData<void()>(31, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'ellipseShadowChanged'
        QtMocHelpers::SignalData<void()>(32, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'textShadowChanged'
        QtMocHelpers::SignalData<void()>(33, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'numberShadowChanged'
        QtMocHelpers::SignalData<void()>(34, 6, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'annotationToolType'
        QtMocHelpers::PropertyData<int>(35, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
        // property 'isAnnotationToolTypeImmutable'
        QtMocHelpers::PropertyData<bool>(36, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultAnnotationToolTypeValue'
        QtMocHelpers::PropertyData<int>(37, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'freehandStrokeWidth'
        QtMocHelpers::PropertyData<uint>(38, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'isFreehandStrokeWidthImmutable'
        QtMocHelpers::PropertyData<bool>(39, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultFreehandStrokeWidthValue'
        QtMocHelpers::PropertyData<uint>(40, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'highlighterStrokeWidth'
        QtMocHelpers::PropertyData<uint>(41, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'isHighlighterStrokeWidthImmutable'
        QtMocHelpers::PropertyData<bool>(42, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultHighlighterStrokeWidthValue'
        QtMocHelpers::PropertyData<uint>(43, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'lineStrokeWidth'
        QtMocHelpers::PropertyData<uint>(44, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 3),
        // property 'isLineStrokeWidthImmutable'
        QtMocHelpers::PropertyData<bool>(45, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultLineStrokeWidthValue'
        QtMocHelpers::PropertyData<uint>(46, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'arrowStrokeWidth'
        QtMocHelpers::PropertyData<uint>(47, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 4),
        // property 'isArrowStrokeWidthImmutable'
        QtMocHelpers::PropertyData<bool>(48, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultArrowStrokeWidthValue'
        QtMocHelpers::PropertyData<uint>(49, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'rectangleStrokeWidth'
        QtMocHelpers::PropertyData<uint>(50, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 5),
        // property 'isRectangleStrokeWidthImmutable'
        QtMocHelpers::PropertyData<bool>(51, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultRectangleStrokeWidthValue'
        QtMocHelpers::PropertyData<uint>(52, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'ellipseStrokeWidth'
        QtMocHelpers::PropertyData<uint>(53, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 6),
        // property 'isEllipseStrokeWidthImmutable'
        QtMocHelpers::PropertyData<bool>(54, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultEllipseStrokeWidthValue'
        QtMocHelpers::PropertyData<uint>(55, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'freehandStrokeColor'
        QtMocHelpers::PropertyData<QColor>(56, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 7),
        // property 'isFreehandStrokeColorImmutable'
        QtMocHelpers::PropertyData<bool>(58, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultFreehandStrokeColorValue'
        QtMocHelpers::PropertyData<QColor>(59, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'highlighterStrokeColor'
        QtMocHelpers::PropertyData<QColor>(60, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 8),
        // property 'isHighlighterStrokeColorImmutable'
        QtMocHelpers::PropertyData<bool>(61, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultHighlighterStrokeColorValue'
        QtMocHelpers::PropertyData<QColor>(62, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'lineStrokeColor'
        QtMocHelpers::PropertyData<QColor>(63, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 9),
        // property 'isLineStrokeColorImmutable'
        QtMocHelpers::PropertyData<bool>(64, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultLineStrokeColorValue'
        QtMocHelpers::PropertyData<QColor>(65, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'arrowStrokeColor'
        QtMocHelpers::PropertyData<QColor>(66, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 10),
        // property 'isArrowStrokeColorImmutable'
        QtMocHelpers::PropertyData<bool>(67, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultArrowStrokeColorValue'
        QtMocHelpers::PropertyData<QColor>(68, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'rectangleStrokeColor'
        QtMocHelpers::PropertyData<QColor>(69, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 11),
        // property 'isRectangleStrokeColorImmutable'
        QtMocHelpers::PropertyData<bool>(70, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultRectangleStrokeColorValue'
        QtMocHelpers::PropertyData<QColor>(71, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'ellipseStrokeColor'
        QtMocHelpers::PropertyData<QColor>(72, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 12),
        // property 'isEllipseStrokeColorImmutable'
        QtMocHelpers::PropertyData<bool>(73, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultEllipseStrokeColorValue'
        QtMocHelpers::PropertyData<QColor>(74, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'rectangleFillColor'
        QtMocHelpers::PropertyData<QColor>(75, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 13),
        // property 'isRectangleFillColorImmutable'
        QtMocHelpers::PropertyData<bool>(76, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultRectangleFillColorValue'
        QtMocHelpers::PropertyData<QColor>(77, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'ellipseFillColor'
        QtMocHelpers::PropertyData<QColor>(78, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 14),
        // property 'isEllipseFillColorImmutable'
        QtMocHelpers::PropertyData<bool>(79, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultEllipseFillColorValue'
        QtMocHelpers::PropertyData<QColor>(80, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'numberFillColor'
        QtMocHelpers::PropertyData<QColor>(81, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 15),
        // property 'isNumberFillColorImmutable'
        QtMocHelpers::PropertyData<bool>(82, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultNumberFillColorValue'
        QtMocHelpers::PropertyData<QColor>(83, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'blurStrength'
        QtMocHelpers::PropertyData<double>(84, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'isBlurStrengthImmutable'
        QtMocHelpers::PropertyData<bool>(85, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultBlurStrengthValue'
        QtMocHelpers::PropertyData<double>(86, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'pixelateStrength'
        QtMocHelpers::PropertyData<double>(87, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 17),
        // property 'isPixelateStrengthImmutable'
        QtMocHelpers::PropertyData<bool>(88, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultPixelateStrengthValue'
        QtMocHelpers::PropertyData<double>(89, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'textFont'
        QtMocHelpers::PropertyData<QFont>(90, 0x80000000 | 91, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 18),
        // property 'isTextFontImmutable'
        QtMocHelpers::PropertyData<bool>(92, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'numberFont'
        QtMocHelpers::PropertyData<QFont>(93, 0x80000000 | 91, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 19),
        // property 'isNumberFontImmutable'
        QtMocHelpers::PropertyData<bool>(94, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'textFontColor'
        QtMocHelpers::PropertyData<QColor>(95, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 20),
        // property 'isTextFontColorImmutable'
        QtMocHelpers::PropertyData<bool>(96, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultTextFontColorValue'
        QtMocHelpers::PropertyData<QColor>(97, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'numberFontColor'
        QtMocHelpers::PropertyData<QColor>(98, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 21),
        // property 'isNumberFontColorImmutable'
        QtMocHelpers::PropertyData<bool>(99, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultNumberFontColorValue'
        QtMocHelpers::PropertyData<QColor>(100, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'freehandShadow'
        QtMocHelpers::PropertyData<bool>(101, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 22),
        // property 'isFreehandShadowImmutable'
        QtMocHelpers::PropertyData<bool>(102, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultFreehandShadowValue'
        QtMocHelpers::PropertyData<bool>(103, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'lineShadow'
        QtMocHelpers::PropertyData<bool>(104, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 23),
        // property 'isLineShadowImmutable'
        QtMocHelpers::PropertyData<bool>(105, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultLineShadowValue'
        QtMocHelpers::PropertyData<bool>(106, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'arrowShadow'
        QtMocHelpers::PropertyData<bool>(107, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 24),
        // property 'isArrowShadowImmutable'
        QtMocHelpers::PropertyData<bool>(108, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultArrowShadowValue'
        QtMocHelpers::PropertyData<bool>(109, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'rectangleShadow'
        QtMocHelpers::PropertyData<bool>(110, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 25),
        // property 'isRectangleShadowImmutable'
        QtMocHelpers::PropertyData<bool>(111, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultRectangleShadowValue'
        QtMocHelpers::PropertyData<bool>(112, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'ellipseShadow'
        QtMocHelpers::PropertyData<bool>(113, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 26),
        // property 'isEllipseShadowImmutable'
        QtMocHelpers::PropertyData<bool>(114, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultEllipseShadowValue'
        QtMocHelpers::PropertyData<bool>(115, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'textShadow'
        QtMocHelpers::PropertyData<bool>(116, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 27),
        // property 'isTextShadowImmutable'
        QtMocHelpers::PropertyData<bool>(117, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultTextShadowValue'
        QtMocHelpers::PropertyData<bool>(118, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'numberShadow'
        QtMocHelpers::PropertyData<bool>(119, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 28),
        // property 'isNumberShadowImmutable'
        QtMocHelpers::PropertyData<bool>(120, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'defaultNumberShadowValue'
        QtMocHelpers::PropertyData<bool>(121, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<AnnotationConfig, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject AnnotationConfig::staticMetaObject = { {
    QMetaObject::SuperData::link<KConfigSkeleton::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16AnnotationConfigE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16AnnotationConfigE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16AnnotationConfigE_t>.metaTypes,
    nullptr
} };

void AnnotationConfig::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<AnnotationConfig *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->annotationToolTypeChanged(); break;
        case 1: _t->freehandStrokeWidthChanged(); break;
        case 2: _t->highlighterStrokeWidthChanged(); break;
        case 3: _t->lineStrokeWidthChanged(); break;
        case 4: _t->arrowStrokeWidthChanged(); break;
        case 5: _t->rectangleStrokeWidthChanged(); break;
        case 6: _t->ellipseStrokeWidthChanged(); break;
        case 7: _t->freehandStrokeColorChanged(); break;
        case 8: _t->highlighterStrokeColorChanged(); break;
        case 9: _t->lineStrokeColorChanged(); break;
        case 10: _t->arrowStrokeColorChanged(); break;
        case 11: _t->rectangleStrokeColorChanged(); break;
        case 12: _t->ellipseStrokeColorChanged(); break;
        case 13: _t->rectangleFillColorChanged(); break;
        case 14: _t->ellipseFillColorChanged(); break;
        case 15: _t->numberFillColorChanged(); break;
        case 16: _t->blurStrengthChanged(); break;
        case 17: _t->pixelateStrengthChanged(); break;
        case 18: _t->textFontChanged(); break;
        case 19: _t->numberFontChanged(); break;
        case 20: _t->textFontColorChanged(); break;
        case 21: _t->numberFontColorChanged(); break;
        case 22: _t->freehandShadowChanged(); break;
        case 23: _t->lineShadowChanged(); break;
        case 24: _t->arrowShadowChanged(); break;
        case 25: _t->rectangleShadowChanged(); break;
        case 26: _t->ellipseShadowChanged(); break;
        case 27: _t->textShadowChanged(); break;
        case 28: _t->numberShadowChanged(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::annotationToolTypeChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::freehandStrokeWidthChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::highlighterStrokeWidthChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::lineStrokeWidthChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::arrowStrokeWidthChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::rectangleStrokeWidthChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::ellipseStrokeWidthChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::freehandStrokeColorChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::highlighterStrokeColorChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::lineStrokeColorChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::arrowStrokeColorChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::rectangleStrokeColorChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::ellipseStrokeColorChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::rectangleFillColorChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::ellipseFillColorChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::numberFillColorChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::blurStrengthChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::pixelateStrengthChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::textFontChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::numberFontChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::textFontColorChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::numberFontColorChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::freehandShadowChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::lineShadowChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::arrowShadowChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::rectangleShadowChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::ellipseShadowChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::textShadowChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (AnnotationConfig::*)()>(_a, &AnnotationConfig::numberShadowChanged, 28))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->annotationToolType(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->isAnnotationToolTypeImmutable(); break;
        case 2: *reinterpret_cast<int*>(_v) = _t->defaultAnnotationToolTypeValue(); break;
        case 3: *reinterpret_cast<uint*>(_v) = _t->freehandStrokeWidth(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->isFreehandStrokeWidthImmutable(); break;
        case 5: *reinterpret_cast<uint*>(_v) = _t->defaultFreehandStrokeWidthValue(); break;
        case 6: *reinterpret_cast<uint*>(_v) = _t->highlighterStrokeWidth(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->isHighlighterStrokeWidthImmutable(); break;
        case 8: *reinterpret_cast<uint*>(_v) = _t->defaultHighlighterStrokeWidthValue(); break;
        case 9: *reinterpret_cast<uint*>(_v) = _t->lineStrokeWidth(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->isLineStrokeWidthImmutable(); break;
        case 11: *reinterpret_cast<uint*>(_v) = _t->defaultLineStrokeWidthValue(); break;
        case 12: *reinterpret_cast<uint*>(_v) = _t->arrowStrokeWidth(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->isArrowStrokeWidthImmutable(); break;
        case 14: *reinterpret_cast<uint*>(_v) = _t->defaultArrowStrokeWidthValue(); break;
        case 15: *reinterpret_cast<uint*>(_v) = _t->rectangleStrokeWidth(); break;
        case 16: *reinterpret_cast<bool*>(_v) = _t->isRectangleStrokeWidthImmutable(); break;
        case 17: *reinterpret_cast<uint*>(_v) = _t->defaultRectangleStrokeWidthValue(); break;
        case 18: *reinterpret_cast<uint*>(_v) = _t->ellipseStrokeWidth(); break;
        case 19: *reinterpret_cast<bool*>(_v) = _t->isEllipseStrokeWidthImmutable(); break;
        case 20: *reinterpret_cast<uint*>(_v) = _t->defaultEllipseStrokeWidthValue(); break;
        case 21: *reinterpret_cast<QColor*>(_v) = _t->freehandStrokeColor(); break;
        case 22: *reinterpret_cast<bool*>(_v) = _t->isFreehandStrokeColorImmutable(); break;
        case 23: *reinterpret_cast<QColor*>(_v) = _t->defaultFreehandStrokeColorValue(); break;
        case 24: *reinterpret_cast<QColor*>(_v) = _t->highlighterStrokeColor(); break;
        case 25: *reinterpret_cast<bool*>(_v) = _t->isHighlighterStrokeColorImmutable(); break;
        case 26: *reinterpret_cast<QColor*>(_v) = _t->defaultHighlighterStrokeColorValue(); break;
        case 27: *reinterpret_cast<QColor*>(_v) = _t->lineStrokeColor(); break;
        case 28: *reinterpret_cast<bool*>(_v) = _t->isLineStrokeColorImmutable(); break;
        case 29: *reinterpret_cast<QColor*>(_v) = _t->defaultLineStrokeColorValue(); break;
        case 30: *reinterpret_cast<QColor*>(_v) = _t->arrowStrokeColor(); break;
        case 31: *reinterpret_cast<bool*>(_v) = _t->isArrowStrokeColorImmutable(); break;
        case 32: *reinterpret_cast<QColor*>(_v) = _t->defaultArrowStrokeColorValue(); break;
        case 33: *reinterpret_cast<QColor*>(_v) = _t->rectangleStrokeColor(); break;
        case 34: *reinterpret_cast<bool*>(_v) = _t->isRectangleStrokeColorImmutable(); break;
        case 35: *reinterpret_cast<QColor*>(_v) = _t->defaultRectangleStrokeColorValue(); break;
        case 36: *reinterpret_cast<QColor*>(_v) = _t->ellipseStrokeColor(); break;
        case 37: *reinterpret_cast<bool*>(_v) = _t->isEllipseStrokeColorImmutable(); break;
        case 38: *reinterpret_cast<QColor*>(_v) = _t->defaultEllipseStrokeColorValue(); break;
        case 39: *reinterpret_cast<QColor*>(_v) = _t->rectangleFillColor(); break;
        case 40: *reinterpret_cast<bool*>(_v) = _t->isRectangleFillColorImmutable(); break;
        case 41: *reinterpret_cast<QColor*>(_v) = _t->defaultRectangleFillColorValue(); break;
        case 42: *reinterpret_cast<QColor*>(_v) = _t->ellipseFillColor(); break;
        case 43: *reinterpret_cast<bool*>(_v) = _t->isEllipseFillColorImmutable(); break;
        case 44: *reinterpret_cast<QColor*>(_v) = _t->defaultEllipseFillColorValue(); break;
        case 45: *reinterpret_cast<QColor*>(_v) = _t->numberFillColor(); break;
        case 46: *reinterpret_cast<bool*>(_v) = _t->isNumberFillColorImmutable(); break;
        case 47: *reinterpret_cast<QColor*>(_v) = _t->defaultNumberFillColorValue(); break;
        case 48: *reinterpret_cast<double*>(_v) = _t->blurStrength(); break;
        case 49: *reinterpret_cast<bool*>(_v) = _t->isBlurStrengthImmutable(); break;
        case 50: *reinterpret_cast<double*>(_v) = _t->defaultBlurStrengthValue(); break;
        case 51: *reinterpret_cast<double*>(_v) = _t->pixelateStrength(); break;
        case 52: *reinterpret_cast<bool*>(_v) = _t->isPixelateStrengthImmutable(); break;
        case 53: *reinterpret_cast<double*>(_v) = _t->defaultPixelateStrengthValue(); break;
        case 54: *reinterpret_cast<QFont*>(_v) = _t->textFont(); break;
        case 55: *reinterpret_cast<bool*>(_v) = _t->isTextFontImmutable(); break;
        case 56: *reinterpret_cast<QFont*>(_v) = _t->numberFont(); break;
        case 57: *reinterpret_cast<bool*>(_v) = _t->isNumberFontImmutable(); break;
        case 58: *reinterpret_cast<QColor*>(_v) = _t->textFontColor(); break;
        case 59: *reinterpret_cast<bool*>(_v) = _t->isTextFontColorImmutable(); break;
        case 60: *reinterpret_cast<QColor*>(_v) = _t->defaultTextFontColorValue(); break;
        case 61: *reinterpret_cast<QColor*>(_v) = _t->numberFontColor(); break;
        case 62: *reinterpret_cast<bool*>(_v) = _t->isNumberFontColorImmutable(); break;
        case 63: *reinterpret_cast<QColor*>(_v) = _t->defaultNumberFontColorValue(); break;
        case 64: *reinterpret_cast<bool*>(_v) = _t->freehandShadow(); break;
        case 65: *reinterpret_cast<bool*>(_v) = _t->isFreehandShadowImmutable(); break;
        case 66: *reinterpret_cast<bool*>(_v) = _t->defaultFreehandShadowValue(); break;
        case 67: *reinterpret_cast<bool*>(_v) = _t->lineShadow(); break;
        case 68: *reinterpret_cast<bool*>(_v) = _t->isLineShadowImmutable(); break;
        case 69: *reinterpret_cast<bool*>(_v) = _t->defaultLineShadowValue(); break;
        case 70: *reinterpret_cast<bool*>(_v) = _t->arrowShadow(); break;
        case 71: *reinterpret_cast<bool*>(_v) = _t->isArrowShadowImmutable(); break;
        case 72: *reinterpret_cast<bool*>(_v) = _t->defaultArrowShadowValue(); break;
        case 73: *reinterpret_cast<bool*>(_v) = _t->rectangleShadow(); break;
        case 74: *reinterpret_cast<bool*>(_v) = _t->isRectangleShadowImmutable(); break;
        case 75: *reinterpret_cast<bool*>(_v) = _t->defaultRectangleShadowValue(); break;
        case 76: *reinterpret_cast<bool*>(_v) = _t->ellipseShadow(); break;
        case 77: *reinterpret_cast<bool*>(_v) = _t->isEllipseShadowImmutable(); break;
        case 78: *reinterpret_cast<bool*>(_v) = _t->defaultEllipseShadowValue(); break;
        case 79: *reinterpret_cast<bool*>(_v) = _t->textShadow(); break;
        case 80: *reinterpret_cast<bool*>(_v) = _t->isTextShadowImmutable(); break;
        case 81: *reinterpret_cast<bool*>(_v) = _t->defaultTextShadowValue(); break;
        case 82: *reinterpret_cast<bool*>(_v) = _t->numberShadow(); break;
        case 83: *reinterpret_cast<bool*>(_v) = _t->isNumberShadowImmutable(); break;
        case 84: *reinterpret_cast<bool*>(_v) = _t->defaultNumberShadowValue(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setAnnotationToolType(*reinterpret_cast<int*>(_v)); break;
        case 3: _t->setFreehandStrokeWidth(*reinterpret_cast<uint*>(_v)); break;
        case 6: _t->setHighlighterStrokeWidth(*reinterpret_cast<uint*>(_v)); break;
        case 9: _t->setLineStrokeWidth(*reinterpret_cast<uint*>(_v)); break;
        case 12: _t->setArrowStrokeWidth(*reinterpret_cast<uint*>(_v)); break;
        case 15: _t->setRectangleStrokeWidth(*reinterpret_cast<uint*>(_v)); break;
        case 18: _t->setEllipseStrokeWidth(*reinterpret_cast<uint*>(_v)); break;
        case 21: _t->setFreehandStrokeColor(*reinterpret_cast<QColor*>(_v)); break;
        case 24: _t->setHighlighterStrokeColor(*reinterpret_cast<QColor*>(_v)); break;
        case 27: _t->setLineStrokeColor(*reinterpret_cast<QColor*>(_v)); break;
        case 30: _t->setArrowStrokeColor(*reinterpret_cast<QColor*>(_v)); break;
        case 33: _t->setRectangleStrokeColor(*reinterpret_cast<QColor*>(_v)); break;
        case 36: _t->setEllipseStrokeColor(*reinterpret_cast<QColor*>(_v)); break;
        case 39: _t->setRectangleFillColor(*reinterpret_cast<QColor*>(_v)); break;
        case 42: _t->setEllipseFillColor(*reinterpret_cast<QColor*>(_v)); break;
        case 45: _t->setNumberFillColor(*reinterpret_cast<QColor*>(_v)); break;
        case 48: _t->setBlurStrength(*reinterpret_cast<double*>(_v)); break;
        case 51: _t->setPixelateStrength(*reinterpret_cast<double*>(_v)); break;
        case 54: _t->setTextFont(*reinterpret_cast<QFont*>(_v)); break;
        case 56: _t->setNumberFont(*reinterpret_cast<QFont*>(_v)); break;
        case 58: _t->setTextFontColor(*reinterpret_cast<QColor*>(_v)); break;
        case 61: _t->setNumberFontColor(*reinterpret_cast<QColor*>(_v)); break;
        case 64: _t->setFreehandShadow(*reinterpret_cast<bool*>(_v)); break;
        case 67: _t->setLineShadow(*reinterpret_cast<bool*>(_v)); break;
        case 70: _t->setArrowShadow(*reinterpret_cast<bool*>(_v)); break;
        case 73: _t->setRectangleShadow(*reinterpret_cast<bool*>(_v)); break;
        case 76: _t->setEllipseShadow(*reinterpret_cast<bool*>(_v)); break;
        case 79: _t->setTextShadow(*reinterpret_cast<bool*>(_v)); break;
        case 82: _t->setNumberShadow(*reinterpret_cast<bool*>(_v)); break;
        default: break;
        }
    }
}

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

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

int AnnotationConfig::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KConfigSkeleton::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 29)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 29;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 29)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 29;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 85;
    }
    return _id;
}

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

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

// SIGNAL 2
void AnnotationConfig::highlighterStrokeWidthChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SIGNAL 19
void AnnotationConfig::numberFontChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 19, nullptr);
}

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

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

// SIGNAL 22
void AnnotationConfig::freehandShadowChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 22, nullptr);
}

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

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

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

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

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

// SIGNAL 28
void AnnotationConfig::numberShadowChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 28, nullptr);
}
QT_WARNING_POP
