// This file is generated by kconfig_compiler_kf5 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();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
      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()->isImmutable( QStringLiteral( "TestOrderLesson" ) ))
        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;
    }

    /**
      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()->isImmutable( QStringLiteral( "TestNumberOfEntries" ) ))
        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;
    }

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

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

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

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

    /**
      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()->isImmutable( QStringLiteral( "PracticeTimeoutMode" ) ))
        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);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
      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()->isImmutable( QStringLiteral( "AllowImageInsteadOfWord" ) ))
        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;
    }

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

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

    /**
      Set The maximum number of new (untrained) words that will be used in a training session.
    */
    static
    void setSessionMaxNewWords( int v )
    {
      if (!self()->isImmutable( QStringLiteral( "SessionMaxNewWords" ) ))
        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;
    }

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

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

    /**
      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()->isImmutable( QStringLiteral( "SessionMaxWordsInitialPhase" ) ))
        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;
    }

    /**
      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()->isImmutable( QStringLiteral( "MultipleChoiceWordTypeConsistancy" ) ))
        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;
    }

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

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

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

    /**
      Get Toggle display of the search bar.
    */
    static
    bool showSearch()
    {
      return self()->mShowSearch;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
      Set The entry must have been asked at least this often to be included in the practice.
    */
    static
    void setPracticeMinimumTimesAsked( int v )
    {
      if (!self()->isImmutable( QStringLiteral( "PracticeMinimumTimesAsked" ) ))
        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;
    }

    /**
      Set The entry must have been asked at most this often to be included in the practice.
    */
    static
    void setPracticeMaximumTimesAsked( int v )
    {
      if (!self()->isImmutable( QStringLiteral( "PracticeMaximumTimesAsked" ) ))
        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;
    }

    /**
      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()->isImmutable( QStringLiteral( "PracticeMinimumWrongCount" ) ))
        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;
    }

    /**
      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()->isImmutable( QStringLiteral( "PracticeMaximumWrongCount" ) ))
        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;
    }

    /**
      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()->isImmutable( QStringLiteral( "PracticeMinimumGrade" ) ))
        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;
    }

    /**
      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()->isImmutable( QStringLiteral( "PracticeMaximumGrade" ) ))
        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;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
      Set Amount of time different confidence levels should be blocked
    */
    static
    void setBlockItem( int i, int v )
    {
      if (!self()->isImmutable( QStringLiteral( "BlockItem%1" ).arg( i ) ))
        self()->mBlockItem[i] = v;
    }

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

    /**
      Set Amount of time after which different confidence levels should expire
    */
    static
    void setExpireItem( int i, int v )
    {
      if (!self()->isImmutable( QStringLiteral( "ExpireItem%1" ).arg( 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];
    }

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

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

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

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

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

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

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

    /**
      Get The command used to start a downloaded vocabulary
    */
    static
    QString installationCommand()
    {
      return self()->mInstallationCommand;
    }

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

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

  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;

  private:
};

#endif

