// This file is generated by kconfig_compiler_kf6 from parley.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 <qfontdatabase.h>

class Prefs : public KConfigSkeleton
{
  public:
    class EnumPracticeTimeoutMode
    {
      public:
      enum type { Show, Continue, COUNT };
    };
    class EnumLessonEditingSelection
    {
      public:
      enum type { CurrentLesson, LessonsInQuery, AllLessons, UserFiltered, COUNT };
    };
    class EnumPracticeMode
    {
      public:
      enum type { FlashCardsPractice, MixedLettersPractice, MultipleChoicePractice, WrittenPractice, ExampleSentencesPractice, GenderPractice, ComparisonPractice, ConjugationPractice, COUNT };
    };
    class EnumPracticeDirection
    {
      public:
      enum type { KnownToLearning, LearningToKnown, MixedDirectionsWordsOnly, MixedDirectionsWithSound, COUNT };
    };

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

    /**
      Set Theme to use for practice and welcome screen
    */
    static
    void setTheme( const QString & v )
    {
      if (!self()->isThemeImmutable())
        self()->mTheme = v;
    }

    /**
      Get Theme to use for practice and welcome screen
    */
    static
    QString theme()
    {
      return self()->mTheme;
    }

    /**
      Is Theme to use for practice and welcome screen Immutable
    */
    static
    bool isThemeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Theme" ) );
    }

    /**
      Set Number of stored setting profiles
    */
    static
    void setNumPreSetting( int v )
    {
      if (!self()->isNumPreSettingImmutable())
        self()->mNumPreSetting = v;
    }

    /**
      Get Number of stored setting profiles
    */
    static
    int numPreSetting()
    {
      return self()->mNumPreSetting;
    }

    /**
      Is Number of stored setting profiles Immutable
    */
    static
    bool isNumPreSettingImmutable()
    {
      return self()->isImmutable( QStringLiteral( "NumPreSetting" ) );
    }

    /**
      Set If true, when using the entry dialog, new rows will be appended as needed
    */
    static
    void setSmartAppend( bool v )
    {
      if (!self()->isSmartAppendImmutable())
        self()->mSmartAppend = v;
    }

    /**
      Get If true, when using the entry dialog, new rows will be appended as needed
    */
    static
    bool smartAppend()
    {
      return self()->mSmartAppend;
    }

    /**
      Is If true, when using the entry dialog, new rows will be appended as needed Immutable
    */
    static
    bool isSmartAppendImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SmartAppend" ) );
    }

    /**
      Set This sets the separator used when copying/pasting text, default is Tab
    */
    static
    void setSeparator( const QString & v )
    {
      if (!self()->isSeparatorImmutable())
        self()->mSeparator = v;
    }

    /**
      Get This sets the separator used when copying/pasting text, default is Tab
    */
    static
    QString separator()
    {
      return self()->mSeparator;
    }

    /**
      Is This sets the separator used when copying/pasting text, default is Tab Immutable
    */
    static
    bool isSeparatorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Separator" ) );
    }

    /**
      Set The number of entries per unit
    */
    static
    void setEntriesPerLesson( int v )
    {
      if (!self()->isEntriesPerLessonImmutable())
        self()->mEntriesPerLesson = v;
    }

    /**
      Get The number of entries per unit
    */
    static
    int entriesPerLesson()
    {
      return self()->mEntriesPerLesson;
    }

    /**
      Is The number of entries per unit Immutable
    */
    static
    bool isEntriesPerLessonImmutable()
    {
      return self()->isImmutable( QStringLiteral( "EntriesPerLesson" ) );
    }

    /**
      Set If true, on each application start the last opened file will be loaded
    */
    static
    void setAutoOpenLast( bool v )
    {
      if (!self()->isAutoOpenLastImmutable())
        self()->mAutoOpenLast = v;
    }

    /**
      Get If true, on each application start the last opened file will be loaded
    */
    static
    bool autoOpenLast()
    {
      return self()->mAutoOpenLast;
    }

    /**
      Is If true, on each application start the last opened file will be loaded Immutable
    */
    static
    bool isAutoOpenLastImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoOpenLast" ) );
    }

    /**
      Set If true, vocabularies are automatically saved on close and exit
    */
    static
    void setAutoSave( bool v )
    {
      if (!self()->isAutoSaveImmutable())
        self()->mAutoSave = v;
    }

    /**
      Get If true, vocabularies are automatically saved on close and exit
    */
    static
    bool autoSave()
    {
      return self()->mAutoSave;
    }

    /**
      Is If true, vocabularies are automatically saved on close and exit Immutable
    */
    static
    bool isAutoSaveImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoSave" ) );
    }

    /**
      Set SeparatorCombo
    */
    static
    void setSeparatorCombo( int v )
    {
      if (!self()->isSeparatorComboImmutable())
        self()->mSeparatorCombo = v;
    }

    /**
      Get SeparatorCombo
    */
    static
    int separatorCombo()
    {
      return self()->mSeparatorCombo;
    }

    /**
      Is SeparatorCombo Immutable
    */
    static
    bool isSeparatorComboImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SeparatorCombo" ) );
    }

    /**
      Set If true, a backup is saved every BackupTime minutes
    */
    static
    void setAutoBackup( bool v )
    {
      if (!self()->isAutoBackupImmutable())
        self()->mAutoBackup = v;
    }

    /**
      Get If true, a backup is saved every BackupTime minutes
    */
    static
    bool autoBackup()
    {
      return self()->mAutoBackup;
    }

    /**
      Is If true, a backup is saved every BackupTime minutes Immutable
    */
    static
    bool isAutoBackupImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoBackup" ) );
    }

    /**
      Set Time interval between two automatic backups
    */
    static
    void setBackupTime( int v )
    {
      if (!self()->isBackupTimeImmutable())
        self()->mBackupTime = v;
    }

    /**
      Get Time interval between two automatic backups
    */
    static
    int backupTime()
    {
      return self()->mBackupTime;
    }

    /**
      Is Time interval between two automatic backups Immutable
    */
    static
    bool isBackupTimeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "BackupTime" ) );
    }

    /**
      Set Enable automatic translation of the unit entries.
    */
    static
    void setAutomaticTranslation( bool v )
    {
      if (!self()->isAutomaticTranslationImmutable())
        self()->mAutomaticTranslation = v;
    }

    /**
      Get Enable automatic translation of the unit entries.
    */
    static
    bool automaticTranslation()
    {
      return self()->mAutomaticTranslation;
    }

    /**
      Is Enable automatic translation of the unit entries. Immutable
    */
    static
    bool isAutomaticTranslationImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutomaticTranslation" ) );
    }

    /**
      Set Show images on the front of the flashcard.
    */
    static
    void setFlashcardsFrontImage( bool v )
    {
      if (!self()->isFlashcardsFrontImageImmutable())
        self()->mFlashcardsFrontImage = v;
    }

    /**
      Get Show images on the front of the flashcard.
    */
    static
    bool flashcardsFrontImage()
    {
      return self()->mFlashcardsFrontImage;
    }

    /**
      Is Show images on the front of the flashcard. Immutable
    */
    static
    bool isFlashcardsFrontImageImmutable()
    {
      return self()->isImmutable( QStringLiteral( "FlashcardsFrontImage" ) );
    }

    /**
      Set Show images on the back of the flashcard.
    */
    static
    void setFlashcardsBackImage( bool v )
    {
      if (!self()->isFlashcardsBackImageImmutable())
        self()->mFlashcardsBackImage = v;
    }

    /**
      Get Show images on the back of the flashcard.
    */
    static
    bool flashcardsBackImage()
    {
      return self()->mFlashcardsBackImage;
    }

    /**
      Is Show images on the back of the flashcard. Immutable
    */
    static
    bool isFlashcardsBackImageImmutable()
    {
      return self()->isImmutable( QStringLiteral( "FlashcardsBackImage" ) );
    }

    /**
      Set In Blocking Query Tab Dialog, if checked then the Query is blocked
    */
    static
    void setBlock( bool v )
    {
      if (!self()->isBlockImmutable())
        self()->mBlock = v;
    }

    /**
      Get In Blocking Query Tab Dialog, if checked then the Query is blocked
    */
    static
    bool block()
    {
      return self()->mBlock;
    }

    /**
      Is In Blocking Query Tab Dialog, if checked then the Query is blocked Immutable
    */
    static
    bool isBlockImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Block" ) );
    }

    /**
      Set In Blocking Query Tab Dialog, if checked then the Query accepts an expiring time
    */
    static
    void setExpire( bool v )
    {
      if (!self()->isExpireImmutable())
        self()->mExpire = v;
    }

    /**
      Get In Blocking Query Tab Dialog, if checked then the Query accepts an expiring time
    */
    static
    bool expire()
    {
      return self()->mExpire;
    }

    /**
      Is In Blocking Query Tab Dialog, if checked then the Query accepts an expiring time Immutable
    */
    static
    bool isExpireImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Expire" ) );
    }

    /**
      Set Append new vocabulary in a collection in order of their units. Note that this will not be a hard transition, but a slow mix from one unit to the next.
    */
    static
    void setTestOrderLesson( bool v )
    {
      if (!self()->isTestOrderLessonImmutable())
        self()->mTestOrderLesson = v;
    }

    /**
      Get Append new vocabulary in a collection in order of their units. Note that this will not be a hard transition, but a slow mix from one unit to the next.
    */
    static
    bool testOrderLesson()
    {
      return self()->mTestOrderLesson;
    }

    /**
      Is Append new vocabulary in a collection in order of their units. Note that this will not be a hard transition, but a slow mix from one unit to the next. Immutable
    */
    static
    bool isTestOrderLessonImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TestOrderLesson" ) );
    }

    /**
      Set The number of entries that are practiced at the same time. If one of these is answered correctly another entry will be appended.
    */
    static
    void setTestNumberOfEntries( int v )
    {
      if (!self()->isTestNumberOfEntriesImmutable())
        self()->mTestNumberOfEntries = v;
    }

    /**
      Get The number of entries that are practiced at the same time. If one of these is answered correctly another entry will be appended.
    */
    static
    int testNumberOfEntries()
    {
      return self()->mTestNumberOfEntries;
    }

    /**
      Is The number of entries that are practiced at the same time. If one of these is answered correctly another entry will be appended. Immutable
    */
    static
    bool isTestNumberOfEntriesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TestNumberOfEntries" ) );
    }

    /**
      Set Swap direction randomly
    */
    static
    void setSwapDirection( bool v )
    {
      if (!self()->isSwapDirectionImmutable())
        self()->mSwapDirection = v;
    }

    /**
      Get Swap direction randomly
    */
    static
    bool swapDirection()
    {
      return self()->mSwapDirection;
    }

    /**
      Is Swap direction randomly Immutable
    */
    static
    bool isSwapDirectionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SwapDirection" ) );
    }

    /**
      Set Limit the time for the user to answer in a test.
    */
    static
    void setPracticeTimeout( bool v )
    {
      if (!self()->isPracticeTimeoutImmutable())
        self()->mPracticeTimeout = v;
    }

    /**
      Get Limit the time for the user to answer in a test.
    */
    static
    bool practiceTimeout()
    {
      return self()->mPracticeTimeout;
    }

    /**
      Is Limit the time for the user to answer in a test. Immutable
    */
    static
    bool isPracticeTimeoutImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PracticeTimeout" ) );
    }

    /**
      Set Show - show the solution after the given time; Continue - go to the next question after the given time.
    */
    static
    void setPracticeTimeoutMode( EnumPracticeTimeoutMode::type v )
    {
      if (!self()->isPracticeTimeoutModeImmutable())
        self()->mPracticeTimeoutMode = v;
    }

    /**
      Get Show - show the solution after the given time; Continue - go to the next question after the given time.
    */
    static
    EnumPracticeTimeoutMode::type practiceTimeoutMode()
    {
      return static_cast<EnumPracticeTimeoutMode::type>(self()->mPracticeTimeoutMode);
    }

    /**
      Is Show - show the solution after the given time; Continue - go to the next question after the given time. Immutable
    */
    static
    bool isPracticeTimeoutModeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PracticeTimeoutMode" ) );
    }

    /**
      Set Maximum time allowed to answer.
    */
    static
    void setPracticeTimeoutTimePerAnswer( int v )
    {
      if (!self()->isPracticeTimeoutTimePerAnswerImmutable())
        self()->mPracticeTimeoutTimePerAnswer = v;
    }

    /**
      Get Maximum time allowed to answer.
    */
    static
    int practiceTimeoutTimePerAnswer()
    {
      return self()->mPracticeTimeoutTimePerAnswer;
    }

    /**
      Is Maximum time allowed to answer. Immutable
    */
    static
    bool isPracticeTimeoutTimePerAnswerImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PracticeTimeoutTimePerAnswer" ) );
    }

    /**
      Set Enable suggestion lists in written practice.
    */
    static
    void setSuggestions( bool v )
    {
      if (!self()->isSuggestionsImmutable())
        self()->mSuggestions = v;
    }

    /**
      Get Enable suggestion lists in written practice.
    */
    static
    bool suggestions()
    {
      return self()->mSuggestions;
    }

    /**
      Is Enable suggestion lists in written practice. Immutable
    */
    static
    bool isSuggestionsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Suggestions" ) );
    }

    /**
      Set Enable the showing of hints.
    */
    static
    void setShowHints( bool v )
    {
      if (!self()->isShowHintsImmutable())
        self()->mShowHints = v;
    }

    /**
      Get Enable the showing of hints.
    */
    static
    bool showHints()
    {
      return self()->mShowHints;
    }

    /**
      Is Enable the showing of hints. Immutable
    */
    static
    bool isShowHintsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowHints" ) );
    }

    /**
      Set Count answers as right when only the accentuation is wrong.
    */
    static
    void setIgnoreAccentMistakes( bool v )
    {
      if (!self()->isIgnoreAccentMistakesImmutable())
        self()->mIgnoreAccentMistakes = v;
    }

    /**
      Get Count answers as right when only the accentuation is wrong.
    */
    static
    bool ignoreAccentMistakes()
    {
      return self()->mIgnoreAccentMistakes;
    }

    /**
      Is Count answers as right when only the accentuation is wrong. Immutable
    */
    static
    bool isIgnoreAccentMistakesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "IgnoreAccentMistakes" ) );
    }

    /**
      Set Count answers as right when only the capitalization is wrong.
    */
    static
    void setIgnoreCapitalizationMistakes( bool v )
    {
      if (!self()->isIgnoreCapitalizationMistakesImmutable())
        self()->mIgnoreCapitalizationMistakes = v;
    }

    /**
      Get Count answers as right when only the capitalization is wrong.
    */
    static
    bool ignoreCapitalizationMistakes()
    {
      return self()->mIgnoreCapitalizationMistakes;
    }

    /**
      Is Count answers as right when only the capitalization is wrong. Immutable
    */
    static
    bool isIgnoreCapitalizationMistakesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "IgnoreCapitalizationMistakes" ) );
    }

    /**
      Set Count answers as right when only the punctuation is wrong.
    */
    static
    void setIgnorePunctuationMistakes( bool v )
    {
      if (!self()->isIgnorePunctuationMistakesImmutable())
        self()->mIgnorePunctuationMistakes = v;
    }

    /**
      Get Count answers as right when only the punctuation is wrong.
    */
    static
    bool ignorePunctuationMistakes()
    {
      return self()->mIgnorePunctuationMistakes;
    }

    /**
      Is Count answers as right when only the punctuation is wrong. Immutable
    */
    static
    bool isIgnorePunctuationMistakesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "IgnorePunctuationMistakes" ) );
    }

    /**
      Set Split translations in written practice.
    */
    static
    void setSplitTranslations( bool v )
    {
      if (!self()->isSplitTranslationsImmutable())
        self()->mSplitTranslations = v;
    }

    /**
      Get Split translations in written practice.
    */
    static
    bool splitTranslations()
    {
      return self()->mSplitTranslations;
    }

    /**
      Is Split translations in written practice. Immutable
    */
    static
    bool isSplitTranslationsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SplitTranslations" ) );
    }

    /**
      Set Split translations at periods.
    */
    static
    void setPeriods( bool v )
    {
      if (!self()->isPeriodsImmutable())
        self()->mPeriods = v;
    }

    /**
      Get Split translations at periods.
    */
    static
    bool periods()
    {
      return self()->mPeriods;
    }

    /**
      Is Split translations at periods. Immutable
    */
    static
    bool isPeriodsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Periods" ) );
    }

    /**
      Set Split translations at colons.
    */
    static
    void setColons( bool v )
    {
      if (!self()->isColonsImmutable())
        self()->mColons = v;
    }

    /**
      Get Split translations at colons.
    */
    static
    bool colons()
    {
      return self()->mColons;
    }

    /**
      Is Split translations at colons. Immutable
    */
    static
    bool isColonsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Colons" ) );
    }

    /**
      Set Split translations at semicolons.
    */
    static
    void setSemicolons( bool v )
    {
      if (!self()->isSemicolonsImmutable())
        self()->mSemicolons = v;
    }

    /**
      Get Split translations at semicolons.
    */
    static
    bool semicolons()
    {
      return self()->mSemicolons;
    }

    /**
      Is Split translations at semicolons. Immutable
    */
    static
    bool isSemicolonsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Semicolons" ) );
    }

    /**
      Set Split translations at commas.
    */
    static
    void setCommas( bool v )
    {
      if (!self()->isCommasImmutable())
        self()->mCommas = v;
    }

    /**
      Get Split translations at commas.
    */
    static
    bool commas()
    {
      return self()->mCommas;
    }

    /**
      Is Split translations at commas. Immutable
    */
    static
    bool isCommasImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Commas" ) );
    }

    /**
      Set Enable Show More button to reveal parts of the solution in written practice.
    */
    static
    void setShowMore( bool v )
    {
      if (!self()->isShowMoreImmutable())
        self()->mShowMore = v;
    }

    /**
      Get Enable Show More button to reveal parts of the solution in written practice.
    */
    static
    bool showMore()
    {
      return self()->mShowMore;
    }

    /**
      Is Enable Show More button to reveal parts of the solution in written practice. Immutable
    */
    static
    bool isShowMoreImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowMore" ) );
    }

    /**
      Set Enable Skip (I Know It) button in written practice.
    */
    static
    void setSkipKnownEnabled( bool v )
    {
      if (!self()->isSkipKnownEnabledImmutable())
        self()->mSkipKnownEnabled = v;
    }

    /**
      Get Enable Skip (I Know It) button in written practice.
    */
    static
    bool skipKnownEnabled()
    {
      return self()->mSkipKnownEnabled;
    }

    /**
      Is Enable Skip (I Know It) button in written practice. Immutable
    */
    static
    bool isSkipKnownEnabledImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SkipKnownEnabled" ) );
    }

    /**
      Set When the synonym instead of the word was entered, does it count as correct?
    */
    static
    void setCountSynonymsAsCorrect( bool v )
    {
      if (!self()->isCountSynonymsAsCorrectImmutable())
        self()->mCountSynonymsAsCorrect = v;
    }

    /**
      Get When the synonym instead of the word was entered, does it count as correct?
    */
    static
    bool countSynonymsAsCorrect()
    {
      return self()->mCountSynonymsAsCorrect;
    }

    /**
      Is When the synonym instead of the word was entered, does it count as correct? Immutable
    */
    static
    bool isCountSynonymsAsCorrectImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CountSynonymsAsCorrect" ) );
    }

    /**
      Set Enable image display in the practice dialogs.
    */
    static
    void setPracticeImagesEnabled( bool v )
    {
      if (!self()->isPracticeImagesEnabledImmutable())
        self()->mPracticeImagesEnabled = v;
    }

    /**
      Get Enable image display in the practice dialogs.
    */
    static
    bool practiceImagesEnabled()
    {
      return self()->mPracticeImagesEnabled;
    }

    /**
      Is Enable image display in the practice dialogs. Immutable
    */
    static
    bool isPracticeImagesEnabledImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PracticeImagesEnabled" ) );
    }

    /**
      Set Enable sound playback in the practice dialogs.
    */
    static
    void setPracticeSoundEnabled( bool v )
    {
      if (!self()->isPracticeSoundEnabledImmutable())
        self()->mPracticeSoundEnabled = v;
    }

    /**
      Get Enable sound playback in the practice dialogs.
    */
    static
    bool practiceSoundEnabled()
    {
      return self()->mPracticeSoundEnabled;
    }

    /**
      Is Enable sound playback in the practice dialogs. Immutable
    */
    static
    bool isPracticeSoundEnabledImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PracticeSoundEnabled" ) );
    }

    /**
      Set Allow using images instead of words in flashcards. This will only be done if there is no word in the entry.
    */
    static
    void setAllowImageInsteadOfWord( bool v )
    {
      if (!self()->isAllowImageInsteadOfWordImmutable())
        self()->mAllowImageInsteadOfWord = v;
    }

    /**
      Get Allow using images instead of words in flashcards. This will only be done if there is no word in the entry.
    */
    static
    bool allowImageInsteadOfWord()
    {
      return self()->mAllowImageInsteadOfWord;
    }

    /**
      Is Allow using images instead of words in flashcards. This will only be done if there is no word in the entry. Immutable
    */
    static
    bool isAllowImageInsteadOfWordImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AllowImageInsteadOfWord" ) );
    }

    /**
      Set The maximum number of words that will be practiced in a training session.
    */
    static
    void setSessionMaxSize( int v )
    {
      if (!self()->isSessionMaxSizeImmutable())
        self()->mSessionMaxSize = v;
    }

    /**
      Get The maximum number of words that will be practiced in a training session.
    */
    static
    int sessionMaxSize()
    {
      return self()->mSessionMaxSize;
    }

    /**
      Is The maximum number of words that will be practiced in a training session. Immutable
    */
    static
    bool isSessionMaxSizeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SessionMaxSize" ) );
    }

    /**
      Set The maximum number of new (untrained) words that will be used in a training session.
    */
    static
    void setSessionMaxNewWords( int v )
    {
      if (!self()->isSessionMaxNewWordsImmutable())
        self()->mSessionMaxNewWords = v;
    }

    /**
      Get The maximum number of new (untrained) words that will be used in a training session.
    */
    static
    int sessionMaxNewWords()
    {
      return self()->mSessionMaxNewWords;
    }

    /**
      Is The maximum number of new (untrained) words that will be used in a training session. Immutable
    */
    static
    bool isSessionMaxNewWordsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SessionMaxNewWords" ) );
    }

    /**
      Set Limit the number of words in the initial phase.
    */
    static
    void setSessionLimitWordsInitialPhase( bool v )
    {
      if (!self()->isSessionLimitWordsInitialPhaseImmutable())
        self()->mSessionLimitWordsInitialPhase = v;
    }

    /**
      Get Limit the number of words in the initial phase.
    */
    static
    bool sessionLimitWordsInitialPhase()
    {
      return self()->mSessionLimitWordsInitialPhase;
    }

    /**
      Is Limit the number of words in the initial phase. Immutable
    */
    static
    bool isSessionLimitWordsInitialPhaseImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SessionLimitWordsInitialPhase" ) );
    }

    /**
      Set The maximum number of words in the initial phase. If this limit is exceeded, no new words will be introduced.
    */
    static
    void setSessionMaxWordsInitialPhase( int v )
    {
      if (!self()->isSessionMaxWordsInitialPhaseImmutable())
        self()->mSessionMaxWordsInitialPhase = v;
    }

    /**
      Get The maximum number of words in the initial phase. If this limit is exceeded, no new words will be introduced.
    */
    static
    int sessionMaxWordsInitialPhase()
    {
      return self()->mSessionMaxWordsInitialPhase;
    }

    /**
      Is The maximum number of words in the initial phase. If this limit is exceeded, no new words will be introduced. Immutable
    */
    static
    bool isSessionMaxWordsInitialPhaseImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SessionMaxWordsInitialPhase" ) );
    }

    /**
      Set Use the same word type as the solution for the incorrect answers in a multiple choice practice.
    */
    static
    void setMultipleChoiceWordTypeConsistancy( bool v )
    {
      if (!self()->isMultipleChoiceWordTypeConsistancyImmutable())
        self()->mMultipleChoiceWordTypeConsistancy = v;
    }

    /**
      Get Use the same word type as the solution for the incorrect answers in a multiple choice practice.
    */
    static
    bool multipleChoiceWordTypeConsistancy()
    {
      return self()->mMultipleChoiceWordTypeConsistancy;
    }

    /**
      Is Use the same word type as the solution for the incorrect answers in a multiple choice practice. Immutable
    */
    static
    bool isMultipleChoiceWordTypeConsistancyImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MultipleChoiceWordTypeConsistancy" ) );
    }

    /**
      Set How many answers are provided for a multiple choice question, including the correct answer.
    */
    static
    void setNumberMultipleChoiceAnswers( int v )
    {
      if (!self()->isNumberMultipleChoiceAnswersImmutable())
        self()->mNumberMultipleChoiceAnswers = v;
    }

    /**
      Get How many answers are provided for a multiple choice question, including the correct answer.
    */
    static
    int numberMultipleChoiceAnswers()
    {
      return self()->mNumberMultipleChoiceAnswers;
    }

    /**
      Is How many answers are provided for a multiple choice question, including the correct answer. Immutable
    */
    static
    bool isNumberMultipleChoiceAnswersImmutable()
    {
      return self()->isImmutable( QStringLiteral( "NumberMultipleChoiceAnswers" ) );
    }

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

    /**
      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" ) );
    }

    /**
      Set When enabled a unit also shows entries from its subunits.
    */
    static
    void setShowSublessonentries( bool v )
    {
      if (!self()->isShowSublessonentriesImmutable())
        self()->mShowSublessonentries = v;
    }

    /**
      Get When enabled a unit also shows entries from its subunits.
    */
    static
    bool showSublessonentries()
    {
      return self()->mShowSublessonentries;
    }

    /**
      Is When enabled a unit also shows entries from its subunits. Immutable
    */
    static
    bool isShowSublessonentriesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowSublessonentries" ) );
    }

    /**
      Set Show/hide the unit column.
    */
    static
    void setTableLessonColumnVisible( bool v )
    {
      if (!self()->isTableLessonColumnVisibleImmutable())
        self()->mTableLessonColumnVisible = v;
    }

    /**
      Get Show/hide the unit column.
    */
    static
    bool tableLessonColumnVisible()
    {
      return self()->mTableLessonColumnVisible;
    }

    /**
      Is Show/hide the unit column. Immutable
    */
    static
    bool isTableLessonColumnVisibleImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TableLessonColumnVisible" ) );
    }

    /**
      Set Show/hide the active column.
    */
    static
    void setTableActiveColumnVisible( bool v )
    {
      if (!self()->isTableActiveColumnVisibleImmutable())
        self()->mTableActiveColumnVisible = v;
    }

    /**
      Get Show/hide the active column.
    */
    static
    bool tableActiveColumnVisible()
    {
      return self()->mTableActiveColumnVisible;
    }

    /**
      Is Show/hide the active column. Immutable
    */
    static
    bool isTableActiveColumnVisibleImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TableActiveColumnVisible" ) );
    }

    /**
      Set Select which units are displayed for editing
    */
    static
    void setLessonEditingSelection( EnumLessonEditingSelection::type v )
    {
      if (!self()->isLessonEditingSelectionImmutable())
        self()->mLessonEditingSelection = v;
    }

    /**
      Get Select which units are displayed for editing
    */
    static
    EnumLessonEditingSelection::type lessonEditingSelection()
    {
      return static_cast<EnumLessonEditingSelection::type>(self()->mLessonEditingSelection);
    }

    /**
      Is Select which units are displayed for editing Immutable
    */
    static
    bool isLessonEditingSelectionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LessonEditingSelection" ) );
    }

    /**
      Set How the main window is divided.
    */
    static
    void setMainWindowSplitter( const QList<int> & v )
    {
      if (!self()->isMainWindowSplitterImmutable())
        self()->mMainWindowSplitter = v;
    }

    /**
      Get How the main window is divided.
    */
    static
    QList<int> mainWindowSplitter()
    {
      return self()->mMainWindowSplitter;
    }

    /**
      Is How the main window is divided. Immutable
    */
    static
    bool isMainWindowSplitterImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MainWindowSplitter" ) );
    }

    /**
      Set The font used in the vocabulary table
    */
    static
    void setPracticeFont( const QFont & v )
    {
      if (!self()->isPracticeFontImmutable())
        self()->mPracticeFont = v;
    }

    /**
      Get The font used in the vocabulary table
    */
    static
    QFont practiceFont()
    {
      return self()->mPracticeFont;
    }

    /**
      Is The font used in the vocabulary table Immutable
    */
    static
    bool isPracticeFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PracticeFont" ) );
    }

    /**
      Set The font used for phonetics
    */
    static
    void setIPAFont( const QFont & v )
    {
      if (!self()->isIPAFontImmutable())
        self()->mIPAFont = v;
    }

    /**
      Get The font used for phonetics
    */
    static
    QFont iPAFont()
    {
      return self()->mIPAFont;
    }

    /**
      Is The font used for phonetics Immutable
    */
    static
    bool isIPAFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "IPAFont" ) );
    }

    /**
      Set Currently selected column
    */
    static
    void setCurrentCol( int v )
    {
      if (!self()->isCurrentColImmutable())
        self()->mCurrentCol = v;
    }

    /**
      Get Currently selected column
    */
    static
    int currentCol()
    {
      return self()->mCurrentCol;
    }

    /**
      Is Currently selected column Immutable
    */
    static
    bool isCurrentColImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CurrentCol" ) );
    }

    /**
      Set Currently selected row
    */
    static
    void setCurrentRow( int v )
    {
      if (!self()->isCurrentRowImmutable())
        self()->mCurrentRow = v;
    }

    /**
      Get Currently selected row
    */
    static
    int currentRow()
    {
      return self()->mCurrentRow;
    }

    /**
      Is Currently selected row Immutable
    */
    static
    bool isCurrentRowImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CurrentRow" ) );
    }

    /**
      Set Color used to display the confidence levels
    */
    static
    void setGradeColor( const QColor & v )
    {
      if (!self()->isGradeColorImmutable())
        self()->mGradeColor = v;
    }

    /**
      Get Color used to display the confidence levels
    */
    static
    QColor gradeColor()
    {
      return self()->mGradeColor;
    }

    /**
      Is Color used to display the confidence levels Immutable
    */
    static
    bool isGradeColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "GradeColor" ) );
    }

    /**
      Set Color used to display the early confidence levels
    */
    static
    void setPreGradeColor( const QColor & v )
    {
      if (!self()->isPreGradeColorImmutable())
        self()->mPreGradeColor = v;
    }

    /**
      Get Color used to display the early confidence levels
    */
    static
    QColor preGradeColor()
    {
      return self()->mPreGradeColor;
    }

    /**
      Is Color used to display the early confidence levels Immutable
    */
    static
    bool isPreGradeColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PreGradeColor" ) );
    }

    /**
      Set Color used to display invalid units
    */
    static
    void setInvalidUnitColor( const QColor & v )
    {
      if (!self()->isInvalidUnitColorImmutable())
        self()->mInvalidUnitColor = v;
    }

    /**
      Get Color used to display invalid units
    */
    static
    QColor invalidUnitColor()
    {
      return self()->mInvalidUnitColor;
    }

    /**
      Is Color used to display invalid units Immutable
    */
    static
    bool isInvalidUnitColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "InvalidUnitColor" ) );
    }

    /**
      Set The entry must have been asked at least this often to be included in the practice.
    */
    static
    void setPracticeMinimumTimesAsked( int v )
    {
      if (!self()->isPracticeMinimumTimesAskedImmutable())
        self()->mPracticeMinimumTimesAsked = v;
    }

    /**
      Get The entry must have been asked at least this often to be included in the practice.
    */
    static
    int practiceMinimumTimesAsked()
    {
      return self()->mPracticeMinimumTimesAsked;
    }

    /**
      Is The entry must have been asked at least this often to be included in the practice. Immutable
    */
    static
    bool isPracticeMinimumTimesAskedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PracticeMinimumTimesAsked" ) );
    }

    /**
      Set The entry must have been asked at most this often to be included in the practice.
    */
    static
    void setPracticeMaximumTimesAsked( int v )
    {
      if (!self()->isPracticeMaximumTimesAskedImmutable())
        self()->mPracticeMaximumTimesAsked = v;
    }

    /**
      Get The entry must have been asked at most this often to be included in the practice.
    */
    static
    int practiceMaximumTimesAsked()
    {
      return self()->mPracticeMaximumTimesAsked;
    }

    /**
      Is The entry must have been asked at most this often to be included in the practice. Immutable
    */
    static
    bool isPracticeMaximumTimesAskedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PracticeMaximumTimesAsked" ) );
    }

    /**
      Set The entry must have been answered incorrectly at least this often to be included in the practice.
    */
    static
    void setPracticeMinimumWrongCount( int v )
    {
      if (!self()->isPracticeMinimumWrongCountImmutable())
        self()->mPracticeMinimumWrongCount = v;
    }

    /**
      Get The entry must have been answered incorrectly at least this often to be included in the practice.
    */
    static
    int practiceMinimumWrongCount()
    {
      return self()->mPracticeMinimumWrongCount;
    }

    /**
      Is The entry must have been answered incorrectly at least this often to be included in the practice. Immutable
    */
    static
    bool isPracticeMinimumWrongCountImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PracticeMinimumWrongCount" ) );
    }

    /**
      Set The entry must have been answered incorrectly at most this often to be included in the practice.
    */
    static
    void setPracticeMaximumWrongCount( int v )
    {
      if (!self()->isPracticeMaximumWrongCountImmutable())
        self()->mPracticeMaximumWrongCount = v;
    }

    /**
      Get The entry must have been answered incorrectly at most this often to be included in the practice.
    */
    static
    int practiceMaximumWrongCount()
    {
      return self()->mPracticeMaximumWrongCount;
    }

    /**
      Is The entry must have been answered incorrectly at most this often to be included in the practice. Immutable
    */
    static
    bool isPracticeMaximumWrongCountImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PracticeMaximumWrongCount" ) );
    }

    /**
      Set The entry must have at least this confidence level to be included in the practice (0..7).
    */
    static
    void setPracticeMinimumGrade( int v )
    {
      if (!self()->isPracticeMinimumGradeImmutable())
        self()->mPracticeMinimumGrade = v;
    }

    /**
      Get The entry must have at least this confidence level to be included in the practice (0..7).
    */
    static
    int practiceMinimumGrade()
    {
      return self()->mPracticeMinimumGrade;
    }

    /**
      Is The entry must have at least this confidence level to be included in the practice (0..7). Immutable
    */
    static
    bool isPracticeMinimumGradeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PracticeMinimumGrade" ) );
    }

    /**
      Set The entry must have at most this confidence level to be included in the practice (0..7).
    */
    static
    void setPracticeMaximumGrade( int v )
    {
      if (!self()->isPracticeMaximumGradeImmutable())
        self()->mPracticeMaximumGrade = v;
    }

    /**
      Get The entry must have at most this confidence level to be included in the practice (0..7).
    */
    static
    int practiceMaximumGrade()
    {
      return self()->mPracticeMaximumGrade;
    }

    /**
      Is The entry must have at most this confidence level to be included in the practice (0..7). Immutable
    */
    static
    bool isPracticeMaximumGradeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PracticeMaximumGrade" ) );
    }

    /**
      Set Only selected word types will be included in practice.
    */
    static
    void setWordTypesInPracticeEnabled( bool v )
    {
      if (!self()->isWordTypesInPracticeEnabledImmutable())
        self()->mWordTypesInPracticeEnabled = v;
    }

    /**
      Get Only selected word types will be included in practice.
    */
    static
    bool wordTypesInPracticeEnabled()
    {
      return self()->mWordTypesInPracticeEnabled;
    }

    /**
      Is Only selected word types will be included in practice. Immutable
    */
    static
    bool isWordTypesInPracticeEnabledImmutable()
    {
      return self()->isImmutable( QStringLiteral( "WordTypesInPracticeEnabled" ) );
    }

    /**
      Set Selected word types for practices.
    */
    static
    void setWordTypesInPractice( const QStringList & v )
    {
      if (!self()->isWordTypesInPracticeImmutable())
        self()->mWordTypesInPractice = v;
    }

    /**
      Get Selected word types for practices.
    */
    static
    QStringList wordTypesInPractice()
    {
      return self()->mWordTypesInPractice;
    }

    /**
      Is Selected word types for practices. Immutable
    */
    static
    bool isWordTypesInPracticeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "WordTypesInPractice" ) );
    }

    /**
      Set Selected sub word types for practices.
    */
    static
    void setSubWordTypesInPractice( const QStringList & v )
    {
      if (!self()->isSubWordTypesInPracticeImmutable())
        self()->mSubWordTypesInPractice = v;
    }

    /**
      Get Selected sub word types for practices.
    */
    static
    QStringList subWordTypesInPractice()
    {
      return self()->mSubWordTypesInPractice;
    }

    /**
      Is Selected sub word types for practices. Immutable
    */
    static
    bool isSubWordTypesInPracticeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SubWordTypesInPractice" ) );
    }

    /**
      Set The language that you are learning.
    */
    static
    void setLearningLanguage( int v )
    {
      if (!self()->isLearningLanguageImmutable())
        self()->mLearningLanguage = v;
    }

    /**
      Get The language that you are learning.
    */
    static
    int learningLanguage()
    {
      return self()->mLearningLanguage;
    }

    /**
      Is The language that you are learning. Immutable
    */
    static
    bool isLearningLanguageImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LearningLanguage" ) );
    }

    /**
      Set The language that you know already.
    */
    static
    void setKnownLanguage( int v )
    {
      if (!self()->isKnownLanguageImmutable())
        self()->mKnownLanguage = v;
    }

    /**
      Get The language that you know already.
    */
    static
    int knownLanguage()
    {
      return self()->mKnownLanguage;
    }

    /**
      Is The language that you know already. Immutable
    */
    static
    bool isKnownLanguageImmutable()
    {
      return self()->isImmutable( QStringLiteral( "KnownLanguage" ) );
    }

    /**
      Set Show the solution after an answer was given.
    */
    static
    void setShowSolutionAfterAnswer( bool v )
    {
      if (!self()->isShowSolutionAfterAnswerImmutable())
        self()->mShowSolutionAfterAnswer = v;
    }

    /**
      Get Show the solution after an answer was given.
    */
    static
    bool showSolutionAfterAnswer()
    {
      return self()->mShowSolutionAfterAnswer;
    }

    /**
      Is Show the solution after an answer was given. Immutable
    */
    static
    bool isShowSolutionAfterAnswerImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowSolutionAfterAnswer" ) );
    }

    /**
      Set The time the solution is shown (seconds). 0 is unlimited.
    */
    static
    void setShowSolutionAfterAnswerTime( int v )
    {
      if (!self()->isShowSolutionAfterAnswerTimeImmutable())
        self()->mShowSolutionAfterAnswerTime = v;
    }

    /**
      Get The time the solution is shown (seconds). 0 is unlimited.
    */
    static
    int showSolutionAfterAnswerTime()
    {
      return self()->mShowSolutionAfterAnswerTime;
    }

    /**
      Is The time the solution is shown (seconds). 0 is unlimited. Immutable
    */
    static
    bool isShowSolutionAfterAnswerTimeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowSolutionAfterAnswerTime" ) );
    }

    /**
      Set The practice method that is currently selected.
    */
    static
    void setPracticeMode( EnumPracticeMode::type v )
    {
      if (!self()->isPracticeModeImmutable())
        self()->mPracticeMode = v;
    }

    /**
      Get The practice method that is currently selected.
    */
    static
    EnumPracticeMode::type practiceMode()
    {
      return static_cast<EnumPracticeMode::type>(self()->mPracticeMode);
    }

    /**
      Is The practice method that is currently selected. Immutable
    */
    static
    bool isPracticeModeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PracticeMode" ) );
    }

    /**
      Set The practice mode that is currently selected.
    */
    static
    void setPracticeDirection( EnumPracticeDirection::type v )
    {
      if (!self()->isPracticeDirectionImmutable())
        self()->mPracticeDirection = v;
    }

    /**
      Get The practice mode that is currently selected.
    */
    static
    EnumPracticeDirection::type practiceDirection()
    {
      return static_cast<EnumPracticeDirection::type>(self()->mPracticeDirection);
    }

    /**
      Is The practice mode that is currently selected. Immutable
    */
    static
    bool isPracticeDirectionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PracticeDirection" ) );
    }

    /**
      Set Amount of time different confidence levels should be blocked
    */
    static
    void setBlockItem( int i, int v )
    {
      if (!self()->isBlockItemImmutable( i ))
        self()->mBlockItem[i] = v;
    }

    /**
      Get Amount of time different confidence levels should be blocked
    */
    static
    int blockItem( int i )
    {
      return self()->mBlockItem[i];
    }

    /**
      Is Amount of time different confidence levels should be blocked Immutable
    */
    static
    bool isBlockItemImmutable( int i )
    {
      return self()->isImmutable( QStringLiteral( "BlockItem%1" ).arg( i ) );
    }

    /**
      Set Amount of time after which different confidence levels should expire
    */
    static
    void setExpireItem( int i, int v )
    {
      if (!self()->isExpireItemImmutable( i ))
        self()->mExpireItem[i] = v;
    }

    /**
      Get Amount of time after which different confidence levels should expire
    */
    static
    int expireItem( int i )
    {
      return self()->mExpireItem[i];
    }

    /**
      Is Amount of time after which different confidence levels should expire Immutable
    */
    static
    bool isExpireItemImmutable( int i )
    {
      return self()->isImmutable( QStringLiteral( "ExpireItem%1" ).arg( i ) );
    }

    /**
      Set If true, the practice direction for each practice mode is stored.
    */
    static
    void setRememberPracticeDirection( bool v )
    {
      if (!self()->isRememberPracticeDirectionImmutable())
        self()->mRememberPracticeDirection = v;
    }

    /**
      Get If true, the practice direction for each practice mode is stored.
    */
    static
    bool rememberPracticeDirection()
    {
      return self()->mRememberPracticeDirection;
    }

    /**
      Is If true, the practice direction for each practice mode is stored. Immutable
    */
    static
    bool isRememberPracticeDirectionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "RememberPracticeDirection" ) );
    }

    /**
      Set Stored values of practice direction for each practice mode.
    */
    static
    void setPracticeDirectionsByPracticeMode( const QList<int> & v )
    {
      if (!self()->isPracticeDirectionsByPracticeModeImmutable())
        self()->mPracticeDirectionsByPracticeMode = v;
    }

    /**
      Get Stored values of practice direction for each practice mode.
    */
    static
    QList<int> practiceDirectionsByPracticeMode()
    {
      return self()->mPracticeDirectionsByPracticeMode;
    }

    /**
      Is Stored values of practice direction for each practice mode. Immutable
    */
    static
    bool isPracticeDirectionsByPracticeModeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PracticeDirectionsByPracticeMode" ) );
    }

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

    /**
      Get The Providers path for Parley
    */
    static
    QString providersUrl()
    {
      return self()->mProvidersUrl;
    }

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

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

    /**
      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" ) );
    }

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

    /**
      Get The folder where downloaded vocabularies are saved by default
    */
    static
    QString installPath()
    {
      return self()->mInstallPath;
    }

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

  protected:
    Prefs();
    friend class PrefsHelper;


    // General
    QString mTheme;
    int mNumPreSetting;
    bool mSmartAppend;
    QString mSeparator;
    int mEntriesPerLesson;
    bool mAutoOpenLast;
    bool mAutoSave;
    int mSeparatorCombo;
    bool mAutoBackup;
    int mBackupTime;
    bool mAutomaticTranslation;

    // PracticeOptions
    bool mFlashcardsFrontImage;
    bool mFlashcardsBackImage;
    bool mBlock;
    bool mExpire;
    bool mTestOrderLesson;
    int mTestNumberOfEntries;
    bool mSwapDirection;
    bool mPracticeTimeout;
    int mPracticeTimeoutMode;
    int mPracticeTimeoutTimePerAnswer;
    bool mSuggestions;
    bool mShowHints;
    bool mIgnoreAccentMistakes;
    bool mIgnoreCapitalizationMistakes;
    bool mIgnorePunctuationMistakes;
    bool mSplitTranslations;
    bool mPeriods;
    bool mColons;
    bool mSemicolons;
    bool mCommas;
    bool mShowMore;
    bool mSkipKnownEnabled;
    bool mCountSynonymsAsCorrect;
    bool mPracticeImagesEnabled;
    bool mPracticeSoundEnabled;
    bool mAllowImageInsteadOfWord;
    int mSessionMaxSize;
    int mSessionMaxNewWords;
    bool mSessionLimitWordsInitialPhase;
    int mSessionMaxWordsInitialPhase;
    bool mMultipleChoiceWordTypeConsistancy;
    int mNumberMultipleChoiceAnswers;

    // Appearance
    bool mShowSearch;
    bool mShowSublessonentries;
    bool mTableLessonColumnVisible;
    bool mTableActiveColumnVisible;
    int mLessonEditingSelection;
    QList<int> mMainWindowSplitter;
    QFont mPracticeFont;
    QFont mIPAFont;
    int mCurrentCol;
    int mCurrentRow;
    QColor mGradeColor;
    QColor mPreGradeColor;
    QColor mInvalidUnitColor;

    // Thresholds
    int mPracticeMinimumTimesAsked;
    int mPracticeMaximumTimesAsked;
    int mPracticeMinimumWrongCount;
    int mPracticeMaximumWrongCount;
    int mPracticeMinimumGrade;
    int mPracticeMaximumGrade;
    bool mWordTypesInPracticeEnabled;
    QStringList mWordTypesInPractice;
    QStringList mSubWordTypesInPractice;

    // PracticeManager
    int mLearningLanguage;
    int mKnownLanguage;
    bool mShowSolutionAfterAnswer;
    int mShowSolutionAfterAnswerTime;
    int mPracticeMode;
    int mPracticeDirection;
    int mBlockItem[8];
    int mExpireItem[8];
    bool mRememberPracticeDirection;
    QList<int> mPracticeDirectionsByPracticeMode;

    // KNewStuff
    QString mProvidersUrl;
    QString mInstallationCommand;
    QString mInstallPath;
};

#endif

