diff --git a/src/editor/browserwidget.cpp b/src/editor/browserwidget.cpp
index 31ca7925..9dae4519 100644
--- a/src/editor/browserwidget.cpp
+++ b/src/editor/browserwidget.cpp
@@ -1,142 +1,138 @@
 /***************************************************************************
 
     Copyright 2008 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "browserwidget.h"
 
 #include <keduvocexpression.h>
 #include <QWebEngineView>
 
 #include <QDragEnterEvent>
 
 using namespace Editor;
 
 BrowserWidget::BrowserWidget(QWidget *parent) : QWidget(parent)
 {
     setupUi(this);
     m_currentTranslation = -1;
     m_entry = 0;
     m_currentProvider = 0; ///@todo kconfig?
 
     m_htmlPart = new QWebEngineView(widget);
     QHBoxLayout *layout = new QHBoxLayout(widget);
     widget->setLayout(layout);
     layout->addWidget(m_htmlPart);
 
     connect(showCurrentButton, &QPushButton::clicked, this, &BrowserWidget::showCurrentTranslation);
 
     setupProviders();
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(providerComboBox, static_cast<void (KComboBox::*)(int)>(&KComboBox::currentIndexChanged), this, &BrowserWidget::providerChanged);
-#else
-    connect(providerComboBox, static_cast<void (KComboBox::*)(int, const QString &)>(&KComboBox::currentIndexChanged) , this, &BrowserWidget::providerChanged);
-#endif
 
 }
 
 void BrowserWidget::setupProviders()
 {
     providerComboBox->clear();
 
     DictionaryProvider provider;
     provider.name = QStringLiteral("De-Es Beolingus");
     provider.url = QStringLiteral("https://dict.tu-chemnitz.de/dings.cgi?service=dees&query=\\{@}");
     provider.languages << QStringLiteral("de") << QStringLiteral("es");
     m_providers.append(provider);
     providerComboBox->addItem(provider.name);
 
     provider.name = QStringLiteral("De-En Beolingus");
     provider.url = QStringLiteral("https://dict.tu-chemnitz.de/dings.cgi?service=deen?query=\\{@}");
     provider.languages << QStringLiteral("de") << QStringLiteral("en");
     m_providers.append(provider);
     providerComboBox->addItem(provider.name);
 
     provider.name = QStringLiteral("De-En Leo");
     provider.url = QStringLiteral("https://dict.leo.org/?search=\\{@}");
     provider.languages << QStringLiteral("de") << QStringLiteral("en");
     m_providers.append(provider);
     providerComboBox->addItem(provider.name);
 
     provider.name = QStringLiteral("De-Es Leo");
     provider.url = QStringLiteral("https://dict.leo.org/?lp=esde&search=\\{@}");
     provider.languages << QStringLiteral("de") << QStringLiteral("es");
     m_providers.append(provider);
     providerComboBox->addItem(provider.name);
 
     provider.name = QStringLiteral("De-Fr Leo");
     provider.url = QStringLiteral("https://dict.leo.org/?lp=frde&search=\\{@}");
     provider.languages << QStringLiteral("de") << QStringLiteral("fr");
     m_providers.append(provider);
     providerComboBox->addItem(provider.name);
 
     provider.name = QStringLiteral("Ru-En Multitran");
     provider.url = QStringLiteral("https://multitran.com/c/m.exe?SHL=1&CL=1&l1=1&s=\\{@}");
     provider.languages << QStringLiteral("ru") << QStringLiteral("en");
     m_providers.append(provider);
     providerComboBox->addItem(provider.name);
 
     provider.name = QStringLiteral("Ru-De Multitran");
     provider.url = QStringLiteral("https://multitran.com/c/m.exe?SHL=1&CL=1&l1=3&s=\\{@}");
     provider.languages << QStringLiteral("ru") << QStringLiteral("de");
     m_providers.append(provider);
     providerComboBox->addItem(provider.name);
 
     provider.name = QStringLiteral("Ru-Fr Multitran");
     provider.url = QStringLiteral("https://multitran.com/c/m.exe?SHL=1&CL=1&l1=4&s=\\{@}");
     provider.languages << QStringLiteral("ru") << QStringLiteral("fr");
     m_providers.append(provider);
     providerComboBox->addItem(provider.name);
 
     provider.name = QStringLiteral("Heinzelnisse");
     provider.url = QStringLiteral("https://heinzelnisse.info/dict?setOptions=true&searchItem=\\{@}&dictDeNoSearch=on&dictNoDeSearch=on&dictExactSearch=on&dictPhoneticSearch=on&wikiSearch=on&dictNynorskSearch=on&dictBokmaalSearch=checked&forumKeywordSearch=on&suggestion=on");
     provider.languages << QStringLiteral("no") << QStringLiteral("de");
     m_providers.append(provider);
     providerComboBox->addItem(provider.name);
 
 }
 
 void BrowserWidget::setTranslation(KEduVocExpression* entry, int translation)
 {
     m_currentTranslation = translation;
     m_entry = entry;
 
     if (followTableCheckBox->isChecked()) {
         showCurrentTranslation();
     }
 }
 
 void BrowserWidget::showCurrentTranslation()
 {
     if (m_entry) {
         if (m_entry->translation(m_currentTranslation)) {
             QString text = m_entry->translation(m_currentTranslation)->text();
             if (!text.isEmpty()) {
                 m_htmlPart->load(QUrl(QString(m_providers.value(m_currentProvider).url.replace(QLatin1String("\\{@}"), text))));
                 m_htmlPart->show();
             }
         }
     }
 }
 
 void BrowserWidget::openUrl(const QUrl & targetUrl)
 {
     m_htmlPart->load(targetUrl);
     m_htmlPart->show();
 }
 
 void BrowserWidget::providerChanged(int provider)
 {
     m_currentProvider = provider;
     showCurrentTranslation();
 }
diff --git a/src/editor/declensionwidget.cpp b/src/editor/declensionwidget.cpp
index 3311beb1..cde4b371 100644
--- a/src/editor/declensionwidget.cpp
+++ b/src/editor/declensionwidget.cpp
@@ -1,205 +1,201 @@
 /***************************************************************************
     Copyright 2008 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
     Copyright 2011 Jan Gerrit Marker <jangerrit@weiler-marker.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "declensionwidget.h"
 
 #include <keduvocdocument.h>
 #include <keduvocexpression.h>
 #include <keduvocwordtype.h>
 #include <keduvocdeclension.h>
 
 #include <KMessageBox>
 #include <KLocalizedString>
 
 using namespace Editor;
 
 DeclensionWidget::DeclensionWidget(QWidget *parent) : QWidget(parent)
 {
     m_doc = 0;
     m_entry = 0;
     m_identifier = -1;
 
     setupUi(this);
 
     numberSelection->setItemData(0, KEduVocWordFlag::Singular);
     numberSelection->setItemData(1, KEduVocWordFlag::Dual);
     numberSelection->setItemData(2, KEduVocWordFlag::Plural);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(numberSelection, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &DeclensionWidget::updateEntries);
-#else
-    connect(numberSelection, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) , this, &DeclensionWidget::updateEntries);
-#endif
 
     connect(nextButton, &QPushButton::clicked, this, &DeclensionWidget::nextNumber);
 
     setupLineEdits();
 
     foreach(int index, m_DeclensionLineEdits.keys()) {
         connect(m_DeclensionLineEdits.value(index), &QLineEdit::textChanged, this, &DeclensionWidget::textChanged);
     }
 }
 
 
 void DeclensionWidget::textChanged(const QString& text)
 {
     int valueIndex = m_DeclensionLineEdits.values().indexOf(qobject_cast<QLineEdit*>(sender()));
     int key = m_DeclensionLineEdits.keys().value(valueIndex) | currentAdditionalWordFlag();
     m_entry->translation(m_identifier)->declension()->setDeclension(text, (KEduVocWordFlag::Flags)key);
     emit sigModified();
 }
 
 
 void DeclensionWidget::updateEntries()
 {
     foreach(int key, m_DeclensionLineEdits.keys()) {
         m_DeclensionLineEdits.value(key)->setText(m_entry->translation(m_identifier)->declension()->declension((KEduVocWordFlag::Flags)(key | currentAdditionalWordFlag())).text());
     }
 }
 
 void DeclensionWidget::setTranslation(KEduVocExpression * entry, int identifier)
 {
     if (!m_doc) {
         return;
     }
 
     m_entry = entry;
     if (m_identifier != identifier) {
         m_identifier = identifier;
     }
 
     if (!entry) {
         setEnabled(false);
         return;
     }
 
     setupLineEdits();
 
     setEnabled(true);
     if (entry->translation(m_identifier)->wordType()) {
         KEduVocWordFlags wordType = entry->translation(m_identifier)->wordType()->wordType();
         if (wordType & KEduVocWordFlag::Noun || wordType & KEduVocWordFlag::Adjective) {
 
             // we create declensions on demand. if empty it will simply not be saved.
             // very little memory overhead, comfy to use ;)
             if (!entry->translation(m_identifier)->declension()) {
                 entry->translation(m_identifier)->setDeclension(new KEduVocDeclension);
             }
 
             updateEntries();
         }
     }
 }
 
 void DeclensionWidget::setDocument(KEduVocDocument * doc)
 {
     m_doc = doc;
 }
 
 int DeclensionWidget::currentAdditionalWordFlag()
 {
     if (m_entry->translation(m_identifier)->wordType()->wordType() & KEduVocWordFlag::Noun) {
         ///@todo easier and better way to get gender?
         if (m_entry->translation(m_identifier)->wordType()->wordType() & KEduVocWordFlag::Feminine)
             return KEduVocWordFlag::Feminine;
         if (m_entry->translation(m_identifier)->wordType()->wordType() & KEduVocWordFlag::Masculine)
             return KEduVocWordFlag::Masculine;
         if (m_entry->translation(m_identifier)->wordType()->wordType() & KEduVocWordFlag::Neuter)
             return KEduVocWordFlag::Neuter;
     }
 
     return numberSelection->itemData(numberSelection->currentIndex()).toInt();
 }
 
 void DeclensionWidget::nextNumber()
 {
     int newIndex = numberSelection->currentIndex() + 1;
     if (newIndex >= numberSelection->count())
         newIndex = 0;
 
     numberSelection->setCurrentIndex(newIndex);
 }
 
 void DeclensionWidget::setupLineEdits()
 {
     m_DeclensionLineEdits.clear();
 
     if (m_entry == 0 || !m_entry->translation(m_identifier) || !m_entry->translation(m_identifier)->wordType()
             || m_entry->translation(m_identifier)->wordType()->wordType() & KEduVocWordFlag::Noun) {
         label_3->setText(i18n("Singular"));
         label_4->setText(i18n("Dual"));
         label_5->setText(i18n("Plural"));
 
         /* Hide the GUI elements which are needed to switch the number */
         for (int i = 0; i < numberLayout->count(); ++i) {
             numberLayout->itemAt(i)->widget()->hide();
         }
 
         m_DeclensionLineEdits[KEduVocWordFlag::Singular | KEduVocWordFlag::Nominative] = masculine_1;
         m_DeclensionLineEdits[KEduVocWordFlag::Singular | KEduVocWordFlag::Genitive] = masculine_2;
         m_DeclensionLineEdits[KEduVocWordFlag::Singular | KEduVocWordFlag::Dative] = masculine_3;
         m_DeclensionLineEdits[KEduVocWordFlag::Singular | KEduVocWordFlag::Accusative] = masculine_4;
         m_DeclensionLineEdits[KEduVocWordFlag::Singular | KEduVocWordFlag::Ablative] = masculine_5;
         m_DeclensionLineEdits[KEduVocWordFlag::Singular | KEduVocWordFlag::Locative] = masculine_6;
         m_DeclensionLineEdits[KEduVocWordFlag::Singular | KEduVocWordFlag::Vocative] = masculine_7;
 
         m_DeclensionLineEdits[KEduVocWordFlag::Dual | KEduVocWordFlag::Nominative] = feminine_1;
         m_DeclensionLineEdits[KEduVocWordFlag::Dual | KEduVocWordFlag::Genitive] = feminine_2;
         m_DeclensionLineEdits[KEduVocWordFlag::Dual | KEduVocWordFlag::Dative] = feminine_3;
         m_DeclensionLineEdits[KEduVocWordFlag::Dual | KEduVocWordFlag::Accusative] = feminine_4;
         m_DeclensionLineEdits[KEduVocWordFlag::Dual | KEduVocWordFlag::Ablative] = feminine_5;
         m_DeclensionLineEdits[KEduVocWordFlag::Dual | KEduVocWordFlag::Locative] = feminine_6;
         m_DeclensionLineEdits[KEduVocWordFlag::Dual | KEduVocWordFlag::Vocative] = feminine_7;
 
         m_DeclensionLineEdits[KEduVocWordFlag::Plural | KEduVocWordFlag::Nominative] = neuter_1;
         m_DeclensionLineEdits[KEduVocWordFlag::Plural | KEduVocWordFlag::Genitive] = neuter_2;
         m_DeclensionLineEdits[KEduVocWordFlag::Plural | KEduVocWordFlag::Dative] = neuter_3;
         m_DeclensionLineEdits[KEduVocWordFlag::Plural | KEduVocWordFlag::Accusative] = neuter_4;
         m_DeclensionLineEdits[KEduVocWordFlag::Plural | KEduVocWordFlag::Ablative] = neuter_5;
         m_DeclensionLineEdits[KEduVocWordFlag::Plural | KEduVocWordFlag::Locative] = neuter_6;
         m_DeclensionLineEdits[KEduVocWordFlag::Plural | KEduVocWordFlag::Vocative] = neuter_7;
     } else {
         label_3->setText(i18n("Masculine"));
         label_4->setText(i18n("Feminine"));
         label_5->setText(i18n("Neuter"));
 
         /* Show the GUI elements which are needed to switch the number */
         for (int i = 0; i < numberLayout->count(); ++i) {
             numberLayout->itemAt(i)->widget()->show();
         }
 
         m_DeclensionLineEdits[KEduVocWordFlag::Masculine | KEduVocWordFlag::Nominative] = masculine_1;
         m_DeclensionLineEdits[KEduVocWordFlag::Masculine | KEduVocWordFlag::Genitive] = masculine_2;
         m_DeclensionLineEdits[KEduVocWordFlag::Masculine | KEduVocWordFlag::Dative] = masculine_3;
         m_DeclensionLineEdits[KEduVocWordFlag::Masculine | KEduVocWordFlag::Accusative] = masculine_4;
         m_DeclensionLineEdits[KEduVocWordFlag::Masculine | KEduVocWordFlag::Ablative] = masculine_5;
         m_DeclensionLineEdits[KEduVocWordFlag::Masculine | KEduVocWordFlag::Locative] = masculine_6;
         m_DeclensionLineEdits[KEduVocWordFlag::Masculine | KEduVocWordFlag::Vocative] = masculine_7;
 
         m_DeclensionLineEdits[KEduVocWordFlag::Feminine | KEduVocWordFlag::Nominative] = feminine_1;
         m_DeclensionLineEdits[KEduVocWordFlag::Feminine | KEduVocWordFlag::Genitive] = feminine_2;
         m_DeclensionLineEdits[KEduVocWordFlag::Feminine | KEduVocWordFlag::Dative] = feminine_3;
         m_DeclensionLineEdits[KEduVocWordFlag::Feminine | KEduVocWordFlag::Accusative] = feminine_4;
         m_DeclensionLineEdits[KEduVocWordFlag::Feminine | KEduVocWordFlag::Ablative] = feminine_5;
         m_DeclensionLineEdits[KEduVocWordFlag::Feminine | KEduVocWordFlag::Locative] = feminine_6;
         m_DeclensionLineEdits[KEduVocWordFlag::Feminine | KEduVocWordFlag::Vocative] = feminine_7;
 
         m_DeclensionLineEdits[KEduVocWordFlag::Neuter | KEduVocWordFlag::Nominative] = neuter_1;
         m_DeclensionLineEdits[KEduVocWordFlag::Neuter | KEduVocWordFlag::Genitive] = neuter_2;
         m_DeclensionLineEdits[KEduVocWordFlag::Neuter | KEduVocWordFlag::Dative] = neuter_3;
         m_DeclensionLineEdits[KEduVocWordFlag::Neuter | KEduVocWordFlag::Accusative] = neuter_4;
         m_DeclensionLineEdits[KEduVocWordFlag::Neuter | KEduVocWordFlag::Ablative] = neuter_5;
         m_DeclensionLineEdits[KEduVocWordFlag::Neuter | KEduVocWordFlag::Locative] = neuter_6;
         m_DeclensionLineEdits[KEduVocWordFlag::Neuter | KEduVocWordFlag::Vocative] = neuter_7;
     }
 }
diff --git a/src/statistics/statisticsmainwindow.cpp b/src/statistics/statisticsmainwindow.cpp
index 8baa882d..016b1297 100644
--- a/src/statistics/statisticsmainwindow.cpp
+++ b/src/statistics/statisticsmainwindow.cpp
@@ -1,339 +1,335 @@
 /***************************************************************************
 
     Copyright 2008-2010 Frederik Gladhorn <gladhorn@kde.org>
     Copyright 2008 Daniel Laidig <d.laidig@gmx.de>
 
  ***************************************************************************
 
  ***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "statisticsmainwindow.h"
 
 #include <QHeaderView>
 
 #include <KLocalizedString>
 #include <KConfig>
 #include <KActionCollection>
 
 #include <keduvocdocument.h>
 
 #include "practice/configure/configurepracticedialog.h"
 #include "lessonstatisticsview.h"
 #include "statisticsmodel.h"
 #include "parleymainwindow.h"
 #include "parleyactions.h"
 
 #include "prefs.h"
 
 
 #include "ui_statisticsmainwindow.h"
 #include "conjugationoptions.h"
 
 
 StatisticsMainWindow::StatisticsMainWindow(KEduVocDocument *doc, ParleyMainWindow *parent)
     : KXmlGuiWindow(parent)
     , m_mainWindow(parent)
     , m_doc(doc)
     , m_ui(new Ui::StatisticsMainWindow)
     , m_conjugationOptions(0)
 {
     // KXmlGui
     setXMLFile(QStringLiteral("statisticsui.rc"));
     setObjectName(QStringLiteral("Statistics"));
 
     QWidget *mainWidget = new QWidget(this);
     setCentralWidget(mainWidget);
     m_ui->setupUi(mainWidget);
     //m_ui->caption->setText(i18nc("caption for an overview of the confidence levels for a document"
     //                             "Statistics for \"%1\"", m_doc->title()));
     m_statisticsModel = new StatisticsModel(this);
 
     setDocument(doc);
     initActions();
     initPracticeModeSelection();
     initLanguages();
     initPracticeMode();
 
     KConfigGroup cfg(KSharedConfig::openConfig(QStringLiteral("parleyrc")), objectName());
     applyMainWindowSettings(cfg);
 }
 
 StatisticsMainWindow::~StatisticsMainWindow()
 {
     if (m_conjugationOptions) {
         m_conjugationOptions->updateSettings();
     }
     KConfigGroup cfg(KSharedConfig::openConfig(QStringLiteral("parleyrc")), objectName());
     saveMainWindowSettings(cfg);
     delete m_ui;
 }
 
 void StatisticsMainWindow::syncConfig()
 {
     //qDebug() << "save tenses";
     if (m_conjugationOptions) {
         m_conjugationOptions->updateSettings();
     }
 }
 
 void StatisticsMainWindow::setDocument(KEduVocDocument* doc)
 {
     m_doc = doc;
     m_statisticsModel->setDocument(doc);
     m_ui->lessonStatistics->setModel(m_statisticsModel);
     m_ui->lessonStatistics->restoreExpandedStatus();
     m_ui->lessonStatistics->resizeColumnToContents(0);
 }
 
 void StatisticsMainWindow::initActions()
 {
     ParleyActions::create(ParleyActions::EnterEditMode, m_mainWindow, SLOT(showEditor()), actionCollection());
     ParleyActions::create(ParleyActions::StartPractice, m_mainWindow, SLOT(startPractice()), actionCollection());
     ParleyActions::create(ParleyActions::ConfigurePractice, m_mainWindow, SLOT(configurePractice()), actionCollection());
 }
 
 void StatisticsMainWindow::initPracticeModeSelection()
 {
     switch (Prefs::practiceMode()) {
     case Prefs::EnumPracticeMode::FlashCardsPractice:
         m_ui->flashCard->setChecked(true);
         break;
     case Prefs::EnumPracticeMode::MixedLettersPractice:
         m_ui->mixedLetters->setChecked(true);
         break;
     case Prefs::EnumPracticeMode::MultipleChoicePractice:
         m_ui->multipleChoice->setChecked(true);
         break;
     case Prefs::EnumPracticeMode::WrittenPractice:
         m_ui->written->setChecked(true);
         break;
     case Prefs::EnumPracticeMode::ExampleSentencesPractice:
         m_ui->exampleSentence->setChecked(true);
         break;
     case Prefs::EnumPracticeMode::GenderPractice:
         m_ui->gender->setChecked(true);
         break;
     case Prefs::EnumPracticeMode::ComparisonPractice:
         m_ui->comparisonForms->setChecked(true);
         break;
     case Prefs::EnumPracticeMode::ConjugationPractice:
         m_ui->conjugations->setChecked(true);
         showConjugationOptions();
         break;
     default:
         break;
     }
     connect(m_ui->flashCard, &QRadioButton::clicked,
             this, [=] {practiceModeSelected(Prefs::EnumPracticeMode::FlashCardsPractice);});
     connect(m_ui->mixedLetters, &QRadioButton::clicked,
             this, [=] {practiceModeSelected(Prefs::EnumPracticeMode::MixedLettersPractice);});
     connect(m_ui->multipleChoice, &QRadioButton::clicked,
             this, [=] {practiceModeSelected(Prefs::EnumPracticeMode::MultipleChoicePractice);});
     connect(m_ui->written, &QRadioButton::clicked,
             this, [=] {practiceModeSelected(Prefs::EnumPracticeMode::WrittenPractice);});
     connect(m_ui->exampleSentence, &QRadioButton::clicked,
             this, [=] {practiceModeSelected(Prefs::EnumPracticeMode::ExampleSentencesPractice);});
     connect(m_ui->gender, &QRadioButton::clicked,
             this, [=] {practiceModeSelected(Prefs::EnumPracticeMode::GenderPractice);});
     connect(m_ui->comparisonForms, &QRadioButton::clicked,
             this, [=] {practiceModeSelected(Prefs::EnumPracticeMode::ComparisonPractice);});
     connect(m_ui->conjugations, &QRadioButton::clicked,
             this, [=] {practiceModeSelected(Prefs::EnumPracticeMode::ConjugationPractice);});
 }
 
 void StatisticsMainWindow::initLanguages()
 {
     //qDebug() << "init languages: " << Prefs::learningLanguage() << Prefs::knownLanguage();
     const int totalNumLanguages = m_doc->identifierCount();
 
     if ( Prefs::knownLanguage() < 0 || totalNumLanguages <= Prefs::knownLanguage() ) {
         Prefs::setKnownLanguage(0);
     }
     if ( Prefs::learningLanguage() < 0 || totalNumLanguages <= Prefs::learningLanguage() ) {
         Prefs::setLearningLanguage(0);
     }
 
     if (Prefs::knownLanguage() >= totalNumLanguages
         || Prefs::learningLanguage() >= totalNumLanguages
         || Prefs::learningLanguage() == Prefs::knownLanguage())
     {
         Prefs::setKnownLanguage(0);
         Prefs::setLearningLanguage(1);
         //qDebug() << "Invalid language selection.";
     }
 
     // Insert data into the comboboxes.
     for (int i = 0; i < totalNumLanguages; ++i) {
         m_ui->learnedLanguage->insertItem(i, m_doc->identifier(i).name());
         m_ui->knownLanguage->insertItem(i, m_doc->identifier(i).name());
     }
     m_ui->learnedLanguage->setCurrentIndex(Prefs::learningLanguage());
     m_ui->knownLanguage->setCurrentIndex(Prefs::knownLanguage());
 
     connect(m_ui->learnedLanguage, SIGNAL(currentIndexChanged(int)), SLOT(languagesChanged()));
     connect(m_ui->knownLanguage, SIGNAL(currentIndexChanged(int)), SLOT(languagesChanged()));
 
     languagesChanged();
 }
 
 void StatisticsMainWindow::languagesChanged()
 {
     int knownLanguage = m_ui->knownLanguage->currentIndex();
     int learningLanguage = m_ui->learnedLanguage->currentIndex();
     Prefs::setLearningLanguage(learningLanguage);
     Prefs::setKnownLanguage(knownLanguage);
 
     emit languagesChanged(knownLanguage, learningLanguage);
 
     updateVisibleColumns();
     updateModelSettings();
 }
 
 void StatisticsMainWindow::initPracticeMode()
 {
     m_ui->practiceDirection->insertItem(0, i18n("Known to Learning"));
     m_ui->practiceDirection->insertItem(1, i18n("Learning to Known"));
     m_ui->practiceDirection->insertItem(2, i18n("Mixed Directions"));
     //m_ui->practiceDirection->insertItem(3, i18n("Mixed Directions with Sound"));
 
     int practiceDirection(Prefs::rememberPracticeDirection()
         ? practiceDirectionForPracticeMode(Prefs::practiceMode()) : Prefs::practiceDirection());
 
     if (practiceDirection < 0 || 3 < practiceDirection)
         Prefs::setPracticeDirection(Prefs::EnumPracticeDirection::MixedDirectionsWordsOnly);
 
     m_ui->practiceDirection->setCurrentIndex(practiceDirection);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(m_ui->practiceDirection, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
-#else
-    connect(m_ui->practiceDirection, static_cast<void (QComboBox::*)(int, const QString &)>(&QComboBox::currentIndexChanged) ,
-#endif
             this, &StatisticsMainWindow::practiceDirectionChanged);
 
     m_ui->rememberPracticeDirection->setChecked(Prefs::rememberPracticeDirection());
     connect(m_ui->rememberPracticeDirection, &QCheckBox::toggled,
             this, &StatisticsMainWindow::rememberPracticeDirectionChanged);
 }
 
 void StatisticsMainWindow::practiceModeSelected(int mode)
 {
     int previousPracticeMode = Prefs::practiceMode();
     Prefs::setPracticeMode(static_cast<Prefs::EnumPracticeMode::type>(mode));
     //qDebug() << "mode: " << mode << Prefs::practiceMode();
 
     showConjugationOptions(mode == Prefs::EnumPracticeMode::ConjugationPractice);
 
     if (Prefs::rememberPracticeDirection()) {
         setPracticeDirectionForPracticeMode(Prefs::practiceDirection(), previousPracticeMode);
         m_ui->practiceDirection->setCurrentIndex(practiceDirectionForPracticeMode(mode));
     }
 
     updateModelSettings();
 }
 
 void StatisticsMainWindow::practiceDirectionChanged(int mode)
 {
     //qDebug() << "new practice direction:" << mode;
     Prefs::setPracticeDirection(static_cast<Prefs::EnumPracticeDirection::type>(mode));
     if (Prefs::rememberPracticeDirection()) {
         setPracticeDirectionForPracticeMode(mode, Prefs::practiceMode());
     }
     updateVisibleColumns();
     updateModelSettings();
 }
 
 void StatisticsMainWindow::rememberPracticeDirectionChanged(bool checked)
 {
 //     qDebug() << "remember practice direction changed to: " << checked;
     Prefs::setRememberPracticeDirection(checked);
     if (checked) {
         setPracticeDirectionForPracticeMode(Prefs::practiceDirection(), Prefs::practiceMode());
     }
 }
 
 void StatisticsMainWindow::updateVisibleColumns()
 {
     bool isHidden;
     for (int i = ContainerModel::FirstDataColumn; i < m_ui->lessonStatistics->header()->count(); i++) {
         int iLang = i - ContainerModel::FirstDataColumn;
 
         switch (Prefs::practiceDirection()) {
         case Prefs::EnumPracticeDirection::LearningToKnown:
             isHidden = iLang != Prefs::knownLanguage();
             break;
         case Prefs::EnumPracticeDirection::MixedDirectionsWordsOnly:
         case Prefs::EnumPracticeDirection::MixedDirectionsWithSound:
             isHidden = iLang != Prefs::knownLanguage() && iLang !=  Prefs::learningLanguage();
             break;
         case Prefs::EnumPracticeDirection::KnownToLearning:
         // Use KnownToLearning as default.
         default:
             isHidden = iLang != Prefs::learningLanguage();
             break;
         }
 
         m_ui->lessonStatistics->setColumnHidden(i, isHidden);
         m_ui->lessonStatistics->adjustColumnWidths();
     }
 }
 
 void StatisticsMainWindow::showConjugationOptions(bool visible)
 {
     if (!m_conjugationOptions && !visible) {
         return;
     }
 
     if (!m_conjugationOptions) {
         m_conjugationOptions = new ConjugationOptions(m_doc, m_ui->modeSpecificOptions);
         QHBoxLayout* layout = new QHBoxLayout(m_ui->modeSpecificOptions);
         layout->setContentsMargins(0, 0, 0, 0);
         layout->addWidget(m_conjugationOptions);
         connect(this, QOverload<int, int>::of(&StatisticsMainWindow::languagesChanged),
                 m_conjugationOptions, &ConjugationOptions::setLanguages);
         m_conjugationOptions->setLanguages(Prefs::knownLanguage(), Prefs::learningLanguage());
         connect(m_conjugationOptions, &ConjugationOptions::checkBoxChanged,
                 this, &StatisticsMainWindow::updateModelSettings);
     }
     m_conjugationOptions->setVisible(visible);
 }
 
 void StatisticsMainWindow::configurePractice()
 {
     ConfigurePracticeDialog dialog(m_doc, this, QStringLiteral("practice settings"),  Prefs::self());
     dialog.exec();
 }
 
 int StatisticsMainWindow::practiceDirectionForPracticeMode(int mode) const
 {
     int direction = Prefs::practiceDirectionsByPracticeMode().value(mode, Prefs::practiceDirection());
     if ((direction < 0) || (direction > Prefs::EnumPracticeDirection::MixedDirectionsWordsOnly)) {
         direction = Prefs::EnumPracticeDirection::MixedDirectionsWordsOnly;
     }
     return direction;
 }
 
 void StatisticsMainWindow::setPracticeDirectionForPracticeMode(int direction, int mode)
 {
     QList<int> directions = Prefs::practiceDirectionsByPracticeMode();
     // Expand list if fields not used before
     for (int i = directions.size() - 1; i < mode; ++i) {
         directions.append(Prefs::practiceDirection());
     }
     directions[mode] = direction;
     Prefs::setPracticeDirectionsByPracticeMode(directions);
 }
 
 void StatisticsMainWindow::updateModelSettings()
 {
     m_ui->lessonStatistics->saveExpandedStatus();
     m_statisticsModel->updateDocumentSettings();
     m_ui->lessonStatistics->restoreExpandedStatus();
 }