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

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

#include <QFontDatabase>

class QQmlEngine;
class QJSEngine;

class Prefs : public KConfigSkeleton
{
  Q_OBJECT
  QML_ELEMENT
  QML_SINGLETON
  public:
    enum EnumStartSession { Editor, Flashcard, MultipleChoice, QA };
    Q_ENUM(EnumStartSession)
    enum EnumTutorTiming { FixedInterval, RandomInterval };
    Q_ENUM(EnumTutorTiming)
    enum EnumTutorCardAppearance { Native, Minimalistic };
    Q_ENUM(EnumTutorCardAppearance)

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

    /**
      Set Is this the first time KWordQuiz is run?
    */
    static
    void setFirstRun( bool v )
    {
      if (v != self()->mFirstRun && !self()->isFirstRunImmutable()) {
        self()->mFirstRun = v;
        Q_EMIT self()->FirstRunChanged();
      }
    }

    Q_PROPERTY(bool firstRun READ firstRun WRITE setFirstRun NOTIFY FirstRunChanged)
    Q_PROPERTY(bool isFirstRunImmutable READ isFirstRunImmutable CONSTANT)
    Q_PROPERTY(bool defaultFirstRunValue READ defaultFirstRunValue CONSTANT)
    /**
      Get Is this the first time KWordQuiz is run?
    */
    static
    bool firstRun()
    {
      return self()->mFirstRun;
    }

    /**
      Is Is this the first time KWordQuiz is run? Immutable
    */
    static
    bool isFirstRunImmutable()
    {
      return self()->isImmutable( QStringLiteral( "FirstRun" ) );
    }

    /**
      Get Is this the first time KWordQuiz is run? default value
    */
    static
    bool defaultFirstRunValue()
    {
        return defaultFirstRunValue_helper();
    }

    /**
      Set Toggle display of the search bar.
    */
    static
    void setShowSearch( bool v )
    {
      if (v != self()->mShowSearch && !self()->isShowSearchImmutable()) {
        self()->mShowSearch = v;
        Q_EMIT self()->ShowSearchChanged();
      }
    }

    Q_PROPERTY(bool showSearch READ showSearch WRITE setShowSearch NOTIFY ShowSearchChanged)
    Q_PROPERTY(bool isShowSearchImmutable READ isShowSearchImmutable CONSTANT)
    Q_PROPERTY(bool defaultShowSearchValue READ defaultShowSearchValue CONSTANT)
    /**
      Get Toggle display of the search bar.
    */
    static
    bool showSearch()
    {
      return self()->mShowSearch;
    }

    /**
      Is Toggle display of the search bar. Immutable
    */
    static
    bool isShowSearchImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowSearch" ) );
    }

    /**
      Get Toggle display of the search bar. default value
    */
    static
    bool defaultShowSearchValue()
    {
        return defaultShowSearchValue_helper();
    }

    /**
      Set Type of session to use when opening files
    */
    static
    void setStartSession( int v )
    {
      if (v != self()->mStartSession && !self()->isStartSessionImmutable()) {
        self()->mStartSession = v;
        Q_EMIT self()->StartSessionChanged();
      }
    }

    Q_PROPERTY(int startSession READ startSession WRITE setStartSession NOTIFY StartSessionChanged)
    Q_PROPERTY(bool isStartSessionImmutable READ isStartSessionImmutable CONSTANT)
    Q_PROPERTY(int defaultStartSessionValue READ defaultStartSessionValue CONSTANT)
    /**
      Get Type of session to use when opening files
    */
    static
    int startSession()
    {
      return self()->mStartSession;
    }

    /**
      Is Type of session to use when opening files Immutable
    */
    static
    bool isStartSessionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "StartSession" ) );
    }

    /**
      Get Type of session to use when opening files default value
    */
    static
    int defaultStartSessionValue()
    {
        return defaultStartSessionValue_helper();
    }

    /**
      Set If Fill-in-the-blank should be enabled
    */
    static
    void setEnableBlanks( bool v )
    {
      if (v != self()->mEnableBlanks && !self()->isEnableBlanksImmutable()) {
        self()->mEnableBlanks = v;
        Q_EMIT self()->EnableBlanksChanged();
      }
    }

    Q_PROPERTY(bool enableBlanks READ enableBlanks WRITE setEnableBlanks NOTIFY EnableBlanksChanged)
    Q_PROPERTY(bool isEnableBlanksImmutable READ isEnableBlanksImmutable CONSTANT)
    Q_PROPERTY(bool defaultEnableBlanksValue READ defaultEnableBlanksValue CONSTANT)
    /**
      Get If Fill-in-the-blank should be enabled
    */
    static
    bool enableBlanks()
    {
      return self()->mEnableBlanks;
    }

    /**
      Is If Fill-in-the-blank should be enabled Immutable
    */
    static
    bool isEnableBlanksImmutable()
    {
      return self()->isImmutable( QStringLiteral( "EnableBlanks" ) );
    }

    /**
      Get If Fill-in-the-blank should be enabled default value
    */
    static
    bool defaultEnableBlanksValue()
    {
        return defaultEnableBlanksValue_helper();
    }

    /**
      Set Direction the Enter key moves in the editor
    */
    static
    void setEnterMove( int v )
    {
      if (v != self()->mEnterMove && !self()->isEnterMoveImmutable()) {
        self()->mEnterMove = v;
        Q_EMIT self()->EnterMoveChanged();
      }
    }

    Q_PROPERTY(int enterMove READ enterMove WRITE setEnterMove NOTIFY EnterMoveChanged)
    Q_PROPERTY(bool isEnterMoveImmutable READ isEnterMoveImmutable CONSTANT)
    Q_PROPERTY(int defaultEnterMoveValue READ defaultEnterMoveValue CONSTANT)
    /**
      Get Direction the Enter key moves in the editor
    */
    static
    int enterMove()
    {
      return self()->mEnterMove;
    }

    /**
      Is Direction the Enter key moves in the editor Immutable
    */
    static
    bool isEnterMoveImmutable()
    {
      return self()->isImmutable( QStringLiteral( "EnterMove" ) );
    }

    /**
      Get Direction the Enter key moves in the editor default value
    */
    static
    int defaultEnterMoveValue()
    {
        return defaultEnterMoveValue_helper();
    }

    /**
      Set Characters for the special character toolbar
    */
    static
    void setSpecialCharacters( const QString & v )
    {
      if (v != self()->mSpecialCharacters && !self()->isSpecialCharactersImmutable()) {
        self()->mSpecialCharacters = v;
        Q_EMIT self()->SpecialCharactersChanged();
      }
    }

    Q_PROPERTY(QString specialCharacters READ specialCharacters WRITE setSpecialCharacters NOTIFY SpecialCharactersChanged)
    Q_PROPERTY(bool isSpecialCharactersImmutable READ isSpecialCharactersImmutable CONSTANT)
    Q_PROPERTY(QString defaultSpecialCharactersValue READ defaultSpecialCharactersValue CONSTANT)
    /**
      Get Characters for the special character toolbar
    */
    static
    QString specialCharacters()
    {
      return self()->mSpecialCharacters;
    }

    /**
      Is Characters for the special character toolbar Immutable
    */
    static
    bool isSpecialCharactersImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SpecialCharacters" ) );
    }

    /**
      Get Characters for the special character toolbar default value
    */
    static
    QString defaultSpecialCharactersValue()
    {
        return defaultSpecialCharactersValue_helper();
    }

    /**
      Set Clear all data in selected entries
    */
    static
    void setClearAll( bool v )
    {
      if (v != self()->mClearAll && !self()->isClearAllImmutable()) {
        self()->mClearAll = v;
        Q_EMIT self()->ClearAllChanged();
      }
    }

    Q_PROPERTY(bool clearAll READ clearAll WRITE setClearAll NOTIFY ClearAllChanged)
    Q_PROPERTY(bool isClearAllImmutable READ isClearAllImmutable CONSTANT)
    Q_PROPERTY(bool defaultClearAllValue READ defaultClearAllValue CONSTANT)
    /**
      Get Clear all data in selected entries
    */
    static
    bool clearAll()
    {
      return self()->mClearAll;
    }

    /**
      Is Clear all data in selected entries Immutable
    */
    static
    bool isClearAllImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ClearAll" ) );
    }

    /**
      Get Clear all data in selected entries default value
    */
    static
    bool defaultClearAllValue()
    {
        return defaultClearAllValue_helper();
    }

    /**
      Set Clear the text in selected entries
    */
    static
    void setClearText( bool v )
    {
      if (v != self()->mClearText && !self()->isClearTextImmutable()) {
        self()->mClearText = v;
        Q_EMIT self()->ClearTextChanged();
      }
    }

    Q_PROPERTY(bool clearText READ clearText WRITE setClearText NOTIFY ClearTextChanged)
    Q_PROPERTY(bool isClearTextImmutable READ isClearTextImmutable CONSTANT)
    Q_PROPERTY(bool defaultClearTextValue READ defaultClearTextValue CONSTANT)
    /**
      Get Clear the text in selected entries
    */
    static
    bool clearText()
    {
      return self()->mClearText;
    }

    /**
      Is Clear the text in selected entries Immutable
    */
    static
    bool isClearTextImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ClearText" ) );
    }

    /**
      Get Clear the text in selected entries default value
    */
    static
    bool defaultClearTextValue()
    {
        return defaultClearTextValue_helper();
    }

    /**
      Set Clear the image link in selected entries
    */
    static
    void setClearImageLink( bool v )
    {
      if (v != self()->mClearImageLink && !self()->isClearImageLinkImmutable()) {
        self()->mClearImageLink = v;
        Q_EMIT self()->ClearImageLinkChanged();
      }
    }

    Q_PROPERTY(bool clearImageLink READ clearImageLink WRITE setClearImageLink NOTIFY ClearImageLinkChanged)
    Q_PROPERTY(bool isClearImageLinkImmutable READ isClearImageLinkImmutable CONSTANT)
    Q_PROPERTY(bool defaultClearImageLinkValue READ defaultClearImageLinkValue CONSTANT)
    /**
      Get Clear the image link in selected entries
    */
    static
    bool clearImageLink()
    {
      return self()->mClearImageLink;
    }

    /**
      Is Clear the image link in selected entries Immutable
    */
    static
    bool isClearImageLinkImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ClearImageLink" ) );
    }

    /**
      Get Clear the image link in selected entries default value
    */
    static
    bool defaultClearImageLinkValue()
    {
        return defaultClearImageLinkValue_helper();
    }

    /**
      Set Clear the sound link in selected entries
    */
    static
    void setClearSoundLink( bool v )
    {
      if (v != self()->mClearSoundLink && !self()->isClearSoundLinkImmutable()) {
        self()->mClearSoundLink = v;
        Q_EMIT self()->ClearSoundLinkChanged();
      }
    }

    Q_PROPERTY(bool clearSoundLink READ clearSoundLink WRITE setClearSoundLink NOTIFY ClearSoundLinkChanged)
    Q_PROPERTY(bool isClearSoundLinkImmutable READ isClearSoundLinkImmutable CONSTANT)
    Q_PROPERTY(bool defaultClearSoundLinkValue READ defaultClearSoundLinkValue CONSTANT)
    /**
      Get Clear the sound link in selected entries
    */
    static
    bool clearSoundLink()
    {
      return self()->mClearSoundLink;
    }

    /**
      Is Clear the sound link in selected entries Immutable
    */
    static
    bool isClearSoundLinkImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ClearSoundLink" ) );
    }

    /**
      Get Clear the sound link in selected entries default value
    */
    static
    bool defaultClearSoundLinkValue()
    {
        return defaultClearSoundLinkValue_helper();
    }

    /**
      Set Automatically check selected answer in multiple choice
    */
    static
    void setAutoCheck( bool v )
    {
      if (v != self()->mAutoCheck && !self()->isAutoCheckImmutable()) {
        self()->mAutoCheck = v;
        Q_EMIT self()->AutoCheckChanged();
      }
    }

    Q_PROPERTY(bool autoCheck READ autoCheck WRITE setAutoCheck NOTIFY AutoCheckChanged)
    Q_PROPERTY(bool isAutoCheckImmutable READ isAutoCheckImmutable CONSTANT)
    Q_PROPERTY(bool defaultAutoCheckValue READ defaultAutoCheckValue CONSTANT)
    /**
      Get Automatically check selected answer in multiple choice
    */
    static
    bool autoCheck()
    {
      return self()->mAutoCheck;
    }

    /**
      Is Automatically check selected answer in multiple choice Immutable
    */
    static
    bool isAutoCheckImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoCheck" ) );
    }

    /**
      Get Automatically check selected answer in multiple choice default value
    */
    static
    bool defaultAutoCheckValue()
    {
        return defaultAutoCheckValue_helper();
    }

    /**
      Set Automatically flip flashcard
    */
    static
    void setAutoFlip( bool v )
    {
      if (v != self()->mAutoFlip && !self()->isAutoFlipImmutable()) {
        self()->mAutoFlip = v;
        Q_EMIT self()->AutoFlipChanged();
      }
    }

    Q_PROPERTY(bool autoFlip READ autoFlip WRITE setAutoFlip NOTIFY AutoFlipChanged)
    Q_PROPERTY(bool isAutoFlipImmutable READ isAutoFlipImmutable CONSTANT)
    Q_PROPERTY(bool defaultAutoFlipValue READ defaultAutoFlipValue CONSTANT)
    /**
      Get Automatically flip flashcard
    */
    static
    bool autoFlip()
    {
      return self()->mAutoFlip;
    }

    /**
      Is Automatically flip flashcard Immutable
    */
    static
    bool isAutoFlipImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoFlip" ) );
    }

    /**
      Get Automatically flip flashcard default value
    */
    static
    bool defaultAutoFlipValue()
    {
        return defaultAutoFlipValue_helper();
    }

    /**
      Set Time delay for flipping flashcard
    */
    static
    void setFlipDelay( int v )
    {
      if (v != self()->mFlipDelay && !self()->isFlipDelayImmutable()) {
        self()->mFlipDelay = v;
        Q_EMIT self()->FlipDelayChanged();
      }
    }

    Q_PROPERTY(int flipDelay READ flipDelay WRITE setFlipDelay NOTIFY FlipDelayChanged)
    Q_PROPERTY(bool isFlipDelayImmutable READ isFlipDelayImmutable CONSTANT)
    Q_PROPERTY(int defaultFlipDelayValue READ defaultFlipDelayValue CONSTANT)
    /**
      Get Time delay for flipping flashcard
    */
    static
    int flipDelay()
    {
      return self()->mFlipDelay;
    }

    /**
      Is Time delay for flipping flashcard Immutable
    */
    static
    bool isFlipDelayImmutable()
    {
      return self()->isImmutable( QStringLiteral( "FlipDelay" ) );
    }

    /**
      Get Time delay for flipping flashcard default value
    */
    static
    int defaultFlipDelayValue()
    {
        return defaultFlipDelayValue_helper();
    }

    /**
      Set Treat use of hint as error
    */
    static
    void setHintError( bool v )
    {
      if (v != self()->mHintError && !self()->isHintErrorImmutable()) {
        self()->mHintError = v;
        Q_EMIT self()->HintErrorChanged();
      }
    }

    Q_PROPERTY(bool hintError READ hintError WRITE setHintError NOTIFY HintErrorChanged)
    Q_PROPERTY(bool isHintErrorImmutable READ isHintErrorImmutable CONSTANT)
    Q_PROPERTY(bool defaultHintErrorValue READ defaultHintErrorValue CONSTANT)
    /**
      Get Treat use of hint as error
    */
    static
    bool hintError()
    {
      return self()->mHintError;
    }

    /**
      Is Treat use of hint as error Immutable
    */
    static
    bool isHintErrorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "HintError" ) );
    }

    /**
      Get Treat use of hint as error default value
    */
    static
    bool defaultHintErrorValue()
    {
        return defaultHintErrorValue_helper();
    }

    /**
      Set Compare answers in a case sensitive way
    */
    static
    void setCaseSensitiveAnswers( bool v )
    {
      if (v != self()->mCaseSensitiveAnswers && !self()->isCaseSensitiveAnswersImmutable()) {
        self()->mCaseSensitiveAnswers = v;
        Q_EMIT self()->CaseSensitiveAnswersChanged();
      }
    }

    Q_PROPERTY(bool caseSensitiveAnswers READ caseSensitiveAnswers WRITE setCaseSensitiveAnswers NOTIFY CaseSensitiveAnswersChanged)
    Q_PROPERTY(bool isCaseSensitiveAnswersImmutable READ isCaseSensitiveAnswersImmutable CONSTANT)
    Q_PROPERTY(bool defaultCaseSensitiveAnswersValue READ defaultCaseSensitiveAnswersValue CONSTANT)
    /**
      Get Compare answers in a case sensitive way
    */
    static
    bool caseSensitiveAnswers()
    {
      return self()->mCaseSensitiveAnswers;
    }

    /**
      Is Compare answers in a case sensitive way Immutable
    */
    static
    bool isCaseSensitiveAnswersImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CaseSensitiveAnswers" ) );
    }

    /**
      Get Compare answers in a case sensitive way default value
    */
    static
    bool defaultCaseSensitiveAnswersValue()
    {
        return defaultCaseSensitiveAnswersValue_helper();
    }

    /**
      Set Count flashcard as correct or error
    */
    static
    void setKeepDiscard( int v )
    {
      if (v != self()->mKeepDiscard && !self()->isKeepDiscardImmutable()) {
        self()->mKeepDiscard = v;
        Q_EMIT self()->KeepDiscardChanged();
      }
    }

    Q_PROPERTY(int keepDiscard READ keepDiscard WRITE setKeepDiscard NOTIFY KeepDiscardChanged)
    Q_PROPERTY(bool isKeepDiscardImmutable READ isKeepDiscardImmutable CONSTANT)
    Q_PROPERTY(int defaultKeepDiscardValue READ defaultKeepDiscardValue CONSTANT)
    /**
      Get Count flashcard as correct or error
    */
    static
    int keepDiscard()
    {
      return self()->mKeepDiscard;
    }

    /**
      Is Count flashcard as correct or error Immutable
    */
    static
    bool isKeepDiscardImmutable()
    {
      return self()->isImmutable( QStringLiteral( "KeepDiscard" ) );
    }

    /**
      Get Count flashcard as correct or error default value
    */
    static
    int defaultKeepDiscardValue()
    {
        return defaultKeepDiscardValue_helper();
    }

    /**
      Set The left column is considered as a question
    */
    static
    void setQuestionInLeftColumn( bool v )
    {
      if (v != self()->mQuestionInLeftColumn && !self()->isQuestionInLeftColumnImmutable()) {
        self()->mQuestionInLeftColumn = v;
        Q_EMIT self()->QuestionInLeftColumnChanged();
      }
    }

    Q_PROPERTY(bool questionInLeftColumn READ questionInLeftColumn WRITE setQuestionInLeftColumn NOTIFY QuestionInLeftColumnChanged)
    Q_PROPERTY(bool isQuestionInLeftColumnImmutable READ isQuestionInLeftColumnImmutable CONSTANT)
    Q_PROPERTY(bool defaultQuestionInLeftColumnValue READ defaultQuestionInLeftColumnValue CONSTANT)
    /**
      Get The left column is considered as a question
    */
    static
    bool questionInLeftColumn()
    {
      return self()->mQuestionInLeftColumn;
    }

    /**
      Is The left column is considered as a question Immutable
    */
    static
    bool isQuestionInLeftColumnImmutable()
    {
      return self()->isImmutable( QStringLiteral( "QuestionInLeftColumn" ) );
    }

    /**
      Get The left column is considered as a question default value
    */
    static
    bool defaultQuestionInLeftColumnValue()
    {
        return defaultQuestionInLeftColumnValue_helper();
    }

    /**
      Set The right column is considered as a question
    */
    static
    void setQuestionInRightColumn( bool v )
    {
      if (v != self()->mQuestionInRightColumn && !self()->isQuestionInRightColumnImmutable()) {
        self()->mQuestionInRightColumn = v;
        Q_EMIT self()->QuestionInRightColumnChanged();
      }
    }

    Q_PROPERTY(bool questionInRightColumn READ questionInRightColumn WRITE setQuestionInRightColumn NOTIFY QuestionInRightColumnChanged)
    Q_PROPERTY(bool isQuestionInRightColumnImmutable READ isQuestionInRightColumnImmutable CONSTANT)
    Q_PROPERTY(bool defaultQuestionInRightColumnValue READ defaultQuestionInRightColumnValue CONSTANT)
    /**
      Get The right column is considered as a question
    */
    static
    bool questionInRightColumn()
    {
      return self()->mQuestionInRightColumn;
    }

    /**
      Is The right column is considered as a question Immutable
    */
    static
    bool isQuestionInRightColumnImmutable()
    {
      return self()->isImmutable( QStringLiteral( "QuestionInRightColumn" ) );
    }

    /**
      Get The right column is considered as a question default value
    */
    static
    bool defaultQuestionInRightColumnValue()
    {
        return defaultQuestionInRightColumnValue_helper();
    }

    /**
      Set The right column is considered as a question
    */
    static
    void setRandomize( bool v )
    {
      if (v != self()->mRandomize && !self()->isRandomizeImmutable()) {
        self()->mRandomize = v;
        Q_EMIT self()->RandomizeChanged();
      }
    }

    Q_PROPERTY(bool randomize READ randomize WRITE setRandomize NOTIFY RandomizeChanged)
    Q_PROPERTY(bool isRandomizeImmutable READ isRandomizeImmutable CONSTANT)
    Q_PROPERTY(bool defaultRandomizeValue READ defaultRandomizeValue CONSTANT)
    /**
      Get The right column is considered as a question
    */
    static
    bool randomize()
    {
      return self()->mRandomize;
    }

    /**
      Is The right column is considered as a question Immutable
    */
    static
    bool isRandomizeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Randomize" ) );
    }

    /**
      Get The right column is considered as a question default value
    */
    static
    bool defaultRandomizeValue()
    {
        return defaultRandomizeValue_helper();
    }

    /**
      Set Show score as percentage
    */
    static
    void setPercent( bool v )
    {
      if (v != self()->mPercent && !self()->isPercentImmutable()) {
        self()->mPercent = v;
        Q_EMIT self()->PercentChanged();
      }
    }

    Q_PROPERTY(bool percent READ percent WRITE setPercent NOTIFY PercentChanged)
    Q_PROPERTY(bool isPercentImmutable READ isPercentImmutable CONSTANT)
    Q_PROPERTY(bool defaultPercentValue READ defaultPercentValue CONSTANT)
    /**
      Get Show score as percentage
    */
    static
    bool percent()
    {
      return self()->mPercent;
    }

    /**
      Is Show score as percentage Immutable
    */
    static
    bool isPercentImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Percent" ) );
    }

    /**
      Get Show score as percentage default value
    */
    static
    bool defaultPercentValue()
    {
        return defaultPercentValue_helper();
    }

    /**
      Set Font used for front of flashcard
    */
    static
    void setFrontFont( const QFont & v )
    {
      if (v != self()->mFrontFont && !self()->isFrontFontImmutable()) {
        self()->mFrontFont = v;
        Q_EMIT self()->FrontFontChanged();
      }
    }

    Q_PROPERTY(QFont frontFont READ frontFont WRITE setFrontFont NOTIFY FrontFontChanged)
    Q_PROPERTY(bool isFrontFontImmutable READ isFrontFontImmutable CONSTANT)
    Q_PROPERTY(QFont defaultFrontFontValue READ defaultFrontFontValue CONSTANT)
    /**
      Get Font used for front of flashcard
    */
    static
    QFont frontFont()
    {
      return self()->mFrontFont;
    }

    /**
      Is Font used for front of flashcard Immutable
    */
    static
    bool isFrontFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "FrontFont" ) );
    }

    /**
      Get Font used for front of flashcard default value
    */
    static
    QFont defaultFrontFontValue()
    {
        return defaultFrontFontValue_helper();
    }

    /**
      Set Color used for text on front of flashcard
    */
    static
    void setFrontTextColor( const QColor & v )
    {
      if (v != self()->mFrontTextColor && !self()->isFrontTextColorImmutable()) {
        self()->mFrontTextColor = v;
        Q_EMIT self()->FrontTextColorChanged();
      }
    }

    Q_PROPERTY(QColor frontTextColor READ frontTextColor WRITE setFrontTextColor NOTIFY FrontTextColorChanged)
    Q_PROPERTY(bool isFrontTextColorImmutable READ isFrontTextColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultFrontTextColorValue READ defaultFrontTextColorValue CONSTANT)
    /**
      Get Color used for text on front of flashcard
    */
    static
    QColor frontTextColor()
    {
      return self()->mFrontTextColor;
    }

    /**
      Is Color used for text on front of flashcard Immutable
    */
    static
    bool isFrontTextColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "FrontTextColor" ) );
    }

    /**
      Get Color used for text on front of flashcard default value
    */
    static
    QColor defaultFrontTextColorValue()
    {
        return defaultFrontTextColorValue_helper();
    }

    /**
      Set Color used for front of flashcard
    */
    static
    void setFrontCardColor( const QColor & v )
    {
      if (v != self()->mFrontCardColor && !self()->isFrontCardColorImmutable()) {
        self()->mFrontCardColor = v;
        Q_EMIT self()->FrontCardColorChanged();
      }
    }

    Q_PROPERTY(QColor frontCardColor READ frontCardColor WRITE setFrontCardColor NOTIFY FrontCardColorChanged)
    Q_PROPERTY(bool isFrontCardColorImmutable READ isFrontCardColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultFrontCardColorValue READ defaultFrontCardColorValue CONSTANT)
    /**
      Get Color used for front of flashcard
    */
    static
    QColor frontCardColor()
    {
      return self()->mFrontCardColor;
    }

    /**
      Is Color used for front of flashcard Immutable
    */
    static
    bool isFrontCardColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "FrontCardColor" ) );
    }

    /**
      Get Color used for front of flashcard default value
    */
    static
    QColor defaultFrontCardColorValue()
    {
        return defaultFrontCardColorValue_helper();
    }

    /**
      Set Color used for frame on front of flashcard
    */
    static
    void setFrontFrameColor( const QColor & v )
    {
      if (v != self()->mFrontFrameColor && !self()->isFrontFrameColorImmutable()) {
        self()->mFrontFrameColor = v;
        Q_EMIT self()->FrontFrameColorChanged();
      }
    }

    Q_PROPERTY(QColor frontFrameColor READ frontFrameColor WRITE setFrontFrameColor NOTIFY FrontFrameColorChanged)
    Q_PROPERTY(bool isFrontFrameColorImmutable READ isFrontFrameColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultFrontFrameColorValue READ defaultFrontFrameColorValue CONSTANT)
    /**
      Get Color used for frame on front of flashcard
    */
    static
    QColor frontFrameColor()
    {
      return self()->mFrontFrameColor;
    }

    /**
      Is Color used for frame on front of flashcard Immutable
    */
    static
    bool isFrontFrameColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "FrontFrameColor" ) );
    }

    /**
      Get Color used for frame on front of flashcard default value
    */
    static
    QColor defaultFrontFrameColorValue()
    {
        return defaultFrontFrameColorValue_helper();
    }

    /**
      Set Font used for back of flashcard
    */
    static
    void setBackFont( const QFont & v )
    {
      if (v != self()->mBackFont && !self()->isBackFontImmutable()) {
        self()->mBackFont = v;
        Q_EMIT self()->BackFontChanged();
      }
    }

    Q_PROPERTY(QFont backFont READ backFont WRITE setBackFont NOTIFY BackFontChanged)
    Q_PROPERTY(bool isBackFontImmutable READ isBackFontImmutable CONSTANT)
    Q_PROPERTY(QFont defaultBackFontValue READ defaultBackFontValue CONSTANT)
    /**
      Get Font used for back of flashcard
    */
    static
    QFont backFont()
    {
      return self()->mBackFont;
    }

    /**
      Is Font used for back of flashcard Immutable
    */
    static
    bool isBackFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "BackFont" ) );
    }

    /**
      Get Font used for back of flashcard default value
    */
    static
    QFont defaultBackFontValue()
    {
        return defaultBackFontValue_helper();
    }

    /**
      Set Color used for text on back of flashcard
    */
    static
    void setBackTextColor( const QColor & v )
    {
      if (v != self()->mBackTextColor && !self()->isBackTextColorImmutable()) {
        self()->mBackTextColor = v;
        Q_EMIT self()->BackTextColorChanged();
      }
    }

    Q_PROPERTY(QColor backTextColor READ backTextColor WRITE setBackTextColor NOTIFY BackTextColorChanged)
    Q_PROPERTY(bool isBackTextColorImmutable READ isBackTextColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultBackTextColorValue READ defaultBackTextColorValue CONSTANT)
    /**
      Get Color used for text on back of flashcard
    */
    static
    QColor backTextColor()
    {
      return self()->mBackTextColor;
    }

    /**
      Is Color used for text on back of flashcard Immutable
    */
    static
    bool isBackTextColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "BackTextColor" ) );
    }

    /**
      Get Color used for text on back of flashcard default value
    */
    static
    QColor defaultBackTextColorValue()
    {
        return defaultBackTextColorValue_helper();
    }

    /**
      Set Color used for back of flashcard
    */
    static
    void setBackCardColor( const QColor & v )
    {
      if (v != self()->mBackCardColor && !self()->isBackCardColorImmutable()) {
        self()->mBackCardColor = v;
        Q_EMIT self()->BackCardColorChanged();
      }
    }

    Q_PROPERTY(QColor backCardColor READ backCardColor WRITE setBackCardColor NOTIFY BackCardColorChanged)
    Q_PROPERTY(bool isBackCardColorImmutable READ isBackCardColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultBackCardColorValue READ defaultBackCardColorValue CONSTANT)
    /**
      Get Color used for back of flashcard
    */
    static
    QColor backCardColor()
    {
      return self()->mBackCardColor;
    }

    /**
      Is Color used for back of flashcard Immutable
    */
    static
    bool isBackCardColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "BackCardColor" ) );
    }

    /**
      Get Color used for back of flashcard default value
    */
    static
    QColor defaultBackCardColorValue()
    {
        return defaultBackCardColorValue_helper();
    }

    /**
      Set Color used for frame on back of flashcard
    */
    static
    void setBackFrameColor( const QColor & v )
    {
      if (v != self()->mBackFrameColor && !self()->isBackFrameColorImmutable()) {
        self()->mBackFrameColor = v;
        Q_EMIT self()->BackFrameColorChanged();
      }
    }

    Q_PROPERTY(QColor backFrameColor READ backFrameColor WRITE setBackFrameColor NOTIFY BackFrameColorChanged)
    Q_PROPERTY(bool isBackFrameColorImmutable READ isBackFrameColorImmutable CONSTANT)
    Q_PROPERTY(QColor defaultBackFrameColorValue READ defaultBackFrameColorValue CONSTANT)
    /**
      Get Color used for frame on back of flashcard
    */
    static
    QColor backFrameColor()
    {
      return self()->mBackFrameColor;
    }

    /**
      Is Color used for frame on back of flashcard Immutable
    */
    static
    bool isBackFrameColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "BackFrameColor" ) );
    }

    /**
      Get Color used for frame on back of flashcard default value
    */
    static
    QColor defaultBackFrameColorValue()
    {
        return defaultBackFrameColorValue_helper();
    }

    /**
      Set The Providers path for KWordQuiz
    */
    static
    void setProvidersUrl( const QString & v )
    {
      if (v != self()->mProvidersUrl && !self()->isProvidersUrlImmutable()) {
        self()->mProvidersUrl = v;
        Q_EMIT self()->ProvidersUrlChanged();
      }
    }

    Q_PROPERTY(QString providersUrl READ providersUrl WRITE setProvidersUrl NOTIFY ProvidersUrlChanged)
    Q_PROPERTY(bool isProvidersUrlImmutable READ isProvidersUrlImmutable CONSTANT)
    Q_PROPERTY(QString defaultProvidersUrlValue READ defaultProvidersUrlValue CONSTANT)
    /**
      Get The Providers path for KWordQuiz
    */
    static
    QString providersUrl()
    {
      return self()->mProvidersUrl;
    }

    /**
      Is The Providers path for KWordQuiz Immutable
    */
    static
    bool isProvidersUrlImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ProvidersUrl" ) );
    }

    /**
      Get The Providers path for KWordQuiz default value
    */
    static
    QString defaultProvidersUrlValue()
    {
        return defaultProvidersUrlValue_helper();
    }

    /**
      Set The command used to start a downloaded vocabulary
    */
    static
    void setInstallationCommand( const QString & v )
    {
      if (v != self()->mInstallationCommand && !self()->isInstallationCommandImmutable()) {
        self()->mInstallationCommand = v;
        Q_EMIT self()->InstallationCommandChanged();
      }
    }

    Q_PROPERTY(QString installationCommand READ installationCommand WRITE setInstallationCommand NOTIFY InstallationCommandChanged)
    Q_PROPERTY(bool isInstallationCommandImmutable READ isInstallationCommandImmutable CONSTANT)
    Q_PROPERTY(QString defaultInstallationCommandValue READ defaultInstallationCommandValue CONSTANT)
    /**
      Get The command used to start a downloaded vocabulary
    */
    static
    QString installationCommand()
    {
      return self()->mInstallationCommand;
    }

    /**
      Is The command used to start a downloaded vocabulary Immutable
    */
    static
    bool isInstallationCommandImmutable()
    {
      return self()->isImmutable( QStringLiteral( "InstallationCommand" ) );
    }

    /**
      Get The command used to start a downloaded vocabulary default value
    */
    static
    QString defaultInstallationCommandValue()
    {
        return defaultInstallationCommandValue_helper();
    }

    /**
      Set The folder where downloaded vocabularies are saved by default (relative to $HOME)
    */
    static
    void setInstallPath( const QString & v )
    {
      if (v != self()->mInstallPath && !self()->isInstallPathImmutable()) {
        self()->mInstallPath = v;
        Q_EMIT self()->InstallPathChanged();
      }
    }

    Q_PROPERTY(QString installPath READ installPath WRITE setInstallPath NOTIFY InstallPathChanged)
    Q_PROPERTY(bool isInstallPathImmutable READ isInstallPathImmutable CONSTANT)
    Q_PROPERTY(QString defaultInstallPathValue READ defaultInstallPathValue CONSTANT)
    /**
      Get The folder where downloaded vocabularies are saved by default (relative to $HOME)
    */
    static
    QString installPath()
    {
      return self()->mInstallPath;
    }

    /**
      Is The folder where downloaded vocabularies are saved by default (relative to $HOME) Immutable
    */
    static
    bool isInstallPathImmutable()
    {
      return self()->isImmutable( QStringLiteral( "InstallPath" ) );
    }

    /**
      Get The folder where downloaded vocabularies are saved by default (relative to $HOME) default value
    */
    static
    QString defaultInstallPathValue()
    {
        return defaultInstallPathValue_helper();
    }

    /**
      Set Pop up flashcards at fixed or random intervals
    */
    static
    void setTutorTiming( int v )
    {
      if (v != self()->mTutorTiming && !self()->isTutorTimingImmutable()) {
        self()->mTutorTiming = v;
        Q_EMIT self()->TutorTimingChanged();
      }
    }

    Q_PROPERTY(int tutorTiming READ tutorTiming WRITE setTutorTiming NOTIFY TutorTimingChanged)
    Q_PROPERTY(bool isTutorTimingImmutable READ isTutorTimingImmutable CONSTANT)
    Q_PROPERTY(int defaultTutorTimingValue READ defaultTutorTimingValue CONSTANT)
    /**
      Get Pop up flashcards at fixed or random intervals
    */
    static
    int tutorTiming()
    {
      return self()->mTutorTiming;
    }

    /**
      Is Pop up flashcards at fixed or random intervals Immutable
    */
    static
    bool isTutorTimingImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TutorTiming" ) );
    }

    /**
      Get Pop up flashcards at fixed or random intervals default value
    */
    static
    int defaultTutorTimingValue()
    {
        return defaultTutorTimingValue_helper();
    }

    /**
      Set The interval in minutes at which to pop up a flash card
    */
    static
    void setTutorEvery( int v )
    {
      if (v != self()->mTutorEvery && !self()->isTutorEveryImmutable()) {
        self()->mTutorEvery = v;
        Q_EMIT self()->TutorEveryChanged();
      }
    }

    Q_PROPERTY(int tutorEvery READ tutorEvery WRITE setTutorEvery NOTIFY TutorEveryChanged)
    Q_PROPERTY(bool isTutorEveryImmutable READ isTutorEveryImmutable CONSTANT)
    Q_PROPERTY(int defaultTutorEveryValue READ defaultTutorEveryValue CONSTANT)
    /**
      Get The interval in minutes at which to pop up a flash card
    */
    static
    int tutorEvery()
    {
      return self()->mTutorEvery;
    }

    /**
      Is The interval in minutes at which to pop up a flash card Immutable
    */
    static
    bool isTutorEveryImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TutorEvery" ) );
    }

    /**
      Get The interval in minutes at which to pop up a flash card default value
    */
    static
    int defaultTutorEveryValue()
    {
        return defaultTutorEveryValue_helper();
    }

    /**
      Set The minimum interval in minutes at which to pop up a flash card
    */
    static
    void setTutorMin( int v )
    {
      if (v != self()->mTutorMin && !self()->isTutorMinImmutable()) {
        self()->mTutorMin = v;
        Q_EMIT self()->TutorMinChanged();
      }
    }

    Q_PROPERTY(int tutorMin READ tutorMin WRITE setTutorMin NOTIFY TutorMinChanged)
    Q_PROPERTY(bool isTutorMinImmutable READ isTutorMinImmutable CONSTANT)
    Q_PROPERTY(int defaultTutorMinValue READ defaultTutorMinValue CONSTANT)
    /**
      Get The minimum interval in minutes at which to pop up a flash card
    */
    static
    int tutorMin()
    {
      return self()->mTutorMin;
    }

    /**
      Is The minimum interval in minutes at which to pop up a flash card Immutable
    */
    static
    bool isTutorMinImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TutorMin" ) );
    }

    /**
      Get The minimum interval in minutes at which to pop up a flash card default value
    */
    static
    int defaultTutorMinValue()
    {
        return defaultTutorMinValue_helper();
    }

    /**
      Set The maximum interval in minutes at which to pop up a flash card
    */
    static
    void setTutorMax( int v )
    {
      if (v != self()->mTutorMax && !self()->isTutorMaxImmutable()) {
        self()->mTutorMax = v;
        Q_EMIT self()->TutorMaxChanged();
      }
    }

    Q_PROPERTY(int tutorMax READ tutorMax WRITE setTutorMax NOTIFY TutorMaxChanged)
    Q_PROPERTY(bool isTutorMaxImmutable READ isTutorMaxImmutable CONSTANT)
    Q_PROPERTY(int defaultTutorMaxValue READ defaultTutorMaxValue CONSTANT)
    /**
      Get The maximum interval in minutes at which to pop up a flash card
    */
    static
    int tutorMax()
    {
      return self()->mTutorMax;
    }

    /**
      Is The maximum interval in minutes at which to pop up a flash card Immutable
    */
    static
    bool isTutorMaxImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TutorMax" ) );
    }

    /**
      Get The maximum interval in minutes at which to pop up a flash card default value
    */
    static
    int defaultTutorMaxValue()
    {
        return defaultTutorMaxValue_helper();
    }

    /**
      Set Geometry of the last flash card
    */
    static
    void setTutorFlashCardGeometry( const QRect & v )
    {
      if (v != self()->mTutorFlashCardGeometry && !self()->isTutorFlashCardGeometryImmutable()) {
        self()->mTutorFlashCardGeometry = v;
        Q_EMIT self()->TutorFlashCardGeometryChanged();
      }
    }

    Q_PROPERTY(QRect tutorFlashCardGeometry READ tutorFlashCardGeometry WRITE setTutorFlashCardGeometry NOTIFY TutorFlashCardGeometryChanged)
    Q_PROPERTY(bool isTutorFlashCardGeometryImmutable READ isTutorFlashCardGeometryImmutable CONSTANT)
    Q_PROPERTY(QRect defaultTutorFlashCardGeometryValue READ defaultTutorFlashCardGeometryValue CONSTANT)
    /**
      Get Geometry of the last flash card
    */
    static
    QRect tutorFlashCardGeometry()
    {
      return self()->mTutorFlashCardGeometry;
    }

    /**
      Is Geometry of the last flash card Immutable
    */
    static
    bool isTutorFlashCardGeometryImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TutorFlashCardGeometry" ) );
    }

    /**
      Get Geometry of the last flash card default value
    */
    static
    QRect defaultTutorFlashCardGeometryValue()
    {
        return defaultTutorFlashCardGeometryValue_helper();
    }

    /**
      Set Show flash card in a native KWordQuiz style
    */
    static
    void setTutorCardAppearance( int v )
    {
      if (v != self()->mTutorCardAppearance && !self()->isTutorCardAppearanceImmutable()) {
        self()->mTutorCardAppearance = v;
        Q_EMIT self()->TutorCardAppearanceChanged();
      }
    }

    Q_PROPERTY(int tutorCardAppearance READ tutorCardAppearance WRITE setTutorCardAppearance NOTIFY TutorCardAppearanceChanged)
    Q_PROPERTY(bool isTutorCardAppearanceImmutable READ isTutorCardAppearanceImmutable CONSTANT)
    Q_PROPERTY(int defaultTutorCardAppearanceValue READ defaultTutorCardAppearanceValue CONSTANT)
    /**
      Get Show flash card in a native KWordQuiz style
    */
    static
    int tutorCardAppearance()
    {
      return self()->mTutorCardAppearance;
    }

    /**
      Is Show flash card in a native KWordQuiz style Immutable
    */
    static
    bool isTutorCardAppearanceImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TutorCardAppearance" ) );
    }

    /**
      Get Show flash card in a native KWordQuiz style default value
    */
    static
    int defaultTutorCardAppearanceValue()
    {
        return defaultTutorCardAppearanceValue_helper();
    }

    /**
      Set Last open vocabulary file to be opened automatically if none other is specified on the command line
    */
    static
    void setLastVocabFile( const QString & v )
    {
      if (v != self()->mLastVocabFile && !self()->isLastVocabFileImmutable()) {
        self()->mLastVocabFile = v;
        Q_EMIT self()->LastVocabFileChanged();
      }
    }

    Q_PROPERTY(QString lastVocabFile READ lastVocabFile WRITE setLastVocabFile NOTIFY LastVocabFileChanged)
    Q_PROPERTY(bool isLastVocabFileImmutable READ isLastVocabFileImmutable CONSTANT)
    /**
      Get Last open vocabulary file to be opened automatically if none other is specified on the command line
    */
    static
    QString lastVocabFile()
    {
      return self()->mLastVocabFile;
    }

    /**
      Is Last open vocabulary file to be opened automatically if none other is specified on the command line Immutable
    */
    static
    bool isLastVocabFileImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LastVocabFile" ) );
    }

    /**
      Set Start exercise as soon as the user opens vocabulary file
    */
    static
    void setStartExerciseAsSoonAsFileIsLoaded( bool v )
    {
      if (v != self()->mStartExerciseAsSoonAsFileIsLoaded && !self()->isStartExerciseAsSoonAsFileIsLoadedImmutable()) {
        self()->mStartExerciseAsSoonAsFileIsLoaded = v;
        Q_EMIT self()->StartExerciseAsSoonAsFileIsLoadedChanged();
      }
    }

    Q_PROPERTY(bool startExerciseAsSoonAsFileIsLoaded READ startExerciseAsSoonAsFileIsLoaded WRITE setStartExerciseAsSoonAsFileIsLoaded NOTIFY StartExerciseAsSoonAsFileIsLoadedChanged)
    Q_PROPERTY(bool isStartExerciseAsSoonAsFileIsLoadedImmutable READ isStartExerciseAsSoonAsFileIsLoadedImmutable CONSTANT)
    Q_PROPERTY(bool defaultStartExerciseAsSoonAsFileIsLoadedValue READ defaultStartExerciseAsSoonAsFileIsLoadedValue CONSTANT)
    /**
      Get Start exercise as soon as the user opens vocabulary file
    */
    static
    bool startExerciseAsSoonAsFileIsLoaded()
    {
      return self()->mStartExerciseAsSoonAsFileIsLoaded;
    }

    /**
      Is Start exercise as soon as the user opens vocabulary file Immutable
    */
    static
    bool isStartExerciseAsSoonAsFileIsLoadedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "StartExerciseAsSoonAsFileIsLoaded" ) );
    }

    /**
      Get Start exercise as soon as the user opens vocabulary file default value
    */
    static
    bool defaultStartExerciseAsSoonAsFileIsLoadedValue()
    {
        return defaultStartExerciseAsSoonAsFileIsLoadedValue_helper();
    }


    enum {
      signalFirstRunChanged = 1,
      signalShowSearchChanged = 2,
      signalStartSessionChanged = 3,
      signalEnableBlanksChanged = 4,
      signalEnterMoveChanged = 5,
      signalSpecialCharactersChanged = 6,
      signalClearAllChanged = 7,
      signalClearTextChanged = 8,
      signalClearImageLinkChanged = 9,
      signalClearSoundLinkChanged = 10,
      signalAutoCheckChanged = 11,
      signalAutoFlipChanged = 12,
      signalFlipDelayChanged = 13,
      signalHintErrorChanged = 14,
      signalCaseSensitiveAnswersChanged = 15,
      signalKeepDiscardChanged = 16,
      signalQuestionInLeftColumnChanged = 17,
      signalQuestionInRightColumnChanged = 18,
      signalRandomizeChanged = 19,
      signalPercentChanged = 20,
      signalFrontFontChanged = 21,
      signalFrontTextColorChanged = 22,
      signalFrontCardColorChanged = 23,
      signalFrontFrameColorChanged = 24,
      signalBackFontChanged = 25,
      signalBackTextColorChanged = 26,
      signalBackCardColorChanged = 27,
      signalBackFrameColorChanged = 28,
      signalProvidersUrlChanged = 29,
      signalInstallationCommandChanged = 30,
      signalInstallPathChanged = 31,
      signalTutorTimingChanged = 32,
      signalTutorEveryChanged = 33,
      signalTutorMinChanged = 34,
      signalTutorMaxChanged = 35,
      signalTutorFlashCardGeometryChanged = 36,
      signalTutorCardAppearanceChanged = 37,
      signalLastVocabFileChanged = 38,
      signalStartExerciseAsSoonAsFileIsLoadedChanged = 39
    };

  Q_SIGNALS:
    void FirstRunChanged();

    void ShowSearchChanged();

    void StartSessionChanged();

    void EnableBlanksChanged();

    void EnterMoveChanged();

    void SpecialCharactersChanged();

    void ClearAllChanged();

    void ClearTextChanged();

    void ClearImageLinkChanged();

    void ClearSoundLinkChanged();

    void AutoCheckChanged();

    void AutoFlipChanged();

    void FlipDelayChanged();

    void HintErrorChanged();

    void CaseSensitiveAnswersChanged();

    void KeepDiscardChanged();

    void QuestionInLeftColumnChanged();

    void QuestionInRightColumnChanged();

    void RandomizeChanged();

    void PercentChanged();

    void FrontFontChanged();

    void FrontTextColorChanged();

    void FrontCardColorChanged();

    void FrontFrameColorChanged();

    void BackFontChanged();

    void BackTextColorChanged();

    void BackCardColorChanged();

    void BackFrameColorChanged();

    void ProvidersUrlChanged();

    void InstallationCommandChanged();

    void InstallPathChanged();

    void TutorTimingChanged();

    void TutorEveryChanged();

    void TutorMinChanged();

    void TutorMaxChanged();

    void TutorFlashCardGeometryChanged();

    void TutorCardAppearanceChanged();

    void LastVocabFileChanged();

    void StartExerciseAsSoonAsFileIsLoadedChanged();

  private:
    void itemChanged(quint64 signalFlag);

  protected:
    Prefs(QObject *parent = nullptr);
    friend class PrefsHelper;


    // General
    bool mFirstRun;
    static bool defaultFirstRunValue_helper();
    bool mShowSearch;
    static bool defaultShowSearchValue_helper();
    int mStartSession;
    static int defaultStartSessionValue_helper();

    // Editor
    bool mEnableBlanks;
    static bool defaultEnableBlanksValue_helper();
    int mEnterMove;
    static int defaultEnterMoveValue_helper();
    QString mSpecialCharacters;
    static QString defaultSpecialCharactersValue_helper();
    bool mClearAll;
    static bool defaultClearAllValue_helper();
    bool mClearText;
    static bool defaultClearTextValue_helper();
    bool mClearImageLink;
    static bool defaultClearImageLinkValue_helper();
    bool mClearSoundLink;
    static bool defaultClearSoundLinkValue_helper();

    // Quiz
    bool mAutoCheck;
    static bool defaultAutoCheckValue_helper();
    bool mAutoFlip;
    static bool defaultAutoFlipValue_helper();
    int mFlipDelay;
    static int defaultFlipDelayValue_helper();
    bool mHintError;
    static bool defaultHintErrorValue_helper();
    bool mCaseSensitiveAnswers;
    static bool defaultCaseSensitiveAnswersValue_helper();
    int mKeepDiscard;
    static int defaultKeepDiscardValue_helper();
    bool mQuestionInLeftColumn;
    static bool defaultQuestionInLeftColumnValue_helper();
    bool mQuestionInRightColumn;
    static bool defaultQuestionInRightColumnValue_helper();
    bool mRandomize;
    static bool defaultRandomizeValue_helper();
    bool mPercent;
    static bool defaultPercentValue_helper();

    // FlashCard
    QFont mFrontFont;
    static QFont defaultFrontFontValue_helper();
    QColor mFrontTextColor;
    static QColor defaultFrontTextColorValue_helper();
    QColor mFrontCardColor;
    static QColor defaultFrontCardColorValue_helper();
    QColor mFrontFrameColor;
    static QColor defaultFrontFrameColorValue_helper();
    QFont mBackFont;
    static QFont defaultBackFontValue_helper();
    QColor mBackTextColor;
    static QColor defaultBackTextColorValue_helper();
    QColor mBackCardColor;
    static QColor defaultBackCardColorValue_helper();
    QColor mBackFrameColor;
    static QColor defaultBackFrameColorValue_helper();

    // KNewStuff
    QString mProvidersUrl;
    static QString defaultProvidersUrlValue_helper();
    QString mInstallationCommand;
    static QString defaultInstallationCommandValue_helper();
    QString mInstallPath;
    static QString defaultInstallPathValue_helper();

    // Tutor
    int mTutorTiming;
    static int defaultTutorTimingValue_helper();
    int mTutorEvery;
    static int defaultTutorEveryValue_helper();
    int mTutorMin;
    static int defaultTutorMinValue_helper();
    int mTutorMax;
    static int defaultTutorMaxValue_helper();
    QRect mTutorFlashCardGeometry;
    static QRect defaultTutorFlashCardGeometryValue_helper();
    int mTutorCardAppearance;
    static int defaultTutorCardAppearanceValue_helper();
    QString mLastVocabFile;
    static QString defaultLastVocabFileValue_helper();
    bool mStartExerciseAsSoonAsFileIsLoaded;
    static bool defaultStartExerciseAsSoonAsFileIsLoadedValue_helper();
};

#endif

