diff --git a/src/networking/onlinesearch/onlinesearchabstract.cpp b/src/networking/onlinesearch/onlinesearchabstract.cpp
index 458dccfc..369b4ff8 100644
--- a/src/networking/onlinesearch/onlinesearchabstract.cpp
+++ b/src/networking/onlinesearch/onlinesearchabstract.cpp
@@ -1,683 +1,702 @@
 /***************************************************************************
  *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "onlinesearchabstract.h"
 
 #include <QFileInfo>
 #include <QNetworkReply>
 #include <QDir>
 #include <QTimer>
 #include <QStandardPaths>
 #include <QRegularExpression>
 #ifdef HAVE_QTWIDGETS
 #include <QListWidgetItem>
 #include <QDBusConnection>
 #include <QDBusConnectionInterface>
 #endif // HAVE_QTWIDGETS
 
 #ifdef HAVE_KF5
 #include <KLocalizedString>
 #include <KMessageBox>
 #endif // HAVE_KF5
 
 #include <KBibTeX>
 #include <Encoder>
 #include "internalnetworkaccessmanager.h"
+#include "onlinesearchabstract_p.h"
 #include "logging_networking.h"
 
 const QString OnlineSearchAbstract::queryKeyFreeText = QStringLiteral("free");
 const QString OnlineSearchAbstract::queryKeyTitle = QStringLiteral("title");
 const QString OnlineSearchAbstract::queryKeyAuthor = QStringLiteral("author");
 const QString OnlineSearchAbstract::queryKeyYear = QStringLiteral("year");
 
 const int OnlineSearchAbstract::resultNoError = 0;
 const int OnlineSearchAbstract::resultCancelled = 0; /// may get redefined in the future!
 const int OnlineSearchAbstract::resultUnspecifiedError = 1;
 const int OnlineSearchAbstract::resultAuthorizationRequired = 2;
 const int OnlineSearchAbstract::resultNetworkError = 3;
 const int OnlineSearchAbstract::resultInvalidArguments = 4;
 
 const char *OnlineSearchAbstract::httpUnsafeChars = "%:/=+$?&\0";
 
 
 #ifdef HAVE_QTWIDGETS
-QStringList OnlineSearchQueryFormAbstract::authorLastNames(const Entry &entry)
+OnlineSearchAbstract::Form::Private::Private()
+        : config(KSharedConfig::openConfig(QStringLiteral("kbibtexrc"))) {
+    /// nothing
+}
+
+QStringList OnlineSearchAbstract::Form::Private::authorLastNames(const Entry &entry)
 {
     const Encoder &encoder = Encoder::instance();
     const Value v = entry[Entry::ftAuthor];
     QStringList result;
     result.reserve(v.size());
     for (const QSharedPointer<ValueItem> &vi : v) {
         QSharedPointer<const Person> p = vi.dynamicCast<const Person>();
         if (!p.isNull())
             result.append(encoder.convertToPlainAscii(p->lastName()));
     }
 
     return result;
 }
 
-QString OnlineSearchQueryFormAbstract::guessFreeText(const Entry &entry) const
+QString OnlineSearchAbstract::Form::Private::guessFreeText(const Entry &entry)
 {
     /// If there is a DOI value in this entry, use it as free text
     static const QStringList doiKeys = {Entry::ftDOI, Entry::ftUrl};
     for (const QString &doiKey : doiKeys)
         if (!entry.value(doiKey).isEmpty()) {
             const QString text = PlainTextValue::text(entry[doiKey]);
             const QRegularExpressionMatch doiRegExpMatch = KBibTeX::doiRegExp.match(text);
             if (doiRegExpMatch.hasMatch())
                 return doiRegExpMatch.captured(0);
         }
 
     /// If there is no free text yet (e.g. no DOI number), try to identify an arXiv eprint number
     static const QStringList arxivKeys = {QStringLiteral("eprint"), Entry::ftNumber};
     for (const QString &arxivKey : arxivKeys)
         if (!entry.value(arxivKey).isEmpty()) {
             const QString text = PlainTextValue::text(entry[arxivKey]);
             const QRegularExpressionMatch arXivRegExpMatch = KBibTeX::arXivRegExpWithPrefix.match(text);
             if (arXivRegExpMatch.hasMatch())
                 return arXivRegExpMatch.captured(1);
         }
 
     return QString();
 }
 #endif // HAVE_QTWIDGETS
 
 OnlineSearchAbstract::OnlineSearchAbstract(QObject *parent)
         : QObject(parent), m_hasBeenCanceled(false), numSteps(0), curStep(0), m_previousBusyState(false), m_delayedStoppedSearchReturnCode(0)
 {
     m_parent = parent;
 }
 
 #ifdef HAVE_QTWIDGETS
 QIcon OnlineSearchAbstract::icon(QListWidgetItem *listWidgetItem)
 {
     static const QRegularExpression invalidChars(QStringLiteral("[^-a-z0-9_]"), QRegularExpression::CaseInsensitiveOption);
     const QString cacheDirectory = QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + QStringLiteral("/favicons/");
     QDir().mkpath(cacheDirectory);
     const QString fileNameStem = cacheDirectory + QString(favIconUrl()).remove(invalidChars);
     const QStringList fileNameExtensions {QStringLiteral(".ico"), QStringLiteral(".png"), QString()};
 
     for (const QString &extension : fileNameExtensions) {
         const QString fileName = fileNameStem + extension;
         if (QFileInfo::exists(fileName))
             return QIcon(fileName);
     }
 
     QNetworkRequest request(favIconUrl());
     QNetworkReply *reply = InternalNetworkAccessManager::instance().get(request);
     reply->setObjectName(fileNameStem);
     if (listWidgetItem != nullptr)
         m_iconReplyToListWidgetItem.insert(reply, listWidgetItem);
     connect(reply, &QNetworkReply::finished, this, &OnlineSearchAbstract::iconDownloadFinished);
     return QIcon::fromTheme(QStringLiteral("applications-internet"));
 }
 
-OnlineSearchQueryFormAbstract *OnlineSearchAbstract::customWidget(QWidget *) {
+OnlineSearchAbstract::Form *OnlineSearchAbstract::customWidget(QWidget *) {
     return nullptr;
 }
 
 void OnlineSearchAbstract::startSearchFromForm()
 {
     m_hasBeenCanceled = false;
     curStep = numSteps = 0;
     delayedStoppedSearch(resultNoError);
 }
 #endif // HAVE_QTWIDGETS
 
 QString OnlineSearchAbstract::name()
 {
     if (m_name.isEmpty()) {
         static const QRegularExpression invalidChars(QStringLiteral("[^-a-z0-9]"), QRegularExpression::CaseInsensitiveOption);
         m_name = label().remove(invalidChars);
     }
     return m_name;
 }
 
 bool OnlineSearchAbstract::busy() const
 {
     return numSteps > 0 && curStep < numSteps;
 }
 
 void OnlineSearchAbstract::cancel()
 {
     m_hasBeenCanceled = true;
 
     curStep = numSteps = 0;
     refreshBusyProperty();
 }
 
 QStringList OnlineSearchAbstract::splitRespectingQuotationMarks(const QString &text)
 {
     int p1 = 0, p2, max = text.length();
     QStringList result;
 
     while (p1 < max) {
         while (text[p1] == ' ') ++p1;
         p2 = p1;
         if (text[p2] == '"') {
             ++p2;
             while (p2 < max && text[p2] != '"')  ++p2;
         } else
             while (p2 < max && text[p2] != ' ') ++p2;
         result << text.mid(p1, p2 - p1 + 1).simplified();
         p1 = p2 + 1;
     }
     return result;
 }
 
 bool OnlineSearchAbstract::handleErrors(QNetworkReply *reply)
 {
     QUrl url;
     return handleErrors(reply, url);
 }
 
 bool OnlineSearchAbstract::handleErrors(QNetworkReply *reply, QUrl &newUrl)
 {
     /// The URL to be shown or logged shall not contain any API key
     const QUrl urlToShow = InternalNetworkAccessManager::removeApiKey(reply->url());
 
     newUrl = QUrl();
     if (m_hasBeenCanceled) {
         stopSearch(resultCancelled);
         return false;
     } else if (reply->error() != QNetworkReply::NoError) {
         m_hasBeenCanceled = true;
         const QString errorString = reply->errorString();
         qCWarning(LOG_KBIBTEX_NETWORKING) << "Search using" << label() << "failed (error code" << reply->error() << "," << errorString << "), HTTP code" << reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() << ":" << reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toByteArray() << ") for URL" << urlToShow.toDisplayString();
         const QNetworkRequest &request = reply->request();
         /// Dump all HTTP headers that were sent with the original request (except for API keys)
         const QList<QByteArray> rawHeadersSent = request.rawHeaderList();
         for (const QByteArray &rawHeaderName : rawHeadersSent) {
             if (rawHeaderName.toLower().contains("apikey") || rawHeaderName.toLower().contains("api-key")) continue; ///< skip dumping header values containing an API key
             qCDebug(LOG_KBIBTEX_NETWORKING) << "SENT " << rawHeaderName << ":" << request.rawHeader(rawHeaderName);
         }
         /// Dump all HTTP headers that were received
         const QList<QByteArray> rawHeadersReceived = reply->rawHeaderList();
         for (const QByteArray &rawHeaderName : rawHeadersReceived) {
             if (rawHeaderName.toLower().contains("apikey") || rawHeaderName.toLower().contains("api-key")) continue; ///< skip dumping header values containing an API key
             qCDebug(LOG_KBIBTEX_NETWORKING) << "RECVD " << rawHeaderName << ":" << reply->rawHeader(rawHeaderName);
         }
 #ifdef HAVE_KF5
         sendVisualNotification(errorString.isEmpty() ? i18n("Searching '%1' failed for unknown reason.", label()) : i18n("Searching '%1' failed with error message:\n\n%2", label(), errorString), label(), QStringLiteral("kbibtex"), 7 * 1000);
 #endif // HAVE_KF5
 
         int resultCode = resultUnspecifiedError;
         if (reply->error() == QNetworkReply::AuthenticationRequiredError || reply->error() == QNetworkReply::ProxyAuthenticationRequiredError)
             resultCode = resultAuthorizationRequired;
         else if (reply->error() == QNetworkReply::HostNotFoundError || reply->error() == QNetworkReply::TimeoutError)
             resultCode = resultNetworkError;
         stopSearch(resultCode);
 
         return false;
     }
 
     /**
      * Check the reply for various problems that might point to
      * more severe issues. Remember: those are only indicators
      * to problems which have to be handled elsewhere (therefore,
      * returning 'true' is totally ok here).
      */
     if (reply->attribute(QNetworkRequest::RedirectionTargetAttribute).isValid()) {
         newUrl = reply->url().resolved(reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl());
     } else if (reply->size() == 0)
         qCWarning(LOG_KBIBTEX_NETWORKING) << "Search using" << label() << "on url" << urlToShow.toDisplayString() << "returned no data";
 
     return true;
 }
 
 QString OnlineSearchAbstract::htmlAttribute(const QString &htmlCode, const int startPos, const QString &attribute) const
 {
     const int endPos = htmlCode.indexOf(QLatin1Char('>'), startPos);
     if (endPos < 0) return QString(); ///< no closing angle bracket found
 
     const QString attributePattern = QString(QStringLiteral(" %1=")).arg(attribute);
     const int attributePatternPos = htmlCode.indexOf(attributePattern, startPos, Qt::CaseInsensitive);
     if (attributePatternPos < 0 || attributePatternPos > endPos) return QString(); ///< attribute not found within limits
 
     const int attributePatternLen = attributePattern.length();
     const int openingQuotationMarkPos = attributePatternPos + attributePatternLen;
     const QChar quotationMark = htmlCode[openingQuotationMarkPos];
     if (quotationMark != QLatin1Char('"') && quotationMark != QLatin1Char('\'')) {
         /// No valid opening quotation mark found
         int spacePos = openingQuotationMarkPos;
         while (spacePos < endPos && !htmlCode[spacePos].isSpace()) ++spacePos;
         if (spacePos > endPos) return QString(); ///< no closing space found
         return htmlCode.mid(openingQuotationMarkPos, spacePos - openingQuotationMarkPos);
     } else {
         /// Attribute has either single or double quotation marks
         const int closingQuotationMarkPos = htmlCode.indexOf(quotationMark, openingQuotationMarkPos + 1);
         if (closingQuotationMarkPos < 0 || closingQuotationMarkPos > endPos) return QString(); ///< closing quotation mark not found within limits
         return htmlCode.mid(openingQuotationMarkPos + 1, closingQuotationMarkPos - openingQuotationMarkPos - 1);
     }
 }
 
 bool OnlineSearchAbstract::htmlAttributeIsSelected(const QString &htmlCode, const int startPos, const QString &attribute) const
 {
     const int endPos = htmlCode.indexOf(QLatin1Char('>'), startPos);
     if (endPos < 0) return false; ///< no closing angle bracket found
 
     const QString attributePattern = QStringLiteral(" ") + attribute;
     const int attributePatternPos = htmlCode.indexOf(attributePattern, startPos, Qt::CaseInsensitive);
     if (attributePatternPos < 0 || attributePatternPos > endPos) return false; ///< attribute not found within limits
 
     const int attributePatternLen = attributePattern.length();
     const QChar nextAfterAttributePattern = htmlCode[attributePatternPos + attributePatternLen];
     if (nextAfterAttributePattern.isSpace() || nextAfterAttributePattern == QLatin1Char('>') || nextAfterAttributePattern == QLatin1Char('/'))
         /// No value given for attribute (old-style HTML), so assuming it means checked/selected
         return true;
     else if (nextAfterAttributePattern == QLatin1Char('=')) {
         /// Expecting value to attribute, so retrieve it and check for 'selected' or 'checked'
         const QString attributeValue = htmlAttribute(htmlCode, attributePatternPos, attribute).toLower();
         return attributeValue == QStringLiteral("selected") || attributeValue == QStringLiteral("checked");
     }
 
     /// Reaching this point only if HTML code is invalid
     return false;
 }
 
 #ifdef HAVE_KF5
 /**
  * Display a passive notification popup using the D-Bus interface.
  * Copied from KDialog with modifications.
  */
 void OnlineSearchAbstract::sendVisualNotification(const QString &text, const QString &title, const QString &icon, int timeout)
 {
     static const QString dbusServiceName = QStringLiteral("org.freedesktop.Notifications");
     static const QString dbusInterfaceName = QStringLiteral("org.freedesktop.Notifications");
     static const QString dbusPath = QStringLiteral("/org/freedesktop/Notifications");
 
     // check if service already exists on plugin instantiation
     QDBusConnectionInterface *interface = QDBusConnection::sessionBus().interface();
     if (interface == nullptr || !interface->isServiceRegistered(dbusServiceName)) {
         return;
     }
 
     if (timeout <= 0)
         timeout = 10 * 1000;
 
     QDBusMessage m = QDBusMessage::createMethodCall(dbusServiceName, dbusPath, dbusInterfaceName, QStringLiteral("Notify"));
     const QList<QVariant> args {QStringLiteral("kdialog"), 0U, icon, title, text, QStringList(), QVariantMap(), timeout};
     m.setArguments(args);
 
     QDBusMessage replyMsg = QDBusConnection::sessionBus().call(m);
     if (replyMsg.type() == QDBusMessage::ReplyMessage) {
         if (!replyMsg.arguments().isEmpty()) {
             return;
         }
         // Not displaying any error messages as this is optional for kdialog
         // and KPassivePopup is a perfectly valid fallback.
         //else {
         //  qCDebug(LOG_KBIBTEX_NETWORKING) << "Error: received reply with no arguments.";
         //}
     } else if (replyMsg.type() == QDBusMessage::ErrorMessage) {
         //qCDebug(LOG_KBIBTEX_NETWORKING) << "Error: failed to send D-Bus message";
         //qCDebug(LOG_KBIBTEX_NETWORKING) << replyMsg;
     } else {
         //qCDebug(LOG_KBIBTEX_NETWORKING) << "Unexpected reply type";
     }
 }
 #endif // HAVE_KF5
 
 QString OnlineSearchAbstract::encodeURL(QString rawText)
 {
     const char *cur = httpUnsafeChars;
     while (*cur != '\0') {
         rawText = rawText.replace(QChar(*cur), '%' + QString::number(*cur, 16));
         ++cur;
     }
     rawText = rawText.replace(QLatin1Char(' '), QLatin1Char('+'));
     return rawText;
 }
 
 QString OnlineSearchAbstract::decodeURL(QString rawText)
 {
     static const QRegularExpression mimeRegExp(QStringLiteral("%([0-9A-Fa-f]{2})"));
     QRegularExpressionMatch mimeRegExpMatch;
     while ((mimeRegExpMatch = mimeRegExp.match(rawText)).hasMatch()) {
         bool ok = false;
         QChar c(mimeRegExpMatch.captured(1).toInt(&ok, 16));
         if (ok)
             rawText = rawText.replace(mimeRegExpMatch.captured(0), c);
     }
     rawText = rawText.replace(QStringLiteral("&amp;"), QStringLiteral("&")).replace(QLatin1Char('+'), QStringLiteral(" "));
     return rawText;
 }
 
 QMap<QString, QString> OnlineSearchAbstract::formParameters(const QString &htmlText, int startPos) const
 {
     /// how to recognize HTML tags
     static const QString formTagEnd = QStringLiteral("</form>");
     static const QString inputTagBegin = QStringLiteral("<input ");
     static const QString selectTagBegin = QStringLiteral("<select ");
     static const QString selectTagEnd = QStringLiteral("</select>");
     static const QString optionTagBegin = QStringLiteral("<option ");
 
     /// initialize result map
     QMap<QString, QString> result;
 
     /// determined boundaries of (only) "form" tag
     int endPos = htmlText.indexOf(formTagEnd, startPos, Qt::CaseInsensitive);
     if (startPos < 0 || endPos < 0) {
         qCWarning(LOG_KBIBTEX_NETWORKING) << "Could not locate form in text";
         return result;
     }
 
     /// search for "input" tags within form
     int p = htmlText.indexOf(inputTagBegin, startPos, Qt::CaseInsensitive);
     while (p > startPos && p < endPos) {
         /// get "type", "name", and "value" attributes
         const QString inputType = htmlAttribute(htmlText, p, QStringLiteral("type")).toLower();
         const QString inputName = htmlAttribute(htmlText, p, QStringLiteral("name"));
         const QString inputValue = htmlAttribute(htmlText, p, QStringLiteral("value"));
 
         if (!inputName.isEmpty()) {
             /// get value of input types
             if (inputType == QStringLiteral("hidden") || inputType == QStringLiteral("text") || inputType == QStringLiteral("submit"))
                 result[inputName] = inputValue;
             else if (inputType == QStringLiteral("radio")) {
                 /// must be selected
                 if (htmlAttributeIsSelected(htmlText, p, QStringLiteral("checked"))) {
                     result[inputName] = inputValue;
                 }
             } else if (inputType == QStringLiteral("checkbox")) {
                 /// must be checked
                 if (htmlAttributeIsSelected(htmlText, p, QStringLiteral("checked"))) {
                     /// multiple checkbox values with the same name are possible
                     result.insertMulti(inputName, inputValue);
                 }
             }
         }
         /// ignore input type "image"
 
         p = htmlText.indexOf(inputTagBegin, p + 1, Qt::CaseInsensitive);
     }
 
     /// search for "select" tags within form
     p = htmlText.indexOf(selectTagBegin, startPos, Qt::CaseInsensitive);
     while (p > startPos && p < endPos) {
         /// get "name" attribute from "select" tag
         const QString selectName = htmlAttribute(htmlText, p, QStringLiteral("name"));
 
         /// "select" tag contains one or several "option" tags, search all
         int popt = htmlText.indexOf(optionTagBegin, p, Qt::CaseInsensitive);
         int endSelect = htmlText.indexOf(selectTagEnd, p, Qt::CaseInsensitive);
         while (popt > p && popt < endSelect) {
             /// get "value" attribute from "option" tag
             const QString optionValue =  htmlAttribute(htmlText, popt, QStringLiteral("value"));
             if (!selectName.isEmpty() && !optionValue.isEmpty()) {
                 /// if this "option" tag is "selected", store value
                 if (htmlAttributeIsSelected(htmlText, popt, QStringLiteral("selected"))) {
                     result[selectName] = optionValue;
                 }
             }
 
             popt = htmlText.indexOf(optionTagBegin, popt + 1, Qt::CaseInsensitive);
         }
 
         p = htmlText.indexOf(selectTagBegin, p + 1, Qt::CaseInsensitive);
     }
 
     return result;
 }
 
 #ifdef HAVE_QTWIDGETS
 void OnlineSearchAbstract::iconDownloadFinished()
 {
     QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
 
     if (reply->error() == QNetworkReply::NoError) {
         const QUrl redirUrl = reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
         if (redirUrl.isValid()) {
             QNetworkRequest request(redirUrl);
             QNetworkReply *newReply = InternalNetworkAccessManager::instance().get(request);
             newReply->setObjectName(reply->objectName());
             QListWidgetItem *listWidgetItem = m_iconReplyToListWidgetItem.value(reply, nullptr);
             m_iconReplyToListWidgetItem.remove(reply);
             if (listWidgetItem != nullptr)
                 m_iconReplyToListWidgetItem.insert(newReply, listWidgetItem);
             connect(newReply, &QNetworkReply::finished, this, &OnlineSearchAbstract::iconDownloadFinished);
             return;
         }
 
         const QByteArray iconData = reply->readAll();
         if (iconData.size() < 10) {
             /// Unlikely that an icon's data is less than 10 bytes,
             /// must be an error.
             qCWarning(LOG_KBIBTEX_NETWORKING) << "Received invalid icon data from " << InternalNetworkAccessManager::removeApiKey(reply->url()).toDisplayString();
             return;
         }
 
         QString extension;
         if (iconData[1] == 'P' && iconData[2] == 'N' && iconData[3] == 'G') {
             /// PNG files have string "PNG" at second to fourth byte
             extension = QStringLiteral(".png");
         } else if (iconData[0] == (char)0x00 && iconData[1] == (char)0x00 && iconData[2] == (char)0x01 && iconData[3] == (char)0x00) {
             /// Microsoft Icon have first two bytes always 0x0000,
             /// third and fourth byte is 0x0001 (for .ico)
             extension = QStringLiteral(".ico");
         } else if (iconData[0] == '<') {
             /// HTML or XML code
             const QString htmlCode = QString::fromUtf8(iconData);
             qCDebug(LOG_KBIBTEX_NETWORKING) << "Received XML or HTML data from " << InternalNetworkAccessManager::removeApiKey(reply->url()).toDisplayString() << ": " << htmlCode.left(128);
             return;
         } else {
             qCWarning(LOG_KBIBTEX_NETWORKING) << "Favicon is of unknown format: " << InternalNetworkAccessManager::removeApiKey(reply->url()).toDisplayString();
             return;
         }
         const QString filename = reply->objectName() + extension;
 
         QFile iconFile(filename);
         if (iconFile.open(QFile::WriteOnly)) {
             iconFile.write(iconData);
             iconFile.close();
 
             QListWidgetItem *listWidgetItem = m_iconReplyToListWidgetItem.value(reply, nullptr);
             if (listWidgetItem != nullptr) {
                 /// Disable signals while updating the widget and its items
                 blockSignals(true);
                 listWidgetItem->setIcon(QIcon(filename));
                 /// Re-enable signals after updating the widget and its items
                 blockSignals(false);
             }
         } else {
             qCWarning(LOG_KBIBTEX_NETWORKING) << "Could not save icon data from URL" << InternalNetworkAccessManager::removeApiKey(reply->url()).toDisplayString() << "to file" << filename;
             return;
         }
     } else
         qCWarning(LOG_KBIBTEX_NETWORKING) << "Could not download icon from URL " << InternalNetworkAccessManager::removeApiKey(reply->url()).toDisplayString() << ": " << reply->errorString();
 }
 #endif // HAVE_QTWIDGETS
 
 void OnlineSearchAbstract::dumpToFile(const QString &filename, const QString &text)
 {
     const QString usedFilename = QDir::tempPath() + QLatin1Char('/') + filename;
 
     QFile f(usedFilename);
     if (f.open(QFile::WriteOnly)) {
         qCDebug(LOG_KBIBTEX_NETWORKING) << "Dumping text" << KBibTeX::squeezeText(text, 96) << "to" << usedFilename;
         f.write(text.toUtf8());
         f.close();
     }
 }
 
 void OnlineSearchAbstract::delayedStoppedSearch(int returnCode)
 {
     m_delayedStoppedSearchReturnCode = returnCode;
     QTimer::singleShot(500, this, &OnlineSearchAbstract::delayedStoppedSearchTimer);
 }
 
 void OnlineSearchAbstract::delayedStoppedSearchTimer()
 {
     stopSearch(m_delayedStoppedSearchReturnCode);
 }
 
 void OnlineSearchAbstract::sanitizeEntry(QSharedPointer<Entry> entry)
 {
     if (entry.isNull()) return;
 
     /// Sometimes, there is no identifier, so set a random one
     if (entry->id().isEmpty())
         entry->setId(QString(QStringLiteral("entry-%1")).arg(QString::number(qrand(), 36)));
     /// Missing entry type? Set it to 'misc'
     if (entry->type().isEmpty())
         entry->setType(Entry::etMisc);
 
     static const QString ftIssue = QStringLiteral("issue");
     if (entry->contains(ftIssue)) {
         /// ACM's Digital Library uses "issue" instead of "number" -> fix that
         Value v = entry->value(ftIssue);
         entry->remove(ftIssue);
         entry->insert(Entry::ftNumber, v);
     }
 
     /// If entry contains a description field but no abstract,
     /// rename description field to abstract
     static const QString ftDescription = QStringLiteral("description");
     if (!entry->contains(Entry::ftAbstract) && entry->contains(ftDescription)) {
         Value v = entry->value(ftDescription);
         entry->remove(ftDescription);
         entry->insert(Entry::ftAbstract, v);
     }
 
     /// Remove "dblp" artifacts in abstracts and keywords
     if (entry->contains(Entry::ftAbstract)) {
         const QString abstract = PlainTextValue::text(entry->value(Entry::ftAbstract));
         if (abstract == QStringLiteral("dblp"))
             entry->remove(Entry::ftAbstract);
     }
     if (entry->contains(Entry::ftKeywords)) {
         const QString keywords = PlainTextValue::text(entry->value(Entry::ftKeywords));
         if (keywords == QStringLiteral("dblp"))
             entry->remove(Entry::ftKeywords);
     }
 
     if (entry->contains(Entry::ftMonth)) {
         /// Fix strings for months: "September" -> "sep"
         Value monthValue = entry->value(Entry::ftMonth);
         bool updated = false;
         for (Value::Iterator it = monthValue.begin(); it != monthValue.end(); ++it) {
             const QString valueItem = PlainTextValue::text(*it);
 
             static const QRegularExpression longMonth = QRegularExpression(QStringLiteral("(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*"), QRegularExpression::CaseInsensitiveOption);
             const QRegularExpressionMatch longMonthMatch = longMonth.match(valueItem);
             if (longMonthMatch.hasMatch()) {
                 it = monthValue.erase(it);
                 it = monthValue.insert(it, QSharedPointer<MacroKey>(new MacroKey(longMonthMatch.captured(1).toLower())));
                 updated = true;
             }
         }
         if (updated)
             entry->insert(Entry::ftMonth, monthValue);
     }
 
     if (entry->contains(Entry::ftDOI) && entry->contains(Entry::ftUrl)) {
         /// Remove URL from entry if contains a DOI and the DOI field matches the DOI in the URL
         const Value &doiValue = entry->value(Entry::ftDOI);
         for (const auto &doiValueItem : doiValue) {
             const QString doi = PlainTextValue::text(doiValueItem);
             Value v = entry->value(Entry::ftUrl);
             bool gotChanged = false;
             for (Value::Iterator it = v.begin(); it != v.end();) {
                 const QSharedPointer<ValueItem> &vi = (*it);
                 if (vi->containsPattern(QStringLiteral("/") + doi)) {
                     it = v.erase(it);
                     gotChanged = true;
                 } else
                     ++it;
             }
             if (v.isEmpty())
                 entry->remove(Entry::ftUrl);
             else if (gotChanged)
                 entry->insert(Entry::ftUrl, v);
         }
     } else if (!entry->contains(Entry::ftDOI) && entry->contains(Entry::ftUrl)) {
         /// If URL looks like a DOI, remove URL and add a DOI field
         QSet<QString> doiSet; ///< using a QSet here to keep only unique DOIs
         Value v = entry->value(Entry::ftUrl);
         bool gotChanged = false;
         for (Value::Iterator it = v.begin(); it != v.end();) {
             const QString viText = PlainTextValue::text(*it);
             const QRegularExpressionMatch doiRegExpMatch = KBibTeX::doiRegExp.match(viText);
             if (doiRegExpMatch.hasMatch()) {
                 doiSet.insert(doiRegExpMatch.captured());
                 it = v.erase(it);
                 gotChanged = true;
             } else
                 ++it;
         }
         if (v.isEmpty())
             entry->remove(Entry::ftUrl);
         else if (gotChanged)
             entry->insert(Entry::ftUrl, v);
         if (!doiSet.isEmpty()) {
             Value doiValue;
             /// Rewriting QSet<QString> doiSet into a (sorted) list for reproducibility
             /// (required for automated test in KBibTeXNetworkingTest)
             QStringList list;
             for (const QString &doi : doiSet)
                 list.append(doi);
             list.sort();
             for (const QString &doi : const_cast<const QStringList &>(list))
                 doiValue.append(QSharedPointer<PlainText>(new PlainText(doi)));
             entry->insert(Entry::ftDOI, doiValue);
         }
     } else if (!entry->contains(Entry::ftDOI)) {
         const QRegularExpressionMatch doiRegExpMatch = KBibTeX::doiRegExp.match(entry->id());
         if (doiRegExpMatch.hasMatch()) {
             /// If entry id looks like a DOI, add a DOI field
             Value doiValue;
             doiValue.append(QSharedPointer<PlainText>(new PlainText(doiRegExpMatch.captured())));
             entry->insert(Entry::ftDOI, doiValue);
         }
     }
 
     /// Referenced strings or entries do not exist in the search result
     /// and BibTeX breaks if it finds a reference to a non-existing string or entry
     entry->remove(Entry::ftCrossRef);
 }
 
 bool OnlineSearchAbstract::publishEntry(QSharedPointer<Entry> entry)
 {
     if (entry.isNull()) return false;
 
     Value v;
     v.append(QSharedPointer<PlainText>(new PlainText(label())));
     entry->insert(QStringLiteral("x-fetchedfrom"), v);
 
     sanitizeEntry(entry);
 
     emit foundEntry(entry);
 
     return true;
 }
 
 void OnlineSearchAbstract::stopSearch(int errorCode) {
     if (errorCode == resultNoError)
         curStep = numSteps;
     else
         curStep = numSteps = 0;
     emit progress(curStep, numSteps);
     emit stoppedSearch(errorCode);
 }
 
 void OnlineSearchAbstract::refreshBusyProperty() {
     const bool newBusyState = busy();
     if (newBusyState != m_previousBusyState) {
         m_previousBusyState = newBusyState;
         emit busyChanged();
     }
 }
+
+#ifdef HAVE_QTWIDGETS
+OnlineSearchAbstract::Form::Form(QWidget *parent)
+        : QWidget(parent), d(new OnlineSearchAbstract::Form::Private())
+{
+    /// nothing
+}
+
+OnlineSearchAbstract::Form::~Form()
+{
+    delete d;
+}
+#endif // HAVE_QTWIDGETS
diff --git a/src/networking/onlinesearch/onlinesearchabstract.h b/src/networking/onlinesearch/onlinesearchabstract.h
index 97180037..18a3dfd4 100644
--- a/src/networking/onlinesearch/onlinesearchabstract.h
+++ b/src/networking/onlinesearch/onlinesearchabstract.h
@@ -1,229 +1,218 @@
 /***************************************************************************
  *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifndef KBIBTEX_NETWORKING_ONLINESEARCHABSTRACT_H
 #define KBIBTEX_NETWORKING_ONLINESEARCHABSTRACT_H
 
 #include <QObject>
 #include <QMap>
 #include <QString>
 #ifdef HAVE_QTWIDGETS
 #include <QWidget>
 #endif // HAVE_QTWIDGETS
 #include <QMetaType>
 #include <QIcon>
 #include <QUrl>
 
-#ifdef HAVE_KF5
-#include <KSharedConfig>
-#endif // HAVE_KF5
-
 #include <Entry>
 
 #ifdef HAVE_KF5
 #include "kbibtexnetworking_export.h"
 #endif // HAVE_KF5
 
 class QNetworkReply;
 class QNetworkRequest;
 class QListWidgetItem;
 
-#ifdef HAVE_QTWIDGETS
-/**
- * @author Thomas Fischer <fischer@unix-ag.uni-kl.de>
- */
-class KBIBTEXNETWORKING_EXPORT OnlineSearchQueryFormAbstract : public QWidget
-{
-    Q_OBJECT
-
-public:
-    explicit OnlineSearchQueryFormAbstract(QWidget *parent)
-            : QWidget(parent), config(KSharedConfig::openConfig(QStringLiteral("kbibtexrc"))) {
-        // nothing
-    }
-
-    ~OnlineSearchQueryFormAbstract() override {
-        /// nothing
-    }
-
-    virtual bool readyToStart() const = 0;
-
-    virtual void copyFromEntry(const Entry &) = 0;
-
-protected:
-    KSharedConfigPtr config;
-
-    QStringList authorLastNames(const Entry &entry);
-    QString guessFreeText(const Entry &entry) const;
-
-signals:
-    void returnPressed();
-};
-
-Q_DECLARE_METATYPE(OnlineSearchQueryFormAbstract *)
-#endif // HAVE_QTWIDGETS
-
 /**
  * @author Thomas Fischer <fischer@unix-ag.uni-kl.de>
  */
 class KBIBTEXNETWORKING_EXPORT OnlineSearchAbstract : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(bool busy READ busy NOTIFY busyChanged)
 
 public:
     explicit OnlineSearchAbstract(QObject *parent);
 
+#ifdef HAVE_QTWIDGETS
+    class Form;
+#endif // HAVE_QTWIDGETS
+
     static const QString queryKeyFreeText;
     static const QString queryKeyTitle;
     static const QString queryKeyAuthor;
     static const QString queryKeyYear;
 
     static const int resultCancelled;
     static const int resultNoError;
     static const int resultUnspecifiedError;
     static const int resultAuthorizationRequired;
     static const int resultNetworkError;
     static const int resultInvalidArguments;
 
 #ifdef HAVE_QTWIDGETS
     virtual void startSearchFromForm();
 #endif // HAVE_QTWIDGETS
     virtual void startSearch(const QMap<QString, QString> &query, int numResults) = 0;
     virtual QString label() const = 0;
     QString name();
 #ifdef HAVE_QTWIDGETS
     virtual QIcon icon(QListWidgetItem *listWidgetItem = nullptr);
-    virtual OnlineSearchQueryFormAbstract *customWidget(QWidget *parent);
+    virtual OnlineSearchAbstract::Form *customWidget(QWidget *parent);
 #endif // HAVE_QTWIDGETS
     virtual QUrl homepage() const = 0;
     virtual bool busy() const;
 
 public slots:
     void cancel();
 
 protected:
     QObject *m_parent;
     bool m_hasBeenCanceled;
 
     int numSteps, curStep;
 
     virtual QString favIconUrl() const = 0;
 
     /**
      * Split a string along spaces, but keep text in quotation marks together
      */
     static QStringList splitRespectingQuotationMarks(const QString &text);
 
     /**
     * Will check for common problems with downloads via QNetworkReply. It will return true
     * if there is no problem and you may process this job result. If there is a problem,
     * this function will notify the user if necessary (KMessageBox), emit a
     * "stoppedSearch" signal (by invoking "stopSearch"), and return false.
     * @see handleErrors(KJob*)
     */
     bool handleErrors(QNetworkReply *reply);
 
     /**
     * Will check for common problems with downloads via QNetworkReply. It will return true
     * if there is no problem and you may process this job result. If there is a problem,
     * this function will notify the user if necessary (KMessageBox), emit a
     * "stoppedSearch" signal (by invoking "stopSearch"), and return false.
     * @see handleErrors(KJob*)
     * @param newUrl will be set to the new URL if reply contains a redirection, otherwise reply's original URL
     */
     bool handleErrors(QNetworkReply *reply, QUrl &newUrl);
 
     /**
      * Encode a text to be HTTP URL save, e.g. replace '=' by '%3D'.
      */
     static QString encodeURL(QString rawText);
 
     static QString decodeURL(QString rawText);
 
     QMap<QString, QString> formParameters(const QString &htmlText, int startPos) const;
 
     void dumpToFile(const QString &filename, const QString &text);
 
     /**
      * Delay sending of stop signal by a few milliseconds.
      * Necessary if search stops (is cancelled) already in one
      * of the startSearch functions.
      */
     void delayedStoppedSearch(int returnCode);
 
     /**
      * Correct the most common problems encountered in fetched entries.
      * This function should be specialized in each descendant of this class.
      * @param entry Entry to sanitize
      */
     virtual void sanitizeEntry(QSharedPointer<Entry> entry);
 
     /**
      * Perform the following steps: (1) sanitize entry, (2) add name
      * of search engine that found the entry, (3) send it back to search
      * result list.
      * Returns true if a valid entry was passed to this function and all
      * steps could be performed.
      * @param entry Entry to publish
      * @return returns true if a valid entry was passed to this function and all steps could be performed.
      */
     bool publishEntry(QSharedPointer<Entry> entry);
 
     void stopSearch(int errorCode);
 
     /**
      * Allows an online search to notify about a change of its busy state,
      * i.e. that the public function @see busy may return a different value
      * than before. If the actual busy state has changed compared to previous
      * invocations of this function, the signal @see busyChanged will be
      * emitted.
      * This function here may be called both on changes from active to
      * inactive as well as vice versa.
      */
     void refreshBusyProperty();
 
 #ifdef HAVE_KF5
     void sendVisualNotification(const QString &text, const QString &title, const QString &icon, int timeout);
 #endif // HAVE_KF5
 
 private:
     bool m_previousBusyState;
     QString m_name;
     static const char *httpUnsafeChars;
 #ifdef HAVE_QTWIDGETS
     QMap<QNetworkReply *, QListWidgetItem *> m_iconReplyToListWidgetItem;
 #endif // HAVE_QTWIDGETS
     int m_delayedStoppedSearchReturnCode;
 
     QString htmlAttribute(const QString &htmlCode, const int startPos, const QString &attribute) const;
     bool htmlAttributeIsSelected(const QString &htmlCode, const int startPos, const QString &attribute) const;
 
 private slots:
 #ifdef HAVE_QTWIDGETS
     void iconDownloadFinished();
 #endif // HAVE_QTWIDGETS
     void delayedStoppedSearchTimer();
 
 signals:
     void foundEntry(QSharedPointer<Entry>);
     void stoppedSearch(int);
     void progress(int, int);
     void busyChanged();
 };
 
+#ifdef HAVE_QTWIDGETS
+/**
+ * @author Thomas Fischer <fischer@unix-ag.uni-kl.de>
+ */
+class KBIBTEXNETWORKING_EXPORT OnlineSearchAbstract::Form : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit Form(QWidget *parent);
+    ~Form();
+
+    virtual bool readyToStart() const = 0;
+    virtual void copyFromEntry(const Entry &) = 0;
+
+signals:
+    void returnPressed();
+
+protected:
+    class Private;
+    Private *d;
+};
+#endif // HAVE_QTWIDGETS
+
 #endif // KBIBTEX_NETWORKING_ONLINESEARCHABSTRACT_H
diff --git a/src/networking/onlinesearch/onlinesearchgeneral.h b/src/networking/onlinesearch/onlinesearchabstract_p.h
similarity index 62%
copy from src/networking/onlinesearch/onlinesearchgeneral.h
copy to src/networking/onlinesearch/onlinesearchabstract_p.h
index 91bb13ed..46f482f3 100644
--- a/src/networking/onlinesearch/onlinesearchgeneral.h
+++ b/src/networking/onlinesearch/onlinesearchabstract_p.h
@@ -1,56 +1,44 @@
 /***************************************************************************
  *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
-#ifndef KBIBTEX_NETWORKING_ONLINESEARCHGENERAL_H
-#define KBIBTEX_NETWORKING_ONLINESEARCHGENERAL_H
+#ifndef KBIBTEX_NETWORKING_ONLINESEARCHABSTRACT_P_H
+#define KBIBTEX_NETWORKING_ONLINESEARCHABSTRACT_P_H
 
-#include <KSharedConfig>
-
-#include <onlinesearch/OnlineSearchAbstract>
+#ifdef HAVE_QTWIDGETS
+#include "onlinesearchabstract.h"
 
-#ifdef HAVE_KF5
-#include "kbibtexnetworking_export.h"
-#endif // HAVE_KF5
+#include <QWidget>
 
-#ifdef HAVE_QTWIDGETS
-class QSpinBox;
-class QLineEdit;
+#include <KSharedConfig>
 
-class KBIBTEXNETWORKING_EXPORT OnlineSearchQueryFormGeneral : public OnlineSearchQueryFormAbstract
+/**
+ * @author Thomas Fischer <fischer@unix-ag.uni-kl.de>
+ */
+class OnlineSearchAbstract::Form::Private
 {
-    Q_OBJECT
-
 public:
-    explicit OnlineSearchQueryFormGeneral(QWidget *parent);
-
-    bool readyToStart() const override;
-    void copyFromEntry(const Entry &) override;
+    explicit Private();
 
-    QMap<QString, QString> getQueryTerms();
-    int getNumResults();
+    KSharedConfigPtr config;
 
-private:
-    QMap<QString, QLineEdit *> queryFields;
-    QSpinBox *numResultsField;
-    const QString configGroupName;
-
-    void loadState();
-    void saveState();
+    static QStringList authorLastNames(const Entry &entry);
+    static QString guessFreeText(const Entry &entry);
 };
+
 #endif // HAVE_QTWIDGETS
 
-#endif // KBIBTEX_NETWORKING_ONLINESEARCHGENERAL_H
+#endif // KBIBTEX_NETWORKING_ONLINESEARCHABSTRACT_P_H
diff --git a/src/networking/onlinesearch/onlinesearcharxiv.cpp b/src/networking/onlinesearch/onlinesearcharxiv.cpp
index e7e7564a..d87ef9e9 100644
--- a/src/networking/onlinesearch/onlinesearcharxiv.cpp
+++ b/src/networking/onlinesearch/onlinesearcharxiv.cpp
@@ -1,745 +1,746 @@
 /***************************************************************************
- *   Copyright (C) 2004-2018 by Thomas Fischer <fischer@unix-ag.uni-kl.de> *
+ *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "onlinesearcharxiv.h"
 
 #include <QNetworkReply>
 #include <QRegularExpression>
 #ifdef HAVE_QTWIDGETS
 #include <QGridLayout>
 #include <QLabel>
 #include <QSpinBox>
 #include <QLineEdit>
 #include <QTextStream>
 #endif // HAVE_QTWIDGETS
 
 #ifdef HAVE_KF5
 #include <KMessageBox>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #else // HAVE_KF5
 #define i18n(text) QObject::tr(text)
 #endif // HAVE_KF5
 
 #include <FileImporterBibTeX>
 #include <XSLTransform>
 #include <EncoderXML>
 #include "internalnetworkaccessmanager.h"
+#include "onlinesearchabstract_p.h"
 #include "logging_networking.h"
 
 #ifdef HAVE_QTWIDGETS
-class OnlineSearchArXiv::OnlineSearchQueryFormArXiv : public OnlineSearchQueryFormAbstract
+class OnlineSearchArXiv::Form : public OnlineSearchAbstract::Form
 {
     Q_OBJECT
 
 private:
     QString configGroupName;
 
     void loadState() {
-        KConfigGroup configGroup(config, configGroupName);
+        KConfigGroup configGroup(d->config, configGroupName);
         lineEditFreeText->setText(configGroup.readEntry(QStringLiteral("freeText"), QString()));
         numResultsField->setValue(configGroup.readEntry(QStringLiteral("numResults"), 10));
     }
 
 public:
     QLineEdit *lineEditFreeText;
     QSpinBox *numResultsField;
 
-    OnlineSearchQueryFormArXiv(QWidget *parent)
-            : OnlineSearchQueryFormAbstract(parent), configGroupName(QStringLiteral("Search Engine arXiv.org")) {
+    Form(QWidget *parent)
+            : OnlineSearchAbstract::Form(parent), configGroupName(QStringLiteral("Search Engine arXiv.org")) {
         QGridLayout *layout = new QGridLayout(this);
         layout->setMargin(0);
 
         QLabel *label = new QLabel(i18n("Free text:"), this);
         layout->addWidget(label, 0, 0, 1, 1);
         lineEditFreeText = new QLineEdit(this);
         lineEditFreeText->setClearButtonEnabled(true);
         lineEditFreeText->setFocus(Qt::TabFocusReason);
         layout->addWidget(lineEditFreeText, 0, 1, 1, 1);
         label->setBuddy(lineEditFreeText);
-        connect(lineEditFreeText, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormArXiv::returnPressed);
+        connect(lineEditFreeText, &QLineEdit::returnPressed, this, &OnlineSearchArXiv::Form::returnPressed);
 
         label = new QLabel(i18n("Number of Results:"), this);
         layout->addWidget(label, 1, 0, 1, 1);
         numResultsField = new QSpinBox(this);
         numResultsField->setMinimum(3);
         numResultsField->setMaximum(100);
         numResultsField->setValue(20);
         layout->addWidget(numResultsField, 1, 1, 1, 1);
         label->setBuddy(numResultsField);
 
         layout->setRowStretch(2, 100);
 
         loadState();
     }
 
     bool readyToStart() const override {
         return !lineEditFreeText->text().isEmpty();
     }
 
     void copyFromEntry(const Entry &entry) override {
-        lineEditFreeText->setText(authorLastNames(entry).join(QStringLiteral(" ")) + QLatin1Char(' ') + PlainTextValue::text(entry[Entry::ftTitle]));
+        lineEditFreeText->setText(d->authorLastNames(entry).join(QStringLiteral(" ")) + QLatin1Char(' ') + PlainTextValue::text(entry[Entry::ftTitle]));
     }
 
     void saveState() {
-        KConfigGroup configGroup(config, configGroupName);
+        KConfigGroup configGroup(d->config, configGroupName);
         configGroup.writeEntry(QStringLiteral("freeText"), lineEditFreeText->text());
         configGroup.writeEntry(QStringLiteral("numResults"), numResultsField->value());
-        config->sync();
+        d->config->sync();
     }
 };
 #endif // HAVE_QTWIDGETS
 
 class OnlineSearchArXiv::OnlineSearchArXivPrivate
 {
 private:
     static const QString xsltFilenameBase;
 
 public:
     const XSLTransform xslt;
 #ifdef HAVE_QTWIDGETS
-    OnlineSearchQueryFormArXiv *form;
+    OnlineSearchArXiv::Form *form;
 #endif // HAVE_QTWIDGETS
     const QString arXivQueryBaseUrl;
 
     OnlineSearchArXivPrivate(OnlineSearchArXiv *)
             : xslt(XSLTransform::locateXSLTfile(xsltFilenameBase)),
 #ifdef HAVE_QTWIDGETS
           form(nullptr),
 #endif // HAVE_QTWIDGETS
           arXivQueryBaseUrl(QStringLiteral("https://export.arxiv.org/api/query?"))
     {
         if (!xslt.isValid())
             qCWarning(LOG_KBIBTEX_NETWORKING) << "Failed to initialize XSL transformation based on file '" << xsltFilenameBase << "'";
     }
 
 #ifdef HAVE_QTWIDGETS
     QUrl buildQueryUrl() {
         /// format search terms
         const auto respectingQuotationMarks = OnlineSearchAbstract::splitRespectingQuotationMarks(form->lineEditFreeText->text());
         QStringList queryFragments;
         queryFragments.reserve(respectingQuotationMarks.size());
         for (const QString &queryFragment : respectingQuotationMarks)
             queryFragments.append(OnlineSearchAbstract::encodeURL(queryFragment));
         return QUrl(QString(QStringLiteral("%1search_query=all:\"%3\"&start=0&max_results=%2")).arg(arXivQueryBaseUrl).arg(form->numResultsField->value()).arg(queryFragments.join(QStringLiteral("\"+AND+all:\"")))); ///< join search terms with an AND operation
     }
 #endif // HAVE_QTWIDGETS
 
     QUrl buildQueryUrl(const QMap<QString, QString> &query, int numResults) {
         /// format search terms
         QStringList queryFragments;
         for (QMap<QString, QString>::ConstIterator it = query.constBegin(); it != query.constEnd(); ++it) {
             const auto respectingQuotationMarks = OnlineSearchAbstract::splitRespectingQuotationMarks(it.value());
             for (const auto &queryFragment : respectingQuotationMarks)
                 queryFragments.append(OnlineSearchAbstract::encodeURL(queryFragment));
         }
         return QUrl(QString(QStringLiteral("%1search_query=all:\"%3\"&start=0&max_results=%2")).arg(arXivQueryBaseUrl).arg(numResults).arg(queryFragments.join(QStringLiteral("\"+AND+all:\"")))); ///< join search terms with an AND operation
     }
 
     void interpreteJournal(Entry &entry) {
         /**
          * TODO examples
          *  - https://arxiv.org/abs/1111.5338
          *    Eur. Phys. J. H 36, 183-201 (2011)
          *  - https://arxiv.org/abs/1111.5348
          *    IJCSI International Journal of Computer Science Issues, Vol. 8, Issue 3, No. 1, 2011, 224-229
          *  - https://arxiv.org/abs/1110.3379
          *    IJCSI International Journal of Computer Science Issues, Vol. 8, Issue 5, No 3, September 2011 ISSN (Online): 1694-0814
          *  - https://arxiv.org/abs/1102.5769
          *    The International Journal of Multimedia & Its Applications, 3(1), 2011
          *  - https://arxiv.org/abs/1003.3022
          *    American Journal of Physics -- April 2010 -- Volume 78, Issue 4, pp. 377-383
          */
         static const QRegularExpression
         /**
          * Structure:
          *  - journal title: letters, space, dot
          *  - optional: spaces
          *  - volume: number
          *  - volume: number
          * Examples:
          *   Journal of Inefficient Algorithms 5 (2003) 35-39
          *   New J. Phys. 10 (2008) 033023
          *   Physics Letters A 297 (2002) 4-8
          *   Appl.Phys. B75 (2002) 655-665
          *   JHEP 0611 (2006) 045
          *  - https://arxiv.org/abs/1105.4915
          *    Astrophys. J. 736 (2011) 7
          *  - https://arxiv.org/abs/astro-ph/0209123
          *    Astrophys.J. 578 (2002) L103-L106
          *  - https://arxiv.org/abs/quant-ph/0611139
          *    Journal of Physics: Conference Series 70 (2007) 012003
          * Captures:
          *   1: journal title
          *   2: volume
          *   3: year
          *   4: page start
          *   6: page end
          */
         journalRef1(QStringLiteral("^([a-z. ]+[a-z.])\\s*(\\d+)\\s+\\((\\d{4})\\)\\s+([0-9A-Z]+)(-([0-9A-Z]+))?$"), QRegularExpression::CaseInsensitiveOption),
         /**
          * Examples:
          *  Journal of Inefficient Algorithms, Vol. 93, No. 2 (2009), pp. 42-51
          *  Stud. Hist. Phil. Mod. Phys., Vol 33 no 3 (2003), pp. 441-468
          *  - https://arxiv.org/abs/quant-ph/0311028
          *    International Journal of Quantum Information, Vol. 1, No. 4 (2003) 427-441
          *  - https://arxiv.org/abs/1003.3521
          *    Int. J. Geometric Methods in Modern Physics Vol. 8, No. 1 (2011) 155-165
          * Captures:
          *   1: journal title
          *   2: volume
          *   3: number
          *   4: year
          *   5: page start
          *   7: page end
          */
         journalRef2(QStringLiteral("^([a-zA-Z. ]+[a-zA-Z.]),\\s+Vol\\.?\\s+(\\d+)[,]?\\s+No\\.?\\s+(\\d+)\\s+\\((\\d{4})\\)[,]?\\s+(pp\\.\\s+)?(\\d+)(-(\\d+))?$"), QRegularExpression::CaseInsensitiveOption),
         /**
          * Examples:
          *   Journal of Inefficient Algorithms, volume 4, number 1, pp. 12-21, 2008
          *  - https://arxiv.org/abs/cs/0601030
          *    Scientometrics, volume 69, number 3, pp. 669-687, 2006
          * Captures:
          *   1: journal title
          *   2: volume
          *   3: number
          *   4: page start
          *   6: page end
          *   7: year
          */
         journalRef3(QStringLiteral("^([a-zA-Z. ]+),\\s+volume\\s+(\\d+),\\s+number\\s+(\\d+),\\s+pp\\.\\s+(\\d+)(-(\\d+))?,\\s+(\\d{4})$"), QRegularExpression::CaseInsensitiveOption),
         /**
          * Examples:
          *  Journal of Inefficient Algorithms 4(1): 101-122, 2010
          *  JHEP0809:131,2008
          *  Phys.Rev.D78:013004,2008
          *  Lect.NotesPhys.690:107-127,2006
          *  Europhys. Letters 70:1-7 (2005)
          *  - https://arxiv.org/abs/quant-ph/0608209
          *    J.Phys.A40:9025-9032,2007
          *  - https://arxiv.org/abs/hep-th/9907001
          *    Phys.Rev.Lett.85:5042-5045,2000
          *  - https://arxiv.org/abs/physics/0606007
          *    Journal of Conflict Resolution 51(1): 58 - 88 (2007)
          *  - https://arxiv.org/abs/arxiv:cs/0609126
          *    Learn.Publ.20:16-22,2007
          *  - https://arxiv.org/abs/cs/9901005
          *    Journal of Artificial Intelligence Research (JAIR), 9:247-293
          *  - https://arxiv.org/abs/hep-ph/0403113
          *    Nucl.Instrum.Meth.A534:250-259,2004
          * Captures:
          *   1: journal title
          *   2: volume
          *   4: number
          *   5: page start
          *   7: page end
          *   9 or 10: year
          */
         journalRef4(QStringLiteral("^([a-z. ()]+)[,]?\\s*(\\d+)(\\((\\d+)\\))?:\\s*(\\d+)(\\s*-\\s*(\\d+))?(,\\s*(\\d{4})|\\s+\\((\\d{4})\\))?$"), QRegularExpression::CaseInsensitiveOption),
         /**
          * Examples:
          *  Journal of Inefficient Algorithms vol. 31, 4 2000
          *  Phys. Rev. A 71, 032339 (2005)
          *  Phys. Rev. Lett. 91, 027901 (2003)
          *  Phys. Rev. A 78, 013620 (2008)
          *  Phys. Rev. E 62, 1842 (2000)
          *  J. Math. Phys. 49, 032105 (2008)
          *  Phys. Rev. Lett. 91, 217905 (2003).
          *  Physical Review B vol. 66, 161320(R) (2002)
          *  - https://arxiv.org/abs/1003.1050
          *    Phys. Rev. A 82, 012304 (2010)
          *  - https://arxiv.org/abs/quant-ph/0607107
          *    J. Mod. Opt., 54, 2211 (2007)
          *  - https://arxiv.org/abs/quant-ph/0602069
          *    New J. Phys. 8, 58 (2006)
          *  - https://arxiv.org/abs/quant-ph/0610030
          *    Rev. Mod. Phys. 79, 555 (2007)
          *  - https://arxiv.org/abs/1007.2292
          *    J. Phys. A: Math. Theor. 44, 145304 (2011)
          * Captures:
          *   1: journal title
          *   3: volume
          *   4: page start
          *   6: year
          */
         journalRef5(QStringLiteral("^([a-zA-Z. ]+)\\s+(vol\\.\\s+)?(\\d+),\\s+(\\d+)(\\([A-Z]+\\))?\\s+\\((\\d{4})\\)[.]?$")),
         /**
          * Examples:
          *  Journal of Inefficient Algorithms, 11(2) (1999) 42-55
          *  Learned Publishing, 20(1) (January 2007) 16-22
          * Captures:
          *   1: journal title
          *   2: volume
          *   3: number
          *   4: year
          *   5: page start
          *   7: page end
          */
         journalRef6(QStringLiteral("^([a-zA-Z. ]+),\\s+(\\d+)\\((\\d+)\\)\\s+(\\(([A-Za-z]+\\s+)?(\\d{4})\\))?\\s+(\\d+)(-(\\d+))?$")),
         /**
          * Examples:
          *  Pacific J. Math. 231 (2007), no. 2, 279–291
          * Captures:
          *   1: journal title
          *   2: volume
          *   3: year
          *   4: number
          *   5: page start
          *   6: page end
          */
         journalRef7(QStringLiteral("^([a-zA-Z. ]+[a-zA-Z.])\\s+(\\d+)\\s+\\((\\d+)\\), no\\.\\s+(\\d+),\\s+(\\d)[^ ]+(\\d+)$")),
         generalJour(QStringLiteral("^[a-z0-9]{,3}[a-z. ]+"), QRegularExpression::CaseInsensitiveOption),
         generalYear(QStringLiteral("\\b(18|19|20)\\d{2}\\b")),
         generalPages(QStringLiteral("\\b([1-9]\\d{0,2})\\s*[-]+\\s*([1-9]\\d{0,2})\\b"));
         const QString journalText = PlainTextValue::text(entry.value(Entry::ftJournal));
 
         /// nothing to do on empty journal text
         if (journalText.isEmpty()) return;
         else entry.remove(Entry::ftJournal);
 
         QRegularExpressionMatch match;
         if ((match = journalRef1.match(journalText)).hasMatch()) {
             /**
              * Captures:
              *   1: journal title
              *   2: volume
              *   3: year
              *   4: page start
              *   6: page end
              */
 
             QString text;
             if (!(text = match.captured(1)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftJournal, v);
             }
             if (!(text = match.captured(2)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftVolume, v);
             }
             if (!(text = match.captured(3)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftYear, v);
             }
             if (!(text = match.captured(4)).isEmpty()) {
                 const QString endPage = match.captured(6);
                 if (endPage.isEmpty()) {
                     Value v;
                     v.append(QSharedPointer<PlainText>(new PlainText(text)));
                     entry.insert(Entry::ftPages, v);
                 } else {
                     Value v;
                     v.append(QSharedPointer<PlainText>(new PlainText(QString(QStringLiteral("%1--%2")).arg(text, endPage))));
                     entry.insert(Entry::ftPages, v);
                 }
             }
         } else if ((match = journalRef2.match(journalText)).hasMatch()) {
             /**
              * Captures:
              *   1: journal title
              *   2: volume
              *   3: number
              *   4: year
              *   5: page start
              *   7: page end
              */
 
             QString text;
             if (!(text = match.captured(1)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftJournal, v);
             }
             if (!(text = match.captured(2)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftVolume, v);
             }
             if (!(text = match.captured(3)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftNumber, v);
             }
             if (!(text = match.captured(4)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftYear, v);
             }
             if (!(text = match.captured(5)).isEmpty()) {
                 const QString endPage = match.captured(7);
                 if (endPage.isEmpty()) {
                     Value v;
                     v.append(QSharedPointer<PlainText>(new PlainText(text)));
                     entry.insert(Entry::ftPages, v);
                 } else {
                     Value v;
                     v.append(QSharedPointer<PlainText>(new PlainText(QString(QStringLiteral("%1%3%2")).arg(text, endPage, QChar(0x2013)))));
                     entry.insert(Entry::ftPages, v);
                 }
             }
         } else if ((match = journalRef3.match(journalText)).hasMatch()) {
             /**
              * Captures:
              *   1: journal title
              *   2: volume
              *   4: number
              *   5: page start
              *   7: page end
              *   9 or 10: year
              */
 
             QString text;
             if (!(text = match.captured(1)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftJournal, v);
             }
             if (!(text = match.captured(2)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftVolume, v);
             }
             if (!(text = match.captured(4)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftNumber, v);
             }
             if (!(text = match.captured(9)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftYear, v);
                 if (!(text = match.captured(10)).isEmpty()) {
                     Value v;
                     v.append(QSharedPointer<PlainText>(new PlainText(text)));
                     entry.insert(Entry::ftYear, v);
                 }
                 if (!(text = match.captured(5)).isEmpty()) {
                     const QString endPage = match.captured(7);
                     if (endPage.isEmpty()) {
                         Value v;
                         v.append(QSharedPointer<PlainText>(new PlainText(text)));
                         entry.insert(Entry::ftPages, v);
                     } else {
                         Value v;
                         v.append(QSharedPointer<PlainText>(new PlainText(QString(QStringLiteral("%1%3%2")).arg(text, endPage, QChar(0x2013)))));
                         entry.insert(Entry::ftPages, v);
                     }
                 }
             }
 
         } else if ((match = journalRef4.match(journalText)).hasMatch()) {
             /**
              * Captures:
              *   1: journal title
              *   2: volume
              *   4: number
              *   5: page start
              *   7: page end
              *   9 or 10: year
              */
 
             QString text;
             if (!(text = match.captured(1)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftJournal, v);
             }
             if (!(text = match.captured(2)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftVolume, v);
             }
             if (!(text = match.captured(5)).isEmpty()) {
                 const QString endPage = match.captured(7);
                 if (endPage.isEmpty()) {
                     Value v;
                     v.append(QSharedPointer<PlainText>(new PlainText(text)));
                     entry.insert(Entry::ftPages, v);
                 } else {
                     Value v;
                     v.append(QSharedPointer<PlainText>(new PlainText(text.append(QChar(0x2013)).append(endPage))));
                     entry.insert(Entry::ftPages, v);
                 }
             }
             if (!(text = match.captured(9)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftYear, v);
             }
 
         } else if ((match = journalRef5.match(journalText)).hasMatch()) {
             /** Captures:
               *   1: journal title
               *   3: volume
               *   4: page start
               *   6: year
               */
 
             QString text;
             if (!(text = match.captured(1)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftJournal, v);
             }
             if (!(text = match.captured(3)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftVolume, v);
             }
             if (!(text = match.captured(4)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftPages, v);
             }
             if (!(text = match.captured(6)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftYear, v);
             }
 
         } else if ((match = journalRef6.match(journalText)).hasMatch()) {
             /** Captures:
               *   1: journal title
               *   2: volume
               *   3: number
               *   4: year
               *   5: page start
               *   7: page end
               */
 
             QString text;
             if (!(text = match.captured(1)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftJournal, v);
             }
             if (!(text = match.captured(2)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftVolume, v);
             }
             if (!(text = match.captured(3)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftNumber, v);
             }
             if (!(text = match.captured(4)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftYear, v);
             }
             if (!(text = match.captured(5)).isEmpty()) {
                 const QString endPage = match.captured(7);
                 if (endPage.isEmpty()) {
                     Value v;
                     v.append(QSharedPointer<PlainText>(new PlainText(text)));
                     entry.insert(Entry::ftPages, v);
                 } else {
                     Value v;
                     v.append(QSharedPointer<PlainText>(new PlainText(QString(QStringLiteral("%1%3%2")).arg(text, endPage, QChar(0x2013)))));
                     entry.insert(Entry::ftPages, v);
                 }
             }
 
         } else if ((match = journalRef7.match(journalText)).hasMatch()) {
             /** Captures:
              *   1: journal title
              *   2: volume
              *   3: year
              *   4: number
              *   5: page start
              *   6: page end
              */
 
             QString text;
             if (!(text = match.captured(1)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftJournal, v);
             }
             if (!(text = match.captured(2)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftVolume, v);
             }
             if (!(text = match.captured(3)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftYear, v);
             }
             if (!(text = match.captured(4)).isEmpty()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(text)));
                 entry.insert(Entry::ftNumber, v);
             }
             if (!(text = match.captured(5)).isEmpty()) {
                 const QString endPage = match.captured(6);
                 if (endPage.isEmpty()) {
                     Value v;
                     v.append(QSharedPointer<PlainText>(new PlainText(text)));
                     entry.insert(Entry::ftPages, v);
                 } else {
                     Value v;
                     v.append(QSharedPointer<PlainText>(new PlainText(QString(QStringLiteral("%1%3%2")).arg(text, endPage, QChar(0x2013)))));
                     entry.insert(Entry::ftPages, v);
                 }
             }
 
         } else {
             if ((match = generalJour.match(journalText)).hasMatch()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(match.captured(0))));
                 entry.insert(Entry::ftPages, v);
             }
             if ((match = generalYear.match(journalText)).hasMatch()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(match.captured(0))));
                 entry.insert(Entry::ftYear, v);
             }
             if ((match = generalPages.match(journalText)).hasMatch()) {
                 Value v;
                 v.append(QSharedPointer<PlainText>(new PlainText(match.captured(0))));
                 entry.insert(Entry::ftPages, v);
             }
         }
     }
 };
 
 const QString OnlineSearchArXiv::OnlineSearchArXivPrivate::xsltFilenameBase = QStringLiteral("arxiv2bibtex.xsl");
 
 
 OnlineSearchArXiv::OnlineSearchArXiv(QObject *parent)
         : OnlineSearchAbstract(parent), d(new OnlineSearchArXiv::OnlineSearchArXivPrivate(this))
 {
     /// nothing
 }
 
 OnlineSearchArXiv::~OnlineSearchArXiv()
 {
     delete d;
 }
 
 #ifdef HAVE_QTWIDGETS
 void OnlineSearchArXiv::startSearchFromForm()
 {
     m_hasBeenCanceled = false;
     emit progress(curStep = 0, numSteps = 1);
 
     QNetworkRequest request(d->buildQueryUrl());
     QNetworkReply *reply = InternalNetworkAccessManager::instance().get(request);
     InternalNetworkAccessManager::instance().setNetworkReplyTimeout(reply);
     connect(reply, &QNetworkReply::finished, this, &OnlineSearchArXiv::downloadDone);
 
     d->form->saveState();
 
     refreshBusyProperty();
 }
 #endif // HAVE_QTWIDGETS
 
 void OnlineSearchArXiv::startSearch(const QMap<QString, QString> &query, int numResults)
 {
     m_hasBeenCanceled = false;
     emit progress(curStep = 0, numSteps = 1);
 
     QNetworkRequest request(d->buildQueryUrl(query, numResults));
     QNetworkReply *reply = InternalNetworkAccessManager::instance().get(request);
     InternalNetworkAccessManager::instance().setNetworkReplyTimeout(reply);
     connect(reply, &QNetworkReply::finished, this, &OnlineSearchArXiv::downloadDone);
 
     refreshBusyProperty();
 }
 
 QString OnlineSearchArXiv::label() const
 {
 #ifdef HAVE_KF5
     return i18n("arXiv.org");
 #else // HAVE_KF5
     //= onlinesearch-arxiv-label
     return QObject::tr("arXiv.org");
 #endif // HAVE_KF5
 }
 
 QString OnlineSearchArXiv::favIconUrl() const
 {
     return QStringLiteral("https://arxiv.org/favicon.ico");
 }
 
 #ifdef HAVE_QTWIDGETS
-OnlineSearchQueryFormAbstract *OnlineSearchArXiv::customWidget(QWidget *parent)
+OnlineSearchAbstract::Form *OnlineSearchArXiv::customWidget(QWidget *parent)
 {
     if (d->form == nullptr)
-        d->form = new OnlineSearchArXiv::OnlineSearchQueryFormArXiv(parent);
+        d->form = new OnlineSearchArXiv::Form(parent);
     return d->form;
 }
 #endif // HAVE_QTWIDGETS
 
 QUrl OnlineSearchArXiv::homepage() const
 {
     return QUrl(QStringLiteral("https://arxiv.org/"));
 }
 
 void OnlineSearchArXiv::downloadDone()
 {
     emit progress(++curStep, numSteps);
 
     QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
 
     if (handleErrors(reply)) {
         /// ensure proper treatment of UTF-8 characters
         QString result = QString::fromUtf8(reply->readAll().constData());
         result = result.remove(QStringLiteral("xmlns=\"http://www.w3.org/2005/Atom\"")); // FIXME fix arxiv2bibtex.xsl to handle namespace
 
         /// use XSL transformation to get BibTeX document from XML result
         const QString bibTeXcode = EncoderXML::instance().decode(d->xslt.transform(result));
         if (bibTeXcode.isEmpty()) {
             qCWarning(LOG_KBIBTEX_NETWORKING) << "XSL tranformation failed for data from " << InternalNetworkAccessManager::removeApiKey(reply->url()).toDisplayString();
             stopSearch(resultInvalidArguments);
         } else {
             FileImporterBibTeX importer(this);
             File *bibtexFile = importer.fromString(bibTeXcode);
 
             bool hasEntries = false;
             if (bibtexFile != nullptr) {
                 for (const auto &element : const_cast<const File &>(*bibtexFile)) {
                     QSharedPointer<Entry> entry = element.dynamicCast<Entry>();
                     hasEntries |= publishEntry(entry);
                 }
 
                 stopSearch(resultNoError);
 
                 delete bibtexFile;
             } else {
                 qCWarning(LOG_KBIBTEX_NETWORKING) << "No valid BibTeX file results returned on request on" << InternalNetworkAccessManager::removeApiKey(reply->url()).toDisplayString();
                 stopSearch(resultUnspecifiedError);
             }
         }
     }
 
     refreshBusyProperty();
 }
 
 void OnlineSearchArXiv::sanitizeEntry(QSharedPointer<Entry> entry)
 {
     OnlineSearchAbstract::sanitizeEntry(entry);
 
     d->interpreteJournal(*entry);
 }
 
 #include "onlinesearcharxiv.moc"
diff --git a/src/networking/onlinesearch/onlinesearcharxiv.h b/src/networking/onlinesearch/onlinesearcharxiv.h
index 61f44d35..54fd08cd 100644
--- a/src/networking/onlinesearch/onlinesearcharxiv.h
+++ b/src/networking/onlinesearch/onlinesearcharxiv.h
@@ -1,63 +1,63 @@
 /***************************************************************************
  *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifndef KBIBTEX_NETWORKING_ONLINESEARCHARXIV_H
 #define KBIBTEX_NETWORKING_ONLINESEARCHARXIV_H
 
 #include <onlinesearch/OnlineSearchAbstract>
 
 #ifdef HAVE_KF5
 #include "kbibtexnetworking_export.h"
 #endif // HAVE_KF5
 
 /**
  * @author Thomas Fischer <fischer@unix-ag.uni-kl.de>
  */
 class KBIBTEXNETWORKING_EXPORT OnlineSearchArXiv : public OnlineSearchAbstract
 {
     Q_OBJECT
 
 public:
     explicit OnlineSearchArXiv(QObject *parent);
     ~OnlineSearchArXiv() override;
 
 #ifdef HAVE_QTWIDGETS
     void startSearchFromForm() override;
 #endif // HAVE_QTWIDGETS
     void startSearch(const QMap<QString, QString> &query, int numResults) override;
     QString label() const override;
 #ifdef HAVE_QTWIDGETS
-    OnlineSearchQueryFormAbstract *customWidget(QWidget *parent) override;
+    OnlineSearchAbstract::Form *customWidget(QWidget *parent) override;
 #endif // HAVE_QTWIDGETS
     QUrl homepage() const override;
 
 protected:
     QString favIconUrl() const override;
     void sanitizeEntry(QSharedPointer<Entry> entry) override;
 
 private:
 #ifdef HAVE_QTWIDGETS
-    class OnlineSearchQueryFormArXiv;
+    class Form;
 #endif // HAVE_QTWIDGETS
     class OnlineSearchArXivPrivate;
     OnlineSearchArXivPrivate *d;
 
 private slots:
     void downloadDone();
 };
 
 #endif // KBIBTEX_NETWORKING_ONLINESEARCHARXIV_H
diff --git a/src/networking/onlinesearch/onlinesearchbibsonomy.cpp b/src/networking/onlinesearch/onlinesearchbibsonomy.cpp
index 3dc321a1..9ebf2384 100644
--- a/src/networking/onlinesearch/onlinesearchbibsonomy.cpp
+++ b/src/networking/onlinesearch/onlinesearchbibsonomy.cpp
@@ -1,291 +1,292 @@
 /***************************************************************************
- *   Copyright (C) 2004-2018 by Thomas Fischer <fischer@unix-ag.uni-kl.de> *
+ *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "onlinesearchbibsonomy.h"
 
 #include <QBuffer>
 #ifdef HAVE_QTWIDGETS
 #include <QLayout>
 #include <QSpinBox>
 #include <QComboBox>
 #include <QLineEdit>
 #include <QLabel>
 #include <QIcon>
 #endif // HAVE_QTWIDGETS
 #include <QNetworkReply>
 
 #ifdef HAVE_KF5
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KMessageBox>
 #else // HAVE_KF5
 #define i18n(text) QObject::tr(text)
 #endif // HAVE_KF5
 
 #include <FileImporterBibTeX>
 #include <File>
 #include <Entry>
 #include "internalnetworkaccessmanager.h"
+#include "onlinesearchabstract_p.h"
 #include "logging_networking.h"
 
 #ifdef HAVE_QTWIDGETS
-class OnlineSearchBibsonomy::OnlineSearchQueryFormBibsonomy : public OnlineSearchQueryFormAbstract
+class OnlineSearchBibsonomy::Form : public OnlineSearchAbstract::Form
 {
     Q_OBJECT
 
 private:
     QString configGroupName;
 
     void loadState() {
-        KConfigGroup configGroup(config, configGroupName);
+        KConfigGroup configGroup(d->config, configGroupName);
         comboBoxSearchWhere->setCurrentIndex(configGroup.readEntry(QStringLiteral("searchWhere"), 0));
         lineEditSearchTerm->setText(configGroup.readEntry(QStringLiteral("searchTerm"), QString()));
         numResultsField->setValue(configGroup.readEntry(QStringLiteral("numResults"), 10));
     }
 
 public:
     QComboBox *comboBoxSearchWhere;
     QLineEdit *lineEditSearchTerm;
     QSpinBox *numResultsField;
 
-    OnlineSearchQueryFormBibsonomy(QWidget *widget)
-            : OnlineSearchQueryFormAbstract(widget), configGroupName(QStringLiteral("Search Engine Bibsonomy")) {
+    Form(QWidget *widget)
+            : OnlineSearchAbstract::Form(widget), configGroupName(QStringLiteral("Search Engine Bibsonomy")) {
         QGridLayout *layout = new QGridLayout(this);
         layout->setMargin(0);
 
         comboBoxSearchWhere = new QComboBox(this);
         layout->addWidget(comboBoxSearchWhere, 0, 0, 1, 1);
         comboBoxSearchWhere->setEditable(true);
         comboBoxSearchWhere->addItem(i18n("Tag"), "tag");
         comboBoxSearchWhere->addItem(i18n("User"), "user");
         comboBoxSearchWhere->addItem(i18n("Group"), "group");
         comboBoxSearchWhere->addItem(i18n("Author"), "author");
         comboBoxSearchWhere->addItem(i18n("Concept"), "concept/tag");
         comboBoxSearchWhere->addItem(i18n("BibTeX Key"), "bibtexkey");
         comboBoxSearchWhere->addItem(i18n("Everywhere"), "search");
         comboBoxSearchWhere->setCurrentIndex(comboBoxSearchWhere->count() - 1);
 
         lineEditSearchTerm = new QLineEdit(this);
         layout->addWidget(lineEditSearchTerm, 0, 1, 1, 1);
         lineEditSearchTerm->setClearButtonEnabled(true);
-        connect(lineEditSearchTerm, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormBibsonomy::returnPressed);
+        connect(lineEditSearchTerm, &QLineEdit::returnPressed, this, &OnlineSearchBibsonomy::Form::returnPressed);
 
         QLabel *label = new QLabel(i18n("Number of Results:"), this);
         layout->addWidget(label, 1, 0, 1, 1);
         numResultsField = new QSpinBox(this);
         numResultsField->setMinimum(3);
         numResultsField->setMaximum(100);
         numResultsField->setValue(20);
         layout->addWidget(numResultsField, 1, 1, 1, 1);
         label->setBuddy(numResultsField);
 
         layout->setRowStretch(2, 100);
         lineEditSearchTerm->setFocus(Qt::TabFocusReason);
 
         loadState();
     }
 
     bool readyToStart() const override {
         return !lineEditSearchTerm->text().isEmpty();
     }
 
     void copyFromEntry(const Entry &entry) override {
         comboBoxSearchWhere->setCurrentIndex(comboBoxSearchWhere->count() - 1);
-        lineEditSearchTerm->setText(authorLastNames(entry).join(QStringLiteral(" ")) + QLatin1Char(' ') + PlainTextValue::text(entry[Entry::ftTitle]));
+        lineEditSearchTerm->setText(d->authorLastNames(entry).join(QStringLiteral(" ")) + QLatin1Char(' ') + PlainTextValue::text(entry[Entry::ftTitle]));
     }
 
     void saveState() {
-        KConfigGroup configGroup(config, configGroupName);
+        KConfigGroup configGroup(d->config, configGroupName);
         configGroup.writeEntry(QStringLiteral("searchWhere"), comboBoxSearchWhere->currentIndex());
         configGroup.writeEntry(QStringLiteral("searchTerm"), lineEditSearchTerm->text());
         configGroup.writeEntry(QStringLiteral("numResults"), numResultsField->value());
-        config->sync();
+        d->config->sync();
     }
 };
 #endif // HAVE_QTWIDGETS
 
 class OnlineSearchBibsonomy::OnlineSearchBibsonomyPrivate
 {
 public:
 #ifdef HAVE_QTWIDGETS
-    OnlineSearchQueryFormBibsonomy *form;
+    OnlineSearchBibsonomy::Form *form;
 #endif // HAVE_QTWIDGETS
 
     OnlineSearchBibsonomyPrivate(OnlineSearchBibsonomy *)
 #ifdef HAVE_QTWIDGETS
             : form(nullptr)
 #endif // HAVE_QTWIDGETS
     {
         /// nothing
     }
 
 #ifdef HAVE_QTWIDGETS
     QUrl buildQueryUrl() {
         if (form == nullptr) {
             qCWarning(LOG_KBIBTEX_NETWORKING) << "Cannot build query url if no form is specified";
             return QUrl();
         }
 
         QString queryString = OnlineSearchAbstract::encodeURL(form->lineEditSearchTerm->text());
         return QUrl(QStringLiteral("https://www.bibsonomy.org/bib/") + form->comboBoxSearchWhere->itemData(form->comboBoxSearchWhere->currentIndex()).toString() + QStringLiteral("/") + queryString + QString(QStringLiteral("?items=%1")).arg(form->numResultsField->value()));
     }
 #endif // HAVE_QTWIDGETS
 
     QUrl buildQueryUrl(const QMap<QString, QString> &query, int numResults) {
         QString url = QStringLiteral("https://www.bibsonomy.org/bib/");
 
         const bool hasFreeText = !query[queryKeyFreeText].isEmpty();
         const bool hasTitle = !query[queryKeyTitle].isEmpty();
         const bool hasAuthor = !query[queryKeyAuthor].isEmpty();
         const bool hasYear = !query[queryKeyYear].isEmpty();
 
         QString searchType = QStringLiteral("search");
         if (hasAuthor && !hasFreeText && !hasTitle && !hasYear) {
             /// if only the author field is used, a special author search
             /// on BibSonomy can be used
             searchType = QStringLiteral("author");
         }
 
         QStringList queryFragments;
         for (QMap<QString, QString>::ConstIterator it = query.constBegin(); it != query.constEnd(); ++it) {
             queryFragments << OnlineSearchAbstract::encodeURL(it.value());
         }
 
         QString queryString = queryFragments.join(QStringLiteral("%20"));
         url.append(searchType + QLatin1Char('/') + queryString + QString(QStringLiteral("?items=%1")).arg(numResults));
 
         return QUrl(url);
     }
 
     void sanitizeEntry(QSharedPointer<Entry> entry) {
         /// if entry contains a description field but no abstract,
         /// rename description field to abstract
         const QString ftDescription = QStringLiteral("description");
         if (!entry->contains(Entry::ftAbstract) && entry->contains(ftDescription)) {
             Value v = entry->value(QStringLiteral("description"));
             entry->insert(Entry::ftAbstract, v);
             entry->remove(ftDescription);
         }
     }
 };
 
 OnlineSearchBibsonomy::OnlineSearchBibsonomy(QObject *parent)
         : OnlineSearchAbstract(parent), d(new OnlineSearchBibsonomyPrivate(this))
 {
     /// nothing
 }
 
 OnlineSearchBibsonomy::~OnlineSearchBibsonomy()
 {
     delete d;
 }
 
 void OnlineSearchBibsonomy::startSearch(const QMap<QString, QString> &query, int numResults)
 {
     m_hasBeenCanceled = false;
     emit progress(curStep = 0, numSteps = 1);
 
     QNetworkRequest request(d->buildQueryUrl(query, numResults));
     QNetworkReply *reply = InternalNetworkAccessManager::instance().get(request);
     InternalNetworkAccessManager::instance().setNetworkReplyTimeout(reply);
     connect(reply, &QNetworkReply::finished, this, &OnlineSearchBibsonomy::downloadDone);
 
     refreshBusyProperty();
 }
 
 #ifdef HAVE_QTWIDGETS
 void OnlineSearchBibsonomy::startSearchFromForm()
 {
     m_hasBeenCanceled = false;
     emit progress(curStep = 0, numSteps = 1);
 
     QNetworkRequest request(d->buildQueryUrl());
     QNetworkReply *reply = InternalNetworkAccessManager::instance().get(request);
     InternalNetworkAccessManager::instance().setNetworkReplyTimeout(reply);
     connect(reply, &QNetworkReply::finished, this, &OnlineSearchBibsonomy::downloadDone);
 
     refreshBusyProperty();
 }
 #endif // HAVE_QTWIDGETS
 
 QString OnlineSearchBibsonomy::label() const
 {
 #ifdef HAVE_KF5
     return i18n("Bibsonomy");
 #else // HAVE_KF5
     //= onlinesearch-bibsonomy-label
     return QObject::tr("Bibsonomy");
 #endif // HAVE_KF5
 }
 
 QString OnlineSearchBibsonomy::favIconUrl() const
 {
     return QStringLiteral("https://www.bibsonomy.org/resources/image/favicon.png");
 }
 
 #ifdef HAVE_QTWIDGETS
-OnlineSearchQueryFormAbstract *OnlineSearchBibsonomy::customWidget(QWidget *parent)
+OnlineSearchAbstract::Form *OnlineSearchBibsonomy::customWidget(QWidget *parent)
 {
     if (d->form == nullptr)
-        d->form = new OnlineSearchBibsonomy::OnlineSearchQueryFormBibsonomy(parent);
+        d->form = new OnlineSearchBibsonomy::Form(parent);
     return d->form;
 }
 #endif // HAVE_QTWIDGETS
 
 QUrl OnlineSearchBibsonomy::homepage() const
 {
     return QUrl(QStringLiteral("https://www.bibsonomy.org/"));
 }
 
 void OnlineSearchBibsonomy::downloadDone()
 {
     emit progress(++curStep, numSteps);
 
     QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
 
     if (handleErrors(reply)) {
         /// ensure proper treatment of UTF-8 characters
         QString bibTeXcode = QString::fromUtf8(reply->readAll().constData());
 
         if (!bibTeXcode.isEmpty()) {
             FileImporterBibTeX importer(this);
             const File *bibtexFile = importer.fromString(bibTeXcode);
 
             bool hasEntries = false;
             if (bibtexFile != nullptr) {
                 for (const auto &element : const_cast<const File &>(*bibtexFile)) {
                     QSharedPointer<Entry> entry = element.dynamicCast<Entry>();
                     hasEntries |= publishEntry(entry);
                 }
 
                 stopSearch(resultNoError);
 
                 delete bibtexFile;
             } else {
                 qCWarning(LOG_KBIBTEX_NETWORKING) << "No valid BibTeX file results returned on request on" << InternalNetworkAccessManager::removeApiKey(reply->url()).toDisplayString();
                 stopSearch(resultUnspecifiedError);
             }
         } else {
             /// returned file is empty
             stopSearch(resultNoError);
         }
     }
 
     refreshBusyProperty();
 }
 
 #include "onlinesearchbibsonomy.moc"
diff --git a/src/networking/onlinesearch/onlinesearchbibsonomy.h b/src/networking/onlinesearch/onlinesearchbibsonomy.h
index c5a58aec..5ff1ff99 100644
--- a/src/networking/onlinesearch/onlinesearchbibsonomy.h
+++ b/src/networking/onlinesearch/onlinesearchbibsonomy.h
@@ -1,62 +1,62 @@
 /***************************************************************************
  *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifndef KBIBTEX_NETWORKING_ONLINESEARCHBIBSONOMY_H
 #define KBIBTEX_NETWORKING_ONLINESEARCHBIBSONOMY_H
 
 #include <onlinesearch/OnlineSearchAbstract>
 
 #ifdef HAVE_KF5
 #include "kbibtexnetworking_export.h"
 #endif // HAVE_KF5
 
 /**
  * @author Thomas Fischer <fischer@unix-ag.uni-kl.de>
  */
 class KBIBTEXNETWORKING_EXPORT OnlineSearchBibsonomy : public OnlineSearchAbstract
 {
     Q_OBJECT
 
 public:
     explicit OnlineSearchBibsonomy(QObject *parent);
     ~OnlineSearchBibsonomy() override;
 
 #ifdef HAVE_QTWIDGETS
     void startSearchFromForm() override;
 #endif // HAVE_QTWIDGETS
     void startSearch(const QMap<QString, QString> &query, int numResults) override;
     QString label() const override;
 #ifdef HAVE_QTWIDGETS
-    OnlineSearchQueryFormAbstract *customWidget(QWidget *parent) override;
+    virtual OnlineSearchAbstract::Form *customWidget(QWidget *parent) override;
 #endif // HAVE_QTWIDGETS
     QUrl homepage() const override;
 
 protected:
     QString favIconUrl() const override;
 
 private:
 #ifdef HAVE_QTWIDGETS
-    class OnlineSearchQueryFormBibsonomy;
+    class Form;
 #endif // HAVE_QTWIDGETS
     class OnlineSearchBibsonomyPrivate;
     OnlineSearchBibsonomyPrivate *d;
 
 private slots:
     void downloadDone();
 };
 
 #endif // KBIBTEX_NETWORKING_ONLINESEARCHBIBSONOMY_H
diff --git a/src/networking/onlinesearch/onlinesearchdoi.cpp b/src/networking/onlinesearch/onlinesearchdoi.cpp
index 2a07b6ed..c461b735 100644
--- a/src/networking/onlinesearch/onlinesearchdoi.cpp
+++ b/src/networking/onlinesearch/onlinesearchdoi.cpp
@@ -1,251 +1,252 @@
 /***************************************************************************
- *   Copyright (C) 2004-2018 by Thomas Fischer <fischer@unix-ag.uni-kl.de> *
+ *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "onlinesearchdoi.h"
 
 #ifdef HAVE_QTWIDGETS
 #include <QLabel>
 #include <QLineEdit>
 #include <QGridLayout>
 #endif // HAVE_QTWIDGETS
 #include <QNetworkRequest>
 #include <QNetworkReply>
 #include <QRegularExpression>
 
 #ifdef HAVE_KF5
 #include <KConfigGroup>
 #include <KLocalizedString>
 #endif // HAVE_KF5
 
 #include <KBibTeX>
 #include <FileImporterBibTeX>
 #include "internalnetworkaccessmanager.h"
+#include "onlinesearchabstract_p.h"
 #include "logging_networking.h"
 
 #ifdef HAVE_QTWIDGETS
-class OnlineSearchDOI::OnlineSearchQueryFormDOI : public OnlineSearchQueryFormAbstract
+class OnlineSearchDOI::Form : public OnlineSearchAbstract::Form
 {
     Q_OBJECT
 
 private:
     QString configGroupName;
 
     void loadState() {
-        KConfigGroup configGroup(config, configGroupName);
+        KConfigGroup configGroup(d->config, configGroupName);
         lineEditDoiNumber->setText(configGroup.readEntry(QStringLiteral("doiNumber"), QString()));
     }
 
 public:
     QLineEdit *lineEditDoiNumber;
 
-    OnlineSearchQueryFormDOI(QWidget *widget)
-            : OnlineSearchQueryFormAbstract(widget), configGroupName(QStringLiteral("Search Engine DOI")) {
+    Form(QWidget *widget)
+            : OnlineSearchAbstract::Form(widget), configGroupName(QStringLiteral("Search Engine DOI")) {
         QGridLayout *layout = new QGridLayout(this);
         layout->setMargin(0);
 
         QLabel *label = new QLabel(i18n("DOI:"), this);
         layout->addWidget(label, 0, 0, 1, 1);
         lineEditDoiNumber = new QLineEdit(this);
         layout->addWidget(lineEditDoiNumber, 0, 1, 1, 1);
         lineEditDoiNumber->setClearButtonEnabled(true);
-        connect(lineEditDoiNumber, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormDOI::returnPressed);
+        connect(lineEditDoiNumber, &QLineEdit::returnPressed, this, &OnlineSearchDOI::Form::returnPressed);
 
         layout->setRowStretch(1, 100);
         lineEditDoiNumber->setFocus(Qt::TabFocusReason);
 
         loadState();
     }
 
     bool readyToStart() const override {
         return !lineEditDoiNumber->text().isEmpty();
     }
 
     void copyFromEntry(const Entry &entry) override {
         lineEditDoiNumber->setText(PlainTextValue::text(entry[Entry::ftDOI]));
     }
 
     void saveState() {
-        KConfigGroup configGroup(config, configGroupName);
+        KConfigGroup configGroup(d->config, configGroupName);
         configGroup.writeEntry(QStringLiteral("doiNumber"), lineEditDoiNumber->text());
-        config->sync();
+        d->config->sync();
     }
 };
 #endif // HAVE_QTWIDGETS
 
 
 class OnlineSearchDOI::OnlineSearchDOIPrivate
 {
 public:
 #ifdef HAVE_QTWIDGETS
-    OnlineSearchQueryFormDOI *form;
+    OnlineSearchDOI::Form *form;
 #endif // HAVE_QTWIDGETS
 
     OnlineSearchDOIPrivate(OnlineSearchDOI *parent)
 #ifdef HAVE_QTWIDGETS
             : form(nullptr)
 #endif // HAVE_QTWIDGETS
     {
         Q_UNUSED(parent)
     }
 
 #ifdef HAVE_QTWIDGETS
     QUrl buildQueryUrl() {
         if (form == nullptr) {
             qCWarning(LOG_KBIBTEX_NETWORKING) << "Cannot build query url if no form is specified";
             return QUrl();
         }
 
         return QUrl(QStringLiteral("https://dx.doi.org/") + form->lineEditDoiNumber->text());
     }
 #endif // HAVE_QTWIDGETS
 
     QUrl buildQueryUrl(const QMap<QString, QString> &query, int numResults) {
         Q_UNUSED(numResults)
 
         const QRegularExpressionMatch doiRegExpMatch = KBibTeX::doiRegExp.match(query[queryKeyFreeText]);
         if (doiRegExpMatch.hasMatch()) {
             return QUrl(QStringLiteral("https://dx.doi.org/") + doiRegExpMatch.captured(0));
         }
 
         return QUrl();
     }
 };
 
 
 OnlineSearchDOI::OnlineSearchDOI(QWidget *parent)
         : OnlineSearchAbstract(parent), d(new OnlineSearchDOIPrivate(this))
 {
     // TODO
 }
 
 OnlineSearchDOI::~OnlineSearchDOI()
 {
     delete d;
 }
 
 #ifdef HAVE_QTWIDGETS
 void OnlineSearchDOI::startSearchFromForm()
 {
     m_hasBeenCanceled = false;
     emit progress(curStep = 0, numSteps = 1);
 
     const QUrl url = d->buildQueryUrl();
     if (url.isValid()) {
         QNetworkRequest request(url);
         request.setRawHeader(QByteArray("Accept"), QByteArray("text/bibliography; style=bibtex"));
         QNetworkReply *reply = InternalNetworkAccessManager::instance().get(request);
         InternalNetworkAccessManager::instance().setNetworkReplyTimeout(reply);
         connect(reply, &QNetworkReply::finished, this, &OnlineSearchDOI::downloadDone);
 
         d->form->saveState();
     } else
         delayedStoppedSearch(resultNoError);
 
     refreshBusyProperty();
 }
 #endif // HAVE_QTWIDGETS
 
 void OnlineSearchDOI::startSearch(const QMap<QString, QString> &query, int numResults)
 {
     m_hasBeenCanceled = false;
     emit progress(curStep = 0, numSteps = 1);
 
     const QUrl url = d->buildQueryUrl(query, numResults);
     if (url.isValid()) {
         QNetworkRequest request(url);
         request.setRawHeader(QByteArray("Accept"), QByteArray("text/bibliography; style=bibtex"));
         QNetworkReply *reply = InternalNetworkAccessManager::instance().get(request);
         InternalNetworkAccessManager::instance().setNetworkReplyTimeout(reply);
         connect(reply, &QNetworkReply::finished, this, &OnlineSearchDOI::downloadDone);
 
         refreshBusyProperty();
     } else
         delayedStoppedSearch(resultNoError);
 }
 
 QString OnlineSearchDOI::label() const
 {
     return i18n("DOI");
 }
 
 #ifdef HAVE_QTWIDGETS
-OnlineSearchQueryFormAbstract *OnlineSearchDOI::customWidget(QWidget *parent)
+OnlineSearchAbstract::Form *OnlineSearchDOI::customWidget(QWidget *parent)
 {
     if (d->form == nullptr)
-        d->form = new OnlineSearchDOI::OnlineSearchQueryFormDOI(parent);
+        d->form = new OnlineSearchDOI::Form(parent);
     return d->form;
 }
 #endif // HAVE_QTWIDGETS
 
 QUrl OnlineSearchDOI::homepage() const
 {
     return QUrl(QStringLiteral("https://dx.doi.org/"));
 }
 
 QString OnlineSearchDOI::favIconUrl() const
 {
     return QStringLiteral("https://dx.doi.org/favicon.ico");
 }
 
 void OnlineSearchDOI::downloadDone()
 {
     emit progress(++curStep, numSteps);
     QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
 
     QUrl redirUrl;
     if (handleErrors(reply, redirUrl)) {
         if (redirUrl.isValid()) {
             /// redirection to another url
             ++numSteps;
 
             QNetworkRequest request(redirUrl);
             request.setRawHeader(QByteArray("Accept"), QByteArray("text/bibliography; style=bibtex"));
             QNetworkReply *newReply = InternalNetworkAccessManager::instance().get(request);
             InternalNetworkAccessManager::instance().setNetworkReplyTimeout(newReply);
             connect(newReply, &QNetworkReply::finished, this, &OnlineSearchDOI::downloadDone);
         } else {  /// ensure proper treatment of UTF-8 characters
             const QString bibTeXcode = QString::fromUtf8(reply->readAll().constData());
 
             if (!bibTeXcode.isEmpty()) {
                 FileImporterBibTeX importer(this);
                 File *bibtexFile = importer.fromString(bibTeXcode);
 
                 bool hasEntries = false;
                 if (bibtexFile != nullptr) {
                     for (const auto &element : const_cast<const File &>(*bibtexFile)) {
                         QSharedPointer<Entry> entry = element.dynamicCast<Entry>();
                         hasEntries |= publishEntry(entry);
                     }
 
                     stopSearch(resultNoError);
 
                     delete bibtexFile;
                 } else {
                     qCWarning(LOG_KBIBTEX_NETWORKING) << "No valid BibTeX file results returned on request on" << InternalNetworkAccessManager::removeApiKey(reply->url()).toDisplayString();
                     stopSearch(resultUnspecifiedError);
                 }
             } else {
                 /// returned file is empty
                 stopSearch(resultNoError);
             }
         }
     }
 
     refreshBusyProperty();
 }
 
 #include "onlinesearchdoi.moc"
diff --git a/src/networking/onlinesearch/onlinesearchdoi.h b/src/networking/onlinesearch/onlinesearchdoi.h
index 5590b1f9..c2feec37 100644
--- a/src/networking/onlinesearch/onlinesearchdoi.h
+++ b/src/networking/onlinesearch/onlinesearchdoi.h
@@ -1,60 +1,62 @@
 /***************************************************************************
  *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifndef KBIBTEX_NETWORKING_ONLINESEARCHDOI_H
 #define KBIBTEX_NETWORKING_ONLINESEARCHDOI_H
 
 #include <onlinesearch/OnlineSearchAbstract>
 
 #ifdef HAVE_KF5
 #include "kbibtexnetworking_export.h"
 #endif // HAVE_KF5
 
 /**
  * @author Thomas Fischer <fischer@unix-ag.uni-kl.de>
  */
 class KBIBTEXNETWORKING_EXPORT OnlineSearchDOI : public OnlineSearchAbstract
 {
     Q_OBJECT
 
 public:
     explicit OnlineSearchDOI(QWidget *parent);
     ~OnlineSearchDOI() override;
 
 #ifdef HAVE_QTWIDGETS
     void startSearchFromForm() override;
 #endif // HAVE_QTWIDGETS
     void startSearch(const QMap<QString, QString> &query, int numResults) override;
     QString label() const override;
 #ifdef HAVE_QTWIDGETS
-    OnlineSearchQueryFormAbstract *customWidget(QWidget *parent) override;
+    OnlineSearchAbstract::Form *customWidget(QWidget *parent) override;
 #endif // HAVE_QTWIDGETS
     QUrl homepage() const override;
 
 protected:
     QString favIconUrl() const override;
 
 private:
-    class OnlineSearchQueryFormDOI;
+#ifdef HAVE_QTWIDGETS
+    class Form;
+#endif // HAVE_QTWIDGETS
     class OnlineSearchDOIPrivate;
     OnlineSearchDOIPrivate *d;
 
 private slots:
     void downloadDone();
 };
 
 #endif // KBIBTEX_NETWORKING_ONLINESEARCHDOI_H
diff --git a/src/networking/onlinesearch/onlinesearchgeneral.cpp b/src/networking/onlinesearch/onlinesearchgeneral.cpp
index 5f5a2d40..619c7858 100644
--- a/src/networking/onlinesearch/onlinesearchgeneral.cpp
+++ b/src/networking/onlinesearch/onlinesearchgeneral.cpp
@@ -1,136 +1,171 @@
 /***************************************************************************
  *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "onlinesearchgeneral.h"
 
 #ifdef HAVE_QTWIDGETS
 #include <QFormLayout>
 #include <QLabel>
 #include <QSpinBox>
 #include <QLineEdit>
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 
 #include <KBibTeX>
 #include <Entry>
+#include "onlinesearchabstract_p.h"
 
-OnlineSearchQueryFormGeneral::OnlineSearchQueryFormGeneral(QWidget *parent)
-        : OnlineSearchQueryFormAbstract(parent),
-      configGroupName(QStringLiteral("Search Engine General"))
+namespace OnlineSearchGeneral {
+
+#ifdef HAVE_QTWIDGETS
+class Form::Private : public OnlineSearchAbstract::Form::Private
+{
+public:
+    explicit Private(Form *parent)
+            : OnlineSearchAbstract::Form::Private(),
+          configGroupName(QStringLiteral("Search Engine General"))
+    {
+        QFormLayout *layout = new QFormLayout(parent);
+        layout->setMargin(0);
+
+        QLabel *label = new QLabel(i18n("Free text:"), parent);
+        QLineEdit *lineEdit = new QLineEdit(parent);
+        layout->addRow(label, lineEdit);
+        lineEdit->setClearButtonEnabled(true);
+        lineEdit->setFocus(Qt::TabFocusReason);
+        queryFields.insert(OnlineSearchAbstract::queryKeyFreeText, lineEdit);
+        label->setBuddy(lineEdit);
+        connect(lineEdit, &QLineEdit::returnPressed, parent, &OnlineSearchAbstract::Form::returnPressed);
+
+        label = new QLabel(i18n("Title:"), parent);
+        lineEdit = new QLineEdit(parent);
+        layout->addRow(label, lineEdit);
+        lineEdit->setClearButtonEnabled(true);
+        queryFields.insert(OnlineSearchAbstract::queryKeyTitle, lineEdit);
+        label->setBuddy(lineEdit);
+        connect(lineEdit, &QLineEdit::returnPressed, parent, &OnlineSearchAbstract::Form::returnPressed);
+
+        label = new QLabel(i18n("Author:"), parent);
+        lineEdit = new QLineEdit(parent);
+        layout->addRow(label, lineEdit);
+        lineEdit->setClearButtonEnabled(true);
+        queryFields.insert(OnlineSearchAbstract::queryKeyAuthor, lineEdit);
+        label->setBuddy(lineEdit);
+        connect(lineEdit, &QLineEdit::returnPressed, parent, &OnlineSearchAbstract::Form::returnPressed);
+
+        label = new QLabel(i18n("Year:"), parent);
+        lineEdit = new QLineEdit(parent);
+        layout->addRow(label, lineEdit);
+        lineEdit->setClearButtonEnabled(true);
+        queryFields.insert(OnlineSearchAbstract::queryKeyYear, lineEdit);
+        label->setBuddy(lineEdit);
+        connect(lineEdit, &QLineEdit::returnPressed, parent, &OnlineSearchAbstract::Form::returnPressed);
+
+        label = new QLabel(i18n("Number of Results:"), parent);
+        numResultsField = new QSpinBox(parent);
+        layout->addRow(label, numResultsField);
+        numResultsField->setMinimum(3);
+        numResultsField->setMaximum(100);
+        numResultsField->setValue(20);
+        label->setBuddy(numResultsField);
+
+        loadState();
+    }
+
+    virtual ~Private() {
+        /// nothing
+    }
+
+    QMap<QString, QLineEdit *> queryFields;
+    QSpinBox *numResultsField;
+    const QString configGroupName;
+
+    void loadState()
+    {
+        KConfigGroup configGroup(config, configGroupName);
+        for (QMap<QString, QLineEdit *>::ConstIterator it = queryFields.constBegin(); it != queryFields.constEnd(); ++it) {
+            it.value()->setText(configGroup.readEntry(it.key(), QString()));
+        }
+        numResultsField->setValue(configGroup.readEntry(QStringLiteral("numResults"), 10));
+    }
+
+    void saveState()
+    {
+        KConfigGroup configGroup(config, configGroupName);
+        for (QMap<QString, QLineEdit *>::ConstIterator it = queryFields.constBegin(); it != queryFields.constEnd(); ++it) {
+            configGroup.writeEntry(it.key(), it.value()->text());
+        }
+        configGroup.writeEntry(QStringLiteral("numResults"), numResultsField->value());
+        config->sync();
+    }
+};
+
+Form::Form(QWidget *parent)
+        : OnlineSearchAbstract::Form(parent), dg(new OnlineSearchGeneral::Form::Private(this))
+{
+    /// nothing
+}
+
+Form::~Form()
 {
-    QFormLayout *layout = new QFormLayout(this);
-    layout->setMargin(0);
-
-    QLabel *label = new QLabel(i18n("Free text:"), this);
-    QLineEdit *lineEdit = new QLineEdit(this);
-    layout->addRow(label, lineEdit);
-    lineEdit->setClearButtonEnabled(true);
-    lineEdit->setFocus(Qt::TabFocusReason);
-    queryFields.insert(OnlineSearchAbstract::queryKeyFreeText, lineEdit);
-    label->setBuddy(lineEdit);
-    connect(lineEdit, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormGeneral::returnPressed);
-
-    label = new QLabel(i18n("Title:"), this);
-    lineEdit = new QLineEdit(this);
-    layout->addRow(label, lineEdit);
-    lineEdit->setClearButtonEnabled(true);
-    queryFields.insert(OnlineSearchAbstract::queryKeyTitle, lineEdit);
-    label->setBuddy(lineEdit);
-    connect(lineEdit, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormGeneral::returnPressed);
-
-    label = new QLabel(i18n("Author:"), this);
-    lineEdit = new QLineEdit(this);
-    layout->addRow(label, lineEdit);
-    lineEdit->setClearButtonEnabled(true);
-    queryFields.insert(OnlineSearchAbstract::queryKeyAuthor, lineEdit);
-    label->setBuddy(lineEdit);
-    connect(lineEdit, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormGeneral::returnPressed);
-
-    label = new QLabel(i18n("Year:"), this);
-    lineEdit = new QLineEdit(this);
-    layout->addRow(label, lineEdit);
-    lineEdit->setClearButtonEnabled(true);
-    queryFields.insert(OnlineSearchAbstract::queryKeyYear, lineEdit);
-    label->setBuddy(lineEdit);
-    connect(lineEdit, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormGeneral::returnPressed);
-
-    label = new QLabel(i18n("Number of Results:"), this);
-    numResultsField = new QSpinBox(this);
-    layout->addRow(label, numResultsField);
-    numResultsField->setMinimum(3);
-    numResultsField->setMaximum(100);
-    numResultsField->setValue(20);
-    label->setBuddy(numResultsField);
-
-    loadState();
+    delete dg;
 }
 
-bool OnlineSearchQueryFormGeneral::readyToStart() const
+#endif // HAVE_QTWIDGETS
+
+
+bool Form::readyToStart() const
 {
-    for (QMap<QString, QLineEdit *>::ConstIterator it = queryFields.constBegin(); it != queryFields.constEnd(); ++it)
+    for (QMap<QString, QLineEdit *>::ConstIterator it = dg->queryFields.constBegin(); it != dg->queryFields.constEnd(); ++it)
         if (!it.value()->text().isEmpty())
             return true;
 
     return false;
 }
 
-void OnlineSearchQueryFormGeneral::copyFromEntry(const Entry &entry)
+void Form::copyFromEntry(const Entry &entry)
 {
-    queryFields[OnlineSearchAbstract::queryKeyFreeText]->setText(guessFreeText(entry));
-    queryFields[OnlineSearchAbstract::queryKeyTitle]->setText(PlainTextValue::text(entry[Entry::ftTitle]));
-    queryFields[OnlineSearchAbstract::queryKeyAuthor]->setText(authorLastNames(entry).join(QStringLiteral(" ")));
-    queryFields[OnlineSearchAbstract::queryKeyYear]->setText(PlainTextValue::text(entry[Entry::ftYear]));
+    dg->queryFields[OnlineSearchAbstract::queryKeyFreeText]->setText(d->guessFreeText(entry));
+    dg->queryFields[OnlineSearchAbstract::queryKeyTitle]->setText(PlainTextValue::text(entry[Entry::ftTitle]));
+    dg->queryFields[OnlineSearchAbstract::queryKeyAuthor]->setText(d->authorLastNames(entry).join(QStringLiteral(" ")));
+    dg->queryFields[OnlineSearchAbstract::queryKeyYear]->setText(PlainTextValue::text(entry[Entry::ftYear]));
 }
 
-QMap<QString, QString> OnlineSearchQueryFormGeneral::getQueryTerms()
+QMap<QString, QString> Form::getQueryTerms()
 {
     QMap<QString, QString> result;
 
-    for (QMap<QString, QLineEdit *>::ConstIterator it = queryFields.constBegin(); it != queryFields.constEnd(); ++it) {
+    for (QMap<QString, QLineEdit *>::ConstIterator it = dg->queryFields.constBegin(); it != dg->queryFields.constEnd(); ++it) {
         if (!it.value()->text().isEmpty())
             result.insert(it.key(), it.value()->text());
     }
 
-    saveState();
+    dg->saveState();
     return result;
 }
 
-int OnlineSearchQueryFormGeneral::getNumResults()
+int Form::getNumResults()
 {
-    return numResultsField->value();
+    return dg->numResultsField->value();
 }
 
-void OnlineSearchQueryFormGeneral::loadState()
-{
-    KConfigGroup configGroup(config, configGroupName);
-    for (QMap<QString, QLineEdit *>::ConstIterator it = queryFields.constBegin(); it != queryFields.constEnd(); ++it) {
-        it.value()->setText(configGroup.readEntry(it.key(), QString()));
-    }
-    numResultsField->setValue(configGroup.readEntry(QStringLiteral("numResults"), 10));
-}
+} /// namespace OnlineSearchGeneral
+
+// #include "onlinesearchgeneral.moc"
 
-void OnlineSearchQueryFormGeneral::saveState()
-{
-    KConfigGroup configGroup(config, configGroupName);
-    for (QMap<QString, QLineEdit *>::ConstIterator it = queryFields.constBegin(); it != queryFields.constEnd(); ++it) {
-        configGroup.writeEntry(it.key(), it.value()->text());
-    }
-    configGroup.writeEntry(QStringLiteral("numResults"), numResultsField->value());
-    config->sync();
-}
 #endif // HAVE_QTWIDGETS
diff --git a/src/networking/onlinesearch/onlinesearchgeneral.h b/src/networking/onlinesearch/onlinesearchgeneral.h
index 91bb13ed..7d1b7e2d 100644
--- a/src/networking/onlinesearch/onlinesearchgeneral.h
+++ b/src/networking/onlinesearch/onlinesearchgeneral.h
@@ -1,56 +1,54 @@
 /***************************************************************************
  *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifndef KBIBTEX_NETWORKING_ONLINESEARCHGENERAL_H
 #define KBIBTEX_NETWORKING_ONLINESEARCHGENERAL_H
 
 #include <KSharedConfig>
 
 #include <onlinesearch/OnlineSearchAbstract>
 
 #ifdef HAVE_KF5
 #include "kbibtexnetworking_export.h"
 #endif // HAVE_KF5
 
 #ifdef HAVE_QTWIDGETS
-class QSpinBox;
-class QLineEdit;
-
-class KBIBTEXNETWORKING_EXPORT OnlineSearchQueryFormGeneral : public OnlineSearchQueryFormAbstract
+namespace OnlineSearchGeneral {
+/**
+ * @author Thomas Fischer <fischer@unix-ag.uni-kl.de>
+ */
+class KBIBTEXNETWORKING_EXPORT Form : public OnlineSearchAbstract::Form
 {
-    Q_OBJECT
-
 public:
-    explicit OnlineSearchQueryFormGeneral(QWidget *parent);
+    explicit Form(QWidget *parent);
+    ~Form();
 
-    bool readyToStart() const override;
-    void copyFromEntry(const Entry &) override;
+    virtual bool readyToStart() const override;
+    virtual void copyFromEntry(const Entry &) override;
 
     QMap<QString, QString> getQueryTerms();
     int getNumResults();
 
 private:
-    QMap<QString, QLineEdit *> queryFields;
-    QSpinBox *numResultsField;
-    const QString configGroupName;
-
-    void loadState();
-    void saveState();
+    class Private;
+    Private *dg;
 };
+} /// namespace OnlineSearchGeneral
 #endif // HAVE_QTWIDGETS
 
+
 #endif // KBIBTEX_NETWORKING_ONLINESEARCHGENERAL_H
diff --git a/src/networking/onlinesearch/onlinesearchingentaconnect.cpp b/src/networking/onlinesearch/onlinesearchingentaconnect.cpp
index c23f0699..c0bb57e5 100644
--- a/src/networking/onlinesearch/onlinesearchingentaconnect.cpp
+++ b/src/networking/onlinesearch/onlinesearchingentaconnect.cpp
@@ -1,424 +1,425 @@
 /***************************************************************************
- *   Copyright (C) 2004-2018 by Thomas Fischer <fischer@unix-ag.uni-kl.de> *
+ *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "onlinesearchingentaconnect.h"
 
 #include <QBuffer>
 #ifdef HAVE_QTWIDGETS
 #include <QLabel>
 #include <QFormLayout>
 #include <QSpinBox>
 #include <QLineEdit>
 #include <QIcon>
 #endif // HAVE_QTWIDGETS
 #include <QNetworkReply>
 #include <QUrlQuery>
 
 #ifdef HAVE_KF5
 #include <KLocalizedString>
 #include <KConfigGroup>
 #else // HAVE_KF5
 #define i18n(text) QObject::tr(text)
 #endif // HAVE_KF5
 
 #include <File>
 #include <Entry>
 #include <FileImporterBibTeX>
 #include "internalnetworkaccessmanager.h"
+#include "onlinesearchabstract_p.h"
 #include "logging_networking.h"
 
 #ifdef HAVE_QTWIDGETS
-class OnlineSearchIngentaConnect::OnlineSearchQueryFormIngentaConnect : public OnlineSearchQueryFormAbstract
+class OnlineSearchIngentaConnect::Form : public OnlineSearchAbstract::Form
 {
     Q_OBJECT
 
 private:
     QString configGroupName;
 
     void loadState() {
-        KConfigGroup configGroup(config, configGroupName);
+        KConfigGroup configGroup(d->config, configGroupName);
         lineEditFullText->setText(configGroup.readEntry(QStringLiteral("fullText"), QString()));
         lineEditTitle->setText(configGroup.readEntry(QStringLiteral("title"), QString()));
         lineEditAuthor->setText(configGroup.readEntry(QStringLiteral("author"), QString()));
         lineEditAbstractKeywords->setText(configGroup.readEntry(QStringLiteral("abstractKeywords"), QString()));
         lineEditPublication->setText(configGroup.readEntry(QStringLiteral("publication"), QString()));
         lineEditISSNDOIISBN->setText(configGroup.readEntry(QStringLiteral("ISSNDOIISBN"), QString()));
         lineEditVolume->setText(configGroup.readEntry(QStringLiteral("volume"), QString()));
         lineEditIssue->setText(configGroup.readEntry(QStringLiteral("issue"), QString()));
         numResultsField->setValue(configGroup.readEntry(QStringLiteral("numResults"), 10));
     }
 
 public:
     QLineEdit *lineEditFullText;
     QLineEdit *lineEditTitle;
     QLineEdit *lineEditAuthor;
     QLineEdit *lineEditAbstractKeywords;
     QLineEdit *lineEditPublication;
     QLineEdit *lineEditISSNDOIISBN;
     QLineEdit *lineEditVolume;
     QLineEdit *lineEditIssue;
     QSpinBox *numResultsField;
 
-    OnlineSearchQueryFormIngentaConnect(QWidget *widget)
-            : OnlineSearchQueryFormAbstract(widget), configGroupName(QStringLiteral("Search Engine IngentaConnect")) {
+    Form(QWidget *widget)
+            : OnlineSearchAbstract::Form(widget), configGroupName(QStringLiteral("Search Engine IngentaConnect")) {
         QFormLayout *layout = new QFormLayout(this);
         layout->setMargin(0);
 
         lineEditFullText = new QLineEdit(this);
         lineEditFullText->setClearButtonEnabled(true);
         layout->addRow(i18n("Full text:"), lineEditFullText);
-        connect(lineEditFullText, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormIngentaConnect::returnPressed);
+        connect(lineEditFullText, &QLineEdit::returnPressed, this, &OnlineSearchIngentaConnect::Form::returnPressed);
 
         lineEditTitle = new QLineEdit(this);
         lineEditTitle->setClearButtonEnabled(true);
         layout->addRow(i18n("Title:"), lineEditTitle);
-        connect(lineEditTitle, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormIngentaConnect::returnPressed);
+        connect(lineEditTitle, &QLineEdit::returnPressed, this, &OnlineSearchIngentaConnect::Form::returnPressed);
 
         lineEditAuthor = new QLineEdit(this);
         lineEditAuthor->setClearButtonEnabled(true);
         layout->addRow(i18n("Author:"), lineEditAuthor);
-        connect(lineEditAuthor, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormIngentaConnect::returnPressed);
+        connect(lineEditAuthor, &QLineEdit::returnPressed, this, &OnlineSearchIngentaConnect::Form::returnPressed);
 
         lineEditAbstractKeywords = new QLineEdit(this);
         lineEditAbstractKeywords->setClearButtonEnabled(true);
         layout->addRow(i18n("Abstract/Keywords:"), lineEditAbstractKeywords);
-        connect(lineEditAbstractKeywords, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormIngentaConnect::returnPressed);
+        connect(lineEditAbstractKeywords, &QLineEdit::returnPressed, this, &OnlineSearchIngentaConnect::Form::returnPressed);
 
         lineEditPublication = new QLineEdit(this);
         lineEditPublication->setClearButtonEnabled(true);
         layout->addRow(i18n("Publication:"), lineEditPublication);
-        connect(lineEditPublication, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormIngentaConnect::returnPressed);
+        connect(lineEditPublication, &QLineEdit::returnPressed, this, &OnlineSearchIngentaConnect::Form::returnPressed);
 
         lineEditISSNDOIISBN = new QLineEdit(this);
         lineEditISSNDOIISBN->setClearButtonEnabled(true);
         layout->addRow(i18n("ISSN/ISBN/DOI:"), lineEditISSNDOIISBN);
-        connect(lineEditISSNDOIISBN, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormIngentaConnect::returnPressed);
+        connect(lineEditISSNDOIISBN, &QLineEdit::returnPressed, this, &OnlineSearchIngentaConnect::Form::returnPressed);
 
         lineEditVolume = new QLineEdit(this);
         lineEditVolume->setClearButtonEnabled(true);
         layout->addRow(i18n("Volume:"), lineEditVolume);
-        connect(lineEditVolume, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormIngentaConnect::returnPressed);
+        connect(lineEditVolume, &QLineEdit::returnPressed, this, &OnlineSearchIngentaConnect::Form::returnPressed);
 
         lineEditIssue = new QLineEdit(this);
         lineEditIssue->setClearButtonEnabled(true);
         layout->addRow(i18n("Issue/Number:"), lineEditIssue);
-        connect(lineEditIssue, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormIngentaConnect::returnPressed);
+        connect(lineEditIssue, &QLineEdit::returnPressed, this, &OnlineSearchIngentaConnect::Form::returnPressed);
 
         numResultsField = new QSpinBox(this);
         layout->addRow(i18n("Number of Results:"), numResultsField);
         numResultsField->setMinimum(3);
         numResultsField->setMaximum(100);
         numResultsField->setValue(10);
     }
 
     bool readyToStart() const override {
         return !(lineEditFullText->text().isEmpty() && lineEditTitle->text().isEmpty() && lineEditAuthor->text().isEmpty() && lineEditAbstractKeywords->text().isEmpty() && lineEditPublication->text().isEmpty() && lineEditISSNDOIISBN->text().isEmpty() && lineEditVolume->text().isEmpty() && lineEditIssue->text().isEmpty());
     }
 
     void copyFromEntry(const Entry &entry) override {
         lineEditTitle->setText(PlainTextValue::text(entry[Entry::ftTitle]));
-        lineEditAuthor->setText(authorLastNames(entry).join(QStringLiteral(" ")));
+        lineEditAuthor->setText(d->authorLastNames(entry).join(QStringLiteral(" ")));
         lineEditVolume->setText(PlainTextValue::text(entry[Entry::ftVolume]));
         lineEditIssue->setText(PlainTextValue::text(entry[Entry::ftNumber]));
         QString issnDoiIsbn = PlainTextValue::text(entry[Entry::ftDOI]);
         if (issnDoiIsbn.isEmpty())
             issnDoiIsbn = PlainTextValue::text(entry[Entry::ftISBN]);
         if (issnDoiIsbn.isEmpty())
             issnDoiIsbn = PlainTextValue::text(entry[Entry::ftISSN]);
         lineEditISSNDOIISBN->setText(issnDoiIsbn);
         QString publication = PlainTextValue::text(entry[Entry::ftJournal]);
         if (publication.isEmpty())
             publication = PlainTextValue::text(entry[Entry::ftBookTitle]);
         lineEditPublication->setText(publication);
 
         // TODO
         lineEditAbstractKeywords->setText(QString());
     }
 
     void saveState() {
-        KConfigGroup configGroup(config, configGroupName);
+        KConfigGroup configGroup(d->config, configGroupName);
         configGroup.writeEntry(QStringLiteral("fullText"), lineEditFullText->text());
         configGroup.writeEntry(QStringLiteral("title"), lineEditTitle->text());
         configGroup.writeEntry(QStringLiteral("author"), lineEditAuthor->text());
         configGroup.writeEntry(QStringLiteral("abstractKeywords"), lineEditAbstractKeywords->text());
         configGroup.writeEntry(QStringLiteral("publication"), lineEditPublication->text());
         configGroup.writeEntry(QStringLiteral("ISSNDOIISBN"), lineEditISSNDOIISBN->text());
         configGroup.writeEntry(QStringLiteral("volume"), lineEditVolume->text());
         configGroup.writeEntry(QStringLiteral("issue"), lineEditIssue->text());
         configGroup.writeEntry(QStringLiteral("numResults"), numResultsField->value());
-        config->sync();
+        d->config->sync();
     }
 };
 #endif // HAVE_QTWIDGETS
 
 class OnlineSearchIngentaConnect::OnlineSearchIngentaConnectPrivate
 {
 private:
     const QString ingentaConnectBaseUrl;
 
 public:
 #ifdef HAVE_QTWIDGETS
-    OnlineSearchQueryFormIngentaConnect *form;
+    OnlineSearchIngentaConnect::Form *form;
 #endif // HAVE_QTWIDGETS
 
     OnlineSearchIngentaConnectPrivate(OnlineSearchIngentaConnect *)
             : ingentaConnectBaseUrl(QStringLiteral("https://www.ingentaconnect.com/search?format=bib"))
 #ifdef HAVE_QTWIDGETS
         , form(nullptr)
 #endif // HAVE_QTWIDGETS
     {
         /// nothing
     }
 
 #ifdef HAVE_QTWIDGETS
     QUrl buildQueryUrl() {
         if (form == nullptr) {
             qCWarning(LOG_KBIBTEX_NETWORKING) << "Cannot build query url if no form is specified";
             return QUrl();
         }
 
         QUrl queryUrl(ingentaConnectBaseUrl);
         QUrlQuery query(queryUrl);
 
         int index = 1;
         const QStringList chunksFullText = OnlineSearchAbstract::splitRespectingQuotationMarks(form->lineEditFullText->text());
         for (const QString &chunk : chunksFullText) {
             if (index > 1)
                 query.addQueryItem(QString(QStringLiteral("operator%1")).arg(index), QStringLiteral("AND")); ///< join search terms with an AND operation
             query.addQueryItem(QString(QStringLiteral("option%1")).arg(index), QStringLiteral("fulltext"));
             query.addQueryItem(QString(QStringLiteral("value%1")).arg(index), chunk);
             ++index;
         }
 
         const QStringList chunksAuthor = OnlineSearchAbstract::splitRespectingQuotationMarks(form->lineEditAuthor->text());
         for (const QString &chunk : chunksAuthor) {
             if (index > 1)
                 query.addQueryItem(QString(QStringLiteral("operator%1")).arg(index), QStringLiteral("AND"));
             query.addQueryItem(QString(QStringLiteral("option%1")).arg(index), QStringLiteral("author"));
             query.addQueryItem(QString(QStringLiteral("value%1")).arg(index), chunk);
             ++index;
         }
 
         const QStringList chunksTitle = OnlineSearchAbstract::splitRespectingQuotationMarks(form->lineEditTitle->text());
         for (const QString &chunk : chunksTitle) {
             if (index > 1)
                 query.addQueryItem(QString(QStringLiteral("operator%1")).arg(index), QStringLiteral("AND"));
             query.addQueryItem(QString(QStringLiteral("option%1")).arg(index), QStringLiteral("title"));
             query.addQueryItem(QString(QStringLiteral("value%1")).arg(index), chunk);
             ++index;
         }
 
         const QStringList chunksPublication = OnlineSearchAbstract::splitRespectingQuotationMarks(form->lineEditPublication->text());
         for (const QString &chunk : chunksPublication) {
             if (index > 1)
                 query.addQueryItem(QString(QStringLiteral("operator%1")).arg(index), QStringLiteral("AND"));
             query.addQueryItem(QString(QStringLiteral("option%1")).arg(index), QStringLiteral("journalbooktitle"));
             query.addQueryItem(QString(QStringLiteral("value%1")).arg(index), chunk);
             ++index;
         }
 
         const QStringList chunksIssue = OnlineSearchAbstract::splitRespectingQuotationMarks(form->lineEditIssue->text());
         for (const QString &chunk : chunksIssue) {
             if (index > 1)
                 query.addQueryItem(QString(QStringLiteral("operator%1")).arg(index), QStringLiteral("AND"));
             query.addQueryItem(QString(QStringLiteral("option%1")).arg(index), QStringLiteral("issue"));
             query.addQueryItem(QString(QStringLiteral("value%1")).arg(index), chunk);
             ++index;
         }
 
         const QStringList chunksVolume = OnlineSearchAbstract::splitRespectingQuotationMarks(form->lineEditVolume->text());
         for (const QString &chunk : chunksVolume) {
             if (index > 1)
                 query.addQueryItem(QString(QStringLiteral("operator%1")).arg(index), QStringLiteral("AND"));
             query.addQueryItem(QString(QStringLiteral("option%1")).arg(index), QStringLiteral("volume"));
             query.addQueryItem(QString(QStringLiteral("value%1")).arg(index), chunk);
             ++index;
         }
 
         const QStringList chunksKeywords = OnlineSearchAbstract::splitRespectingQuotationMarks(form->lineEditAbstractKeywords->text());
         for (const QString &chunk : chunksKeywords) {
             if (index > 1)
                 query.addQueryItem(QString(QStringLiteral("operator%1")).arg(index), QStringLiteral("AND"));
             query.addQueryItem(QString(QStringLiteral("option%1")).arg(index), QStringLiteral("tka"));
             query.addQueryItem(QString(QStringLiteral("value%1")).arg(index), chunk);
             ++index;
         }
 
         query.addQueryItem(QStringLiteral("pageSize"), QString::number(form->numResultsField->value()));
 
         query.addQueryItem(QStringLiteral("sortDescending"), QStringLiteral("true"));
         query.addQueryItem(QStringLiteral("subscribed"), QStringLiteral("false"));
         query.addQueryItem(QStringLiteral("sortField"), QStringLiteral("default"));
 
         queryUrl.setQuery(query);
         return queryUrl;
     }
 #endif // HAVE_QTWIDGETS
 
     QUrl buildQueryUrl(const QMap<QString, QString> &query, int numResults) {
         QUrl queryUrl(ingentaConnectBaseUrl);
         QUrlQuery q(queryUrl);
 
         int index = 1;
         const QStringList chunksFreeText = OnlineSearchAbstract::splitRespectingQuotationMarks(query[queryKeyFreeText]);
         for (const QString &chunk : chunksFreeText) {
             if (index > 1)
                 q.addQueryItem(QString(QStringLiteral("operator%1")).arg(index), QStringLiteral("AND"));
             q.addQueryItem(QString(QStringLiteral("option%1")).arg(index), QStringLiteral("fulltext"));
             q.addQueryItem(QString(QStringLiteral("value%1")).arg(index), chunk);
             ++index;
         }
 
         const QStringList chunksAuthor = OnlineSearchAbstract::splitRespectingQuotationMarks(query[queryKeyAuthor]);
         for (const QString &chunk : chunksAuthor) {
             if (index > 1)
                 q.addQueryItem(QString(QStringLiteral("operator%1")).arg(index), QStringLiteral("AND"));
             q.addQueryItem(QString(QStringLiteral("option%1")).arg(index), QStringLiteral("author"));
             q.addQueryItem(QString(QStringLiteral("value%1")).arg(index), chunk);
             ++index;
         }
 
         const QStringList chunksTitle = OnlineSearchAbstract::splitRespectingQuotationMarks(query[queryKeyTitle]);
         for (const QString &chunk : chunksTitle) {
             if (index > 1)
                 q.addQueryItem(QString(QStringLiteral("operator%1")).arg(index), QStringLiteral("AND"));
             q.addQueryItem(QString(QStringLiteral("option%1")).arg(index), QStringLiteral("title"));
             q.addQueryItem(QString(QStringLiteral("value%1")).arg(index), chunk);
             ++index;
         }
 
         /// Field "year" not supported in IngentaConnect's search
 
         q.addQueryItem(QStringLiteral("pageSize"), QString::number(numResults));
 
         q.addQueryItem(QStringLiteral("sortDescending"), QStringLiteral("true"));
         q.addQueryItem(QStringLiteral("subscribed"), QStringLiteral("false"));
         q.addQueryItem(QStringLiteral("sortField"), QStringLiteral("default"));
 
         queryUrl.setQuery(q);
         return queryUrl;
     }
 };
 
 OnlineSearchIngentaConnect::OnlineSearchIngentaConnect(QObject *parent)
         : OnlineSearchAbstract(parent), d(new OnlineSearchIngentaConnectPrivate(this))
 {
     /// nothing
 }
 
 OnlineSearchIngentaConnect::~OnlineSearchIngentaConnect()
 {
     delete d;
 }
 
 void OnlineSearchIngentaConnect::startSearch(const QMap<QString, QString> &query, int numResults)
 {
     m_hasBeenCanceled = false;
     emit progress(curStep = 0, numSteps = 1);
 
     QNetworkRequest request(d->buildQueryUrl(query, numResults));
     QNetworkReply *reply = InternalNetworkAccessManager::instance().get(request);
     InternalNetworkAccessManager::instance().setNetworkReplyTimeout(reply);
     connect(reply, &QNetworkReply::finished, this, &OnlineSearchIngentaConnect::downloadDone);
 
     refreshBusyProperty();
 }
 
 #ifdef HAVE_QTWIDGETS
 void OnlineSearchIngentaConnect::startSearchFromForm()
 {
     m_hasBeenCanceled = false;
     emit progress(curStep = 0, numSteps = 1);
 
     QNetworkRequest request(d->buildQueryUrl());
     QNetworkReply *reply = InternalNetworkAccessManager::instance().get(request);
     InternalNetworkAccessManager::instance().setNetworkReplyTimeout(reply);
     connect(reply, &QNetworkReply::finished, this, &OnlineSearchIngentaConnect::downloadDone);
 
     d->form->saveState();
 
     refreshBusyProperty();
 }
 #endif // HAVE_QTWIDGETS
 
 QString OnlineSearchIngentaConnect::label() const
 {
 #ifdef HAVE_KF5
     return i18n("IngentaConnect");
 #else // HAVE_KF5
     //= onlinesearch-ingentaconnect-label
     return QObject::tr("IngentaConnect");
 #endif // HAVE_KF5
 }
 
 QString OnlineSearchIngentaConnect::favIconUrl() const
 {
     return QStringLiteral("http://www.ingentaconnect.com/favicon.ico");
 }
 
 #ifdef HAVE_QTWIDGETS
-OnlineSearchQueryFormAbstract *OnlineSearchIngentaConnect::customWidget(QWidget *parent)
+OnlineSearchAbstract::Form *OnlineSearchIngentaConnect::customWidget(QWidget *parent)
 {
     if (d->form == nullptr)
-        d->form = new OnlineSearchIngentaConnect::OnlineSearchQueryFormIngentaConnect(parent);
+        d->form = new OnlineSearchIngentaConnect::Form(parent);
     return d->form;
 }
 #endif // HAVE_QTWIDGETS
 
 QUrl OnlineSearchIngentaConnect::homepage() const
 {
     return QUrl(QStringLiteral("https://www.ingentaconnect.com/"));
 }
 
 void OnlineSearchIngentaConnect::downloadDone()
 {
     emit progress(curStep = numSteps, numSteps);
 
     QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
 
     if (handleErrors(reply)) {
         /// ensure proper treatment of UTF-8 characters
         QString bibTeXcode = QString::fromUtf8(reply->readAll().constData());
 
         if (!bibTeXcode.isEmpty()) {
             FileImporterBibTeX importer(this);
             File *bibtexFile = importer.fromString(bibTeXcode);
 
             bool hasEntries = false;
             if (bibtexFile != nullptr) {
                 for (const auto &element : const_cast<const File &>(*bibtexFile)) {
                     QSharedPointer<Entry> entry = element.dynamicCast<Entry>();
                     hasEntries |= publishEntry(entry);
                 }
 
                 stopSearch(resultNoError);
 
                 delete bibtexFile;
             } else {
                 qCWarning(LOG_KBIBTEX_NETWORKING) << "No valid BibTeX file results returned on request on" << InternalNetworkAccessManager::removeApiKey(reply->url()).toDisplayString();
                 stopSearch(resultUnspecifiedError);
             }
         } else {
             /// returned file is empty
             stopSearch(resultNoError);
         }
     }
 
     refreshBusyProperty();
 }
 
 #include "onlinesearchingentaconnect.moc"
diff --git a/src/networking/onlinesearch/onlinesearchingentaconnect.h b/src/networking/onlinesearch/onlinesearchingentaconnect.h
index 41e58f29..ebd36cc1 100644
--- a/src/networking/onlinesearch/onlinesearchingentaconnect.h
+++ b/src/networking/onlinesearch/onlinesearchingentaconnect.h
@@ -1,64 +1,64 @@
 /***************************************************************************
  *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifndef KBIBTEX_NETWORKING_ONLINESEARCHINGENTACONNECT_H
 #define KBIBTEX_NETWORKING_ONLINESEARCHINGENTACONNECT_H
 
 #include <QByteArray>
 
 #include <onlinesearch/OnlineSearchAbstract>
 
 #ifdef HAVE_KF5
 #include "kbibtexnetworking_export.h"
 #endif // HAVE_KF5
 
 /**
  * @author Thomas Fischer <fischer@unix-ag.uni-kl.de>
  */
 class KBIBTEXNETWORKING_EXPORT OnlineSearchIngentaConnect : public OnlineSearchAbstract
 {
     Q_OBJECT
 
 public:
     explicit OnlineSearchIngentaConnect(QObject *parent);
     ~OnlineSearchIngentaConnect() override;
 
 #ifdef HAVE_QTWIDGETS
     void startSearchFromForm() override;
 #endif // HAVE_QTWIDGETS
     void startSearch(const QMap<QString, QString> &query, int numResults) override;
     QString label() const override;
 #ifdef HAVE_QTWIDGETS
-    OnlineSearchQueryFormAbstract *customWidget(QWidget *parent) override;
+    OnlineSearchAbstract::Form *customWidget(QWidget *parent) override;
 #endif // HAVE_QTWIDGETS
     QUrl homepage() const override;
 
 protected:
     QString favIconUrl() const override;
 
 private:
 #ifdef HAVE_QTWIDGETS
-    class OnlineSearchQueryFormIngentaConnect;
+    class Form;
 #endif // HAVE_QTWIDGETS
     class OnlineSearchIngentaConnectPrivate;
     OnlineSearchIngentaConnectPrivate *d;
 
 private slots:
     void downloadDone();
 };
 
 #endif // KBIBTEX_NETWORKING_ONLINESEARCHINGENTACONNECT_H
diff --git a/src/networking/onlinesearch/onlinesearchsemanticscholar.cpp b/src/networking/onlinesearch/onlinesearchsemanticscholar.cpp
index b4493a2e..1fcece0b 100644
--- a/src/networking/onlinesearch/onlinesearchsemanticscholar.cpp
+++ b/src/networking/onlinesearch/onlinesearchsemanticscholar.cpp
@@ -1,296 +1,297 @@
 /***************************************************************************
  *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "onlinesearchsemanticscholar.h"
 
 #include <QJsonObject>
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QNetworkRequest>
 #include <QNetworkReply>
 #include <QRegularExpression>
 #ifdef HAVE_QTWIDGETS
 #include <QLineEdit>
 #include <QFormLayout>
 #endif // HAVE_QTWIDGETS
 
 #ifdef HAVE_KF5
 #include <KConfigGroup>
 #include <KLocalizedString>
 #endif // HAVE_KF5
 
 #include <KBibTeX>
 #include <FileImporterBibTeX>
 #include "internalnetworkaccessmanager.h"
+#include "onlinesearchabstract_p.h"
 #include "logging_networking.h"
 
 #ifdef HAVE_QTWIDGETS
-class OnlineSearchSemanticScholar::OnlineSearchQueryFormSemanticScholar : public OnlineSearchQueryFormAbstract
+class OnlineSearchSemanticScholar::OnlineSearchQueryFormSemanticScholar : public OnlineSearchAbstract::Form
 {
     Q_OBJECT
 
 private:
     QString configGroupName;
 
     void loadState() {
-        KConfigGroup configGroup(config, configGroupName);
+        KConfigGroup configGroup(d->config, configGroupName);
         lineEditPaperReference->setText(configGroup.readEntry(QStringLiteral("paperReference"), QString()));
     }
 
 public:
     QLineEdit *lineEditPaperReference;
 
     OnlineSearchQueryFormSemanticScholar(QWidget *widget)
-            : OnlineSearchQueryFormAbstract(widget), configGroupName(QStringLiteral("Search Engine Semantic Scholar")) {
+            : OnlineSearchAbstract::Form(widget), configGroupName(QStringLiteral("Search Engine Semantic Scholar")) {
         QFormLayout *layout = new QFormLayout(this);
         layout->setMargin(0);
 
         lineEditPaperReference = new QLineEdit(this);
         lineEditPaperReference->setClearButtonEnabled(true);
         lineEditPaperReference->setFocus(Qt::TabFocusReason);
         layout->addRow(i18n("Paper Reference:"), lineEditPaperReference);
         connect(lineEditPaperReference, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormSemanticScholar::returnPressed);
 
         loadState();
     }
 
     bool readyToStart() const override {
         return !lineEditPaperReference->text().isEmpty();
     }
 
     void copyFromEntry(const Entry &entry) override {
-        lineEditPaperReference->setText(guessFreeText(entry));
+        lineEditPaperReference->setText(d->guessFreeText(entry));
     }
 
     void saveState() {
-        KConfigGroup configGroup(config, configGroupName);
+        KConfigGroup configGroup(d->config, configGroupName);
         configGroup.writeEntry(QStringLiteral("paperReference"), lineEditPaperReference->text());
-        config->sync();
+        d->config->sync();
     }
 };
 #endif // HAVE_QTWIDGETS
 
 
 class OnlineSearchSemanticScholar::OnlineSearchSemanticScholarPrivate
 {
 public:
 #ifdef HAVE_QTWIDGETS
     OnlineSearchQueryFormSemanticScholar *form;
 #endif // HAVE_QTWIDGETS
 
     OnlineSearchSemanticScholarPrivate(OnlineSearchSemanticScholar *parent)
 #ifdef HAVE_QTWIDGETS
             : form(nullptr)
 #endif // HAVE_QTWIDGETS
     {
         Q_UNUSED(parent)
     }
 
 #ifdef HAVE_QTWIDGETS
     QUrl buildQueryUrl() {
         if (form == nullptr) {
             qCWarning(LOG_KBIBTEX_NETWORKING) << "Cannot build query url if no form is specified";
             return QUrl();
         }
 
         const QRegularExpressionMatch doiRegExpMatch = KBibTeX::doiRegExp.match(form->lineEditPaperReference->text());
         if (doiRegExpMatch.hasMatch())
             return QUrl(QStringLiteral("https://api.semanticscholar.org/v1/paper/") + doiRegExpMatch.captured(0));
         else {
             const QRegularExpressionMatch arXivRegExpMatch = KBibTeX::arXivRegExpWithoutPrefix.match(form->lineEditPaperReference->text());
             if (arXivRegExpMatch.hasMatch())
                 return QUrl(QStringLiteral("https://api.semanticscholar.org/v1/paper/") + arXivRegExpMatch.captured(0));
         }
 
         return QUrl();
     }
 #endif // HAVE_QTWIDGETS
 
     QUrl buildQueryUrl(const QMap<QString, QString> &query, int numResults) {
         Q_UNUSED(numResults)
 
         const QRegularExpressionMatch doiRegExpMatch = KBibTeX::doiRegExp.match(query[queryKeyFreeText]);
         if (doiRegExpMatch.hasMatch())
             return QUrl(QStringLiteral("https://api.semanticscholar.org/v1/paper/") + doiRegExpMatch.captured(0));
         else {
             const QRegularExpressionMatch arXivRegExpMatch = KBibTeX::arXivRegExpWithoutPrefix.match(query[queryKeyFreeText]);
             if (arXivRegExpMatch.hasMatch())
                 return QUrl(QStringLiteral("https://api.semanticscholar.org/v1/paper/") + arXivRegExpMatch.captured(0));
         }
         return QUrl();
     }
 
     Entry *entryFromJsonObject(const QJsonObject &object) const {
         const QString title = object.value(QStringLiteral("title")).toString();
         const QString paperId = object.value(QStringLiteral("paperId")).toString();
         const int year = object.value(QStringLiteral("year")).toInt(-1);
         /// Basic sanity check
         if (title.isEmpty() || paperId.isEmpty() || year < 1700)
             return nullptr;
 
         Entry *entry = new Entry(Entry::etMisc, QStringLiteral("SemanticScholar:") + paperId);
         entry->insert(Entry::ftTitle, Value() << QSharedPointer<PlainText>(new PlainText(title)));
         entry->insert(QStringLiteral("x-paperId"), Value() << QSharedPointer<VerbatimText>(new VerbatimText(paperId)));
         entry->insert(Entry::ftYear, Value() << QSharedPointer<PlainText>(new PlainText(QString::number(year))));
 
         const QString doi = object.value(QStringLiteral("doi")).toString();
         const QRegularExpressionMatch doiRegExpMatch = KBibTeX::doiRegExp.match(doi);
         if (doiRegExpMatch.hasMatch())
             entry->insert(Entry::ftDOI, Value() << QSharedPointer<VerbatimText>(new VerbatimText(doiRegExpMatch.captured())));
 
         const QString arxivId = object.value(QStringLiteral("arxivId")).toString();
         const QRegularExpressionMatch arXivRegExpMatch = KBibTeX::arXivRegExpWithoutPrefix.match(arxivId);
         if (arXivRegExpMatch.hasMatch())
             entry->insert(QStringLiteral("eprint"), Value() << QSharedPointer<VerbatimText>(new VerbatimText(arXivRegExpMatch.captured())));
 
         const QJsonArray authorArray = object.value(QStringLiteral("authors")).toArray();
         Value authors;
         for (const QJsonValue &author : authorArray) {
             const QString name = author.toObject().value(QStringLiteral("name")).toString();
             if (!name.isEmpty()) {
                 QSharedPointer<Person> person = FileImporterBibTeX::personFromString(name);
                 if (!person.isNull())
                     authors.append(person);
             }
         }
         if (!authors.isEmpty())
             entry->insert(Entry::ftAuthor, authors);
 
         return entry;
     }
 };
 
 
 OnlineSearchSemanticScholar::OnlineSearchSemanticScholar(QObject *parent)
         : OnlineSearchAbstract(parent), d(new OnlineSearchSemanticScholarPrivate(this))
 {
     /// nothing
 }
 
 OnlineSearchSemanticScholar::~OnlineSearchSemanticScholar()
 {
     delete d;
 }
 
 #ifdef HAVE_QTWIDGETS
 void OnlineSearchSemanticScholar::startSearchFromForm()
 {
     m_hasBeenCanceled = false;
     emit progress(curStep = 0, numSteps = 1);
 
     const QUrl url = d->buildQueryUrl();
     if (url.isValid()) {
         QNetworkRequest request(url);
         QNetworkReply *reply = InternalNetworkAccessManager::instance().get(request);
         InternalNetworkAccessManager::instance().setNetworkReplyTimeout(reply);
         connect(reply, &QNetworkReply::finished, this, &OnlineSearchSemanticScholar::downloadDone);
 
         d->form->saveState();
     } else
         delayedStoppedSearch(resultNoError);
 
     refreshBusyProperty();
 }
 #endif // HAVE_QTWIDGETS
 
 void OnlineSearchSemanticScholar::startSearch(const QMap<QString, QString> &query, int numResults)
 {
     m_hasBeenCanceled = false;
     emit progress(curStep = 0, numSteps = 1);
 
     const QUrl url = d->buildQueryUrl(query, numResults);
     if (url.isValid()) {
         QNetworkRequest request(url);
         QNetworkReply *reply = InternalNetworkAccessManager::instance().get(request);
         InternalNetworkAccessManager::instance().setNetworkReplyTimeout(reply);
         connect(reply, &QNetworkReply::finished, this, &OnlineSearchSemanticScholar::downloadDone);
     } else
         delayedStoppedSearch(resultNoError);
 
     refreshBusyProperty();
 }
 
 QString OnlineSearchSemanticScholar::label() const
 {
     return i18n("Semantic Scholar");
 }
 
 #ifdef HAVE_QTWIDGETS
-OnlineSearchQueryFormAbstract *OnlineSearchSemanticScholar::customWidget(QWidget *parent)
+OnlineSearchAbstract::Form *OnlineSearchSemanticScholar::customWidget(QWidget *parent)
 {
     if (d->form == nullptr)
         d->form = new OnlineSearchSemanticScholar::OnlineSearchQueryFormSemanticScholar(parent);
     return d->form;
 }
 #endif // HAVE_QTWIDGETS
 
 QUrl OnlineSearchSemanticScholar::homepage() const
 {
     return QUrl(QStringLiteral("https://www.semanticscholar.org/"));
 }
 
 QString OnlineSearchSemanticScholar::favIconUrl() const
 {
     return QStringLiteral("https://www.semanticscholar.org/img/favicon.png");
 }
 
 void OnlineSearchSemanticScholar::downloadDone()
 {
     emit progress(++curStep, numSteps);
     QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
 
     QUrl redirUrl;
     if (handleErrors(reply, redirUrl)) {
         if (redirUrl.isValid()) {
             /// redirection to another url
             ++numSteps;
 
             QNetworkRequest request(redirUrl);
             QNetworkReply *newReply = InternalNetworkAccessManager::instance().get(request);
             InternalNetworkAccessManager::instance().setNetworkReplyTimeout(newReply);
             connect(newReply, &QNetworkReply::finished, this, &OnlineSearchSemanticScholar::downloadDone);
         } else {
             QJsonParseError parseError;
             const auto buffer = reply->readAll();
             const QString jsonText = QString::fromUtf8(buffer);
             dumpToFile(QStringLiteral("semanticscholar.json"), jsonText);
             const QJsonDocument document = QJsonDocument::fromJson(buffer, &parseError);
             if (parseError.error == QJsonParseError::NoError) {
                 if (document.isObject()) {
                     Entry *entry = d->entryFromJsonObject(document.object());
                     if (entry != nullptr) {
                         publishEntry(QSharedPointer<Entry>(entry));
                         stopSearch(resultNoError);
                     } else {
                         qCWarning(LOG_KBIBTEX_NETWORKING) << "Problem with JSON data from Semantic Scholar: Data could not be interpreted as a bibliographic entry";
                         stopSearch(resultUnspecifiedError);
                     }
                 } else {
                     qCWarning(LOG_KBIBTEX_NETWORKING) << "Problem with JSON data from Semantic Scholar: Document is not an object";
                     stopSearch(resultUnspecifiedError);
                 }
             } else {
                 qCWarning(LOG_KBIBTEX_NETWORKING) << "Problem with JSON data from Semantic Scholar: " << parseError.errorString();
                 stopSearch(resultUnspecifiedError);
             }
         }
     }
 
     refreshBusyProperty();
 }
 
 #include "onlinesearchsemanticscholar.moc"
diff --git a/src/networking/onlinesearch/onlinesearchsemanticscholar.h b/src/networking/onlinesearch/onlinesearchsemanticscholar.h
index b939eff1..b2b1a139 100644
--- a/src/networking/onlinesearch/onlinesearchsemanticscholar.h
+++ b/src/networking/onlinesearch/onlinesearchsemanticscholar.h
@@ -1,57 +1,57 @@
 /***************************************************************************
  *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifndef KBIBTEX_NETWORKING_ONLINESEARCHSEMANTICSCHOLAR_H
 #define KBIBTEX_NETWORKING_ONLINESEARCHSEMANTICSCHOLAR_H
 
 #include <onlinesearch/OnlineSearchAbstract>
 
 #ifdef HAVE_KF5
 #include "kbibtexnetworking_export.h"
 #endif // HAVE_KF5
 
 class KBIBTEXNETWORKING_EXPORT OnlineSearchSemanticScholar : public OnlineSearchAbstract
 {
     Q_OBJECT
 
 public:
     explicit OnlineSearchSemanticScholar(QObject *parent);
     ~OnlineSearchSemanticScholar() override;
 
 #ifdef HAVE_QTWIDGETS
     void startSearchFromForm() override;
 #endif // HAVE_QTWIDGETS
     void startSearch(const QMap<QString, QString> &query, int numResults) override;
     QString label() const override;
 #ifdef HAVE_QTWIDGETS
-    OnlineSearchQueryFormAbstract *customWidget(QWidget *parent) override;
+    OnlineSearchAbstract::Form *customWidget(QWidget *parent) override;
 #endif // HAVE_QTWIDGETS
     QUrl homepage() const override;
 
 protected:
     QString favIconUrl() const override;
 
 private slots:
     void downloadDone();
 
 private:
     class OnlineSearchQueryFormSemanticScholar;
     class OnlineSearchSemanticScholarPrivate;
     OnlineSearchSemanticScholarPrivate *d;
 };
 
 #endif // KBIBTEX_NETWORKING_ONLINESEARCHSEMANTICSCHOLAR_H
diff --git a/src/networking/onlinesearch/onlinesearchspringerlink.cpp b/src/networking/onlinesearch/onlinesearchspringerlink.cpp
index 08ba63a7..5d545b55 100644
--- a/src/networking/onlinesearch/onlinesearchspringerlink.cpp
+++ b/src/networking/onlinesearch/onlinesearchspringerlink.cpp
@@ -1,357 +1,358 @@
 /***************************************************************************
- *   Copyright (C) 2004-2018 by Thomas Fischer <fischer@unix-ag.uni-kl.de> *
+ *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "onlinesearchspringerlink.h"
 
 #ifdef HAVE_QTWIDGETS
 #include <QFormLayout>
 #include <QSpinBox>
 #include <QLineEdit>
 #include <QLabel>
 #endif // HAVE_QTWIDGETS
 #include <QRegularExpression>
 #include <QNetworkRequest>
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
 #include <QUrlQuery>
 
 #ifdef HAVE_KF5
 #include <KLocalizedString>
 #include <KConfigGroup>
 #else // HAVE_KF5
 #define i18n(text) QObject::tr(text)
 #endif // HAVE_KF5
 
 #include <Encoder>
 #include <EncoderXML>
 #include <FileImporterBibTeX>
 #include <XSLTransform>
 #include "internalnetworkaccessmanager.h"
+#include "onlinesearchabstract_p.h"
 #include "logging_networking.h"
 
 #ifdef HAVE_QTWIDGETS
 /**
  * @author Thomas Fischer <fischer@unix-ag.uni-kl.de>
  */
-class OnlineSearchSpringerLink::OnlineSearchQueryFormSpringerLink : public OnlineSearchQueryFormAbstract
+class OnlineSearchSpringerLink::Form : public OnlineSearchAbstract::Form
 {
     Q_OBJECT
 
 private:
     QString configGroupName;
 
     void loadState() {
-        KConfigGroup configGroup(config, configGroupName);
+        KConfigGroup configGroup(d->config, configGroupName);
         lineEditFreeText->setText(configGroup.readEntry(QStringLiteral("free"), QString()));
         lineEditTitle->setText(configGroup.readEntry(QStringLiteral("title"), QString()));
         lineEditBookTitle->setText(configGroup.readEntry(QStringLiteral("bookTitle"), QString()));
         lineEditAuthorEditor->setText(configGroup.readEntry(QStringLiteral("authorEditor"), QString()));
         lineEditYear->setText(configGroup.readEntry(QStringLiteral("year"), QString()));
         numResultsField->setValue(configGroup.readEntry(QStringLiteral("numResults"), 10));
     }
 
 public:
     QLineEdit *lineEditFreeText, *lineEditTitle, *lineEditBookTitle, *lineEditAuthorEditor, *lineEditYear;
     QSpinBox *numResultsField;
 
-    OnlineSearchQueryFormSpringerLink(QWidget *parent)
-            : OnlineSearchQueryFormAbstract(parent), configGroupName(QStringLiteral("Search Engine SpringerLink")) {
+    Form(QWidget *parent)
+            : OnlineSearchAbstract::Form(parent), configGroupName(QStringLiteral("Search Engine SpringerLink")) {
         QFormLayout *layout = new QFormLayout(this);
         layout->setMargin(0);
 
         lineEditFreeText = new QLineEdit(this);
         lineEditFreeText->setClearButtonEnabled(true);
         QLabel *label = new QLabel(i18n("Free Text:"), this);
         label->setBuddy(lineEditFreeText);
         layout->addRow(label, lineEditFreeText);
-        connect(lineEditFreeText, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormSpringerLink::returnPressed);
+        connect(lineEditFreeText, &QLineEdit::returnPressed, this, &OnlineSearchSpringerLink::Form::returnPressed);
 
         lineEditTitle = new QLineEdit(this);
         lineEditTitle->setClearButtonEnabled(true);
         label = new QLabel(i18n("Title:"), this);
         label->setBuddy(lineEditTitle);
         layout->addRow(label, lineEditTitle);
-        connect(lineEditTitle, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormSpringerLink::returnPressed);
+        connect(lineEditTitle, &QLineEdit::returnPressed, this, &OnlineSearchSpringerLink::Form::returnPressed);
 
         lineEditBookTitle = new QLineEdit(this);
         lineEditBookTitle->setClearButtonEnabled(true);
         label = new QLabel(i18n("Book/Journal title:"), this);
         label->setBuddy(lineEditBookTitle);
         layout->addRow(label, lineEditBookTitle);
-        connect(lineEditBookTitle, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormSpringerLink::returnPressed);
+        connect(lineEditBookTitle, &QLineEdit::returnPressed, this, &OnlineSearchSpringerLink::Form::returnPressed);
 
         lineEditAuthorEditor = new QLineEdit(this);
         lineEditAuthorEditor->setClearButtonEnabled(true);
         label = new QLabel(i18n("Author or Editor:"), this);
         label->setBuddy(lineEditAuthorEditor);
         layout->addRow(label, lineEditAuthorEditor);
-        connect(lineEditAuthorEditor, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormSpringerLink::returnPressed);
+        connect(lineEditAuthorEditor, &QLineEdit::returnPressed, this, &OnlineSearchSpringerLink::Form::returnPressed);
 
         lineEditYear = new QLineEdit(this);
         lineEditYear->setClearButtonEnabled(true);
         label = new QLabel(i18n("Year:"), this);
         label->setBuddy(lineEditYear);
         layout->addRow(label, lineEditYear);
-        connect(lineEditYear, &QLineEdit::returnPressed, this, &OnlineSearchQueryFormSpringerLink::returnPressed);
+        connect(lineEditYear, &QLineEdit::returnPressed, this, &OnlineSearchSpringerLink::Form::returnPressed);
 
         numResultsField = new QSpinBox(this);
         label = new QLabel(i18n("Number of Results:"), this);
         label->setBuddy(numResultsField);
         layout->addRow(label, numResultsField);
         numResultsField->setMinimum(3);
         numResultsField->setMaximum(100);
 
         lineEditFreeText->setFocus(Qt::TabFocusReason);
 
         loadState();
     }
 
     bool readyToStart() const override {
         return !(lineEditFreeText->text().isEmpty() && lineEditTitle->text().isEmpty() && lineEditBookTitle->text().isEmpty() && lineEditAuthorEditor->text().isEmpty());
     }
 
     void copyFromEntry(const Entry &entry) override {
         lineEditTitle->setText(PlainTextValue::text(entry[Entry::ftTitle]));
         QString bookTitle = PlainTextValue::text(entry[Entry::ftBookTitle]);
         if (bookTitle.isEmpty())
             bookTitle = PlainTextValue::text(entry[Entry::ftJournal]);
         lineEditBookTitle->setText(bookTitle);
-        lineEditAuthorEditor->setText(authorLastNames(entry).join(QStringLiteral(" ")));
+        lineEditAuthorEditor->setText(d->authorLastNames(entry).join(QStringLiteral(" ")));
     }
 
     void saveState() {
-        KConfigGroup configGroup(config, configGroupName);
+        KConfigGroup configGroup(d->config, configGroupName);
         configGroup.writeEntry(QStringLiteral("free"), lineEditFreeText->text());
         configGroup.writeEntry(QStringLiteral("title"), lineEditTitle->text());
         configGroup.writeEntry(QStringLiteral("bookTitle"), lineEditBookTitle->text());
         configGroup.writeEntry(QStringLiteral("authorEditor"), lineEditAuthorEditor->text());
         configGroup.writeEntry(QStringLiteral("year"), lineEditYear->text());
         configGroup.writeEntry(QStringLiteral("numResults"), numResultsField->value());
-        config->sync();
+        d->config->sync();
     }
 };
 #endif // HAVE_QTWIDGETS
 
 class OnlineSearchSpringerLink::OnlineSearchSpringerLinkPrivate
 {
 private:
     static const QString xsltFilenameBase;
 
 public:
     static const QString springerMetadataKey;
     const XSLTransform xslt;
 #ifdef HAVE_QTWIDGETS
-    OnlineSearchQueryFormSpringerLink *form;
+    OnlineSearchSpringerLink::Form *form;
 #endif // HAVE_QTWIDGETS
 
     OnlineSearchSpringerLinkPrivate(OnlineSearchSpringerLink *)
             : xslt(XSLTransform::locateXSLTfile(xsltFilenameBase))
 #ifdef HAVE_QTWIDGETS
         , form(nullptr)
 #endif // HAVE_QTWIDGETS
     {
         if (!xslt.isValid())
             qCWarning(LOG_KBIBTEX_NETWORKING) << "Failed to initialize XSL transformation based on file '" << xsltFilenameBase << "'";
     }
 
 #ifdef HAVE_QTWIDGETS
     QUrl buildQueryUrl() {
         if (form == nullptr) return QUrl();
 
         QUrl queryUrl = QUrl(QString(QStringLiteral("http://api.springer.com/metadata/pam/?api_key=")).append(springerMetadataKey));
 
         QString queryString = form->lineEditFreeText->text();
 
         const QStringList titleChunks = OnlineSearchAbstract::splitRespectingQuotationMarks(form->lineEditTitle->text());
         for (const QString &titleChunk : titleChunks) {
             queryString += QString(QStringLiteral(" title:%1")).arg(Encoder::instance().convertToPlainAscii(titleChunk));
         }
 
         const QStringList bookTitleChunks = OnlineSearchAbstract::splitRespectingQuotationMarks(form->lineEditBookTitle->text());
         for (const QString &titleChunk : bookTitleChunks) {
             queryString += QString(QStringLiteral(" ( journal:%1 OR book:%1 )")).arg(Encoder::instance().convertToPlainAscii(titleChunk));
         }
 
         const QStringList authors = OnlineSearchAbstract::splitRespectingQuotationMarks(form->lineEditAuthorEditor->text());
         for (const QString &author : authors) {
             queryString += QString(QStringLiteral(" name:%1")).arg(Encoder::instance().convertToPlainAscii(author));
         }
 
         const QString year = form->lineEditYear->text();
         if (!year.isEmpty())
             queryString += QString(QStringLiteral(" year:%1")).arg(year);
 
         queryString = queryString.simplified();
         QUrlQuery query(queryUrl);
         query.addQueryItem(QStringLiteral("q"), queryString);
         queryUrl.setQuery(query);
 
         return queryUrl;
     }
 #endif // HAVE_QTWIDGETS
 
     QUrl buildQueryUrl(const QMap<QString, QString> &query) {
         QUrl queryUrl = QUrl(QString(QStringLiteral("http://api.springer.com/metadata/pam/?api_key=")).append(springerMetadataKey));
 
         QString queryString = query[queryKeyFreeText];
 
         const QStringList titleChunks = OnlineSearchAbstract::splitRespectingQuotationMarks(query[queryKeyTitle]);
         for (const QString &titleChunk : titleChunks) {
             queryString += QString(QStringLiteral(" title:%1")).arg(Encoder::instance().convertToPlainAscii(titleChunk));
         }
 
         const QStringList authors = OnlineSearchAbstract::splitRespectingQuotationMarks(query[queryKeyAuthor]);
         for (const QString &author : authors) {
             queryString += QString(QStringLiteral(" name:%1")).arg(Encoder::instance().convertToPlainAscii(author));
         }
 
         QString year = query[queryKeyYear];
         if (!year.isEmpty()) {
             static const QRegularExpression yearRegExp("\\b(18|19|20)[0-9]{2}\\b");
             const QRegularExpressionMatch yearRegExpMatch = yearRegExp.match(year);
             if (yearRegExpMatch.hasMatch()) {
                 year = yearRegExpMatch.captured(0);
                 queryString += QString(QStringLiteral(" year:%1")).arg(year);
             }
         }
 
         queryString = queryString.simplified();
         QUrlQuery q(queryUrl);
         q.addQueryItem(QStringLiteral("q"), queryString);
         queryUrl.setQuery(q);
 
         return queryUrl;
     }
 };
 
 const QString OnlineSearchSpringerLink::OnlineSearchSpringerLinkPrivate::xsltFilenameBase = QStringLiteral("pam2bibtex.xsl");
 const QString OnlineSearchSpringerLink::OnlineSearchSpringerLinkPrivate::springerMetadataKey(InternalNetworkAccessManager::reverseObfuscate("\xce\xb8\x4d\x2c\x8d\xba\xa9\xc4\x61\x9\x58\x6c\xbb\xde\x86\xb5\xb1\xc6\x15\x71\x76\x45\xd\x79\x12\x65\x95\xe1\x5d\x2f\x1d\x24\x10\x72\x2a\x5e\x69\x4\xdc\xba\xab\xc3\x28\x58\x8a\xfa\x5e\x69"));
 
 
 OnlineSearchSpringerLink::OnlineSearchSpringerLink(QObject *parent)
         : OnlineSearchAbstract(parent), d(new OnlineSearchSpringerLink::OnlineSearchSpringerLinkPrivate(this))
 {
     /// nothing
 }
 
 OnlineSearchSpringerLink::~OnlineSearchSpringerLink()
 {
     delete d;
 }
 
 #ifdef HAVE_QTWIDGETS
 void OnlineSearchSpringerLink::startSearchFromForm()
 {
     m_hasBeenCanceled = false;
     emit progress(curStep = 0, numSteps = 1);
 
     QUrl springerLinkSearchUrl = d->buildQueryUrl();
 
     QNetworkRequest request(springerLinkSearchUrl);
     QNetworkReply *reply = InternalNetworkAccessManager::instance().get(request);
     InternalNetworkAccessManager::instance().setNetworkReplyTimeout(reply);
     connect(reply, &QNetworkReply::finished, this, &OnlineSearchSpringerLink::doneFetchingPAM);
 
     if (d->form != nullptr) d->form->saveState();
 
     refreshBusyProperty();
 }
 #endif // HAVE_QTWIDGETS
 
 void OnlineSearchSpringerLink::startSearch(const QMap<QString, QString> &query, int numResults)
 {
     m_hasBeenCanceled = false;
 
     QUrl springerLinkSearchUrl = d->buildQueryUrl(query);
     QUrlQuery q(springerLinkSearchUrl);
     q.addQueryItem(QStringLiteral("p"), QString::number(numResults));
     springerLinkSearchUrl.setQuery(q);
 
     emit progress(curStep = 0, numSteps = 1);
     QNetworkRequest request(springerLinkSearchUrl);
     QNetworkReply *reply = InternalNetworkAccessManager::instance().get(request);
     InternalNetworkAccessManager::instance().setNetworkReplyTimeout(reply);
     connect(reply, &QNetworkReply::finished, this, &OnlineSearchSpringerLink::doneFetchingPAM);
 
     refreshBusyProperty();
 }
 
 QString OnlineSearchSpringerLink::label() const
 {
 #ifdef HAVE_KF5
     return i18n("SpringerLink");
 #else // HAVE_KF5
     //= onlinesearch-springerlink-label
     return QObject::tr("SpringerLink");
 #endif // HAVE_KF5
 }
 
 QString OnlineSearchSpringerLink::favIconUrl() const
 {
     return QStringLiteral("http://link.springer.com/static/0.6623/sites/link/images/favicon.ico");
 }
 
 #ifdef HAVE_QTWIDGETS
-OnlineSearchQueryFormAbstract *OnlineSearchSpringerLink::customWidget(QWidget *parent)
+OnlineSearchAbstract::Form *OnlineSearchSpringerLink::customWidget(QWidget *parent)
 {
     if (d->form == nullptr)
-        d->form = new OnlineSearchQueryFormSpringerLink(parent);
+        d->form = new Form(parent);
     return d->form;
 }
 #endif // HAVE_QTWIDGETS
 
 QUrl OnlineSearchSpringerLink::homepage() const
 {
     return QUrl(QStringLiteral("http://www.springerlink.com/"));
 }
 
 void OnlineSearchSpringerLink::doneFetchingPAM()
 {
     QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
     if (handleErrors(reply)) {
         /// ensure proper treatment of UTF-8 characters
         const QString xmlSource = QString::fromUtf8(reply->readAll().constData());
 
         const QString bibTeXcode = EncoderXML::instance().decode(d->xslt.transform(xmlSource).remove(QStringLiteral("<?xml version=\"1.0\" encoding=\"UTF-8\"?>")));
         if (bibTeXcode.isEmpty()) {
             qCWarning(LOG_KBIBTEX_NETWORKING) << "XSL tranformation failed for data from " << InternalNetworkAccessManager::removeApiKey(reply->url()).toDisplayString();
             stopSearch(resultInvalidArguments);
         } else {
             FileImporterBibTeX importer(this);
             const File *bibtexFile = importer.fromString(bibTeXcode);
 
             bool hasEntries = false;
             if (bibtexFile != nullptr) {
                 for (const QSharedPointer<Element> &element : *bibtexFile) {
                     QSharedPointer<Entry> entry = element.dynamicCast<Entry>();
                     hasEntries |= publishEntry(entry);
                 }
 
                 stopSearch(resultNoError);
 
                 delete bibtexFile;
             } else {
                 qCWarning(LOG_KBIBTEX_NETWORKING) << "No valid BibTeX file results returned on request on" << InternalNetworkAccessManager::removeApiKey(reply->url()).toDisplayString();
                 stopSearch(resultUnspecifiedError);
             }
         }
     }
 
     refreshBusyProperty();
 }
 
 #include "onlinesearchspringerlink.moc"
diff --git a/src/networking/onlinesearch/onlinesearchspringerlink.h b/src/networking/onlinesearch/onlinesearchspringerlink.h
index 34e48e63..5f9e7fd2 100644
--- a/src/networking/onlinesearch/onlinesearchspringerlink.h
+++ b/src/networking/onlinesearch/onlinesearchspringerlink.h
@@ -1,73 +1,73 @@
 /***************************************************************************
  *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifndef KBIBTEX_NETWORKING_ONLINESEARCHSPRINGERLINK_H
 #define KBIBTEX_NETWORKING_ONLINESEARCHSPRINGERLINK_H
 
 #include <onlinesearch/OnlineSearchAbstract>
 
 #ifdef HAVE_KF5
 #include "kbibtexnetworking_export.h"
 #endif // HAVE_KF5
 
 /**
  * @author Thomas Fischer <fischer@unix-ag.uni-kl.de>
  *
  * See also: http://dev.springer.com/
  *
  * On the subject of having multiple "constraints" (search terms) in
  * a search, Springer's documentation states: "Each constraint that
  * appears in your request will automatically be ANDed with all the others
  * For instance, a request including constraints: "title:bone+name:Jones"
  * is the equivilent to the request containing constraints concatenated by
  * the AND operator: "title:bone%20AND%20name:Jones".
  * (source: http://dev.springer.com/docs/read/Filters_Facets_and_Constraints)
  */
 class KBIBTEXNETWORKING_EXPORT OnlineSearchSpringerLink : public OnlineSearchAbstract
 {
     Q_OBJECT
 
 public:
     explicit OnlineSearchSpringerLink(QObject *parent);
     ~OnlineSearchSpringerLink() override;
 
 #ifdef HAVE_QTWIDGETS
     void startSearchFromForm() override;
 #endif // HAVE_QTWIDGETS
     void startSearch(const QMap<QString, QString> &query, int numResults) override;
     QString label() const override;
 #ifdef HAVE_QTWIDGETS
-    OnlineSearchQueryFormAbstract *customWidget(QWidget *parent) override;
+    OnlineSearchAbstract::Form *customWidget(QWidget *parent) override;
 #endif // HAVE_QTWIDGETS
     QUrl homepage() const override;
 
 protected:
     QString favIconUrl() const override;
 
 private slots:
     void doneFetchingPAM();
 
 private:
 #ifdef HAVE_QTWIDGETS
-    class OnlineSearchQueryFormSpringerLink;
+    class Form;
 #endif // HAVE_QTWIDGETS
 
     class OnlineSearchSpringerLinkPrivate;
     OnlineSearchSpringerLinkPrivate *d;
 };
 
 #endif // KBIBTEX_NETWORKING_ONLINESEARCHSPRINGERLINK_H
diff --git a/src/program/docklets/searchform.cpp b/src/program/docklets/searchform.cpp
index 8e5c0401..567e9526 100644
--- a/src/program/docklets/searchform.cpp
+++ b/src/program/docklets/searchform.cpp
@@ -1,509 +1,509 @@
 /***************************************************************************
  *   Copyright (C) 2004-2019 by Thomas Fischer <fischer@unix-ag.uni-kl.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.                                   *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, see <https://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "searchform.h"
 
 #include <QLayout>
 #include <QMap>
 #include <QLabel>
 #include <QListWidget>
 #include <QLineEdit>
 #include <QSpinBox>
 #include <QStackedWidget>
 #include <QTabWidget>
 #include <QProgressBar>
 #include <QMimeType>
 #include <QTimer>
 #include <QSet>
 #include <QAction>
 #include <QScrollArea>
 #include <QIcon>
 #include <QPushButton>
 #include <QDebug>
 
 #include <KLocalizedString>
 #include <KRun>
 #include <KMessageBox>
 #include <KParts/Part>
 #include <KParts/ReadOnlyPart>
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <kio_version.h>
 
 #include <Element>
 #include <File>
 #include <Comment>
 #include <FileExporterBibTeX>
 #include <onlinesearch/OnlineSearchAbstract>
 #include <onlinesearch/OnlineSearchGeneral>
 #include <onlinesearch/OnlineSearchBibsonomy>
 #include <onlinesearch/onlinesearchgooglescholar.h>
 #include <onlinesearch/OnlineSearchPubMed>
 #include <onlinesearch/OnlineSearchIEEEXplore>
 #include <onlinesearch/OnlineSearchAcmPortal>
 #include <onlinesearch/OnlineSearchScienceDirect>
 #include <onlinesearch/OnlineSearchSpringerLink>
 #include <onlinesearch/OnlineSearchArXiv>
 #include <onlinesearch/OnlineSearchJStor>
 #include <onlinesearch/OnlineSearchMathSciNet>
 #include <onlinesearch/OnlineSearchMRLookup>
 #include <onlinesearch/OnlineSearchInspireHep>
 #include <onlinesearch/OnlineSearchCERNDS>
 #include <onlinesearch/OnlineSearchIngentaConnect>
 #include <onlinesearch/OnlineSearchSOANASAADS>
 #include <onlinesearch/OnlineSearchIDEASRePEc>
 #include <onlinesearch/OnlineSearchDOI>
 #include <onlinesearch/OnlineSearchBioRxiv>
 #include <onlinesearch/OnlineSearchSemanticScholar>
 #include <file/FileView>
 #include <models/FileModel>
 #include "openfileinfo.h"
 #include "searchresults.h"
 #include "logging_program.h"
 
 class SearchForm::SearchFormPrivate
 {
 private:
     SearchForm *p;
     QStackedWidget *queryTermsStack;
     QWidget *listContainer;
     QListWidget *enginesList;
     QLabel *whichEnginesLabel;
     QAction *actionOpenHomepage;
 
 public:
     KSharedConfigPtr config;
     const QString configGroupName;
 
     SearchResults *sr;
     QMap<QListWidgetItem *, OnlineSearchAbstract *> itemToOnlineSearch;
     QSet<OnlineSearchAbstract *> runningSearches;
     QPushButton *searchButton;
     QPushButton *useEntryButton;
-    OnlineSearchQueryFormGeneral *generalQueryTermsForm;
+    OnlineSearchGeneral::Form *generalQueryTermsForm;
     QTabWidget *tabWidget;
     QSharedPointer<const Entry> currentEntry;
     QProgressBar *progressBar;
     QMap<OnlineSearchAbstract *, int> progressMap;
-    QMap<OnlineSearchQueryFormAbstract *, QScrollArea *> formToScrollArea;
+    QMap<OnlineSearchAbstract::Form *, QScrollArea *> formToScrollArea;
 
     enum SearchFormPrivateRole {
         /// Homepage of a search engine
         HomepageRole = Qt::UserRole + 5,
         /// Special widget for a search engine
         WidgetRole = Qt::UserRole + 6,
         /// Name of a search engine
         NameRole = Qt::UserRole + 7
     };
 
     SearchFormPrivate(SearchResults *searchResults, SearchForm *parent)
             : p(parent), whichEnginesLabel(nullptr), config(KSharedConfig::openConfig(QStringLiteral("kbibtexrc"))),
           configGroupName(QStringLiteral("Search Engines Docklet")), sr(searchResults), searchButton(nullptr), useEntryButton(nullptr), currentEntry(nullptr) {
         createGUI();
     }
 
-    OnlineSearchQueryFormAbstract *currentQueryForm() {
+    OnlineSearchAbstract::Form *currentQueryForm() {
         QScrollArea *area = qobject_cast<QScrollArea *>(queryTermsStack->currentWidget());
         return formToScrollArea.key(area, nullptr);
     }
 
-    QScrollArea *wrapInScrollArea(OnlineSearchQueryFormAbstract *form, QWidget *parent) {
+    QScrollArea *wrapInScrollArea(OnlineSearchAbstract::Form *form, QWidget *parent) {
         QScrollArea *scrollArea = new QScrollArea(parent);
         form->setParent(scrollArea);
         scrollArea->setWidget(form);
         scrollArea->setWidgetResizable(true);
         scrollArea->setFrameShape(QFrame::NoFrame);
         scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
         scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
         formToScrollArea.insert(form, scrollArea);
         return scrollArea;
     }
 
     QWidget *createQueryTermsStack(QWidget *parent) {
         QWidget *container = new QWidget(parent);
         QVBoxLayout *vLayout = new QVBoxLayout(container);
 
         whichEnginesLabel = new QLabel(container);
         whichEnginesLabel->setWordWrap(true);
         vLayout->addWidget(whichEnginesLabel);
         vLayout->setStretchFactor(whichEnginesLabel, 0);
         connect(whichEnginesLabel, &QLabel::linkActivated, p, &SearchForm::switchToEngines);
 
         vLayout->addSpacing(8);
 
         queryTermsStack = new QStackedWidget(container);
         vLayout->addWidget(queryTermsStack);
         vLayout->setStretchFactor(queryTermsStack, 5);
 
         QScrollArea *scrollArea = wrapInScrollArea(createGeneralQueryTermsForm(queryTermsStack), queryTermsStack);
         queryTermsStack->addWidget(scrollArea);
 
         return container;
     }
 
-    OnlineSearchQueryFormAbstract *createGeneralQueryTermsForm(QWidget *parent = nullptr) {
-        generalQueryTermsForm = new OnlineSearchQueryFormGeneral(parent);
+    OnlineSearchGeneral::Form *createGeneralQueryTermsForm(QWidget *parent = nullptr) {
+        generalQueryTermsForm = new OnlineSearchGeneral::Form(parent);
         return generalQueryTermsForm;
     }
 
     QWidget *createEnginesGUI(QWidget *parent) {
         listContainer = new QWidget(parent);
         QGridLayout *layout = new QGridLayout(listContainer);
         layout->setRowStretch(0, 1);
         layout->setRowStretch(1, 0);
 
         enginesList = new QListWidget(listContainer);
         layout->addWidget(enginesList, 0, 0, 1, 1);
         connect(enginesList, &QListWidget::itemChanged, p, &SearchForm::itemCheckChanged);
         connect(enginesList, &QListWidget::currentItemChanged, p, &SearchForm::enginesListCurrentChanged);
         enginesList->setSelectionMode(QAbstractItemView::NoSelection);
 
         actionOpenHomepage = new QAction(QIcon::fromTheme(QStringLiteral("internet-web-browser")), i18n("Go to Homepage"), p);
         connect(actionOpenHomepage, &QAction::triggered, p, &SearchForm::openHomepage);
         enginesList->addAction(actionOpenHomepage);
         enginesList->setContextMenuPolicy(Qt::ActionsContextMenu);
 
         return listContainer;
     }
 
     void createGUI() {
         QGridLayout *layout = new QGridLayout(p);
         layout->setMargin(0);
         layout->setRowStretch(0, 1);
         layout->setRowStretch(1, 0);
         layout->setColumnStretch(0, 0);
         layout->setColumnStretch(1, 1);
         layout->setColumnStretch(2, 0);
 
         tabWidget = new QTabWidget(p);
         tabWidget->setDocumentMode(true);
         layout->addWidget(tabWidget, 0, 0, 1, 3);
 
         QWidget *widget = createQueryTermsStack(tabWidget);
         tabWidget->addTab(widget, QIcon::fromTheme(QStringLiteral("edit-rename")), i18n("Query Terms"));
 
         QWidget *listContainer = createEnginesGUI(tabWidget);
         tabWidget->addTab(listContainer, QIcon::fromTheme(QStringLiteral("applications-engineering")), i18n("Engines"));
 
         connect(tabWidget, &QTabWidget::currentChanged, p, &SearchForm::tabSwitched);
 
         useEntryButton = new QPushButton(QIcon::fromTheme(QStringLiteral("go-up")), i18n("Use Entry"), p);
         layout->addWidget(useEntryButton, 1, 0, 1, 1);
         useEntryButton->setEnabled(false);
         connect(useEntryButton, &QPushButton::clicked, p, &SearchForm::copyFromEntry);
 
         progressBar = new QProgressBar(p);
         layout->addWidget(progressBar, 1, 1, 1, 1);
         progressBar->setMaximum(1000);
         progressBar->hide();
 
         searchButton = new QPushButton(QIcon::fromTheme(QStringLiteral("edit-find")), i18n("Search"), p);
         layout->addWidget(searchButton, 1, 2, 1, 1);
-        connect(generalQueryTermsForm, &OnlineSearchQueryFormGeneral::returnPressed, searchButton, &QPushButton::click);
+        connect(generalQueryTermsForm, &OnlineSearchAbstract::Form::returnPressed, searchButton, &QPushButton::click);
 
         updateGUI();
     }
 
     void loadEngines() {
         enginesList->clear();
 
         addEngine(new OnlineSearchAcmPortal(p));
         addEngine(new OnlineSearchArXiv(p));
         addEngine(new OnlineSearchBioRxiv(p));
         addEngine(new OnlineSearchBibsonomy(p));
         addEngine(new OnlineSearchGoogleScholar(p));
         addEngine(new OnlineSearchIEEEXplore(p));
         addEngine(new OnlineSearchIngentaConnect(p));
         addEngine(new OnlineSearchJStor(p));
         addEngine(new OnlineSearchMathSciNet(p));
         addEngine(new OnlineSearchMRLookup(p));
         addEngine(new OnlineSearchInspireHep(p));
         addEngine(new OnlineSearchCERNDS(p));
         addEngine(new OnlineSearchPubMed(p));
         addEngine(new OnlineSearchScienceDirect(p));
         addEngine(new OnlineSearchSpringerLink(p));
         addEngine(new OnlineSearchSOANASAADS(p));
         /// addEngine(new OnlineSearchIsbnDB(p)); /// disabled as provider switched to a paid model on 2017-12-26
         addEngine(new OnlineSearchIDEASRePEc(p));
         addEngine(new OnlineSearchDOI(p));
         addEngine(new OnlineSearchSemanticScholar(p));
 
         p->itemCheckChanged(nullptr);
         updateGUI();
     }
 
     void addEngine(OnlineSearchAbstract *engine) {
         KConfigGroup configGroup(config, configGroupName);
 
         /// Disable signals while updating the widget and its items
         enginesList->blockSignals(true);
 
         QListWidgetItem *item = new QListWidgetItem(engine->label(), enginesList);
         static const QSet<QString> enginesEnabledByDefault {QStringLiteral("GoogleScholar"), QStringLiteral("Bibsonomy")};
         item->setCheckState(configGroup.readEntry(engine->name(), enginesEnabledByDefault.contains(engine->name())) ? Qt::Checked : Qt::Unchecked);
         item->setIcon(engine->icon(item));
         item->setToolTip(engine->label());
         item->setData(HomepageRole, engine->homepage());
         item->setData(NameRole, engine->name());
 
-        OnlineSearchQueryFormAbstract *widget = engine->customWidget(queryTermsStack);
-        item->setData(WidgetRole, QVariant::fromValue<OnlineSearchQueryFormAbstract *>(widget));
+        OnlineSearchAbstract::Form *widget = engine->customWidget(queryTermsStack);
+        item->setData(WidgetRole, QVariant::fromValue<OnlineSearchAbstract::Form *>(widget));
         if (widget != nullptr) {
-            connect(widget, &OnlineSearchQueryFormAbstract::returnPressed, searchButton, &QPushButton::click);
+            connect(widget, &OnlineSearchAbstract::Form::returnPressed, searchButton, &QPushButton::click);
             QScrollArea *scrollArea = wrapInScrollArea(widget, queryTermsStack);
             queryTermsStack->addWidget(scrollArea);
         }
 
         itemToOnlineSearch.insert(item, engine);
         connect(engine, &OnlineSearchAbstract::foundEntry, p, &SearchForm::foundEntry);
         connect(engine, &OnlineSearchAbstract::stoppedSearch, p, &SearchForm::stoppedSearch);
         connect(engine, &OnlineSearchAbstract::progress, p, &SearchForm::updateProgress);
 
         /// Re-enable signals after updating the widget and its items
         enginesList->blockSignals(false);
     }
 
     void switchToSearch() {
         for (QMap<QListWidgetItem *, OnlineSearchAbstract *>::ConstIterator it = itemToOnlineSearch.constBegin(); it != itemToOnlineSearch.constEnd(); ++it)
             disconnect(searchButton, &QPushButton::clicked, it.value(), &OnlineSearchAbstract::cancel);
 
         connect(searchButton, &QPushButton::clicked, p, &SearchForm::startSearch);
         searchButton->setText(i18n("Search"));
         searchButton->setIcon(QIcon::fromTheme(QStringLiteral("media-playback-start")));
         for (int i = tabWidget->count() - 1; i >= 0; --i)
             tabWidget->widget(i)->setEnabled(true);
         tabWidget->unsetCursor();
     }
 
     void switchToCancel() {
         disconnect(searchButton, &QPushButton::clicked, p, &SearchForm::startSearch);
 
         for (QMap<QListWidgetItem *, OnlineSearchAbstract *>::ConstIterator it = itemToOnlineSearch.constBegin(); it != itemToOnlineSearch.constEnd(); ++it)
             connect(searchButton, &QPushButton::clicked, it.value(), &OnlineSearchAbstract::cancel);
         searchButton->setText(i18n("Stop"));
         searchButton->setIcon(QIcon::fromTheme(QStringLiteral("media-playback-stop")));
         for (int i = tabWidget->count() - 1; i >= 0; --i)
             tabWidget->widget(i)->setEnabled(false);
         tabWidget->setCursor(Qt::WaitCursor);
     }
 
     void switchToEngines() {
         tabWidget->setCurrentWidget(listContainer);
     }
 
     void updateGUI() {
         if (whichEnginesLabel == nullptr) return;
 
         QStringList checkedEngines;
         QListWidgetItem *cursor = nullptr;
         for (QMap<QListWidgetItem *, OnlineSearchAbstract *>::ConstIterator it = itemToOnlineSearch.constBegin(); it != itemToOnlineSearch.constEnd(); ++it)
             if (it.key()->checkState() == Qt::Checked) {
                 checkedEngines << it.key()->text();
                 cursor = it.key();
             }
 
         switch (checkedEngines.size()) {
         case 0: whichEnginesLabel->setText(i18n("No search engine selected (<a href=\"changeEngine\">change</a>).")); break;
         case 1: whichEnginesLabel->setText(i18n("Search engine <b>%1</b> is selected (<a href=\"changeEngine\">change</a>).", checkedEngines.first())); break;
         case 2: whichEnginesLabel->setText(i18n("Search engines <b>%1</b> and <b>%2</b> are selected (<a href=\"changeEngine\">change</a>).", checkedEngines.first(), checkedEngines.at(1))); break;
         case 3: whichEnginesLabel->setText(i18n("Search engines <b>%1</b>, <b>%2</b>, and <b>%3</b> are selected (<a href=\"changeEngine\">change</a>).", checkedEngines.first(), checkedEngines.at(1), checkedEngines.at(2))); break;
         default: whichEnginesLabel->setText(i18n("Search engines <b>%1</b>, <b>%2</b>, and more are selected (<a href=\"changeEngine\">change</a>).", checkedEngines.first(), checkedEngines.at(1))); break;
         }
 
-        OnlineSearchQueryFormAbstract *currentQueryWidget = nullptr;
+        OnlineSearchAbstract::Form *currentQueryWidget = nullptr;
         if (cursor != nullptr && checkedEngines.size() == 1)
-            currentQueryWidget = cursor->data(WidgetRole).value<OnlineSearchQueryFormAbstract *>();
+            currentQueryWidget = cursor->data(WidgetRole).value<OnlineSearchAbstract::Form *>();
         if (currentQueryWidget == nullptr)
             currentQueryWidget = generalQueryTermsForm;
         QScrollArea *area = formToScrollArea.value(currentQueryWidget, nullptr);
         if (area != nullptr)
             queryTermsStack->setCurrentWidget(area);
 
         if (useEntryButton != nullptr)
             useEntryButton->setEnabled(!currentEntry.isNull() && tabWidget->currentIndex() == 0);
     }
 
     void openHomepage() {
         QListWidgetItem *item = enginesList->currentItem();
         if (item != nullptr) {
             QUrl url = item->data(HomepageRole).toUrl();
             /// Guess mime type for url to open
             QMimeType mimeType = FileInfo::mimeTypeForUrl(url);
             const QString mimeTypeName = mimeType.name();
             /// Ask KDE subsystem to open url in viewer matching mime type
             KRun::runUrl(url, mimeTypeName, p, KRun::RunFlags());
         }
     }
 
     void enginesListCurrentChanged(QListWidgetItem *current) {
         actionOpenHomepage->setEnabled(current != nullptr);
     }
 };
 
 SearchForm::SearchForm(SearchResults *searchResults, QWidget *parent)
         : QWidget(parent), d(new SearchFormPrivate(searchResults, this))
 {
     d->loadEngines();
     d->switchToSearch();
 }
 
 SearchForm::~SearchForm()
 {
     delete d;
 }
 
 void SearchForm::updatedConfiguration()
 {
     d->loadEngines();
 }
 
 void SearchForm::setElement(QSharedPointer<Element> element, const File *)
 {
     d->currentEntry = element.dynamicCast<const Entry>();
     d->useEntryButton->setEnabled(!d->currentEntry.isNull() && d->tabWidget->currentIndex() == 0);
 }
 
 void SearchForm::switchToEngines()
 {
     d->switchToEngines();
 }
 
 void SearchForm::startSearch()
 {
-    OnlineSearchQueryFormAbstract *currentForm = d->currentQueryForm();
+    OnlineSearchAbstract::Form *currentForm = d->currentQueryForm();
     if (!currentForm->readyToStart()) {
         KMessageBox::sorry(this, i18n("Could not start searching the Internet:\nThe search terms are not complete or invalid."), i18n("Searching the Internet"));
         return;
     }
 
     d->runningSearches.clear();
     d->sr->clear();
     d->progressBar->setValue(0);
     d->progressMap.clear();
     d->useEntryButton->hide();
     d->progressBar->show();
 
     if (currentForm == d->generalQueryTermsForm) {
         /// start search using the general-purpose form's values
 
         QMap<QString, QString> queryTerms = d->generalQueryTermsForm->getQueryTerms();
         int numResults = d->generalQueryTermsForm->getNumResults();
         for (QMap<QListWidgetItem *, OnlineSearchAbstract *>::ConstIterator it = d->itemToOnlineSearch.constBegin(); it != d->itemToOnlineSearch.constEnd(); ++it)
             if (it.key()->checkState() == Qt::Checked) {
                 it.value()->startSearch(queryTerms, numResults);
                 d->runningSearches.insert(it.value());
             }
         if (d->runningSearches.isEmpty()) {
             /// if no search engine has been checked (selected), something went wrong
             return;
         }
     } else {
         /// use the single selected search engine's specific form
 
         for (QMap<QListWidgetItem *, OnlineSearchAbstract *>::ConstIterator it = d->itemToOnlineSearch.constBegin(); it != d->itemToOnlineSearch.constEnd(); ++it)
             if (it.key()->checkState() == Qt::Checked) {
                 it.value()->startSearchFromForm();
                 d->runningSearches.insert(it.value());
             }
         if (d->runningSearches.isEmpty()) {
             /// if no search engine has been checked (selected), something went wrong
             return;
         }
     }
 
     d->switchToCancel();
 }
 
 void SearchForm::foundEntry(QSharedPointer<Entry> entry)
 {
     d->sr->insertElement(entry);
 }
 
 void SearchForm::stoppedSearch(int)
 {
     OnlineSearchAbstract *engine = static_cast<OnlineSearchAbstract *>(sender());
     if (d->runningSearches.remove(engine)) {
         if (d->runningSearches.isEmpty()) {
             /// last search engine stopped
             d->switchToSearch();
             emit doneSearching();
 
             QTimer::singleShot(1000, d->progressBar, &QProgressBar::hide);
             QTimer::singleShot(1100, d->useEntryButton, &QPushButton::show);
         } else {
             QStringList remainingEngines;
             remainingEngines.reserve(d->runningSearches.size());
             for (OnlineSearchAbstract *running : const_cast<const QSet<OnlineSearchAbstract *> &>(d->runningSearches)) {
                 remainingEngines.append(running->label());
             }
             if (!remainingEngines.isEmpty())
                 qCDebug(LOG_KBIBTEX_PROGRAM) << "Remaining running engines:" << remainingEngines.join(QStringLiteral(", "));
         }
     }
 }
 
 void SearchForm::tabSwitched(int newTab)
 {
     Q_UNUSED(newTab);
     d->updateGUI();
 }
 
 void SearchForm::itemCheckChanged(QListWidgetItem *item)
 {
     int numCheckedEngines = 0;
     for (QMap<QListWidgetItem *, OnlineSearchAbstract *>::ConstIterator it = d->itemToOnlineSearch.constBegin(); it != d->itemToOnlineSearch.constEnd(); ++it)
         if (it.key()->checkState() == Qt::Checked)
             ++numCheckedEngines;
 
     d->searchButton->setEnabled(numCheckedEngines > 0);
 
     if (item != nullptr) {
         KConfigGroup configGroup(d->config, d->configGroupName);
         QString name = item->data(SearchForm::SearchFormPrivate::NameRole).toString();
         configGroup.writeEntry(name, item->checkState() == Qt::Checked);
         d->config->sync();
     }
 }
 
 void SearchForm::openHomepage()
 {
     d->openHomepage();
 }
 
 void SearchForm::enginesListCurrentChanged(QListWidgetItem *current, QListWidgetItem *)
 {
     d->enginesListCurrentChanged(current);
 }
 
 void SearchForm::copyFromEntry()
 {
     Q_ASSERT_X(!d->currentEntry.isNull(), "SearchForm::copyFromEntry", "d->currentEntry is NULL");
 
     d->currentQueryForm()->copyFromEntry(*(d->currentEntry));
 }
 
 void SearchForm::updateProgress(int cur, int total)
 {
     OnlineSearchAbstract *ws = static_cast<OnlineSearchAbstract *>(sender());
     d->progressMap[ws] = total > 0 ? cur * 1000 / total : 0;
 
     int progress = 0, count = 0;
     for (QMap<OnlineSearchAbstract *, int>::ConstIterator it = d->progressMap.constBegin(); it != d->progressMap.constEnd(); ++it, ++count)
         progress += it.value();
 
     d->progressBar->setValue(count >= 1 ? progress / count : 0);
 }