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

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

class Config : public KConfigSkeleton
{
  Q_OBJECT
  public:

    static Config *self();
    ~Config() override;

    /**
      Set Save the compressed image in a new file
    */
    static
    void setSafeMode( bool v )
    {
      if (v != self()->mSafeMode && !self()->isSafeModeImmutable()) {
        self()->mSafeMode = v;
        Q_EMIT self()->SafeModeChanged();
      }
    }

    Q_PROPERTY(bool safeMode READ safeMode WRITE setSafeMode NOTIFY SafeModeChanged)
    Q_PROPERTY(bool isSafeModeImmutable READ isSafeModeImmutable CONSTANT)
    Q_PROPERTY(bool defaultSafeModeValue READ defaultSafeModeValue CONSTANT)
    /**
      Get Save the compressed image in a new file
    */
    static
    bool safeMode()
    {
      return self()->mSafeMode;
    }

    /**
      Is Save the compressed image in a new file Immutable
    */
    static
    bool isSafeModeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SafeMode" ) );
    }

    /**
      Get Save the compressed image in a new file default value
    */
    static
    bool defaultSafeModeValue()
    {
        return defaultSafeModeValue_helper();
    }

    /**
      Set Suffix to append at the end of new file
    */
    static
    void setSuffix( const QString & v )
    {
      if (v != self()->mSuffix && !self()->isSuffixImmutable()) {
        self()->mSuffix = v;
        Q_EMIT self()->SuffixChanged();
      }
    }

    Q_PROPERTY(QString suffix READ suffix WRITE setSuffix NOTIFY SuffixChanged)
    Q_PROPERTY(bool isSuffixImmutable READ isSuffixImmutable CONSTANT)
    Q_PROPERTY(QString defaultSuffixValue READ defaultSuffixValue CONSTANT)
    /**
      Get Suffix to append at the end of new file
    */
    static
    QString suffix()
    {
      return self()->mSuffix;
    }

    /**
      Is Suffix to append at the end of new file Immutable
    */
    static
    bool isSuffixImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Suffix" ) );
    }

    /**
      Get Suffix to append at the end of new file default value
    */
    static
    QString defaultSuffixValue()
    {
        return defaultSuffixValue_helper();
    }

    /**
      Set Keep metadata
    */
    static
    void setKeepMetadata( bool v )
    {
      if (v != self()->mKeepMetadata && !self()->isKeepMetadataImmutable()) {
        self()->mKeepMetadata = v;
        Q_EMIT self()->keepMetadataChanged();
      }
    }

    Q_PROPERTY(bool keepMetadata READ keepMetadata WRITE setKeepMetadata NOTIFY keepMetadataChanged)
    Q_PROPERTY(bool isKeepMetadataImmutable READ isKeepMetadataImmutable CONSTANT)
    Q_PROPERTY(bool defaultKeepMetadataValue READ defaultKeepMetadataValue CONSTANT)
    /**
      Get Keep metadata
    */
    static
    bool keepMetadata()
    {
      return self()->mKeepMetadata;
    }

    /**
      Is Keep metadata Immutable
    */
    static
    bool isKeepMetadataImmutable()
    {
      return self()->isImmutable( QStringLiteral( "keepMetadata" ) );
    }

    /**
      Get Keep metadata default value
    */
    static
    bool defaultKeepMetadataValue()
    {
        return defaultKeepMetadataValue_helper();
    }

    /**
      Set Whether jpg compression is lossless
    */
    static
    void setJpgLossless( bool v )
    {
      if (v != self()->mJpgLossless && !self()->isJpgLosslessImmutable()) {
        self()->mJpgLossless = v;
        Q_EMIT self()->jpgLosslessChanged();
      }
    }

    Q_PROPERTY(bool jpgLossless READ jpgLossless WRITE setJpgLossless NOTIFY jpgLosslessChanged)
    Q_PROPERTY(bool isJpgLosslessImmutable READ isJpgLosslessImmutable CONSTANT)
    Q_PROPERTY(bool defaultJpgLosslessValue READ defaultJpgLosslessValue CONSTANT)
    /**
      Get Whether jpg compression is lossless
    */
    static
    bool jpgLossless()
    {
      return self()->mJpgLossless;
    }

    /**
      Is Whether jpg compression is lossless Immutable
    */
    static
    bool isJpgLosslessImmutable()
    {
      return self()->isImmutable( QStringLiteral( "jpgLossless" ) );
    }

    /**
      Get Whether jpg compression is lossless default value
    */
    static
    bool defaultJpgLosslessValue()
    {
        return defaultJpgLosslessValue_helper();
    }

    /**
      Set Default optimization level of lossy optimization
    */
    static
    void setJpgLossyLevel( int v )
    {
      if (v != self()->mJpgLossyLevel && !self()->isJpgLossyLevelImmutable()) {
        self()->mJpgLossyLevel = v;
        Q_EMIT self()->jpgLossyLevelChanged();
      }
    }

    Q_PROPERTY(int jpgLossyLevel READ jpgLossyLevel WRITE setJpgLossyLevel NOTIFY jpgLossyLevelChanged)
    Q_PROPERTY(bool isJpgLossyLevelImmutable READ isJpgLossyLevelImmutable CONSTANT)
    Q_PROPERTY(int defaultJpgLossyLevelValue READ defaultJpgLossyLevelValue CONSTANT)
    /**
      Get Default optimization level of lossy optimization
    */
    static
    int jpgLossyLevel()
    {
      return self()->mJpgLossyLevel;
    }

    /**
      Is Default optimization level of lossy optimization Immutable
    */
    static
    bool isJpgLossyLevelImmutable()
    {
      return self()->isImmutable( QStringLiteral( "jpgLossyLevel" ) );
    }

    /**
      Get Default optimization level of lossy optimization default value
    */
    static
    int defaultJpgLossyLevelValue()
    {
        return defaultJpgLossyLevelValue_helper();
    }

    /**
      Set Progressive encode jpg image
    */
    static
    void setJpgProgressive( bool v )
    {
      if (v != self()->mJpgProgressive && !self()->isJpgProgressiveImmutable()) {
        self()->mJpgProgressive = v;
        Q_EMIT self()->jpgProgressiveChanged();
      }
    }

    Q_PROPERTY(bool jpgProgressive READ jpgProgressive WRITE setJpgProgressive NOTIFY jpgProgressiveChanged)
    Q_PROPERTY(bool isJpgProgressiveImmutable READ isJpgProgressiveImmutable CONSTANT)
    Q_PROPERTY(bool defaultJpgProgressiveValue READ defaultJpgProgressiveValue CONSTANT)
    /**
      Get Progressive encode jpg image
    */
    static
    bool jpgProgressive()
    {
      return self()->mJpgProgressive;
    }

    /**
      Is Progressive encode jpg image Immutable
    */
    static
    bool isJpgProgressiveImmutable()
    {
      return self()->isImmutable( QStringLiteral( "jpgProgressive" ) );
    }

    /**
      Get Progressive encode jpg image default value
    */
    static
    bool defaultJpgProgressiveValue()
    {
        return defaultJpgProgressiveValue_helper();
    }

    /**
      Set Default optimization level of lossless optimization
    */
    static
    void setPngLosslessLevel( int v )
    {
      if (v != self()->mPngLosslessLevel && !self()->isPngLosslessLevelImmutable()) {
        self()->mPngLosslessLevel = v;
        Q_EMIT self()->pngLosslessLevelChanged();
      }
    }

    Q_PROPERTY(int pngLosslessLevel READ pngLosslessLevel WRITE setPngLosslessLevel NOTIFY pngLosslessLevelChanged)
    Q_PROPERTY(bool isPngLosslessLevelImmutable READ isPngLosslessLevelImmutable CONSTANT)
    Q_PROPERTY(int defaultPngLosslessLevelValue READ defaultPngLosslessLevelValue CONSTANT)
    /**
      Get Default optimization level of lossless optimization
    */
    static
    int pngLosslessLevel()
    {
      return self()->mPngLosslessLevel;
    }

    /**
      Is Default optimization level of lossless optimization Immutable
    */
    static
    bool isPngLosslessLevelImmutable()
    {
      return self()->isImmutable( QStringLiteral( "pngLosslessLevel" ) );
    }

    /**
      Get Default optimization level of lossless optimization default value
    */
    static
    int defaultPngLosslessLevelValue()
    {
        return defaultPngLosslessLevelValue_helper();
    }

    /**
      Set Default optimization level of lossy optimization
    */
    static
    void setPngLossyLevel( int v )
    {
      if (v != self()->mPngLossyLevel && !self()->isPngLossyLevelImmutable()) {
        self()->mPngLossyLevel = v;
        Q_EMIT self()->pngLossyLevelChanged();
      }
    }

    Q_PROPERTY(int pngLossyLevel READ pngLossyLevel WRITE setPngLossyLevel NOTIFY pngLossyLevelChanged)
    Q_PROPERTY(bool isPngLossyLevelImmutable READ isPngLossyLevelImmutable CONSTANT)
    Q_PROPERTY(int defaultPngLossyLevelValue READ defaultPngLossyLevelValue CONSTANT)
    /**
      Get Default optimization level of lossy optimization
    */
    static
    int pngLossyLevel()
    {
      return self()->mPngLossyLevel;
    }

    /**
      Is Default optimization level of lossy optimization Immutable
    */
    static
    bool isPngLossyLevelImmutable()
    {
      return self()->isImmutable( QStringLiteral( "pngLossyLevel" ) );
    }

    /**
      Get Default optimization level of lossy optimization default value
    */
    static
    int defaultPngLossyLevelValue()
    {
        return defaultPngLossyLevelValue_helper();
    }

    /**
      Set Enable full minification
    */
    static
    void setSvgMaximumLevel( bool v )
    {
      if (v != self()->mSvgMaximumLevel && !self()->isSvgMaximumLevelImmutable()) {
        self()->mSvgMaximumLevel = v;
        Q_EMIT self()->svgMaximumLevelChanged();
      }
    }

    Q_PROPERTY(bool svgMaximumLevel READ svgMaximumLevel WRITE setSvgMaximumLevel NOTIFY svgMaximumLevelChanged)
    Q_PROPERTY(bool isSvgMaximumLevelImmutable READ isSvgMaximumLevelImmutable CONSTANT)
    Q_PROPERTY(bool defaultSvgMaximumLevelValue READ defaultSvgMaximumLevelValue CONSTANT)
    /**
      Get Enable full minification
    */
    static
    bool svgMaximumLevel()
    {
      return self()->mSvgMaximumLevel;
    }

    /**
      Is Enable full minification Immutable
    */
    static
    bool isSvgMaximumLevelImmutable()
    {
      return self()->isImmutable( QStringLiteral( "svgMaximumLevel" ) );
    }

    /**
      Get Enable full minification default value
    */
    static
    bool defaultSvgMaximumLevelValue()
    {
        return defaultSvgMaximumLevelValue_helper();
    }

    /**
      Set Whether webP compression is lossless
    */
    static
    void setWebpLossless( bool v )
    {
      if (v != self()->mWebpLossless && !self()->isWebpLosslessImmutable()) {
        self()->mWebpLossless = v;
        Q_EMIT self()->webpLosslessChanged();
      }
    }

    Q_PROPERTY(bool webpLossless READ webpLossless WRITE setWebpLossless NOTIFY webpLosslessChanged)
    Q_PROPERTY(bool isWebpLosslessImmutable READ isWebpLosslessImmutable CONSTANT)
    Q_PROPERTY(bool defaultWebpLosslessValue READ defaultWebpLosslessValue CONSTANT)
    /**
      Get Whether webP compression is lossless
    */
    static
    bool webpLossless()
    {
      return self()->mWebpLossless;
    }

    /**
      Is Whether webP compression is lossless Immutable
    */
    static
    bool isWebpLosslessImmutable()
    {
      return self()->isImmutable( QStringLiteral( "webpLossless" ) );
    }

    /**
      Get Whether webP compression is lossless default value
    */
    static
    bool defaultWebpLosslessValue()
    {
        return defaultWebpLosslessValue_helper();
    }

    /**
      Set Default optimization level of lossy optimization
    */
    static
    void setWebpLossyLevel( int v )
    {
      if (v != self()->mWebpLossyLevel && !self()->isWebpLossyLevelImmutable()) {
        self()->mWebpLossyLevel = v;
        Q_EMIT self()->webpLossyLevelChanged();
      }
    }

    Q_PROPERTY(int webpLossyLevel READ webpLossyLevel WRITE setWebpLossyLevel NOTIFY webpLossyLevelChanged)
    Q_PROPERTY(bool isWebpLossyLevelImmutable READ isWebpLossyLevelImmutable CONSTANT)
    Q_PROPERTY(int defaultWebpLossyLevelValue READ defaultWebpLossyLevelValue CONSTANT)
    /**
      Get Default optimization level of lossy optimization
    */
    static
    int webpLossyLevel()
    {
      return self()->mWebpLossyLevel;
    }

    /**
      Is Default optimization level of lossy optimization Immutable
    */
    static
    bool isWebpLossyLevelImmutable()
    {
      return self()->isImmutable( QStringLiteral( "webpLossyLevel" ) );
    }

    /**
      Get Default optimization level of lossy optimization default value
    */
    static
    int defaultWebpLossyLevelValue()
    {
        return defaultWebpLossyLevelValue_helper();
    }

    /**
      Set Default optimization level of lossless optimization
    */
    static
    void setWebpLosslessLevel( int v )
    {
      if (v != self()->mWebpLosslessLevel && !self()->isWebpLosslessLevelImmutable()) {
        self()->mWebpLosslessLevel = v;
        Q_EMIT self()->webpLosslessLevelChanged();
      }
    }

    Q_PROPERTY(int webpLosslessLevel READ webpLosslessLevel WRITE setWebpLosslessLevel NOTIFY webpLosslessLevelChanged)
    Q_PROPERTY(bool isWebpLosslessLevelImmutable READ isWebpLosslessLevelImmutable CONSTANT)
    Q_PROPERTY(int defaultWebpLosslessLevelValue READ defaultWebpLosslessLevelValue CONSTANT)
    /**
      Get Default optimization level of lossless optimization
    */
    static
    int webpLosslessLevel()
    {
      return self()->mWebpLosslessLevel;
    }

    /**
      Is Default optimization level of lossless optimization Immutable
    */
    static
    bool isWebpLosslessLevelImmutable()
    {
      return self()->isImmutable( QStringLiteral( "webpLosslessLevel" ) );
    }

    /**
      Get Default optimization level of lossless optimization default value
    */
    static
    int defaultWebpLosslessLevelValue()
    {
        return defaultWebpLosslessLevelValue_helper();
    }


    enum {
      signalSafeModeChanged = 1,
      signalSuffixChanged = 2,
      signalKeepMetadataChanged = 3,
      signalJpgLosslessChanged = 4,
      signalJpgLossyLevelChanged = 5,
      signalJpgProgressiveChanged = 6,
      signalPngLosslessLevelChanged = 7,
      signalPngLossyLevelChanged = 8,
      signalSvgMaximumLevelChanged = 9,
      signalWebpLosslessChanged = 10,
      signalWebpLossyLevelChanged = 11,
      signalWebpLosslessLevelChanged = 12
    };

  Q_SIGNALS:
    void SafeModeChanged();

    void SuffixChanged();

    void keepMetadataChanged();

    void jpgLosslessChanged();

    void jpgLossyLevelChanged();

    void jpgProgressiveChanged();

    void pngLosslessLevelChanged();

    void pngLossyLevelChanged();

    void svgMaximumLevelChanged();

    void webpLosslessChanged();

    void webpLossyLevelChanged();

    void webpLosslessLevelChanged();

  private:
    void itemChanged(quint64 signalFlag);

  protected:
    Config(QObject *parent = nullptr);
    friend class ConfigHelper;


    // General
    bool mSafeMode;
    static bool defaultSafeModeValue_helper();
    QString mSuffix;
    static QString defaultSuffixValue_helper();
    bool mKeepMetadata;
    static bool defaultKeepMetadataValue_helper();

    // jpg
    bool mJpgLossless;
    static bool defaultJpgLosslessValue_helper();
    int mJpgLossyLevel;
    static int defaultJpgLossyLevelValue_helper();
    bool mJpgProgressive;
    static bool defaultJpgProgressiveValue_helper();

    // png
    int mPngLosslessLevel;
    static int defaultPngLosslessLevelValue_helper();
    int mPngLossyLevel;
    static int defaultPngLossyLevelValue_helper();

    // svg
    bool mSvgMaximumLevel;
    static bool defaultSvgMaximumLevelValue_helper();

    // webp
    bool mWebpLossless;
    static bool defaultWebpLosslessValue_helper();
    int mWebpLossyLevel;
    static int defaultWebpLossyLevelValue_helper();
    int mWebpLosslessLevel;
    static int defaultWebpLosslessLevelValue_helper();
};

#endif

