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

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

class QQmlEngine;
class QJSEngine;

class KleverConfig : public KConfigSkeleton
{
  Q_OBJECT
  QML_ELEMENT
  QML_SINGLETON
  public:

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

    /**
      Set Path to the ./KleverNotes folder
    */
    static
    void setStoragePath( const QString & v )
    {
      if (v != self()->mStoragePath && !self()->isStoragePathImmutable()) {
        self()->mStoragePath = v;
        Q_EMIT self()->storagePathChanged();
      }
    }

    Q_PROPERTY(QString storagePath READ storagePath WRITE setStoragePath NOTIFY storagePathChanged)
    Q_PROPERTY(bool isStoragePathImmutable READ isStoragePathImmutable CONSTANT)
    Q_PROPERTY(QString defaultStoragePathValue READ defaultStoragePathValue CONSTANT)
    /**
      Get Path to the ./KleverNotes folder
    */
    static
    QString storagePath()
    {
      return self()->mStoragePath;
    }

    /**
      Is Path to the ./KleverNotes folder Immutable
    */
    static
    bool isStoragePathImmutable()
    {
      return self()->isImmutable( QStringLiteral( "storagePath" ) );
    }

    /**
      Get Path to the ./KleverNotes folder default value
    */
    static
    QString defaultStoragePathValue()
    {
        return defaultStoragePathValue_helper();
    }

    /**
      Set The default name for a new Category
    */
    static
    void setDefaultFolderName( const QString & v )
    {
      if (v != self()->mDefaultFolderName && !self()->isDefaultFolderNameImmutable()) {
        self()->mDefaultFolderName = v;
        Q_EMIT self()->defaultFolderNameChanged();
      }
    }

    Q_PROPERTY(QString defaultFolderName READ defaultFolderName WRITE setDefaultFolderName NOTIFY defaultFolderNameChanged)
    Q_PROPERTY(bool isDefaultFolderNameImmutable READ isDefaultFolderNameImmutable CONSTANT)
    /**
      Get The default name for a new Category
    */
    static
    QString defaultFolderName()
    {
      return self()->mDefaultFolderName;
    }

    /**
      Is The default name for a new Category Immutable
    */
    static
    bool isDefaultFolderNameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "defaultFolderName" ) );
    }

    /**
      Set The default name for a new Note
    */
    static
    void setDefaultNoteName( const QString & v )
    {
      if (v != self()->mDefaultNoteName && !self()->isDefaultNoteNameImmutable()) {
        self()->mDefaultNoteName = v;
        Q_EMIT self()->defaultNoteNameChanged();
      }
    }

    Q_PROPERTY(QString defaultNoteName READ defaultNoteName WRITE setDefaultNoteName NOTIFY defaultNoteNameChanged)
    Q_PROPERTY(bool isDefaultNoteNameImmutable READ isDefaultNoteNameImmutable CONSTANT)
    /**
      Get The default name for a new Note
    */
    static
    QString defaultNoteName()
    {
      return self()->mDefaultNoteName;
    }

    /**
      Is The default name for a new Note Immutable
    */
    static
    bool isDefaultNoteNameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "defaultNoteName" ) );
    }

    /**
      Set Whether or not the editor is visible
    */
    static
    void setEditorVisible( bool v )
    {
      if (v != self()->mEditorVisible && !self()->isEditorVisibleImmutable()) {
        self()->mEditorVisible = v;
        Q_EMIT self()->editorVisibleChanged();
      }
    }

    Q_PROPERTY(bool editorVisible READ editorVisible WRITE setEditorVisible NOTIFY editorVisibleChanged)
    Q_PROPERTY(bool isEditorVisibleImmutable READ isEditorVisibleImmutable CONSTANT)
    Q_PROPERTY(bool defaultEditorVisibleValue READ defaultEditorVisibleValue CONSTANT)
    /**
      Get Whether or not the editor is visible
    */
    static
    bool editorVisible()
    {
      return self()->mEditorVisible;
    }

    /**
      Is Whether or not the editor is visible Immutable
    */
    static
    bool isEditorVisibleImmutable()
    {
      return self()->isImmutable( QStringLiteral( "editorVisible" ) );
    }

    /**
      Get Whether or not the editor is visible default value
    */
    static
    bool defaultEditorVisibleValue()
    {
        return defaultEditorVisibleValue_helper();
    }

    /**
      Set Whether or not the preview is visible
    */
    static
    void setPreviewVisible( bool v )
    {
      if (v != self()->mPreviewVisible && !self()->isPreviewVisibleImmutable()) {
        self()->mPreviewVisible = v;
        Q_EMIT self()->previewVisibleChanged();
      }
    }

    Q_PROPERTY(bool previewVisible READ previewVisible WRITE setPreviewVisible NOTIFY previewVisibleChanged)
    Q_PROPERTY(bool isPreviewVisibleImmutable READ isPreviewVisibleImmutable CONSTANT)
    Q_PROPERTY(bool defaultPreviewVisibleValue READ defaultPreviewVisibleValue CONSTANT)
    /**
      Get Whether or not the preview is visible
    */
    static
    bool previewVisible()
    {
      return self()->mPreviewVisible;
    }

    /**
      Is Whether or not the preview is visible Immutable
    */
    static
    bool isPreviewVisibleImmutable()
    {
      return self()->isImmutable( QStringLiteral( "previewVisible" ) );
    }

    /**
      Get Whether or not the preview is visible default value
    */
    static
    bool defaultPreviewVisibleValue()
    {
        return defaultPreviewVisibleValue_helper();
    }

    /**
      Set Whether or not the editor replace tab with space
    */
    static
    void setUseSpaceForTab( bool v )
    {
      if (v != self()->mUseSpaceForTab && !self()->isUseSpaceForTabImmutable()) {
        self()->mUseSpaceForTab = v;
        Q_EMIT self()->useSpaceForTabChanged();
      }
    }

    Q_PROPERTY(bool useSpaceForTab READ useSpaceForTab WRITE setUseSpaceForTab NOTIFY useSpaceForTabChanged)
    Q_PROPERTY(bool isUseSpaceForTabImmutable READ isUseSpaceForTabImmutable CONSTANT)
    Q_PROPERTY(bool defaultUseSpaceForTabValue READ defaultUseSpaceForTabValue CONSTANT)
    /**
      Get Whether or not the editor replace tab with space
    */
    static
    bool useSpaceForTab()
    {
      return self()->mUseSpaceForTab;
    }

    /**
      Is Whether or not the editor replace tab with space Immutable
    */
    static
    bool isUseSpaceForTabImmutable()
    {
      return self()->isImmutable( QStringLiteral( "useSpaceForTab" ) );
    }

    /**
      Get Whether or not the editor replace tab with space default value
    */
    static
    bool defaultUseSpaceForTabValue()
    {
        return defaultUseSpaceForTabValue_helper();
    }

    /**
      Set The number of spaces with which the tab is replaced
    */
    static
    void setSpacesForTab( int v )
    {
      if (v != self()->mSpacesForTab && !self()->isSpacesForTabImmutable()) {
        self()->mSpacesForTab = v;
        Q_EMIT self()->spacesForTabChanged();
      }
    }

    Q_PROPERTY(int spacesForTab READ spacesForTab WRITE setSpacesForTab NOTIFY spacesForTabChanged)
    Q_PROPERTY(bool isSpacesForTabImmutable READ isSpacesForTabImmutable CONSTANT)
    Q_PROPERTY(int defaultSpacesForTabValue READ defaultSpacesForTabValue CONSTANT)
    /**
      Get The number of spaces with which the tab is replaced
    */
    static
    int spacesForTab()
    {
      return self()->mSpacesForTab;
    }

    /**
      Is The number of spaces with which the tab is replaced Immutable
    */
    static
    bool isSpacesForTabImmutable()
    {
      return self()->isImmutable( QStringLiteral( "spacesForTab" ) );
    }

    /**
      Get The number of spaces with which the tab is replaced default value
    */
    static
    int defaultSpacesForTabValue()
    {
        return defaultSpacesForTabValue_helper();
    }

    /**
      Set The list of index of visible text actions
    */
    static
    void setVisibleTools( const QList<int> & v )
    {
      if (v != self()->mVisibleTools && !self()->isVisibleToolsImmutable()) {
        self()->mVisibleTools = v;
        Q_EMIT self()->visibleToolsChanged();
      }
    }

    Q_PROPERTY(QList<int> visibleTools READ visibleTools WRITE setVisibleTools NOTIFY visibleToolsChanged)
    Q_PROPERTY(bool isVisibleToolsImmutable READ isVisibleToolsImmutable CONSTANT)
    Q_PROPERTY(QList<int> defaultVisibleToolsValue READ defaultVisibleToolsValue CONSTANT)
    /**
      Get The list of index of visible text actions
    */
    static
    QList<int> visibleTools()
    {
      return self()->mVisibleTools;
    }

    /**
      Is The list of index of visible text actions Immutable
    */
    static
    bool isVisibleToolsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "visibleTools" ) );
    }

    /**
      Get The list of index of visible text actions default value
    */
    static
    QList<int> defaultVisibleToolsValue()
    {
        return defaultVisibleToolsValue_helper();
    }

    /**
      Set The list of index of invisible text actions
    */
    static
    void setInvisibleTools( const QList<int> & v )
    {
      if (v != self()->mInvisibleTools && !self()->isInvisibleToolsImmutable()) {
        self()->mInvisibleTools = v;
        Q_EMIT self()->invisibleToolsChanged();
      }
    }

    Q_PROPERTY(QList<int> invisibleTools READ invisibleTools WRITE setInvisibleTools NOTIFY invisibleToolsChanged)
    Q_PROPERTY(bool isInvisibleToolsImmutable READ isInvisibleToolsImmutable CONSTANT)
    Q_PROPERTY(QList<int> defaultInvisibleToolsValue READ defaultInvisibleToolsValue CONSTANT)
    /**
      Get The list of index of invisible text actions
    */
    static
    QList<int> invisibleTools()
    {
      return self()->mInvisibleTools;
    }

    /**
      Is The list of index of invisible text actions Immutable
    */
    static
    bool isInvisibleToolsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "invisibleTools" ) );
    }

    /**
      Get The list of index of invisible text actions default value
    */
    static
    QList<int> defaultInvisibleToolsValue()
    {
        return defaultInvisibleToolsValue_helper();
    }

    /**
      Set Whether or not the notes in each folder in Sidebar should be sorted by last modified date
    */
    static
    void setSortByLastModified( bool v )
    {
      if (v != self()->mSortByLastModified && !self()->isSortByLastModifiedImmutable()) {
        self()->mSortByLastModified = v;
        Q_EMIT self()->sortByLastModifiedChanged();
      }
    }

    Q_PROPERTY(bool sortByLastModified READ sortByLastModified WRITE setSortByLastModified NOTIFY sortByLastModifiedChanged)
    Q_PROPERTY(bool isSortByLastModifiedImmutable READ isSortByLastModifiedImmutable CONSTANT)
    Q_PROPERTY(bool defaultSortByLastModifiedValue READ defaultSortByLastModifiedValue CONSTANT)
    /**
      Get Whether or not the notes in each folder in Sidebar should be sorted by last modified date
    */
    static
    bool sortByLastModified()
    {
      return self()->mSortByLastModified;
    }

    /**
      Is Whether or not the notes in each folder in Sidebar should be sorted by last modified date Immutable
    */
    static
    bool isSortByLastModifiedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "sortByLastModified" ) );
    }

    /**
      Get Whether or not the notes in each folder in Sidebar should be sorted by last modified date default value
    */
    static
    bool defaultSortByLastModifiedValue()
    {
        return defaultSortByLastModifiedValue_helper();
    }

    /**
      Set Path to the note display css style
    */
    static
    void setStylePath( const QString & v )
    {
      if (v != self()->mStylePath && !self()->isStylePathImmutable()) {
        self()->mStylePath = v;
        Q_EMIT self()->stylePathChanged();
      }
    }

    Q_PROPERTY(QString stylePath READ stylePath WRITE setStylePath NOTIFY stylePathChanged)
    Q_PROPERTY(bool isStylePathImmutable READ isStylePathImmutable CONSTANT)
    Q_PROPERTY(QString defaultStylePathValue READ defaultStylePathValue CONSTANT)
    /**
      Get Path to the note display css style
    */
    static
    QString stylePath()
    {
      return self()->mStylePath;
    }

    /**
      Is Path to the note display css style Immutable
    */
    static
    bool isStylePathImmutable()
    {
      return self()->isImmutable( QStringLiteral( "stylePath" ) );
    }

    /**
      Get Path to the note display css style default value
    */
    static
    QString defaultStylePathValue()
    {
        return defaultStylePathValue_helper();
    }

    /**
      Set The default code block font
    */
    static
    void setCodeFont( const QFont & v )
    {
      if (v != self()->mCodeFont && !self()->isCodeFontImmutable()) {
        self()->mCodeFont = v;
        Q_EMIT self()->codeFontChanged();
      }
    }

    Q_PROPERTY(QFont codeFont READ codeFont WRITE setCodeFont NOTIFY codeFontChanged)
    Q_PROPERTY(bool isCodeFontImmutable READ isCodeFontImmutable CONSTANT)
    /**
      Get The default code block font
    */
    static
    QFont codeFont()
    {
      return self()->mCodeFont;
    }

    /**
      Is The default code block font Immutable
    */
    static
    bool isCodeFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "codeFont" ) );
    }

    /**
      Set The default text view font (if not specified default to system theme)
    */
    static
    void setViewFont( const QFont & v )
    {
      if (v != self()->mViewFont && !self()->isViewFontImmutable()) {
        self()->mViewFont = v;
        Q_EMIT self()->viewFontChanged();
      }
    }

    Q_PROPERTY(QFont viewFont READ viewFont WRITE setViewFont NOTIFY viewFontChanged)
    Q_PROPERTY(bool isViewFontImmutable READ isViewFontImmutable CONSTANT)
    /**
      Get The default text view font (if not specified default to system theme)
    */
    static
    QFont viewFont()
    {
      return self()->mViewFont;
    }

    /**
      Is The default text view font (if not specified default to system theme) Immutable
    */
    static
    bool isViewFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "viewFont" ) );
    }

    /**
      Set The default text view body color (if not specified default to system theme)
    */
    static
    void setViewBodyColor( const QString & v )
    {
      if (v != self()->mViewBodyColor && !self()->isViewBodyColorImmutable()) {
        self()->mViewBodyColor = v;
        Q_EMIT self()->viewBodyColorChanged();
      }
    }

    Q_PROPERTY(QString viewBodyColor READ viewBodyColor WRITE setViewBodyColor NOTIFY viewBodyColorChanged)
    Q_PROPERTY(bool isViewBodyColorImmutable READ isViewBodyColorImmutable CONSTANT)
    Q_PROPERTY(QString defaultViewBodyColorValue READ defaultViewBodyColorValue CONSTANT)
    /**
      Get The default text view body color (if not specified default to system theme)
    */
    static
    QString viewBodyColor()
    {
      return self()->mViewBodyColor;
    }

    /**
      Is The default text view body color (if not specified default to system theme) Immutable
    */
    static
    bool isViewBodyColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "viewBodyColor" ) );
    }

    /**
      Get The default text view body color (if not specified default to system theme) default value
    */
    static
    QString defaultViewBodyColorValue()
    {
        return defaultViewBodyColorValue_helper();
    }

    /**
      Set The default text view text color (if not specified default to system theme)
    */
    static
    void setViewTextColor( const QString & v )
    {
      if (v != self()->mViewTextColor && !self()->isViewTextColorImmutable()) {
        self()->mViewTextColor = v;
        Q_EMIT self()->viewTextColorChanged();
      }
    }

    Q_PROPERTY(QString viewTextColor READ viewTextColor WRITE setViewTextColor NOTIFY viewTextColorChanged)
    Q_PROPERTY(bool isViewTextColorImmutable READ isViewTextColorImmutable CONSTANT)
    Q_PROPERTY(QString defaultViewTextColorValue READ defaultViewTextColorValue CONSTANT)
    /**
      Get The default text view text color (if not specified default to system theme)
    */
    static
    QString viewTextColor()
    {
      return self()->mViewTextColor;
    }

    /**
      Is The default text view text color (if not specified default to system theme) Immutable
    */
    static
    bool isViewTextColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "viewTextColor" ) );
    }

    /**
      Get The default text view text color (if not specified default to system theme) default value
    */
    static
    QString defaultViewTextColorValue()
    {
        return defaultViewTextColorValue_helper();
    }

    /**
      Set The default text view title color (if not specified default to system theme)
    */
    static
    void setViewTitleColor( const QString & v )
    {
      if (v != self()->mViewTitleColor && !self()->isViewTitleColorImmutable()) {
        self()->mViewTitleColor = v;
        Q_EMIT self()->viewTitleColorChanged();
      }
    }

    Q_PROPERTY(QString viewTitleColor READ viewTitleColor WRITE setViewTitleColor NOTIFY viewTitleColorChanged)
    Q_PROPERTY(bool isViewTitleColorImmutable READ isViewTitleColorImmutable CONSTANT)
    Q_PROPERTY(QString defaultViewTitleColorValue READ defaultViewTitleColorValue CONSTANT)
    /**
      Get The default text view title color (if not specified default to system theme)
    */
    static
    QString viewTitleColor()
    {
      return self()->mViewTitleColor;
    }

    /**
      Is The default text view title color (if not specified default to system theme) Immutable
    */
    static
    bool isViewTitleColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "viewTitleColor" ) );
    }

    /**
      Get The default text view title color (if not specified default to system theme) default value
    */
    static
    QString defaultViewTitleColorValue()
    {
        return defaultViewTitleColorValue_helper();
    }

    /**
      Set The default text view link color (if not specified default to system theme)
    */
    static
    void setViewLinkColor( const QString & v )
    {
      if (v != self()->mViewLinkColor && !self()->isViewLinkColorImmutable()) {
        self()->mViewLinkColor = v;
        Q_EMIT self()->viewLinkColorChanged();
      }
    }

    Q_PROPERTY(QString viewLinkColor READ viewLinkColor WRITE setViewLinkColor NOTIFY viewLinkColorChanged)
    Q_PROPERTY(bool isViewLinkColorImmutable READ isViewLinkColorImmutable CONSTANT)
    Q_PROPERTY(QString defaultViewLinkColorValue READ defaultViewLinkColorValue CONSTANT)
    /**
      Get The default text view link color (if not specified default to system theme)
    */
    static
    QString viewLinkColor()
    {
      return self()->mViewLinkColor;
    }

    /**
      Is The default text view link color (if not specified default to system theme) Immutable
    */
    static
    bool isViewLinkColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "viewLinkColor" ) );
    }

    /**
      Get The default text view link color (if not specified default to system theme) default value
    */
    static
    QString defaultViewLinkColorValue()
    {
        return defaultViewLinkColorValue_helper();
    }

    /**
      Set The default text view visited link color (if not specified default to system theme)
    */
    static
    void setViewVisitedLinkColor( const QString & v )
    {
      if (v != self()->mViewVisitedLinkColor && !self()->isViewVisitedLinkColorImmutable()) {
        self()->mViewVisitedLinkColor = v;
        Q_EMIT self()->viewVisitedLinkColorChanged();
      }
    }

    Q_PROPERTY(QString viewVisitedLinkColor READ viewVisitedLinkColor WRITE setViewVisitedLinkColor NOTIFY viewVisitedLinkColorChanged)
    Q_PROPERTY(bool isViewVisitedLinkColorImmutable READ isViewVisitedLinkColorImmutable CONSTANT)
    Q_PROPERTY(QString defaultViewVisitedLinkColorValue READ defaultViewVisitedLinkColorValue CONSTANT)
    /**
      Get The default text view visited link color (if not specified default to system theme)
    */
    static
    QString viewVisitedLinkColor()
    {
      return self()->mViewVisitedLinkColor;
    }

    /**
      Is The default text view visited link color (if not specified default to system theme) Immutable
    */
    static
    bool isViewVisitedLinkColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "viewVisitedLinkColor" ) );
    }

    /**
      Get The default text view visited link color (if not specified default to system theme) default value
    */
    static
    QString defaultViewVisitedLinkColorValue()
    {
        return defaultViewVisitedLinkColorValue_helper();
    }

    /**
      Set The default text view code color (if not specified default to system theme)
    */
    static
    void setViewCodeColor( const QString & v )
    {
      if (v != self()->mViewCodeColor && !self()->isViewCodeColorImmutable()) {
        self()->mViewCodeColor = v;
        Q_EMIT self()->viewCodeColorChanged();
      }
    }

    Q_PROPERTY(QString viewCodeColor READ viewCodeColor WRITE setViewCodeColor NOTIFY viewCodeColorChanged)
    Q_PROPERTY(bool isViewCodeColorImmutable READ isViewCodeColorImmutable CONSTANT)
    Q_PROPERTY(QString defaultViewCodeColorValue READ defaultViewCodeColorValue CONSTANT)
    /**
      Get The default text view code color (if not specified default to system theme)
    */
    static
    QString viewCodeColor()
    {
      return self()->mViewCodeColor;
    }

    /**
      Is The default text view code color (if not specified default to system theme) Immutable
    */
    static
    bool isViewCodeColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "viewCodeColor" ) );
    }

    /**
      Get The default text view code color (if not specified default to system theme) default value
    */
    static
    QString defaultViewCodeColorValue()
    {
        return defaultViewCodeColorValue_helper();
    }

    /**
      Set The default text view highlight color (if not specified default to system theme)
    */
    static
    void setViewHighlightColor( const QString & v )
    {
      if (v != self()->mViewHighlightColor && !self()->isViewHighlightColorImmutable()) {
        self()->mViewHighlightColor = v;
        Q_EMIT self()->viewHighlightColorChanged();
      }
    }

    Q_PROPERTY(QString viewHighlightColor READ viewHighlightColor WRITE setViewHighlightColor NOTIFY viewHighlightColorChanged)
    Q_PROPERTY(bool isViewHighlightColorImmutable READ isViewHighlightColorImmutable CONSTANT)
    Q_PROPERTY(QString defaultViewHighlightColorValue READ defaultViewHighlightColorValue CONSTANT)
    /**
      Get The default text view highlight color (if not specified default to system theme)
    */
    static
    QString viewHighlightColor()
    {
      return self()->mViewHighlightColor;
    }

    /**
      Is The default text view highlight color (if not specified default to system theme) Immutable
    */
    static
    bool isViewHighlightColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "viewHighlightColor" ) );
    }

    /**
      Get The default text view highlight color (if not specified default to system theme) default value
    */
    static
    QString defaultViewHighlightColorValue()
    {
        return defaultViewHighlightColorValue_helper();
    }

    /**
      Set The default text editor font (if not specified default to system theme)
    */
    static
    void setEditorFont( const QFont & v )
    {
      if (v != self()->mEditorFont && !self()->isEditorFontImmutable()) {
        self()->mEditorFont = v;
        Q_EMIT self()->editorFontChanged();
      }
    }

    Q_PROPERTY(QFont editorFont READ editorFont WRITE setEditorFont NOTIFY editorFontChanged)
    Q_PROPERTY(bool isEditorFontImmutable READ isEditorFontImmutable CONSTANT)
    /**
      Get The default text editor font (if not specified default to system theme)
    */
    static
    QFont editorFont()
    {
      return self()->mEditorFont;
    }

    /**
      Is The default text editor font (if not specified default to system theme) Immutable
    */
    static
    bool isEditorFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "editorFont" ) );
    }

    /**
      Set Wether or not the editor highlighter is enabled
    */
    static
    void setEditorHighlightEnabled( bool v )
    {
      if (v != self()->mEditorHighlightEnabled && !self()->isEditorHighlightEnabledImmutable()) {
        self()->mEditorHighlightEnabled = v;
        Q_EMIT self()->editorHighlightEnabledChanged();
      }
    }

    Q_PROPERTY(bool editorHighlightEnabled READ editorHighlightEnabled WRITE setEditorHighlightEnabled NOTIFY editorHighlightEnabledChanged)
    Q_PROPERTY(bool isEditorHighlightEnabledImmutable READ isEditorHighlightEnabledImmutable CONSTANT)
    Q_PROPERTY(bool defaultEditorHighlightEnabledValue READ defaultEditorHighlightEnabledValue CONSTANT)
    /**
      Get Wether or not the editor highlighter is enabled
    */
    static
    bool editorHighlightEnabled()
    {
      return self()->mEditorHighlightEnabled;
    }

    /**
      Is Wether or not the editor highlighter is enabled Immutable
    */
    static
    bool isEditorHighlightEnabledImmutable()
    {
      return self()->isImmutable( QStringLiteral( "editorHighlightEnabled" ) );
    }

    /**
      Get Wether or not the editor highlighter is enabled default value
    */
    static
    bool defaultEditorHighlightEnabledValue()
    {
        return defaultEditorHighlightEnabledValue_helper();
    }

    /**
      Set Wether or not the tag size should change based on its surroundings
    */
    static
    void setAdaptiveTagSizeEnabled( bool v )
    {
      if (v != self()->mAdaptiveTagSizeEnabled && !self()->isAdaptiveTagSizeEnabledImmutable()) {
        self()->mAdaptiveTagSizeEnabled = v;
        Q_EMIT self()->adaptiveTagSizeEnabledChanged();
      }
    }

    Q_PROPERTY(bool adaptiveTagSizeEnabled READ adaptiveTagSizeEnabled WRITE setAdaptiveTagSizeEnabled NOTIFY adaptiveTagSizeEnabledChanged)
    Q_PROPERTY(bool isAdaptiveTagSizeEnabledImmutable READ isAdaptiveTagSizeEnabledImmutable CONSTANT)
    Q_PROPERTY(bool defaultAdaptiveTagSizeEnabledValue READ defaultAdaptiveTagSizeEnabledValue CONSTANT)
    /**
      Get Wether or not the tag size should change based on its surroundings
    */
    static
    bool adaptiveTagSizeEnabled()
    {
      return self()->mAdaptiveTagSizeEnabled;
    }

    /**
      Is Wether or not the tag size should change based on its surroundings Immutable
    */
    static
    bool isAdaptiveTagSizeEnabledImmutable()
    {
      return self()->isImmutable( QStringLiteral( "adaptiveTagSizeEnabled" ) );
    }

    /**
      Get Wether or not the tag size should change based on its surroundings default value
    */
    static
    bool defaultAdaptiveTagSizeEnabledValue()
    {
        return defaultAdaptiveTagSizeEnabledValue_helper();
    }

    /**
      Set The scale, in percente, applied to the tag size
    */
    static
    void setTagSizeScale( int v )
    {
      if (v != self()->mTagSizeScale && !self()->isTagSizeScaleImmutable()) {
        self()->mTagSizeScale = v;
        Q_EMIT self()->tagSizeScaleChanged();
      }
    }

    Q_PROPERTY(int tagSizeScale READ tagSizeScale WRITE setTagSizeScale NOTIFY tagSizeScaleChanged)
    Q_PROPERTY(bool isTagSizeScaleImmutable READ isTagSizeScaleImmutable CONSTANT)
    Q_PROPERTY(int defaultTagSizeScaleValue READ defaultTagSizeScaleValue CONSTANT)
    /**
      Get The scale, in percente, applied to the tag size
    */
    static
    int tagSizeScale()
    {
      return self()->mTagSizeScale;
    }

    /**
      Is The scale, in percente, applied to the tag size Immutable
    */
    static
    bool isTagSizeScaleImmutable()
    {
      return self()->isImmutable( QStringLiteral( "tagSizeScale" ) );
    }

    /**
      Get The scale, in percente, applied to the tag size default value
    */
    static
    int defaultTagSizeScaleValue()
    {
        return defaultTagSizeScaleValue_helper();
    }

    /**
      Set Whether or not PlantUML is enable
    */
    static
    void setPumlEnabled( bool v )
    {
      if (v != self()->mPumlEnabled && !self()->isPumlEnabledImmutable()) {
        self()->mPumlEnabled = v;
        Q_EMIT self()->pumlEnabledChanged();
      }
    }

    Q_PROPERTY(bool pumlEnabled READ pumlEnabled WRITE setPumlEnabled NOTIFY pumlEnabledChanged)
    Q_PROPERTY(bool isPumlEnabledImmutable READ isPumlEnabledImmutable CONSTANT)
    Q_PROPERTY(bool defaultPumlEnabledValue READ defaultPumlEnabledValue CONSTANT)
    /**
      Get Whether or not PlantUML is enable
    */
    static
    bool pumlEnabled()
    {
      return self()->mPumlEnabled;
    }

    /**
      Is Whether or not PlantUML is enable Immutable
    */
    static
    bool isPumlEnabledImmutable()
    {
      return self()->isImmutable( QStringLiteral( "pumlEnabled" ) );
    }

    /**
      Get Whether or not PlantUML is enable default value
    */
    static
    bool defaultPumlEnabledValue()
    {
        return defaultPumlEnabledValue_helper();
    }

    /**
      Set Whether or not PlantUML diagram use dark background
    */
    static
    void setPumlDark( bool v )
    {
      if (v != self()->mPumlDark && !self()->isPumlDarkImmutable()) {
        self()->mPumlDark = v;
        Q_EMIT self()->pumlDarkChanged();
      }
    }

    Q_PROPERTY(bool pumlDark READ pumlDark WRITE setPumlDark NOTIFY pumlDarkChanged)
    Q_PROPERTY(bool isPumlDarkImmutable READ isPumlDarkImmutable CONSTANT)
    Q_PROPERTY(bool defaultPumlDarkValue READ defaultPumlDarkValue CONSTANT)
    /**
      Get Whether or not PlantUML diagram use dark background
    */
    static
    bool pumlDark()
    {
      return self()->mPumlDark;
    }

    /**
      Is Whether or not PlantUML diagram use dark background Immutable
    */
    static
    bool isPumlDarkImmutable()
    {
      return self()->isImmutable( QStringLiteral( "pumlDark" ) );
    }

    /**
      Get Whether or not PlantUML diagram use dark background default value
    */
    static
    bool defaultPumlDarkValue()
    {
        return defaultPumlDarkValue_helper();
    }

    /**
      Set Whether or not quick emoji (':emoji_name:') is enable
    */
    static
    void setQuickEmojiEnabled( bool v )
    {
      if (v != self()->mQuickEmojiEnabled && !self()->isQuickEmojiEnabledImmutable()) {
        self()->mQuickEmojiEnabled = v;
        Q_EMIT self()->quickEmojiEnabledChanged();
      }
    }

    Q_PROPERTY(bool quickEmojiEnabled READ quickEmojiEnabled WRITE setQuickEmojiEnabled NOTIFY quickEmojiEnabledChanged)
    Q_PROPERTY(bool isQuickEmojiEnabledImmutable READ isQuickEmojiEnabledImmutable CONSTANT)
    Q_PROPERTY(bool defaultQuickEmojiEnabledValue READ defaultQuickEmojiEnabledValue CONSTANT)
    /**
      Get Whether or not quick emoji (':emoji_name:') is enable
    */
    static
    bool quickEmojiEnabled()
    {
      return self()->mQuickEmojiEnabled;
    }

    /**
      Is Whether or not quick emoji (':emoji_name:') is enable Immutable
    */
    static
    bool isQuickEmojiEnabledImmutable()
    {
      return self()->isImmutable( QStringLiteral( "quickEmojiEnabled" ) );
    }

    /**
      Get Whether or not quick emoji (':emoji_name:') is enable default value
    */
    static
    bool defaultQuickEmojiEnabledValue()
    {
        return defaultQuickEmojiEnabledValue_helper();
    }

    /**
      Set The tone the user wants to use by default when tone is available for an emoji
    */
    static
    void setEmojiTone( const QString & v )
    {
      if (v != self()->mEmojiTone && !self()->isEmojiToneImmutable()) {
        self()->mEmojiTone = v;
        Q_EMIT self()->emojiToneChanged();
      }
    }

    Q_PROPERTY(QString emojiTone READ emojiTone WRITE setEmojiTone NOTIFY emojiToneChanged)
    Q_PROPERTY(bool isEmojiToneImmutable READ isEmojiToneImmutable CONSTANT)
    Q_PROPERTY(QString defaultEmojiToneValue READ defaultEmojiToneValue CONSTANT)
    /**
      Get The tone the user wants to use by default when tone is available for an emoji
    */
    static
    QString emojiTone()
    {
      return self()->mEmojiTone;
    }

    /**
      Is The tone the user wants to use by default when tone is available for an emoji Immutable
    */
    static
    bool isEmojiToneImmutable()
    {
      return self()->isImmutable( QStringLiteral( "emojiTone" ) );
    }

    /**
      Get The tone the user wants to use by default when tone is available for an emoji default value
    */
    static
    QString defaultEmojiToneValue()
    {
        return defaultEmojiToneValue_helper();
    }

    /**
      Set Whether or not the emoji dialog insert quick emoji (':emoji_name:')
    */
    static
    void setQuickEmojiDialogEnabled( bool v )
    {
      if (v != self()->mQuickEmojiDialogEnabled && !self()->isQuickEmojiDialogEnabledImmutable()) {
        self()->mQuickEmojiDialogEnabled = v;
        Q_EMIT self()->quickEmojiDialogEnabledChanged();
      }
    }

    Q_PROPERTY(bool quickEmojiDialogEnabled READ quickEmojiDialogEnabled WRITE setQuickEmojiDialogEnabled NOTIFY quickEmojiDialogEnabledChanged)
    Q_PROPERTY(bool isQuickEmojiDialogEnabledImmutable READ isQuickEmojiDialogEnabledImmutable CONSTANT)
    Q_PROPERTY(bool defaultQuickEmojiDialogEnabledValue READ defaultQuickEmojiDialogEnabledValue CONSTANT)
    /**
      Get Whether or not the emoji dialog insert quick emoji (':emoji_name:')
    */
    static
    bool quickEmojiDialogEnabled()
    {
      return self()->mQuickEmojiDialogEnabled;
    }

    /**
      Is Whether or not the emoji dialog insert quick emoji (':emoji_name:') Immutable
    */
    static
    bool isQuickEmojiDialogEnabledImmutable()
    {
      return self()->isImmutable( QStringLiteral( "quickEmojiDialogEnabled" ) );
    }

    /**
      Get Whether or not the emoji dialog insert quick emoji (':emoji_name:') default value
    */
    static
    bool defaultQuickEmojiDialogEnabledValue()
    {
        return defaultQuickEmojiDialogEnabledValue_helper();
    }

    /**
      Set Whether or not the code block syntax highlighting is enable
    */
    static
    void setCodeSynthaxHighlightEnabled( bool v )
    {
      if (v != self()->mCodeSynthaxHighlightEnabled && !self()->isCodeSynthaxHighlightEnabledImmutable()) {
        self()->mCodeSynthaxHighlightEnabled = v;
        Q_EMIT self()->codeSynthaxHighlightEnabledChanged();
      }
    }

    Q_PROPERTY(bool codeSynthaxHighlightEnabled READ codeSynthaxHighlightEnabled WRITE setCodeSynthaxHighlightEnabled NOTIFY codeSynthaxHighlightEnabledChanged)
    Q_PROPERTY(bool isCodeSynthaxHighlightEnabledImmutable READ isCodeSynthaxHighlightEnabledImmutable CONSTANT)
    Q_PROPERTY(bool defaultCodeSynthaxHighlightEnabledValue READ defaultCodeSynthaxHighlightEnabledValue CONSTANT)
    /**
      Get Whether or not the code block syntax highlighting is enable
    */
    static
    bool codeSynthaxHighlightEnabled()
    {
      return self()->mCodeSynthaxHighlightEnabled;
    }

    /**
      Is Whether or not the code block syntax highlighting is enable Immutable
    */
    static
    bool isCodeSynthaxHighlightEnabledImmutable()
    {
      return self()->isImmutable( QStringLiteral( "codeSynthaxHighlightEnabled" ) );
    }

    /**
      Get Whether or not the code block syntax highlighting is enable default value
    */
    static
    bool defaultCodeSynthaxHighlightEnabledValue()
    {
        return defaultCodeSynthaxHighlightEnabledValue_helper();
    }

    /**
      Set The highlighter choosen by the user
    */
    static
    void setCodeSynthaxHighlighter( const QString & v )
    {
      if (v != self()->mCodeSynthaxHighlighter && !self()->isCodeSynthaxHighlighterImmutable()) {
        self()->mCodeSynthaxHighlighter = v;
        Q_EMIT self()->codeSynthaxHighlighterChanged();
      }
    }

    Q_PROPERTY(QString codeSynthaxHighlighter READ codeSynthaxHighlighter WRITE setCodeSynthaxHighlighter NOTIFY codeSynthaxHighlighterChanged)
    Q_PROPERTY(bool isCodeSynthaxHighlighterImmutable READ isCodeSynthaxHighlighterImmutable CONSTANT)
    /**
      Get The highlighter choosen by the user
    */
    static
    QString codeSynthaxHighlighter()
    {
      return self()->mCodeSynthaxHighlighter;
    }

    /**
      Is The highlighter choosen by the user Immutable
    */
    static
    bool isCodeSynthaxHighlighterImmutable()
    {
      return self()->isImmutable( QStringLiteral( "codeSynthaxHighlighter" ) );
    }

    /**
      Set The highlighter style choosen by the user
    */
    static
    void setCodeSynthaxHighlighterStyle( const QString & v )
    {
      if (v != self()->mCodeSynthaxHighlighterStyle && !self()->isCodeSynthaxHighlighterStyleImmutable()) {
        self()->mCodeSynthaxHighlighterStyle = v;
        Q_EMIT self()->codeSynthaxHighlighterStyleChanged();
      }
    }

    Q_PROPERTY(QString codeSynthaxHighlighterStyle READ codeSynthaxHighlighterStyle WRITE setCodeSynthaxHighlighterStyle NOTIFY codeSynthaxHighlighterStyleChanged)
    Q_PROPERTY(bool isCodeSynthaxHighlighterStyleImmutable READ isCodeSynthaxHighlighterStyleImmutable CONSTANT)
    /**
      Get The highlighter style choosen by the user
    */
    static
    QString codeSynthaxHighlighterStyle()
    {
      return self()->mCodeSynthaxHighlighterStyle;
    }

    /**
      Is The highlighter style choosen by the user Immutable
    */
    static
    bool isCodeSynthaxHighlighterStyleImmutable()
    {
      return self()->isImmutable( QStringLiteral( "codeSynthaxHighlighterStyle" ) );
    }

    /**
      Set Whether or not the note map is enable
    */
    static
    void setNoteMapEnabled( bool v )
    {
      if (v != self()->mNoteMapEnabled && !self()->isNoteMapEnabledImmutable()) {
        self()->mNoteMapEnabled = v;
        Q_EMIT self()->noteMapEnabledChanged();
      }
    }

    Q_PROPERTY(bool noteMapEnabled READ noteMapEnabled WRITE setNoteMapEnabled NOTIFY noteMapEnabledChanged)
    Q_PROPERTY(bool isNoteMapEnabledImmutable READ isNoteMapEnabledImmutable CONSTANT)
    Q_PROPERTY(bool defaultNoteMapEnabledValue READ defaultNoteMapEnabledValue CONSTANT)
    /**
      Get Whether or not the note map is enable
    */
    static
    bool noteMapEnabled()
    {
      return self()->mNoteMapEnabled;
    }

    /**
      Is Whether or not the note map is enable Immutable
    */
    static
    bool isNoteMapEnabledImmutable()
    {
      return self()->isImmutable( QStringLiteral( "noteMapEnabled" ) );
    }

    /**
      Get Whether or not the note map is enable default value
    */
    static
    bool defaultNoteMapEnabledValue()
    {
        return defaultNoteMapEnabledValue_helper();
    }


    enum {
      signalStoragePathChanged = 1,
      signalDefaultFolderNameChanged = 2,
      signalDefaultNoteNameChanged = 3,
      signalEditorVisibleChanged = 4,
      signalPreviewVisibleChanged = 5,
      signalUseSpaceForTabChanged = 6,
      signalSpacesForTabChanged = 7,
      signalVisibleToolsChanged = 8,
      signalInvisibleToolsChanged = 9,
      signalSortByLastModifiedChanged = 10,
      signalStylePathChanged = 11,
      signalCodeFontChanged = 12,
      signalViewFontChanged = 13,
      signalViewBodyColorChanged = 14,
      signalViewTextColorChanged = 15,
      signalViewTitleColorChanged = 16,
      signalViewLinkColorChanged = 17,
      signalViewVisitedLinkColorChanged = 18,
      signalViewCodeColorChanged = 19,
      signalViewHighlightColorChanged = 20,
      signalEditorFontChanged = 21,
      signalEditorHighlightEnabledChanged = 22,
      signalAdaptiveTagSizeEnabledChanged = 23,
      signalTagSizeScaleChanged = 24,
      signalPumlEnabledChanged = 25,
      signalPumlDarkChanged = 26,
      signalQuickEmojiEnabledChanged = 27,
      signalEmojiToneChanged = 28,
      signalQuickEmojiDialogEnabledChanged = 29,
      signalCodeSynthaxHighlightEnabledChanged = 30,
      signalCodeSynthaxHighlighterChanged = 31,
      signalCodeSynthaxHighlighterStyleChanged = 32,
      signalNoteMapEnabledChanged = 33
    };

  Q_SIGNALS:
    void storagePathChanged();

    void defaultFolderNameChanged();

    void defaultNoteNameChanged();

    void editorVisibleChanged();

    void previewVisibleChanged();

    void useSpaceForTabChanged();

    void spacesForTabChanged();

    void visibleToolsChanged();

    void invisibleToolsChanged();

    void sortByLastModifiedChanged();

    void stylePathChanged();

    void codeFontChanged();

    void viewFontChanged();

    void viewBodyColorChanged();

    void viewTextColorChanged();

    void viewTitleColorChanged();

    void viewLinkColorChanged();

    void viewVisitedLinkColorChanged();

    void viewCodeColorChanged();

    void viewHighlightColorChanged();

    void editorFontChanged();

    void editorHighlightEnabledChanged();

    void adaptiveTagSizeEnabledChanged();

    void tagSizeScaleChanged();

    void pumlEnabledChanged();

    void pumlDarkChanged();

    void quickEmojiEnabledChanged();

    void emojiToneChanged();

    void quickEmojiDialogEnabledChanged();

    void codeSynthaxHighlightEnabledChanged();

    void codeSynthaxHighlighterChanged();

    void codeSynthaxHighlighterStyleChanged();

    void noteMapEnabledChanged();

  private:
    void itemChanged(quint64 signalFlag);

  protected:
    KleverConfig(QObject *parent = nullptr);
    friend class KleverConfigHelper;


    // General
    QString mStoragePath;
    static QString defaultStoragePathValue_helper();
    QString mDefaultFolderName;
    static QString defaultDefaultFolderNameValue_helper();
    QString mDefaultNoteName;
    static QString defaultDefaultNoteNameValue_helper();
    bool mEditorVisible;
    static bool defaultEditorVisibleValue_helper();
    bool mPreviewVisible;
    static bool defaultPreviewVisibleValue_helper();
    bool mUseSpaceForTab;
    static bool defaultUseSpaceForTabValue_helper();
    int mSpacesForTab;
    static int defaultSpacesForTabValue_helper();
    QList<int> mVisibleTools;
    static QList<int> defaultVisibleToolsValue_helper();
    QList<int> mInvisibleTools;
    static QList<int> defaultInvisibleToolsValue_helper();
    bool mSortByLastModified;
    static bool defaultSortByLastModifiedValue_helper();

    // Appearance
    QString mStylePath;
    static QString defaultStylePathValue_helper();
    QFont mCodeFont;
    static QFont defaultCodeFontValue_helper();
    QFont mViewFont;
    static QFont defaultViewFontValue_helper();
    QString mViewBodyColor;
    static QString defaultViewBodyColorValue_helper();
    QString mViewTextColor;
    static QString defaultViewTextColorValue_helper();
    QString mViewTitleColor;
    static QString defaultViewTitleColorValue_helper();
    QString mViewLinkColor;
    static QString defaultViewLinkColorValue_helper();
    QString mViewVisitedLinkColor;
    static QString defaultViewVisitedLinkColorValue_helper();
    QString mViewCodeColor;
    static QString defaultViewCodeColorValue_helper();
    QString mViewHighlightColor;
    static QString defaultViewHighlightColorValue_helper();

    // Editor
    QFont mEditorFont;
    static QFont defaultEditorFontValue_helper();
    bool mEditorHighlightEnabled;
    static bool defaultEditorHighlightEnabledValue_helper();
    bool mAdaptiveTagSizeEnabled;
    static bool defaultAdaptiveTagSizeEnabledValue_helper();
    int mTagSizeScale;
    static int defaultTagSizeScaleValue_helper();

    // Plugins
    bool mPumlEnabled;
    static bool defaultPumlEnabledValue_helper();
    bool mPumlDark;
    static bool defaultPumlDarkValue_helper();
    bool mQuickEmojiEnabled;
    static bool defaultQuickEmojiEnabledValue_helper();
    QString mEmojiTone;
    static QString defaultEmojiToneValue_helper();
    bool mQuickEmojiDialogEnabled;
    static bool defaultQuickEmojiDialogEnabledValue_helper();
    bool mCodeSynthaxHighlightEnabled;
    static bool defaultCodeSynthaxHighlightEnabledValue_helper();
    QString mCodeSynthaxHighlighter;
    static QString defaultCodeSynthaxHighlighterValue_helper();
    QString mCodeSynthaxHighlighterStyle;
    static QString defaultCodeSynthaxHighlighterStyleValue_helper();
    bool mNoteMapEnabled;
    static bool defaultNoteMapEnabledValue_helper();
};

#endif

