// This file is generated by kconfig_compiler_kf6 from annotationconfig.kcfg.
// All changes you do to this file will be lost.
#ifndef ANNOTATIONCONFIG_H
#define ANNOTATIONCONFIG_H

#include <kconfigskeleton.h>
#include <QCoreApplication>
#include <QDebug>
#include <qqmlintegration.h>

#include <annotationtool.h>

class QQmlEngine;
class QJSEngine;

class AnnotationConfig : public KConfigSkeleton
{
  Q_OBJECT
  QML_ELEMENT
  QML_SINGLETON
  public:

    static AnnotationConfig *self();
    static AnnotationConfig *create(QQmlEngine *, QJSEngine *);
    ~AnnotationConfig() override;

    /**
      Set The last used annotation tool type
    */
    static
    void setAnnotationToolType( int v )
    {
      if (v != self()->mAnnotationToolType && !self()->isAnnotationToolTypeImmutable()) {
        self()->mAnnotationToolType = v;
        Q_EMIT self()->annotationToolTypeChanged();
      }
    }

    Q_PROPERTY(int annotationToolType READ annotationToolType WRITE setAnnotationToolType NOTIFY annotationToolTypeChanged)
    Q_PROPERTY(bool isAnnotationToolTypeImmutable READ isAnnotationToolTypeImmutable CONSTANT)
    Q_PROPERTY(int defaultAnnotationToolTypeValue READ defaultAnnotationToolTypeValue CONSTANT)
    /**
      Get The last used annotation tool type
    */
    static
    int annotationToolType()
    {
      return self()->mAnnotationToolType;
    }

    /**
      Is The last used annotation tool type Immutable
    */
    static
    bool isAnnotationToolTypeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "annotationToolType" ) );
    }

    /**
      Get The last used annotation tool type default value
    */
    static
    int defaultAnnotationToolTypeValue()
    {
        return defaultAnnotationToolTypeValue_helper();
    }

    /**
      Set Stroke width for freehand annotation tool
    */
    static
    void setFreehandStrokeWidth( uint v )
    {
      if (v < 1)
      {
        qDebug() << "setFreehandStrokeWidth: value " << v << " is less than the minimum value of 1";
        v = 1;
      }
      if (v != self()->mFreehandStrokeWidth && !self()->isFreehandStrokeWidthImmutable()) {
        self()->mFreehandStrokeWidth = v;
        Q_EMIT self()->freehandStrokeWidthChanged();
      }
    }

    Q_PROPERTY(uint freehandStrokeWidth READ freehandStrokeWidth WRITE setFreehandStrokeWidth NOTIFY freehandStrokeWidthChanged)
    Q_PROPERTY(bool isFreehandStrokeWidthImmutable READ isFreehandStrokeWidthImmutable CONSTANT)
    Q_PROPERTY(uint defaultFreehandStrokeWidthValue READ defaultFreehandStrokeWidthValue CONSTANT)
    /**
      Get Stroke width for freehand annotation tool
    */
    static
    uint freehandStrokeWidth()
    {
      return self()->mFreehandStrokeWidth;
    }

    /**
      Is Stroke width for freehand annotation tool Immutable
    */
    static
    bool isFreehandStrokeWidthImmutable()
    {
      return self()->isImmutable( QStringLiteral( "freehandStrokeWidth" ) );
    }

    /**
      Get Stroke width for freehand annotation tool default value
    */
    static
    uint defaultFreehandStrokeWidthValue()
    {
        return defaultFreehandStrokeWidthValue_helper();
    }

    /**
      Set Stroke width for highlighter annotation tool
    */
    static
    void setHighlighterStrokeWidth( uint v )
    {
      if (v < 1)
      {
        qDebug() << "setHighlighterStrokeWidth: value " << v << " is less than the minimum value of 1";
        v = 1;
      }
      if (v != self()->mHighlighterStrokeWidth && !self()->isHighlighterStrokeWidthImmutable()) {
        self()->mHighlighterStrokeWidth = v;
        Q_EMIT self()->highlighterStrokeWidthChanged();
      }
    }

    Q_PROPERTY(uint highlighterStrokeWidth READ highlighterStrokeWidth WRITE setHighlighterStrokeWidth NOTIFY highlighterStrokeWidthChanged)
    Q_PROPERTY(bool isHighlighterStrokeWidthImmutable READ isHighlighterStrokeWidthImmutable CONSTANT)
    Q_PROPERTY(uint defaultHighlighterStrokeWidthValue READ defaultHighlighterStrokeWidthValue CONSTANT)
    /**
      Get Stroke width for highlighter annotation tool
    */
    static
    uint highlighterStrokeWidth()
    {
      return self()->mHighlighterStrokeWidth;
    }

    /**
      Is Stroke width for highlighter annotation tool Immutable
    */
    static
    bool isHighlighterStrokeWidthImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlighterStrokeWidth" ) );
    }

    /**
      Get Stroke width for highlighter annotation tool default value
    */
    static
    uint defaultHighlighterStrokeWidthValue()
    {
        return defaultHighlighterStrokeWidthValue_helper();
    }

    /**
      Set Stroke width for line annotation tool
    */
    static
    void setLineStrokeWidth( uint v )
    {
      if (v < 1)
      {
        qDebug() << "setLineStrokeWidth: value " << v << " is less than the minimum value of 1";
        v = 1;
      }
      if (v != self()->mLineStrokeWidth && !self()->isLineStrokeWidthImmutable()) {
        self()->mLineStrokeWidth = v;
        Q_EMIT self()->lineStrokeWidthChanged();
      }
    }

    Q_PROPERTY(uint lineStrokeWidth READ lineStrokeWidth WRITE setLineStrokeWidth NOTIFY lineStrokeWidthChanged)
    Q_PROPERTY(bool isLineStrokeWidthImmutable READ isLineStrokeWidthImmutable CONSTANT)
    Q_PROPERTY(uint defaultLineStrokeWidthValue READ defaultLineStrokeWidthValue CONSTANT)
    /**
      Get Stroke width for line annotation tool
    */
    static
    uint lineStrokeWidth()
    {
      return self()->mLineStrokeWidth;
    }

    /**
      Is Stroke width for line annotation tool Immutable
    */
    static
    bool isLineStrokeWidthImmutable()
    {
      return self()->isImmutable( QStringLiteral( "lineStrokeWidth" ) );
    }

    /**
      Get Stroke width for line annotation tool default value
    */
    static
    uint defaultLineStrokeWidthValue()
    {
        return defaultLineStrokeWidthValue_helper();
    }

    /**
      Set Stroke width for arrow annotation tool
    */
    static
    void setArrowStrokeWidth( uint v )
    {
      if (v < 1)
      {
        qDebug() << "setArrowStrokeWidth: value " << v << " is less than the minimum value of 1";
        v = 1;
      }
      if (v != self()->mArrowStrokeWidth && !self()->isArrowStrokeWidthImmutable()) {
        self()->mArrowStrokeWidth = v;
        Q_EMIT self()->arrowStrokeWidthChanged();
      }
    }

    Q_PROPERTY(uint arrowStrokeWidth READ arrowStrokeWidth WRITE setArrowStrokeWidth NOTIFY arrowStrokeWidthChanged)
    Q_PROPERTY(bool isArrowStrokeWidthImmutable READ isArrowStrokeWidthImmutable CONSTANT)
    Q_PROPERTY(uint defaultArrowStrokeWidthValue READ defaultArrowStrokeWidthValue CONSTANT)
    /**
      Get Stroke width for arrow annotation tool
    */
    static
    uint arrowStrokeWidth()
    {
      return self()->mArrowStrokeWidth;
    }

    /**
      Is Stroke width for arrow annotation tool Immutable
    */
    static
    bool isArrowStrokeWidthImmutable()
    {
      return self()->isImmutable( QStringLiteral( "arrowStrokeWidth" ) );
    }

    /**
      Get Stroke width for arrow annotation tool default value
    */
    static
    uint defaultArrowStrokeWidthValue()
    {
        return defaultArrowStrokeWidthValue_helper();
    }

    /**
      Set Stroke width for rectangle annotation tool
    */
    static
    void setRectangleStrokeWidth( uint v )
    {
      if (v != self()->mRectangleStrokeWidth && !self()->isRectangleStrokeWidthImmutable()) {
        self()->mRectangleStrokeWidth = v;
        Q_EMIT self()->rectangleStrokeWidthChanged();
      }
    }

    Q_PROPERTY(uint rectangleStrokeWidth READ rectangleStrokeWidth WRITE setRectangleStrokeWidth NOTIFY rectangleStrokeWidthChanged)
    Q_PROPERTY(bool isRectangleStrokeWidthImmutable READ isRectangleStrokeWidthImmutable CONSTANT)
    Q_PROPERTY(uint defaultRectangleStrokeWidthValue READ defaultRectangleStrokeWidthValue CONSTANT)
    /**
      Get Stroke width for rectangle annotation tool
    */
    static
    uint rectangleStrokeWidth()
    {
      return self()->mRectangleStrokeWidth;
    }

    /**
      Is Stroke width for rectangle annotation tool Immutable
    */
    static
    bool isRectangleStrokeWidthImmutable()
    {
      return self()->isImmutable( QStringLiteral( "rectangleStrokeWidth" ) );
    }

    /**
      Get Stroke width for rectangle annotation tool default value
    */
    static
    uint defaultRectangleStrokeWidthValue()
    {
        return defaultRectangleStrokeWidthValue_helper();
    }

    /**
      Set Stroke width for ellipse annotation tool
    */
    static
    void setEllipseStrokeWidth( uint v )
    {
      if (v != self()->mEllipseStrokeWidth && !self()->isEllipseStrokeWidthImmutable()) {
        self()->mEllipseStrokeWidth = v;
        Q_EMIT self()->ellipseStrokeWidthChanged();
      }
    }

    Q_PROPERTY(uint ellipseStrokeWidth READ ellipseStrokeWidth WRITE setEllipseStrokeWidth NOTIFY ellipseStrokeWidthChanged)
    Q_PROPERTY(bool isEllipseStrokeWidthImmutable READ isEllipseStrokeWidthImmutable CONSTANT)
    Q_PROPERTY(uint defaultEllipseStrokeWidthValue READ defaultEllipseStrokeWidthValue CONSTANT)
    /**
      Get Stroke width for ellipse annotation tool
    */
    static
    uint ellipseStrokeWidth()
    {
      return self()->mEllipseStrokeWidth;
    }

    /**
      Is Stroke width for ellipse annotation tool Immutable
    */
    static
    bool isEllipseStrokeWidthImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ellipseStrokeWidth" ) );
    }

    /**
      Get Stroke width for ellipse annotation tool default value
    */
    static
    uint defaultEllipseStrokeWidthValue()
    {
        return defaultEllipseStrokeWidthValue_helper();
    }

    /**
      Set Stroke color for freehand annotation tool
    */
    static
    void setFreehandStrokeColor( const QColor & v )
    {
      if (v != self()->mFreehandStrokeColor && !self()->isFreehandStrokeColorImmutable()) {
        self()->mFreehandStrokeColor = v;
        Q_EMIT self()->freehandStrokeColorChanged();
      }
    }

    Q_PROPERTY(QColor freehandStrokeColor READ freehandStrokeColor WRITE setFreehandStrokeColor NOTIFY freehandStrokeColorChanged)
    Q_PROPERTY(bool isFreehandStrokeColorImmutable READ isFreehandStrokeColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultFreehandStrokeColorValue READ defaultFreehandStrokeColorValue CONSTANT)
    /**
      Get Stroke color for freehand annotation tool
    */
    static
    QColor freehandStrokeColor()
    {
      return self()->mFreehandStrokeColor;
    }

    /**
      Is Stroke color for freehand annotation tool Immutable
    */
    static
    bool isFreehandStrokeColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "freehandStrokeColor" ) );
    }

    /**
      Get Stroke color for freehand annotation tool default value
    */
    static
    QColor defaultFreehandStrokeColorValue()
    {
        return defaultFreehandStrokeColorValue_helper();
    }

    /**
      Set Stroke color for highlighter annotation tool
    */
    static
    void setHighlighterStrokeColor( const QColor & v )
    {
      if (v != self()->mHighlighterStrokeColor && !self()->isHighlighterStrokeColorImmutable()) {
        self()->mHighlighterStrokeColor = v;
        Q_EMIT self()->highlighterStrokeColorChanged();
      }
    }

    Q_PROPERTY(QColor highlighterStrokeColor READ highlighterStrokeColor WRITE setHighlighterStrokeColor NOTIFY highlighterStrokeColorChanged)
    Q_PROPERTY(bool isHighlighterStrokeColorImmutable READ isHighlighterStrokeColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultHighlighterStrokeColorValue READ defaultHighlighterStrokeColorValue CONSTANT)
    /**
      Get Stroke color for highlighter annotation tool
    */
    static
    QColor highlighterStrokeColor()
    {
      return self()->mHighlighterStrokeColor;
    }

    /**
      Is Stroke color for highlighter annotation tool Immutable
    */
    static
    bool isHighlighterStrokeColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlighterStrokeColor" ) );
    }

    /**
      Get Stroke color for highlighter annotation tool default value
    */
    static
    QColor defaultHighlighterStrokeColorValue()
    {
        return defaultHighlighterStrokeColorValue_helper();
    }

    /**
      Set Stroke color for line annotation tool
    */
    static
    void setLineStrokeColor( const QColor & v )
    {
      if (v != self()->mLineStrokeColor && !self()->isLineStrokeColorImmutable()) {
        self()->mLineStrokeColor = v;
        Q_EMIT self()->lineStrokeColorChanged();
      }
    }

    Q_PROPERTY(QColor lineStrokeColor READ lineStrokeColor WRITE setLineStrokeColor NOTIFY lineStrokeColorChanged)
    Q_PROPERTY(bool isLineStrokeColorImmutable READ isLineStrokeColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultLineStrokeColorValue READ defaultLineStrokeColorValue CONSTANT)
    /**
      Get Stroke color for line annotation tool
    */
    static
    QColor lineStrokeColor()
    {
      return self()->mLineStrokeColor;
    }

    /**
      Is Stroke color for line annotation tool Immutable
    */
    static
    bool isLineStrokeColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "lineStrokeColor" ) );
    }

    /**
      Get Stroke color for line annotation tool default value
    */
    static
    QColor defaultLineStrokeColorValue()
    {
        return defaultLineStrokeColorValue_helper();
    }

    /**
      Set Stroke color for arrow annotation tool
    */
    static
    void setArrowStrokeColor( const QColor & v )
    {
      if (v != self()->mArrowStrokeColor && !self()->isArrowStrokeColorImmutable()) {
        self()->mArrowStrokeColor = v;
        Q_EMIT self()->arrowStrokeColorChanged();
      }
    }

    Q_PROPERTY(QColor arrowStrokeColor READ arrowStrokeColor WRITE setArrowStrokeColor NOTIFY arrowStrokeColorChanged)
    Q_PROPERTY(bool isArrowStrokeColorImmutable READ isArrowStrokeColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultArrowStrokeColorValue READ defaultArrowStrokeColorValue CONSTANT)
    /**
      Get Stroke color for arrow annotation tool
    */
    static
    QColor arrowStrokeColor()
    {
      return self()->mArrowStrokeColor;
    }

    /**
      Is Stroke color for arrow annotation tool Immutable
    */
    static
    bool isArrowStrokeColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "arrowStrokeColor" ) );
    }

    /**
      Get Stroke color for arrow annotation tool default value
    */
    static
    QColor defaultArrowStrokeColorValue()
    {
        return defaultArrowStrokeColorValue_helper();
    }

    /**
      Set Stroke color for rectangle annotation tool
    */
    static
    void setRectangleStrokeColor( const QColor & v )
    {
      if (v != self()->mRectangleStrokeColor && !self()->isRectangleStrokeColorImmutable()) {
        self()->mRectangleStrokeColor = v;
        Q_EMIT self()->rectangleStrokeColorChanged();
      }
    }

    Q_PROPERTY(QColor rectangleStrokeColor READ rectangleStrokeColor WRITE setRectangleStrokeColor NOTIFY rectangleStrokeColorChanged)
    Q_PROPERTY(bool isRectangleStrokeColorImmutable READ isRectangleStrokeColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultRectangleStrokeColorValue READ defaultRectangleStrokeColorValue CONSTANT)
    /**
      Get Stroke color for rectangle annotation tool
    */
    static
    QColor rectangleStrokeColor()
    {
      return self()->mRectangleStrokeColor;
    }

    /**
      Is Stroke color for rectangle annotation tool Immutable
    */
    static
    bool isRectangleStrokeColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "rectangleStrokeColor" ) );
    }

    /**
      Get Stroke color for rectangle annotation tool default value
    */
    static
    QColor defaultRectangleStrokeColorValue()
    {
        return defaultRectangleStrokeColorValue_helper();
    }

    /**
      Set Stroke color for ellipse annotation tool
    */
    static
    void setEllipseStrokeColor( const QColor & v )
    {
      if (v != self()->mEllipseStrokeColor && !self()->isEllipseStrokeColorImmutable()) {
        self()->mEllipseStrokeColor = v;
        Q_EMIT self()->ellipseStrokeColorChanged();
      }
    }

    Q_PROPERTY(QColor ellipseStrokeColor READ ellipseStrokeColor WRITE setEllipseStrokeColor NOTIFY ellipseStrokeColorChanged)
    Q_PROPERTY(bool isEllipseStrokeColorImmutable READ isEllipseStrokeColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultEllipseStrokeColorValue READ defaultEllipseStrokeColorValue CONSTANT)
    /**
      Get Stroke color for ellipse annotation tool
    */
    static
    QColor ellipseStrokeColor()
    {
      return self()->mEllipseStrokeColor;
    }

    /**
      Is Stroke color for ellipse annotation tool Immutable
    */
    static
    bool isEllipseStrokeColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ellipseStrokeColor" ) );
    }

    /**
      Get Stroke color for ellipse annotation tool default value
    */
    static
    QColor defaultEllipseStrokeColorValue()
    {
        return defaultEllipseStrokeColorValue_helper();
    }

    /**
      Set Fill color for rectangle annotation tool
    */
    static
    void setRectangleFillColor( const QColor & v )
    {
      if (v != self()->mRectangleFillColor && !self()->isRectangleFillColorImmutable()) {
        self()->mRectangleFillColor = v;
        Q_EMIT self()->rectangleFillColorChanged();
      }
    }

    Q_PROPERTY(QColor rectangleFillColor READ rectangleFillColor WRITE setRectangleFillColor NOTIFY rectangleFillColorChanged)
    Q_PROPERTY(bool isRectangleFillColorImmutable READ isRectangleFillColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultRectangleFillColorValue READ defaultRectangleFillColorValue CONSTANT)
    /**
      Get Fill color for rectangle annotation tool
    */
    static
    QColor rectangleFillColor()
    {
      return self()->mRectangleFillColor;
    }

    /**
      Is Fill color for rectangle annotation tool Immutable
    */
    static
    bool isRectangleFillColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "rectangleFillColor" ) );
    }

    /**
      Get Fill color for rectangle annotation tool default value
    */
    static
    QColor defaultRectangleFillColorValue()
    {
        return defaultRectangleFillColorValue_helper();
    }

    /**
      Set Fill color for ellipse annotation tool
    */
    static
    void setEllipseFillColor( const QColor & v )
    {
      if (v != self()->mEllipseFillColor && !self()->isEllipseFillColorImmutable()) {
        self()->mEllipseFillColor = v;
        Q_EMIT self()->ellipseFillColorChanged();
      }
    }

    Q_PROPERTY(QColor ellipseFillColor READ ellipseFillColor WRITE setEllipseFillColor NOTIFY ellipseFillColorChanged)
    Q_PROPERTY(bool isEllipseFillColorImmutable READ isEllipseFillColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultEllipseFillColorValue READ defaultEllipseFillColorValue CONSTANT)
    /**
      Get Fill color for ellipse annotation tool
    */
    static
    QColor ellipseFillColor()
    {
      return self()->mEllipseFillColor;
    }

    /**
      Is Fill color for ellipse annotation tool Immutable
    */
    static
    bool isEllipseFillColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ellipseFillColor" ) );
    }

    /**
      Get Fill color for ellipse annotation tool default value
    */
    static
    QColor defaultEllipseFillColorValue()
    {
        return defaultEllipseFillColorValue_helper();
    }

    /**
      Set Fill color for number annotation tool
    */
    static
    void setNumberFillColor( const QColor & v )
    {
      if (v != self()->mNumberFillColor && !self()->isNumberFillColorImmutable()) {
        self()->mNumberFillColor = v;
        Q_EMIT self()->numberFillColorChanged();
      }
    }

    Q_PROPERTY(QColor numberFillColor READ numberFillColor WRITE setNumberFillColor NOTIFY numberFillColorChanged)
    Q_PROPERTY(bool isNumberFillColorImmutable READ isNumberFillColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultNumberFillColorValue READ defaultNumberFillColorValue CONSTANT)
    /**
      Get Fill color for number annotation tool
    */
    static
    QColor numberFillColor()
    {
      return self()->mNumberFillColor;
    }

    /**
      Is Fill color for number annotation tool Immutable
    */
    static
    bool isNumberFillColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "numberFillColor" ) );
    }

    /**
      Get Fill color for number annotation tool default value
    */
    static
    QColor defaultNumberFillColorValue()
    {
        return defaultNumberFillColorValue_helper();
    }

    /**
      Set The strength of the blur effect.
    */
    static
    void setBlurStrength( double v )
    {
      if (v < 0)
      {
        qDebug() << "setBlurStrength: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

      if (v > 1)
      {
        qDebug() << "setBlurStrength: value " << v << " is greater than the maximum value of 1";
        v = 1;
      }

      if (v != self()->mBlurStrength && !self()->isBlurStrengthImmutable()) {
        self()->mBlurStrength = v;
        Q_EMIT self()->blurStrengthChanged();
      }
    }

    Q_PROPERTY(double blurStrength READ blurStrength WRITE setBlurStrength NOTIFY blurStrengthChanged)
    Q_PROPERTY(bool isBlurStrengthImmutable READ isBlurStrengthImmutable CONSTANT)
    Q_PROPERTY(double defaultBlurStrengthValue READ defaultBlurStrengthValue CONSTANT)
    /**
      Get The strength of the blur effect.
    */
    static
    double blurStrength()
    {
      return self()->mBlurStrength;
    }

    /**
      Is The strength of the blur effect. Immutable
    */
    static
    bool isBlurStrengthImmutable()
    {
      return self()->isImmutable( QStringLiteral( "blurStrength" ) );
    }

    /**
      Get The strength of the blur effect. default value
    */
    static
    double defaultBlurStrengthValue()
    {
        return defaultBlurStrengthValue_helper();
    }

    /**
      Set The strength of the pixelate effect.
    */
    static
    void setPixelateStrength( double v )
    {
      if (v < 0)
      {
        qDebug() << "setPixelateStrength: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

      if (v > 1)
      {
        qDebug() << "setPixelateStrength: value " << v << " is greater than the maximum value of 1";
        v = 1;
      }

      if (v != self()->mPixelateStrength && !self()->isPixelateStrengthImmutable()) {
        self()->mPixelateStrength = v;
        Q_EMIT self()->pixelateStrengthChanged();
      }
    }

    Q_PROPERTY(double pixelateStrength READ pixelateStrength WRITE setPixelateStrength NOTIFY pixelateStrengthChanged)
    Q_PROPERTY(bool isPixelateStrengthImmutable READ isPixelateStrengthImmutable CONSTANT)
    Q_PROPERTY(double defaultPixelateStrengthValue READ defaultPixelateStrengthValue CONSTANT)
    /**
      Get The strength of the pixelate effect.
    */
    static
    double pixelateStrength()
    {
      return self()->mPixelateStrength;
    }

    /**
      Is The strength of the pixelate effect. Immutable
    */
    static
    bool isPixelateStrengthImmutable()
    {
      return self()->isImmutable( QStringLiteral( "pixelateStrength" ) );
    }

    /**
      Get The strength of the pixelate effect. default value
    */
    static
    double defaultPixelateStrengthValue()
    {
        return defaultPixelateStrengthValue_helper();
    }

    /**
      Set Font for text annotations
    */
    static
    void setTextFont( const QFont & v )
    {
      if (v != self()->mTextFont && !self()->isTextFontImmutable()) {
        self()->mTextFont = v;
        Q_EMIT self()->textFontChanged();
      }
    }

    Q_PROPERTY(QFont textFont READ textFont WRITE setTextFont NOTIFY textFontChanged)
    Q_PROPERTY(bool isTextFontImmutable READ isTextFontImmutable CONSTANT)
    /**
      Get Font for text annotations
    */
    static
    QFont textFont()
    {
      return self()->mTextFont;
    }

    /**
      Is Font for text annotations Immutable
    */
    static
    bool isTextFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textFont" ) );
    }

    /**
      Set Font for number annotations
    */
    static
    void setNumberFont( const QFont & v )
    {
      if (v != self()->mNumberFont && !self()->isNumberFontImmutable()) {
        self()->mNumberFont = v;
        Q_EMIT self()->numberFontChanged();
      }
    }

    Q_PROPERTY(QFont numberFont READ numberFont WRITE setNumberFont NOTIFY numberFontChanged)
    Q_PROPERTY(bool isNumberFontImmutable READ isNumberFontImmutable CONSTANT)
    /**
      Get Font for number annotations
    */
    static
    QFont numberFont()
    {
      return self()->mNumberFont;
    }

    /**
      Is Font for number annotations Immutable
    */
    static
    bool isNumberFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "numberFont" ) );
    }

    /**
      Set Font color for annotations
    */
    static
    void setTextFontColor( const QColor & v )
    {
      if (v != self()->mTextFontColor && !self()->isTextFontColorImmutable()) {
        self()->mTextFontColor = v;
        Q_EMIT self()->textFontColorChanged();
      }
    }

    Q_PROPERTY(QColor textFontColor READ textFontColor WRITE setTextFontColor NOTIFY textFontColorChanged)
    Q_PROPERTY(bool isTextFontColorImmutable READ isTextFontColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultTextFontColorValue READ defaultTextFontColorValue CONSTANT)
    /**
      Get Font color for annotations
    */
    static
    QColor textFontColor()
    {
      return self()->mTextFontColor;
    }

    /**
      Is Font color for annotations Immutable
    */
    static
    bool isTextFontColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textFontColor" ) );
    }

    /**
      Get Font color for annotations default value
    */
    static
    QColor defaultTextFontColorValue()
    {
        return defaultTextFontColorValue_helper();
    }

    /**
      Set Font color for annotations
    */
    static
    void setNumberFontColor( const QColor & v )
    {
      if (v != self()->mNumberFontColor && !self()->isNumberFontColorImmutable()) {
        self()->mNumberFontColor = v;
        Q_EMIT self()->numberFontColorChanged();
      }
    }

    Q_PROPERTY(QColor numberFontColor READ numberFontColor WRITE setNumberFontColor NOTIFY numberFontColorChanged)
    Q_PROPERTY(bool isNumberFontColorImmutable READ isNumberFontColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultNumberFontColorValue READ defaultNumberFontColorValue CONSTANT)
    /**
      Get Font color for annotations
    */
    static
    QColor numberFontColor()
    {
      return self()->mNumberFontColor;
    }

    /**
      Is Font color for annotations Immutable
    */
    static
    bool isNumberFontColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "numberFontColor" ) );
    }

    /**
      Get Font color for annotations default value
    */
    static
    QColor defaultNumberFontColorValue()
    {
        return defaultNumberFontColorValue_helper();
    }

    /**
      Set Whether freehand annotation tool has a drop shadow
    */
    static
    void setFreehandShadow( bool v )
    {
      if (v != self()->mFreehandShadow && !self()->isFreehandShadowImmutable()) {
        self()->mFreehandShadow = v;
        Q_EMIT self()->freehandShadowChanged();
      }
    }

    Q_PROPERTY(bool freehandShadow READ freehandShadow WRITE setFreehandShadow NOTIFY freehandShadowChanged)
    Q_PROPERTY(bool isFreehandShadowImmutable READ isFreehandShadowImmutable CONSTANT)
    Q_PROPERTY(bool defaultFreehandShadowValue READ defaultFreehandShadowValue CONSTANT)
    /**
      Get Whether freehand annotation tool has a drop shadow
    */
    static
    bool freehandShadow()
    {
      return self()->mFreehandShadow;
    }

    /**
      Is Whether freehand annotation tool has a drop shadow Immutable
    */
    static
    bool isFreehandShadowImmutable()
    {
      return self()->isImmutable( QStringLiteral( "freehandShadow" ) );
    }

    /**
      Get Whether freehand annotation tool has a drop shadow default value
    */
    static
    bool defaultFreehandShadowValue()
    {
        return defaultFreehandShadowValue_helper();
    }

    /**
      Set Whether line annotation tool has a drop shadow
    */
    static
    void setLineShadow( bool v )
    {
      if (v != self()->mLineShadow && !self()->isLineShadowImmutable()) {
        self()->mLineShadow = v;
        Q_EMIT self()->lineShadowChanged();
      }
    }

    Q_PROPERTY(bool lineShadow READ lineShadow WRITE setLineShadow NOTIFY lineShadowChanged)
    Q_PROPERTY(bool isLineShadowImmutable READ isLineShadowImmutable CONSTANT)
    Q_PROPERTY(bool defaultLineShadowValue READ defaultLineShadowValue CONSTANT)
    /**
      Get Whether line annotation tool has a drop shadow
    */
    static
    bool lineShadow()
    {
      return self()->mLineShadow;
    }

    /**
      Is Whether line annotation tool has a drop shadow Immutable
    */
    static
    bool isLineShadowImmutable()
    {
      return self()->isImmutable( QStringLiteral( "lineShadow" ) );
    }

    /**
      Get Whether line annotation tool has a drop shadow default value
    */
    static
    bool defaultLineShadowValue()
    {
        return defaultLineShadowValue_helper();
    }

    /**
      Set Whether arrow annotation tool has a drop shadow
    */
    static
    void setArrowShadow( bool v )
    {
      if (v != self()->mArrowShadow && !self()->isArrowShadowImmutable()) {
        self()->mArrowShadow = v;
        Q_EMIT self()->arrowShadowChanged();
      }
    }

    Q_PROPERTY(bool arrowShadow READ arrowShadow WRITE setArrowShadow NOTIFY arrowShadowChanged)
    Q_PROPERTY(bool isArrowShadowImmutable READ isArrowShadowImmutable CONSTANT)
    Q_PROPERTY(bool defaultArrowShadowValue READ defaultArrowShadowValue CONSTANT)
    /**
      Get Whether arrow annotation tool has a drop shadow
    */
    static
    bool arrowShadow()
    {
      return self()->mArrowShadow;
    }

    /**
      Is Whether arrow annotation tool has a drop shadow Immutable
    */
    static
    bool isArrowShadowImmutable()
    {
      return self()->isImmutable( QStringLiteral( "arrowShadow" ) );
    }

    /**
      Get Whether arrow annotation tool has a drop shadow default value
    */
    static
    bool defaultArrowShadowValue()
    {
        return defaultArrowShadowValue_helper();
    }

    /**
      Set Whether rectangle annotation tool has a drop shadow
    */
    static
    void setRectangleShadow( bool v )
    {
      if (v != self()->mRectangleShadow && !self()->isRectangleShadowImmutable()) {
        self()->mRectangleShadow = v;
        Q_EMIT self()->rectangleShadowChanged();
      }
    }

    Q_PROPERTY(bool rectangleShadow READ rectangleShadow WRITE setRectangleShadow NOTIFY rectangleShadowChanged)
    Q_PROPERTY(bool isRectangleShadowImmutable READ isRectangleShadowImmutable CONSTANT)
    Q_PROPERTY(bool defaultRectangleShadowValue READ defaultRectangleShadowValue CONSTANT)
    /**
      Get Whether rectangle annotation tool has a drop shadow
    */
    static
    bool rectangleShadow()
    {
      return self()->mRectangleShadow;
    }

    /**
      Is Whether rectangle annotation tool has a drop shadow Immutable
    */
    static
    bool isRectangleShadowImmutable()
    {
      return self()->isImmutable( QStringLiteral( "rectangleShadow" ) );
    }

    /**
      Get Whether rectangle annotation tool has a drop shadow default value
    */
    static
    bool defaultRectangleShadowValue()
    {
        return defaultRectangleShadowValue_helper();
    }

    /**
      Set Whether ellipse annotation tool has a drop shadow
    */
    static
    void setEllipseShadow( bool v )
    {
      if (v != self()->mEllipseShadow && !self()->isEllipseShadowImmutable()) {
        self()->mEllipseShadow = v;
        Q_EMIT self()->ellipseShadowChanged();
      }
    }

    Q_PROPERTY(bool ellipseShadow READ ellipseShadow WRITE setEllipseShadow NOTIFY ellipseShadowChanged)
    Q_PROPERTY(bool isEllipseShadowImmutable READ isEllipseShadowImmutable CONSTANT)
    Q_PROPERTY(bool defaultEllipseShadowValue READ defaultEllipseShadowValue CONSTANT)
    /**
      Get Whether ellipse annotation tool has a drop shadow
    */
    static
    bool ellipseShadow()
    {
      return self()->mEllipseShadow;
    }

    /**
      Is Whether ellipse annotation tool has a drop shadow Immutable
    */
    static
    bool isEllipseShadowImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ellipseShadow" ) );
    }

    /**
      Get Whether ellipse annotation tool has a drop shadow default value
    */
    static
    bool defaultEllipseShadowValue()
    {
        return defaultEllipseShadowValue_helper();
    }

    /**
      Set Whether text annotation tool has a drop shadow
    */
    static
    void setTextShadow( bool v )
    {
      if (v != self()->mTextShadow && !self()->isTextShadowImmutable()) {
        self()->mTextShadow = v;
        Q_EMIT self()->textShadowChanged();
      }
    }

    Q_PROPERTY(bool textShadow READ textShadow WRITE setTextShadow NOTIFY textShadowChanged)
    Q_PROPERTY(bool isTextShadowImmutable READ isTextShadowImmutable CONSTANT)
    Q_PROPERTY(bool defaultTextShadowValue READ defaultTextShadowValue CONSTANT)
    /**
      Get Whether text annotation tool has a drop shadow
    */
    static
    bool textShadow()
    {
      return self()->mTextShadow;
    }

    /**
      Is Whether text annotation tool has a drop shadow Immutable
    */
    static
    bool isTextShadowImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textShadow" ) );
    }

    /**
      Get Whether text annotation tool has a drop shadow default value
    */
    static
    bool defaultTextShadowValue()
    {
        return defaultTextShadowValue_helper();
    }

    /**
      Set Whether number annotation tool has a drop shadow
    */
    static
    void setNumberShadow( bool v )
    {
      if (v != self()->mNumberShadow && !self()->isNumberShadowImmutable()) {
        self()->mNumberShadow = v;
        Q_EMIT self()->numberShadowChanged();
      }
    }

    Q_PROPERTY(bool numberShadow READ numberShadow WRITE setNumberShadow NOTIFY numberShadowChanged)
    Q_PROPERTY(bool isNumberShadowImmutable READ isNumberShadowImmutable CONSTANT)
    Q_PROPERTY(bool defaultNumberShadowValue READ defaultNumberShadowValue CONSTANT)
    /**
      Get Whether number annotation tool has a drop shadow
    */
    static
    bool numberShadow()
    {
      return self()->mNumberShadow;
    }

    /**
      Is Whether number annotation tool has a drop shadow Immutable
    */
    static
    bool isNumberShadowImmutable()
    {
      return self()->isImmutable( QStringLiteral( "numberShadow" ) );
    }

    /**
      Get Whether number annotation tool has a drop shadow default value
    */
    static
    bool defaultNumberShadowValue()
    {
        return defaultNumberShadowValue_helper();
    }


    enum {
      signalAnnotationToolTypeChanged = 1,
      signalFreehandStrokeWidthChanged = 2,
      signalHighlighterStrokeWidthChanged = 3,
      signalLineStrokeWidthChanged = 4,
      signalArrowStrokeWidthChanged = 5,
      signalRectangleStrokeWidthChanged = 6,
      signalEllipseStrokeWidthChanged = 7,
      signalFreehandStrokeColorChanged = 8,
      signalHighlighterStrokeColorChanged = 9,
      signalLineStrokeColorChanged = 10,
      signalArrowStrokeColorChanged = 11,
      signalRectangleStrokeColorChanged = 12,
      signalEllipseStrokeColorChanged = 13,
      signalRectangleFillColorChanged = 14,
      signalEllipseFillColorChanged = 15,
      signalNumberFillColorChanged = 16,
      signalBlurStrengthChanged = 17,
      signalPixelateStrengthChanged = 18,
      signalTextFontChanged = 19,
      signalNumberFontChanged = 20,
      signalTextFontColorChanged = 21,
      signalNumberFontColorChanged = 22,
      signalFreehandShadowChanged = 23,
      signalLineShadowChanged = 24,
      signalArrowShadowChanged = 25,
      signalRectangleShadowChanged = 26,
      signalEllipseShadowChanged = 27,
      signalTextShadowChanged = 28,
      signalNumberShadowChanged = 29
    };

  Q_SIGNALS:
    void annotationToolTypeChanged();

    void freehandStrokeWidthChanged();

    void highlighterStrokeWidthChanged();

    void lineStrokeWidthChanged();

    void arrowStrokeWidthChanged();

    void rectangleStrokeWidthChanged();

    void ellipseStrokeWidthChanged();

    void freehandStrokeColorChanged();

    void highlighterStrokeColorChanged();

    void lineStrokeColorChanged();

    void arrowStrokeColorChanged();

    void rectangleStrokeColorChanged();

    void ellipseStrokeColorChanged();

    void rectangleFillColorChanged();

    void ellipseFillColorChanged();

    void numberFillColorChanged();

    void blurStrengthChanged();

    void pixelateStrengthChanged();

    void textFontChanged();

    void numberFontChanged();

    void textFontColorChanged();

    void numberFontColorChanged();

    void freehandShadowChanged();

    void lineShadowChanged();

    void arrowShadowChanged();

    void rectangleShadowChanged();

    void ellipseShadowChanged();

    void textShadowChanged();

    void numberShadowChanged();

  private:
    void itemChanged(quint64 signalFlag);

  protected:
    AnnotationConfig();
    friend class AnnotationConfigHelper;


    // Annotations
    int mAnnotationToolType;
    static int defaultAnnotationToolTypeValue_helper();
    uint mFreehandStrokeWidth;
    static uint defaultFreehandStrokeWidthValue_helper();
    uint mHighlighterStrokeWidth;
    static uint defaultHighlighterStrokeWidthValue_helper();
    uint mLineStrokeWidth;
    static uint defaultLineStrokeWidthValue_helper();
    uint mArrowStrokeWidth;
    static uint defaultArrowStrokeWidthValue_helper();
    uint mRectangleStrokeWidth;
    static uint defaultRectangleStrokeWidthValue_helper();
    uint mEllipseStrokeWidth;
    static uint defaultEllipseStrokeWidthValue_helper();
    QColor mFreehandStrokeColor;
    static QColor defaultFreehandStrokeColorValue_helper();
    QColor mHighlighterStrokeColor;
    static QColor defaultHighlighterStrokeColorValue_helper();
    QColor mLineStrokeColor;
    static QColor defaultLineStrokeColorValue_helper();
    QColor mArrowStrokeColor;
    static QColor defaultArrowStrokeColorValue_helper();
    QColor mRectangleStrokeColor;
    static QColor defaultRectangleStrokeColorValue_helper();
    QColor mEllipseStrokeColor;
    static QColor defaultEllipseStrokeColorValue_helper();
    QColor mRectangleFillColor;
    static QColor defaultRectangleFillColorValue_helper();
    QColor mEllipseFillColor;
    static QColor defaultEllipseFillColorValue_helper();
    QColor mNumberFillColor;
    static QColor defaultNumberFillColorValue_helper();
    double mBlurStrength;
    static double defaultBlurStrengthValue_helper();
    double mPixelateStrength;
    static double defaultPixelateStrengthValue_helper();
    QFont mTextFont;
    static QFont defaultTextFontValue_helper();
    QFont mNumberFont;
    static QFont defaultNumberFontValue_helper();
    QColor mTextFontColor;
    static QColor defaultTextFontColorValue_helper();
    QColor mNumberFontColor;
    static QColor defaultNumberFontColorValue_helper();
    bool mFreehandShadow;
    static bool defaultFreehandShadowValue_helper();
    bool mLineShadow;
    static bool defaultLineShadowValue_helper();
    bool mArrowShadow;
    static bool defaultArrowShadowValue_helper();
    bool mRectangleShadow;
    static bool defaultRectangleShadowValue_helper();
    bool mEllipseShadow;
    static bool defaultEllipseShadowValue_helper();
    bool mTextShadow;
    static bool defaultTextShadowValue_helper();
    bool mNumberShadow;
    static bool defaultNumberShadowValue_helper();
};

#endif

