diff --git a/src/bibtexkeydialog.cpp b/src/bibtexkeydialog.cpp
index 91da0838..2c61a7fd 100644
--- a/src/bibtexkeydialog.cpp
+++ b/src/bibtexkeydialog.cpp
@@ -1,133 +1,133 @@
 /***************************************************************************
     Copyright (C) 2011 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "bibtexkeydialog.h"
 #include "collections/bibtexcollection.h"
 #include "entry.h"
 #include "tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KTitleWidget>
 #include <KSharedConfig>
 #include <KGuiItem>
 
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QTimer>
 #include <QDialogButtonBox>
 #include <QPushButton>
 
 using Tellico::BibtexKeyDialog;
 
 // default button is going to be used as a print button, so it's separated
 BibtexKeyDialog::BibtexKeyDialog(Data::CollPtr coll_, QWidget* parent_)
     : QDialog(parent_), m_coll(coll_) {
   Q_ASSERT(m_coll);
   setModal(false);
   setWindowTitle(i18n("Citation Key Manager"));
 
   QVBoxLayout* topLayout = new QVBoxLayout;
   setLayout(topLayout);
 
   QWidget* mainWidget = new QWidget(this);
   topLayout->addWidget(mainWidget);
 
   m_dupeLabel = new KTitleWidget(this);
   m_dupeLabel->setText(m_coll->title(), KTitleWidget::PlainMessage);
   m_dupeLabel->setComment(i18n("Checking for entries with duplicate citation keys..."));
   m_dupeLabel->setPixmap(QIcon::fromTheme(QStringLiteral("tools-wizard")).pixmap(64, 64), KTitleWidget::ImageLeft);
   topLayout->addWidget(m_dupeLabel);
 
   QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
   buttonBox->button(QDialogButtonBox::Close)->setDefault(true);
-  connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
-  connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
+  connect(buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
+  connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
 
   QPushButton* checkDuplicates = new QPushButton(buttonBox);
   KGuiItem::assign(checkDuplicates, KGuiItem(i18n("Check for duplicates"), QStringLiteral("system-search")));
   buttonBox->addButton(checkDuplicates, QDialogButtonBox::ActionRole);
   m_filterButton = new QPushButton(buttonBox);
   KGuiItem::assign(m_filterButton, KGuiItem(i18n("Filter for duplicates"), QStringLiteral("view-filter")));
   buttonBox->addButton(m_filterButton, QDialogButtonBox::ActionRole);
 
   topLayout->addWidget(buttonBox);
 
   if(m_coll->type() != Data::Collection::Bibtex)  {
     // if it's not a bibliography, no need to save a pointer
     m_coll = Data::CollPtr();
     myWarning() << "not a bibliography";
   } else {
     // the button is enabled when duplicates are found
     m_filterButton->setEnabled(false);
-    connect(m_filterButton, SIGNAL(clicked()), SLOT(slotFilterDuplicates()));
-    connect(checkDuplicates, SIGNAL(clicked()), SLOT(slotCheckDuplicates()));
-    QTimer::singleShot(0, this, SLOT(slotCheckDuplicatesImpl()));
+    connect(m_filterButton, &QAbstractButton::clicked, this, &BibtexKeyDialog::slotFilterDuplicates);
+    connect(checkDuplicates, &QAbstractButton::clicked, this, &BibtexKeyDialog::slotCheckDuplicates);
+    QTimer::singleShot(0, this, &BibtexKeyDialog::slotCheckDuplicatesImpl);
   }
 }
 
 BibtexKeyDialog::~BibtexKeyDialog() {
 }
 
 void BibtexKeyDialog::slotCheckDuplicates() {
   if(!m_coll) {
     return;
   }
   m_dupeLabel->setComment(i18n("Checking for entries with duplicate citation keys..."));
-  QTimer::singleShot(0, this, SLOT(slotCheckDuplicatesImpl()));
+  QTimer::singleShot(0, this, &BibtexKeyDialog::slotCheckDuplicatesImpl);
 }
 
 void BibtexKeyDialog::slotCheckDuplicatesImpl() {
   const Data::BibtexCollection* c = static_cast<Data::BibtexCollection*>(m_coll.data());
   m_dupes = c->duplicateBibtexKeys();
 
   m_filterButton->setEnabled(false);
   if(m_dupes.isEmpty())  {
     m_dupeLabel->setComment(i18n("There are no duplicate citation keys."));
     m_filterButton->setEnabled(false);
   } else {
     m_dupeLabel->setComment(i18np("There is %1 duplicate citation key.", "There are %1 duplicate citation keys.", m_dupes.count()));
     m_filterButton->setEnabled(true);
   }
 }
 
 void BibtexKeyDialog::slotFilterDuplicates() {
   if(!m_coll || m_dupes.isEmpty()) {
     return;
   }
 
   FilterPtr filter(new Filter(Filter::MatchAny));
 
   QSet<QString> keys;
   foreach(Data::EntryPtr entry, m_dupes) {
     const QString key = entry->field(QStringLiteral("bibtex-key"));
     if(!keys.contains(key)) {
       filter->append(new FilterRule(QStringLiteral("bibtex-key"), key, FilterRule::FuncEquals));
       keys << key;
     }
   }
 
   if(!filter->isEmpty()) {
     emit signalUpdateFilter(filter);
   }
 }
diff --git a/src/borrowerdialog.cpp b/src/borrowerdialog.cpp
index f76e1238..c1edd55f 100644
--- a/src/borrowerdialog.cpp
+++ b/src/borrowerdialog.cpp
@@ -1,204 +1,204 @@
 /***************************************************************************
     Copyright (C) 2005-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "borrowerdialog.h"
 #include "document.h"
 #include "collection.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KLineEdit>
 #include <KJob>
 
 #ifdef HAVE_KABC
 #ifdef QT_STRICT_ITERATORS
 #define WAS_STRICT
 #undef QT_STRICT_ITERATORS
 #endif
 
 #include <kcontacts/addressee.h>
 #include <Akonadi/Contact/ContactSearchJob>
 
 #ifdef WAS_STRICT
 #define QT_STRICT_ITERATORS
 #undef WAS_STRICT
 #endif
 #endif
 
 #include <QVBoxLayout>
 #include <QDialogButtonBox>
 #include <QPushButton>
 
 using Tellico::BorrowerDialog;
 
 #ifdef HAVE_KABC
 BorrowerDialog::Item::Item(QTreeWidget* parent_, const KContacts::Addressee& add_)
     : QTreeWidgetItem(parent_), m_uid(add_.uid()) {
   setData(0, Qt::DisplayRole, add_.realName().trimmed());
   setData(0, Qt::DecorationRole, QIcon::fromTheme(QLatin1String("kaddressbook")));
 }
 #endif
 
 BorrowerDialog::Item::Item(QTreeWidget* parent_, const Tellico::Data::Borrower& bor_)
     : QTreeWidgetItem(parent_), m_uid(bor_.uid()) {
   setData(0, Qt::DisplayRole, bor_.name());
   setData(0, Qt::DecorationRole, QIcon::fromTheme(QStringLiteral("tellico"),
                                                   QIcon(QLatin1String(":/icons/tellico"))));
 }
 
 // default button is going to be used as a print button, so it's separated
 BorrowerDialog::BorrowerDialog(QWidget* parent_)
     : QDialog(parent_) {
   setModal(true);
   setWindowTitle(i18n("Select Borrower"));
 
   QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
   QVBoxLayout *mainLayout = new QVBoxLayout(this);
   setLayout(mainLayout);
 
   QWidget* mainWidget = new QWidget(this);
   mainLayout->addWidget(mainWidget);
 
   QPushButton* okButton = buttonBox->button(QDialogButtonBox::Ok);
   okButton->setDefault(true);
   okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
-  connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
-  connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
+  connect(buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
+  connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
 
   m_treeWidget = new QTreeWidget(mainWidget);
   mainLayout->addWidget(m_treeWidget);
   m_treeWidget->setHeaderLabel(i18n("Name"));
   m_treeWidget->setRootIsDecorated(false);
-  connect(m_treeWidget, SIGNAL(itemDoubleClicked(QTreeWidgetItem*,int)),
-          SLOT(accept()));
-  connect(m_treeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)),
-          SLOT(updateEdit(QTreeWidgetItem*)));
+  connect(m_treeWidget, &QTreeWidget::itemDoubleClicked,
+          this, &QDialog::accept);
+  connect(m_treeWidget, &QTreeWidget::currentItemChanged,
+          this, &BorrowerDialog::updateEdit);
 
   m_lineEdit = new KLineEdit(mainWidget); //krazy:exclude=qclasses
   mainLayout->addWidget(m_lineEdit);
-  connect(m_lineEdit->completionObject(), SIGNAL(match(const QString&)),
-          SLOT(selectItem(const QString&)));
+  connect(m_lineEdit->completionObject(), &KCompletion::match,
+          this, &BorrowerDialog::selectItem);
   m_lineEdit->setFocus();
   m_lineEdit->completionObject()->setIgnoreCase(true);
 
   mainLayout->addWidget(buttonBox);
 
 #ifdef HAVE_KABC
   // Search for all existing contacts
   Akonadi::ContactSearchJob* job = new Akonadi::ContactSearchJob();
   connect(job, SIGNAL(result(KJob*)), this, SLOT(akonadiSearchResult(KJob*)));
 #endif
 
   populateBorrowerList();
 
   setMinimumWidth(400);
 }
 
 void BorrowerDialog::akonadiSearchResult(KJob* job_) {
   if(job_->error() != 0) {
     myDebug() << job_->errorString();
     return;
   }
 
 #ifdef HAVE_KABC
   Akonadi::ContactSearchJob* searchJob = qobject_cast<Akonadi::ContactSearchJob*>(job_);
   Q_ASSERT(searchJob);
 
   populateBorrowerList();
 
   foreach(const KContacts::Addressee& addressee, searchJob->contacts()) {
     // skip people with no name
     const QString name = addressee.realName().trimmed();
     if(name.isEmpty()) {
       continue;
     }
     if(m_itemHash.contains(name)) {
       continue; // if an item already exists with this name
     }
     Item* item = new Item(m_treeWidget, addressee);
     m_itemHash.insert(name, item);
     m_lineEdit->completionObject()->addItem(name);
   }
 #endif
 
   m_treeWidget->sortItems(0, Qt::AscendingOrder);
 }
 
 void BorrowerDialog::populateBorrowerList() {
   m_treeWidget->clear();
   m_itemHash.clear();
   m_lineEdit->completionObject()->clear();
 
   // Bug 307958 - KContacts::Addressee uids are not constant
   // so populate the borrower list with the existing borrowers
   // before adding ones from address book
   Data::BorrowerList borrowers = Data::Document::self()->collection()->borrowers();
   foreach(Data::BorrowerPtr bor, borrowers) {
     if(bor->name().isEmpty()) {
       continue;
     }
     if(m_itemHash.contains(bor->name())) {
       continue; // if an item already exists with this name
     }
     Item* item = new Item(m_treeWidget, *bor);
     m_itemHash.insert(bor->name(), item);
     m_lineEdit->completionObject()->addItem(bor->name());
   }
   m_treeWidget->sortItems(0, Qt::AscendingOrder);
 }
 
 void BorrowerDialog::selectItem(const QString& str_) {
   if(str_.isEmpty()) {
     return;
   }
 
   QTreeWidgetItem* item = m_itemHash.value(str_);
   if(item) {
     m_treeWidget->blockSignals(true);
     m_treeWidget->setCurrentItem(item);
     m_treeWidget->scrollToItem(item);
     m_treeWidget->blockSignals(false);
   }
 }
 
 void BorrowerDialog::updateEdit(QTreeWidgetItem* item_) {
   QString s = item_->data(0, Qt::DisplayRole).toString();
   m_lineEdit->setText(s);
   m_lineEdit->setSelection(0, s.length());
   m_uid = static_cast<Item*>(item_)->uid();
 }
 
 Tellico::Data::BorrowerPtr BorrowerDialog::borrower() {
   return Data::BorrowerPtr(new Data::Borrower(m_lineEdit->text(), m_uid));
 }
 
 // static
 Tellico::Data::BorrowerPtr BorrowerDialog::getBorrower(QWidget* parent_) {
   BorrowerDialog dlg(parent_);
 
   if(dlg.exec() == QDialog::Accepted) {
     return dlg.borrower();
   }
   return Data::BorrowerPtr();
 }
diff --git a/src/collectionfieldsdialog.cpp b/src/collectionfieldsdialog.cpp
index 293e425c..d1f387ca 100644
--- a/src/collectionfieldsdialog.cpp
+++ b/src/collectionfieldsdialog.cpp
@@ -1,1091 +1,1094 @@
 /***************************************************************************
     Copyright (C) 2003-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "collectionfieldsdialog.h"
 #include "collection.h"
 #include "field.h"
 #include "fieldformat.h"
 #include "collectionfactory.h"
 #include "gui/listwidgetitem.h"
 #include "gui/stringmapdialog.h"
 #include "gui/combobox.h"
 #include "tellico_kernel.h"
 #include "translators/tellico_xml.h"
 #include "utils/string_utils.h"
 #include "tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KAcceleratorManager>
 #include <KHelpClient>
 
 #include <QPushButton>
 #include <QLineEdit>
 #include <QLabel>
 #include <QRadioButton>
 #include <QGroupBox>
 #include <QCheckBox>
 #include <QRegExp>
 #include <QTimer>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QGridLayout>
 #include <QListWidget>
 #include <QDialogButtonBox>
 
 using namespace Tellico;
 using Tellico::FieldListItem;
 using Tellico::CollectionFieldsDialog;
 
 class Tellico::FieldListItem : public Tellico::GUI::ListWidgetItem {
 public:
   FieldListItem(QListWidget* parent_, Data::FieldPtr field_) : GUI::ListWidgetItem(field_->title(), parent_), m_field(field_) {}
 
   Data::FieldPtr field() const { return m_field; }
   void setField(Data::FieldPtr field) { m_field = field; }
 
 private:
   Data::FieldPtr m_field;
 };
 
 CollectionFieldsDialog::CollectionFieldsDialog(Tellico::Data::CollPtr coll_, QWidget* parent_)
     : QDialog(parent_),
       m_coll(coll_),
       m_defaultCollection(nullptr),
       m_currentField(nullptr),
       m_modified(false),
       m_updatingValues(false),
       m_reordered(false),
       m_oldIndex(-1),
       m_notifyMode(NotifyKernel) {
   setModal(false);
   setWindowTitle(i18n("Collection Fields"));
 
   QVBoxLayout* mainLayout = new QVBoxLayout();
   setLayout(mainLayout);
 
   QWidget* page = new QWidget(this);
   mainLayout->addWidget(page);
   QBoxLayout* topLayout = new QHBoxLayout(page);
   page->setLayout(topLayout);
 
   QGroupBox* fieldsGroup = new QGroupBox(i18n("Current Fields"), page);
   QBoxLayout* fieldsLayout = new QVBoxLayout(fieldsGroup);
   topLayout->addWidget(fieldsGroup, 1);
 
   m_fieldsWidget = new QListWidget(fieldsGroup);
   m_fieldsWidget->setMinimumWidth(150);
   fieldsLayout->addWidget(m_fieldsWidget);
 
   Data::FieldList fields = m_coll->fields();
   foreach(Data::FieldPtr field, fields) {
     // ignore fields which are not user-editable
     if(!field->hasFlag(Data::Field::NoEdit)) {
       (void) new FieldListItem(m_fieldsWidget, field);
     }
   }
-  connect(m_fieldsWidget, SIGNAL(currentRowChanged(int)), SLOT(slotHighlightedChanged(int)));
+  connect(m_fieldsWidget, &QListWidget::currentRowChanged, this, &CollectionFieldsDialog::slotHighlightedChanged);
 
   QWidget* hb1 = new QWidget(fieldsGroup);
   QHBoxLayout* hb1HBoxLayout = new QHBoxLayout(hb1);
   hb1HBoxLayout->setMargin(0);
   fieldsLayout->addWidget(hb1);
   m_btnNew = new QPushButton(i18nc("New Field", "&New"), hb1);
   hb1HBoxLayout->addWidget(m_btnNew);
   m_btnNew->setIcon(QIcon::fromTheme(QStringLiteral("document-new")));
   m_btnNew->setWhatsThis(i18n("Add a new field to the collection"));
   m_btnDelete = new QPushButton(i18nc("Delete Field", "Delete"), hb1);
   hb1HBoxLayout->addWidget(m_btnDelete);
   m_btnDelete->setIcon(QIcon::fromTheme(QStringLiteral("edit-delete")));
   m_btnDelete->setWhatsThis(i18n("Remove a field from the collection"));
 
-  connect(m_btnNew, SIGNAL(clicked()), SLOT(slotNew()));
-  connect(m_btnDelete, SIGNAL(clicked()), SLOT(slotDelete()));
+  connect(m_btnNew, &QAbstractButton::clicked, this, &CollectionFieldsDialog::slotNew);
+  connect(m_btnDelete, &QAbstractButton::clicked, this, &CollectionFieldsDialog::slotDelete);
 
   QWidget* hb2 = new QWidget(fieldsGroup);
   QHBoxLayout* hb2HBoxLayout = new QHBoxLayout(hb2);
   hb2HBoxLayout->setMargin(0);
   fieldsLayout->addWidget(hb2);
   m_btnUp = new QPushButton(hb2);
   hb2HBoxLayout->addWidget(m_btnUp);
   m_btnUp->setIcon(QIcon::fromTheme(QStringLiteral("go-up")));
   m_btnUp->setWhatsThis(i18n("Move this field up in the list. The list order is important "
                              "for the layout of the entry editor."));
   m_btnDown = new QPushButton(hb2);
   hb2HBoxLayout->addWidget(m_btnDown);
   m_btnDown->setIcon(QIcon::fromTheme(QStringLiteral("go-down")));
   m_btnDown->setWhatsThis(i18n("Move this field down in the list. The list order is important "
                                "for the layout of the entry editor."));
 
-  connect(m_btnUp, SIGNAL(clicked()), SLOT(slotMoveUp()));
-  connect(m_btnDown, SIGNAL(clicked()), SLOT(slotMoveDown()));
+  connect(m_btnUp, &QAbstractButton::clicked, this, &CollectionFieldsDialog::slotMoveUp);
+  connect(m_btnDown, &QAbstractButton::clicked, this, &CollectionFieldsDialog::slotMoveDown);
 
   QWidget* vbox = new QWidget(page);
   QVBoxLayout* vboxVBoxLayout = new QVBoxLayout(vbox);
   vboxVBoxLayout->setMargin(0);
   topLayout->addWidget(vbox, 2);
 
   QGroupBox* propGroup = new QGroupBox(i18n("Field Properties"), vbox);
   vboxVBoxLayout->addWidget(propGroup);
   QBoxLayout* propLayout = new QVBoxLayout(propGroup);
 
   QWidget* grid = new QWidget(propGroup);
   QGridLayout* layout = new QGridLayout(grid);
   propLayout->addWidget(grid);
 
   int row = -1;
   QLabel* label = new QLabel(i18n("&Title:"), grid);
   layout->addWidget(label, ++row, 0);
   m_titleEdit = new QLineEdit(grid);
   layout->addWidget(m_titleEdit, row, 1);
   label->setBuddy(m_titleEdit);
   QString whats = i18n("The title of the field");
   label->setWhatsThis(whats);
   m_titleEdit->setWhatsThis(whats);
-  connect(m_titleEdit, SIGNAL(textChanged(const QString&)), SLOT(slotModified()));
+  connect(m_titleEdit, &QLineEdit::textChanged, this, &CollectionFieldsDialog::slotModified);
 
   label = new QLabel(i18n("T&ype:"), grid);
   layout->addWidget(label, row, 2);
   m_typeCombo = new KComboBox(grid);
   layout->addWidget(m_typeCombo, row, 3);
   label->setBuddy(m_typeCombo);
   whats = QStringLiteral("<qt>");
   whats += i18n("The type of the field determines what values may be used. ");
   whats += i18n("<i>Simple Text</i> is used for most fields. ");
   whats += i18n("<i>Paragraph</i> is for large text blocks. ");
   whats += i18n("<i>Choice</i> limits the field to certain values. ");
   whats += i18n("<i>Checkbox</i> is for a simple yes/no value. ");
   whats += i18n("<i>Number</i> indicates that the field contains a numerical value. ");
   whats += i18n("<i>URL</i> is for fields which refer to URLs, including references to other files. ");
   whats += i18n("A <i>Table</i> may hold one or more columns of values. ");
   whats += i18n("An <i>Image</i> field holds a picture. ");
   whats += i18n("A <i>Date</i> field can be used for values with a day, month, and year. ");
   whats += i18n("A <i>Rating</i> field uses stars to show a rating number. ");
   whats += QLatin1String("</qt>");
   label->setWhatsThis(whats);
   m_typeCombo->setWhatsThis(whats);
   // the typeTitles match the fieldMap().values() but in a better order
   m_typeCombo->addItems(Data::Field::typeTitles());
-  connect(m_typeCombo, SIGNAL(activated(int)), SLOT(slotModified()));
-  connect(m_typeCombo, SIGNAL(activated(const QString&)), SLOT(slotTypeChanged(const QString&)));
+  void (QComboBox::* activatedInt)(int) = &QComboBox::activated;
+  connect(m_typeCombo, activatedInt, this, &CollectionFieldsDialog::slotModified);
+  void (QComboBox::* activatedString)(const QString&) = &QComboBox::activated;
+  connect(m_typeCombo, activatedString, this, &CollectionFieldsDialog::slotTypeChanged);
 
   label = new QLabel(i18n("Cate&gory:"), grid);
   layout->addWidget(label, ++row, 0);
   m_catCombo = new KComboBox(true, grid);
   layout->addWidget(m_catCombo, row, 1);
   label->setBuddy(m_catCombo);
   whats = i18n("The field category determines where the field is placed in the editor.");
   label->setWhatsThis(whats);
   m_catCombo->setWhatsThis(whats);
 
   // I don't want to include the categories for singleCategory fields
   QStringList cats;
   const QStringList allCats = m_coll->fieldCategories();
   foreach(const QString& cat, allCats) {
     Data::FieldList fields = m_coll->fieldsByCategory(cat);
     if(!fields.isEmpty() && !fields.at(0)->isSingleCategory()) {
       cats.append(cat);
     }
   }
   m_catCombo->addItems(cats);
   m_catCombo->setDuplicatesEnabled(false);
-  connect(m_catCombo, SIGNAL(currentTextChanged(const QString&)), SLOT(slotModified()));
+  connect(m_catCombo, &QComboBox::currentTextChanged, this, &CollectionFieldsDialog::slotModified);
 
   m_btnExtended = new QPushButton(i18n("Set &properties..."), grid);
   m_btnExtended->setIcon(QIcon::fromTheme(QStringLiteral("bookmarks")));
   layout->addWidget(m_btnExtended, row, 2, 1, 2);
   label->setBuddy(m_btnExtended);
   whats = i18n("Extended field properties are used to specify things such as the corresponding bibtex field.");
   label->setWhatsThis(whats);
   m_btnExtended->setWhatsThis(whats);
-  connect(m_btnExtended, SIGNAL(clicked()), SLOT(slotShowExtendedProperties()));
+  connect(m_btnExtended, &QAbstractButton::clicked, this, &CollectionFieldsDialog::slotShowExtendedProperties);
 
   label = new QLabel(i18n("Description:"), grid);
   layout->addWidget(label, ++row, 0);
   m_descEdit = new QLineEdit(grid);
   m_descEdit->setMinimumWidth(150);
   layout->addWidget(m_descEdit, row, 1, 1, 3);
   label->setBuddy(m_descEdit);
 
   whats = i18n("The description is a useful reminder of what information is contained in the field.");
   label->setWhatsThis(whats);
   m_descEdit->setWhatsThis(whats);
-  connect(m_descEdit, SIGNAL(textChanged(const QString&)), SLOT(slotModified()));
+  connect(m_descEdit, &QLineEdit::textChanged, this, &CollectionFieldsDialog::slotModified);
 
   QGroupBox* valueGroup = new QGroupBox(i18n("Value Options"), vbox);
   vboxVBoxLayout->addWidget(valueGroup);
   QGridLayout* valueLayout = new QGridLayout(valueGroup);
   int valueRow = -1;
 
   label = new QLabel(i18n("Default value:"), valueGroup);
   valueLayout->addWidget(label, ++valueRow, 0);
   m_defaultEdit = new QLineEdit(valueGroup);
   valueLayout->addWidget(m_defaultEdit, valueRow, 1, 1, 3);
   label->setBuddy(m_defaultEdit);
   whats = i18n("<qt>A default value can be set for new entries.</qt>");
   label->setWhatsThis(whats);
   m_defaultEdit->setWhatsThis(whats);
-  connect(m_defaultEdit, SIGNAL(textChanged(const QString&)), SLOT(slotModified()));
+  connect(m_defaultEdit, &QLineEdit::textChanged, this, &CollectionFieldsDialog::slotModified);
 
   label = new QLabel(i18n("Value template:"), valueGroup);
   valueLayout->addWidget(label, ++valueRow, 0);
   m_derivedEdit = new QLineEdit(valueGroup);
   m_derivedEdit->setMinimumWidth(150);
   valueLayout->addWidget(m_derivedEdit, valueRow, 1);
   label->setBuddy(m_derivedEdit);
 
   /* TRANSLATORS: Do not translate %{year} and %{title}. */
   whats = i18n("Derived values are formed from the values of other fields according to the value template. "
                "Named fields, such as \"%{year} %{title}\", get substituted in the value.");
   label->setWhatsThis(whats);
   m_derivedEdit->setWhatsThis(whats);
-  connect(m_derivedEdit, SIGNAL(textChanged(const QString&)), SLOT(slotModified()));
+  connect(m_derivedEdit, &QLineEdit::textChanged, this, &CollectionFieldsDialog::slotModified);
 
   m_derived = new QCheckBox(i18n("Use derived value"), valueGroup);
   m_derived->setWhatsThis(whats);
   valueLayout->addWidget(m_derived, valueRow, 2, 1, 2);
-  connect(m_derived, SIGNAL(clicked(bool)), SLOT(slotDerivedChecked(bool)));
-  connect(m_derived, SIGNAL(clicked()), SLOT(slotModified()));
+  connect(m_derived, &QAbstractButton::clicked, this, &CollectionFieldsDialog::slotDerivedChecked);
+  connect(m_derived, &QAbstractButton::clicked, this, &CollectionFieldsDialog::slotModified);
 
   label = new QLabel(i18n("A&llowed values:"), valueGroup);
   valueLayout->addWidget(label, ++valueRow, 0);
   m_allowEdit = new QLineEdit(valueGroup);
   valueLayout->addWidget(m_allowEdit, valueRow, 1, 1, 3);
   label->setBuddy(m_allowEdit);
   whats = i18n("<qt>For <i>Choice</i>-type fields, these are the only values allowed. They are "
                "placed in a combo box. The possible values have to be separated by a semi-colon, "
                "for example: \"dog; cat; mouse\"</qt>");
   label->setWhatsThis(whats);
   m_allowEdit->setWhatsThis(whats);
-  connect(m_allowEdit, SIGNAL(textChanged(const QString&)), SLOT(slotModified()));
+  connect(m_allowEdit, &QLineEdit::textChanged, this, &CollectionFieldsDialog::slotModified);
 
   label = new QLabel(i18n("Format options:"), valueGroup);
   valueLayout->addWidget(label, ++valueRow, 0);
   m_formatCombo = new GUI::ComboBox(valueGroup);
   valueLayout->addWidget(m_formatCombo, valueRow, 1, 1, 3);
   label->setBuddy(m_formatCombo);
 
   m_formatCombo->addItem(i18n("No formatting"), FieldFormat::FormatNone);
   m_formatCombo->addItem(i18n("Allow auto-capitalization only"), FieldFormat::FormatPlain);
   m_formatCombo->addItem(i18n("Format as a title"), FieldFormat::FormatTitle);
   m_formatCombo->addItem(i18n("Format as a name"), FieldFormat::FormatName);
-  connect(m_formatCombo, SIGNAL(currentIndexChanged(int)), SLOT(slotModified()));
+  void (QComboBox::* currentIndexChanged)(int) = &QComboBox::currentIndexChanged;
+  connect(m_formatCombo, currentIndexChanged, this, &CollectionFieldsDialog::slotModified);
 
   QGroupBox* optionsGroup = new QGroupBox(i18n("Field Options"), vbox);
   vboxVBoxLayout->addWidget(optionsGroup);
   QBoxLayout* optionsLayout = new QVBoxLayout(optionsGroup);
   m_complete = new QCheckBox(i18n("Enable auto-completion"), optionsGroup);
   m_complete->setWhatsThis(i18n("If checked, KDE auto-completion will be enabled in the "
                                 "text edit box for this field."));
   m_multiple = new QCheckBox(i18n("Allow multiple values"), optionsGroup);
   m_multiple->setWhatsThis(i18n("If checked, Tellico will parse the values in the field "
                                 "for multiple values, separated by a semi-colon."));
   m_grouped = new QCheckBox(i18n("Allow grouping"), optionsGroup);
   m_grouped->setWhatsThis(i18n("If checked, this field may be used to group the entries in "
                                "the group view."));
   optionsLayout->addWidget(m_complete);
   optionsLayout->addWidget(m_multiple);
   optionsLayout->addWidget(m_grouped);
 
-  connect(m_complete, SIGNAL(clicked()), SLOT(slotModified()));
-  connect(m_multiple, SIGNAL(clicked()), SLOT(slotModified()));
-  connect(m_grouped, SIGNAL(clicked()), SLOT(slotModified()));
+  connect(m_complete, &QAbstractButton::clicked, this, &CollectionFieldsDialog::slotModified);
+  connect(m_multiple, &QAbstractButton::clicked, this, &CollectionFieldsDialog::slotModified);
+  connect(m_grouped, &QAbstractButton::clicked, this, &CollectionFieldsDialog::slotModified);
 
   // need to stretch at bottom
   vboxVBoxLayout->addStretch(1);
 
   // keep a default collection
   m_defaultCollection = CollectionFactory::collection(m_coll->type(), true);
 
   m_buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|
                                      QDialogButtonBox::Cancel|
                                      QDialogButtonBox::Help|
                                      QDialogButtonBox::RestoreDefaults|
                                      QDialogButtonBox::Apply);
   mainLayout->addWidget(m_buttonBox);
 
   QPushButton* okButton = m_buttonBox->button(QDialogButtonBox::Ok);
   okButton->setDefault(true);
   okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
-  connect(m_buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
-  connect(m_buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
-  connect(m_buttonBox, SIGNAL(helpRequested()), this, SLOT(slotHelp()));
+  connect(m_buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
+  connect(m_buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
+  connect(m_buttonBox, &QDialogButtonBox::helpRequested, this, &CollectionFieldsDialog::slotHelp);
 
   m_buttonBox->button(QDialogButtonBox::RestoreDefaults)->setWhatsThis(i18n("Revert the selected field's properties to the default values."));
 
-  connect(okButton, SIGNAL(clicked()), SLOT(slotOk()));
-  connect(m_buttonBox->button(QDialogButtonBox::Apply), SIGNAL(clicked()), SLOT(slotApply()));
-  connect(m_buttonBox->button(QDialogButtonBox::RestoreDefaults), SIGNAL(clicked()), SLOT(slotDefault()));
+  connect(okButton, &QAbstractButton::clicked, this, &CollectionFieldsDialog::slotOk);
+  connect(m_buttonBox->button(QDialogButtonBox::Apply), &QAbstractButton::clicked, this, &CollectionFieldsDialog::slotApply);
+  connect(m_buttonBox->button(QDialogButtonBox::RestoreDefaults), &QAbstractButton::clicked, this, &CollectionFieldsDialog::slotDefault);
 
   okButton->setEnabled(false);
   m_buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
   m_buttonBox->button(QDialogButtonBox::RestoreDefaults)->setEnabled(false);
 
   // initially the m_typeCombo is populated with all types, but as soon as something is
   // selected in the fields box, the combo box is cleared and filled with the allowable
   // new types. The problem is that when more types are added, the size of the combo box
   // doesn't change. So when everything is laid out, the combo box needs to have all the
   // items there.
-  QTimer::singleShot(0, this, SLOT(slotSelectInitial()));
+  QTimer::singleShot(0, this, &CollectionFieldsDialog::slotSelectInitial);
 }
 
 CollectionFieldsDialog::~CollectionFieldsDialog() {
 }
 
 void CollectionFieldsDialog::setNotifyKernel(bool notify_) {
   if(notify_) {
     m_notifyMode = NotifyKernel;
   } else {
     m_notifyMode = NoNotification;
   }
 }
 
 void CollectionFieldsDialog::slotSelectInitial() {
   // the accel management is here so that it doesn't cause conflicts with the
   // ones explicitly set in the constructor
   KAcceleratorManager::manage(this);
   m_fieldsWidget->setCurrentRow(0);
 }
 
 void CollectionFieldsDialog::slotHelp() {
   KHelpClient::invokeHelp(QStringLiteral("fields-dialog"));
 }
 
 void CollectionFieldsDialog::slotOk() {
   slotApply();
   accept();
 }
 
 void CollectionFieldsDialog::slotApply() {
   updateField();
   if(!checkValues()) {
     return;
   }
 
   applyChanges();
 }
 
 void CollectionFieldsDialog::applyChanges() {
   // start a command group, "Modify" is a generic term here since the commands could be add, modify, or delete
   if(m_notifyMode == NotifyKernel) {
     Kernel::self()->beginCommandGroup(i18n("Modify Fields"));
   }
 
   foreach(Data::FieldPtr field, m_copiedFields) {
     // check for Choice fields with removed values to warn user
     if(field->type() == Data::Field::Choice || field->type() == Data::Field::Rating) {
       QStringList oldValues = m_coll->fieldByName(field->name())->allowed();
       QStringList newValues = field->allowed();
       for(QStringList::ConstIterator vIt = oldValues.constBegin(); vIt != oldValues.constEnd(); ++vIt) {
         if(newValues.contains(*vIt)) {
           continue;
         }
         int ret = KMessageBox::warningContinueCancel(this,
                                                      i18n("<qt>Removing allowed values from the <i>%1</i> field which "
                                                           "currently exist in the collection may cause data corruption. "
                                                           "Do you want to keep your modified values or cancel and revert "
                                                           "to the current ones?</qt>", field->title()),
                                                      QString(),
                                                      KGuiItem(i18n("Keep modified values")));
         if(ret != KMessageBox::Continue) {
           if(field->type() == Data::Field::Choice) {
             field->setAllowed(oldValues);
           } else { // rating field
             Data::FieldPtr oldField = m_coll->fieldByName(field->name());
             field->setProperty(QStringLiteral("minimum"), oldField->property(QStringLiteral("minimum")));
             field->setProperty(QStringLiteral("maximum"), oldField->property(QStringLiteral("maximum")));
           }
         }
         break;
       }
     }
     if(m_notifyMode == NotifyKernel) {
       Kernel::self()->modifyField(field);
     } else {
       m_coll->modifyField(field);
     }
   }
 
   foreach(Data::FieldPtr field, m_newFields) {
     if(m_notifyMode == NotifyKernel) {
       Kernel::self()->addField(field);
     } else {
       m_coll->addField(field);
     }
   }
 
   // set all text not to be colored, and get new list
   Data::FieldList fields;
   fields.reserve(m_fieldsWidget->count());
   for(int i = 0; i < m_fieldsWidget->count(); ++i) {
     FieldListItem* item = static_cast<FieldListItem*>(m_fieldsWidget->item(i));
     item->setColored(false);
     if(m_reordered) {
       Data::FieldPtr field = item->field();
       if(field) {
         fields.append(field);
       }
     }
   }
 
   // if reordering fields, need to add ReadOnly fields since they were not shown
   if(m_reordered) {
     foreach(Data::FieldPtr field, m_coll->fields()) {
       if(field->hasFlag(Data::Field::NoEdit)) {
         fields.append(field);
       }
     }
   }
 
   if(fields.count() > 0) {
     if(m_notifyMode == NotifyKernel) {
       Kernel::self()->reorderFields(fields);
     } else {
       m_coll->reorderFields(fields);
     }
   }
 
   // commit command group
   if(m_notifyMode == NotifyKernel) {
     Kernel::self()->endCommandGroup();
   }
 
   // now clear copied fields
   m_copiedFields.clear();
   // clear new ones, too
   m_newFields.clear();
 
   m_currentField = static_cast<FieldListItem*>(m_fieldsWidget->currentItem())->field();
 
   // the field type might have changed, so need to update the type combo list with possible values
   if(m_currentField) {
     // set the updating flag since the values are changing and slots are firing
     // but we don't care about UI indications of changes
     bool wasUpdating = m_updatingValues;
     m_updatingValues = true;
     QString currType = m_typeCombo->currentText();
     m_typeCombo->clear();
     m_typeCombo->addItems(newTypesAllowed(m_currentField->type()));
     m_typeCombo->setCurrentItem(currType);
     // template might have been changed for dependent fields
     m_derivedEdit->setText(m_currentField->property(QStringLiteral("template")));
     m_updatingValues = wasUpdating;
   }
   m_buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
 }
 
 void CollectionFieldsDialog::slotNew() {
   // first update the current one with all the values from the edit widgets
   updateField();
 
   // next check old values
   if(!checkValues()) {
     return;
   }
 
   QString name = QLatin1String("custom") + QString::number(m_newFields.count()+1);
   int count = m_newFields.count() + 1;
   QString title = i18n("New Field %1", count);
   while(!m_fieldsWidget->findItems(title, Qt::MatchExactly).isEmpty()) {
     ++count;
     title = i18n("New Field %1", count);
   }
 
   Data::FieldPtr field(new Data::Field(name, title));
   m_newFields.append(field);
 //  myDebug() << "adding new field " << title;
 
   m_currentField = field;
 
   FieldListItem* item = new FieldListItem(m_fieldsWidget, field);
   item->setColored(true);
   m_fieldsWidget->setCurrentItem(item);
   m_fieldsWidget->scrollToItem(item);
   slotModified();
   m_titleEdit->setFocus();
   m_titleEdit->selectAll();
 }
 
 void CollectionFieldsDialog::slotDelete() {
   if(!m_currentField) {
     return;
   }
 
   if(m_newFields.contains(m_currentField)) {
     // remove field from vector before deleting item containing field
     m_newFields.removeAll(m_currentField);
   } else {
     if(m_notifyMode == NotifyKernel) {
       if(!Kernel::self()->removeField(m_currentField)) {
         return;
       }
     } else {
       m_coll->removeField(m_currentField);
     }
     emit signalCollectionModified();
     m_buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
   }
   int currentRow = m_fieldsWidget->currentRow();
   delete m_fieldsWidget->takeItem(currentRow);
   m_fieldsWidget->setCurrentRow(qMin(currentRow, m_fieldsWidget->count()-1));
   m_fieldsWidget->scrollToItem(m_fieldsWidget->currentItem());
   m_currentField = static_cast<FieldListItem*>(m_fieldsWidget->currentItem())->field(); // QSharedData gets auto-deleted
 }
 
 void CollectionFieldsDialog::slotTypeChanged(const QString& type_) {
   Data::Field::Type type = Data::Field::Undef;
   const Data::Field::FieldMap fieldMap = Data::Field::typeMap();
   for(Data::Field::FieldMap::ConstIterator it = fieldMap.begin(); it != fieldMap.end(); ++it) {
     if(it.value() == type_) {
       type = it.key();
       break;
     }
   }
   if(type == Data::Field::Undef) {
     myWarning() << "type name not recognized:" << type_;
     type = Data::Field::Line;
   }
 
   // only choice types gets allowed values
   m_allowEdit->setEnabled(type == Data::Field::Choice);
 
   // paragraphs, tables, and images are their own category
   bool isCategory = (type == Data::Field::Para || type == Data::Field::Table ||
                      type == Data::Field::Image);
   m_catCombo->setEnabled(!isCategory);
 
   // formatting is only applicable when the type is simple text or a table
   bool isText = (type == Data::Field::Line || type == Data::Field::Table);
   // formatNone is the default
   m_formatCombo->setEnabled(isText);
 
   // multiple is only applicable for simple text and number
   isText = (type == Data::Field::Line || type == Data::Field::Number);
   m_multiple->setEnabled(isText);
 
   // completion is only applicable for simple text, number, and URL
   isText = (isText || type == Data::Field::URL);
   m_complete->setEnabled(isText);
 
   // grouping is not possible with paragraphs or images
   m_grouped->setEnabled(type != Data::Field::Para && type != Data::Field::Image);
 }
 
 void CollectionFieldsDialog::slotHighlightedChanged(int index_) {
   if(index_ == m_oldIndex) {
     return; // state when checkValues() returns false
   }
 
   // use this instead of blocking signals everywhere
   m_updatingValues = true;
 
   // first update the current one with all the values from the edit widgets
   updateField();
 
   // next check old values
   if(!checkValues()) {
     // Other functions get called and change selection after this one. Use a SingleShot to revert
-    QTimer::singleShot(0, this, SLOT(resetToCurrent()));
+    QTimer::singleShot(0, this, &CollectionFieldsDialog::resetToCurrent);
     m_updatingValues = false;
     return;
   }
   m_oldIndex = index_;
 
   m_btnUp->setEnabled(index_ > 0);
   m_btnDown->setEnabled(index_ < static_cast<int>(m_fieldsWidget->count())-1);
 
   FieldListItem* item = dynamic_cast<FieldListItem*>(m_fieldsWidget->item(index_));
   if(!item) {
     return;
   }
 
   // need to get a pointer to the field with the new values to insert
   Data::FieldPtr field = item->field();
   if(!field) {
     myDebug() << "no field found!";
     return;
   }
 
   // type is limited to certain types, unless it's a new field
   m_typeCombo->clear();
   if(m_newFields.contains(field)) {
     m_typeCombo->addItems(newTypesAllowed(Data::Field::Undef));
   } else {
     m_typeCombo->addItems(newTypesAllowed(field->type()));
   }
   populate(field);
 
   // default button is enabled only if default collection contains the field
   if(m_defaultCollection) {
     const bool hasField = m_defaultCollection->hasField(field->name());
     m_buttonBox->button(QDialogButtonBox::RestoreDefaults)->setEnabled(hasField);
   }
 
   m_currentField = field;
   m_updatingValues = false;
 }
 
 void CollectionFieldsDialog::updateField() {
   Data::FieldPtr field = m_currentField;
   if(!field || !m_modified) {
     return;
   }
 
   // only update name if it's one of the new ones
   if(m_newFields.contains(field)) {
     // name needs to be a valid XML element name
     QString name = XML::elementName(m_titleEdit->text().toLower());
     if(name.isEmpty()) { // might end up with empty string
       name = QLatin1String("custom") + QString::number(m_newFields.count()+1);
     }
     while(m_coll->hasField(name)) { // ensure name uniqueness
       name += QLatin1String("-new");
     }
     field->setName(name);
   }
 
   const QString title = m_titleEdit->text().simplified();
   updateTitle(title);
 
   const Data::Field::FieldMap& fieldMap = Data::Field::typeMap();
   for(Data::Field::FieldMap::ConstIterator it = fieldMap.begin(); it != fieldMap.end(); ++it) {
     if(it.value() == m_typeCombo->currentText()) {
       field->setType(it.key());
       break;
     }
   }
 
   if(field->type() == Data::Field::Choice) {
     const QRegExp rx(QLatin1String("\\s*;\\s*"));
     field->setAllowed(m_allowEdit->text().split(rx, QString::SkipEmptyParts));
     field->setProperty(QStringLiteral("minimum"), QString());
     field->setProperty(QStringLiteral("maximum"), QString());
   } else if(field->type() == Data::Field::Rating) {
     QString v = field->property(QStringLiteral("minimum"));
     if(v.isEmpty()) {
       field->setProperty(QStringLiteral("minimum"), QString::number(1));
     }
     v = field->property(QStringLiteral("maximum"));
     if(v.isEmpty()) {
       field->setProperty(QStringLiteral("maximum"), QString::number(5));
     }
   }
 
   if(field->isSingleCategory()) {
     field->setCategory(field->title());
   } else {
     QString category = m_catCombo->currentText().simplified();
     field->setCategory(category);
     m_catCombo->setCurrentItem(category, true); // if it doesn't exist, it's added
   }
 
   if(m_derived->isChecked()) {
     field->setProperty(QStringLiteral("template"), m_derivedEdit->text());
   }
   field->setDescription(m_descEdit->text());
   field->setDefaultValue(m_defaultEdit->text());
 
   if(m_formatCombo->isEnabled()) {
     field->setFormatType(static_cast<FieldFormat::Type>(m_formatCombo->currentData().toInt()));
   } else {
     field->setFormatType(FieldFormat::FormatNone);
   }
 
   int flags = 0;
   if(m_derived->isChecked()) {
     flags |= Data::Field::Derived;
   }
   if(m_complete->isChecked()) {
     flags |= Data::Field::AllowCompletion;
   }
   if(m_grouped->isChecked()) {
     flags |= Data::Field::AllowGrouped;
   }
   if(m_multiple->isChecked()) {
     flags |= Data::Field::AllowMultiple;
   }
   field->setFlags(flags);
 
   m_modified = false;
 }
 
 // The purpose here is to first set the modified flag. Then, if the field being edited is one
 // that exists in the collection already, a deep copy needs to be made.
 void CollectionFieldsDialog::slotModified() {
   // if I'm just updating the values, I don't care
   if(m_updatingValues) {
     return;
   }
 
   m_modified = true;
 
   m_buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
   m_buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
 
   if(!m_currentField) {
     myDebug() << "no current field!";
     m_currentField = static_cast<FieldListItem*>(m_fieldsWidget->currentItem())->field();
   }
 
   // color the text
   static_cast<FieldListItem*>(m_fieldsWidget->currentItem())->setColored(true);
 
   // check if copy exists already
   if(m_copiedFields.contains(m_currentField)) {
     return;
   }
 
   // or, check if is a new field, in which case no copy is needed
   // check if copy exists already
   if(m_newFields.contains(m_currentField)) {
     return;
   }
 
   m_currentField = new Data::Field(*m_currentField);
   m_copiedFields.append(m_currentField);
   static_cast<FieldListItem*>(m_fieldsWidget->currentItem())->setField(m_currentField);
 }
 
 void CollectionFieldsDialog::updateTitle(const QString& title_) {
   if(m_currentField && m_currentField->title() != title_) {
     m_fieldsWidget->blockSignals(true);
     FieldListItem* oldItem = findItem(m_currentField);
     if(!oldItem) {
       return;
     }
     oldItem->setText(title_);
     // will always be colored since it's new
     oldItem->setColored(true);
 
     m_currentField->setTitle(title_);
     m_fieldsWidget->blockSignals(false);
   }
 }
 
 void CollectionFieldsDialog::slotDefault() {
   if(!m_currentField) {
     return;
   }
 
   Data::FieldPtr defaultField = m_defaultCollection->fieldByName(m_currentField->name());
   if(!defaultField) {
     return;
   }
 
   QString caption = i18n("Revert Field Properties");
   QString text = i18n("<qt><p>Do you really want to revert the properties for the <em>%1</em> "
                       "field back to their default values?</p></qt>", m_currentField->title());
   QString dontAsk = QStringLiteral("RevertFieldProperties");
   int ret = KMessageBox::warningContinueCancel(this, text, caption, KGuiItem(i18n("Revert")), KStandardGuiItem::cancel(), dontAsk);
   if(ret != KMessageBox::Continue) {
     return;
   }
 
   // now update all values with default
   m_updatingValues = true;
   populate(defaultField);
   m_updatingValues = false;
   slotModified();
 }
 
 void CollectionFieldsDialog::slotMoveUp() {
   int idx = m_fieldsWidget->currentRow();
   if(idx < 1) {
     return;
   }
   // takeItem ends up signalling that the current index changed
   // need to revert m_oldIndex after taking the item
   QListWidgetItem* item = m_fieldsWidget->takeItem(idx);
   m_oldIndex++;
   m_fieldsWidget->insertItem(idx-1, item);
   m_fieldsWidget->setCurrentItem(item);
   m_reordered = true;
   // don't call slotModified() since that creates a deep copy.
   m_modified = true;
 
   m_buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
   m_buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
 }
 
 void CollectionFieldsDialog::slotMoveDown() {
   int idx = m_fieldsWidget->currentRow();
   if(idx > m_fieldsWidget->count()-1) {
     return;
   }
   // takeItem ends up signalling that the current index changed
   // need to revert m_oldIndex after taking the item
   QListWidgetItem* item = m_fieldsWidget->takeItem(idx);
   m_oldIndex--;
   m_fieldsWidget->insertItem(idx+1, item);
   m_fieldsWidget->setCurrentItem(item);
   m_reordered = true;
   // don't call slotModified() since that creates a deep copy.
   m_modified = true;
 
   m_buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
   m_buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
 }
 
 Tellico::FieldListItem* CollectionFieldsDialog::findItem(Tellico::Data::FieldPtr field_) {
   for(int i = 0; i < m_fieldsWidget->count(); ++i) {
     FieldListItem* textItem = static_cast<FieldListItem*>(m_fieldsWidget->item(i));
     if(textItem->field() == field_) {
       return textItem;
     }
   }
   return nullptr;
 }
 
 bool CollectionFieldsDialog::slotShowExtendedProperties() {
   if(!m_currentField) {
     return false;
   }
 
   // the default value is included in properties, but it has a
   // separate edit box
   QString dv = m_currentField->defaultValue();
   QString dt = m_currentField->property(QStringLiteral("template"));
   StringMap props = m_currentField->propertyList();
   props.remove(QStringLiteral("default"));
   props.remove(QStringLiteral("template"));
 
   StringMapDialog dlg(props, this, true);
   dlg.setWindowTitle(i18n("Extended Field Properties"));
   dlg.setLabels(i18n("Property"), i18n("Value"));
   if(dlg.exec() == QDialog::Accepted) {
     props = dlg.stringMap();
     if(!dv.isEmpty()) {
       props.insert(QStringLiteral("default"), dv);
     }
     if(!dt.isEmpty()) {
       props.insert(QStringLiteral("template"), dt);
     }
     m_currentField->setPropertyList(props);
     slotModified();
     return true;
   }
   return false;
 }
 
 void CollectionFieldsDialog::slotDerivedChecked(bool checked_) {
   m_defaultEdit->setEnabled(!checked_);
   m_derivedEdit->setEnabled(checked_);
 }
 
 void CollectionFieldsDialog::resetToCurrent() {
   m_fieldsWidget->setCurrentRow(m_oldIndex);
 }
 
 bool CollectionFieldsDialog::checkValues() {
   if(!m_currentField) {
     return true;
   }
 
   const QString title = m_currentField->title();
   // find total number of boxes with this title in case multiple new ones with same title were added
   int titleCount = m_fieldsWidget->findItems(title, Qt::MatchExactly).count();
   if((m_coll->fieldByTitle(title) && m_coll->fieldNameByTitle(title) != m_currentField->name()) ||
      titleCount > 1) {
     // already have a field with this title
     KMessageBox::sorry(this, i18n("A field with this title already exists. Please enter a different title."));
     m_titleEdit->selectAll();
     return false;
   }
 
   const QString category = m_currentField->category();
   if(category.isEmpty()) {
     KMessageBox::sorry(this, i18n("<qt>The category may not be empty. Please enter a category.</qt>"));
     m_catCombo->lineEdit()->selectAll();
     return false;
   }
 
   Data::FieldList fields = m_coll->fieldsByCategory(category);
   if(!fields.isEmpty() && fields[0]->isSingleCategory() && fields[0]->name() != m_currentField->name()) {
     // can't have this category, cause it conflicts with a single-category field
     KMessageBox::sorry(this, i18n("<qt>A field may not be in the same category as a <em>Paragraph</em>, "
                                   "<em>Table</em> or <em>Image</em> field. Please enter a different category.</qt>"));
     m_catCombo->lineEdit()->selectAll();
     return false;
   }
 
   // the combobox is disabled for single-category fields
   if(!m_catCombo->isEnabled() && m_coll->fieldByTitle(title) && m_coll->fieldNameByTitle(title) != m_currentField->name()) {
     KMessageBox::sorry(this, i18n("A field's title may not be the same as an existing category. "
                                   "Please enter a different title."));
     m_titleEdit->selectAll();
     return false;
   }
 
   // check for rating values outside bounds
   if(m_currentField->type() == Data::Field::Rating) {
     bool ok; // ok to ignore this here
     int low = Tellico::toUInt(m_currentField->property(QStringLiteral("minimum")), &ok);
     int high = Tellico::toUInt(m_currentField->property(QStringLiteral("maximum")), &ok);
     while(low < 1 || low > 9 || high < 1 || high > 10 || low >= high) {
       KMessageBox::sorry(this, i18n("The range for a rating field must be between 1 and 10, "
                                     "and the lower bound must be less than the higher bound. "
                                     "Please enter different low and high properties."));
       if(slotShowExtendedProperties()) {
         low = Tellico::toUInt(m_currentField->property(QStringLiteral("minimum")), &ok);
         high = Tellico::toUInt(m_currentField->property(QStringLiteral("maximum")), &ok);
       } else {
         return false;
       }
     }
   } else if(m_currentField->type() == Data::Field::Table) {
     bool ok; // ok to ignore this here
     int ncols = Tellico::toUInt(m_currentField->property(QStringLiteral("columns")), &ok);
     // also enforced in GUI::TableFieldWidget
     if(ncols > 10) {
       KMessageBox::sorry(this, i18n("Tables are limited to a maximum of ten columns."));
       m_currentField->setProperty(QStringLiteral("columns"), QStringLiteral("10"));
     }
   }
 
   if(m_derived->isChecked() && !m_derivedEdit->text().contains(QLatin1Char('%'))) {
     KMessageBox::sorry(this, i18n("A field with a derived value must have a value template."));
     m_derivedEdit->setFocus();
     m_derivedEdit->selectAll();
     return false;
   }
 
   return true;
 }
 
 void CollectionFieldsDialog::populate(Data::FieldPtr field_) {
   m_titleEdit->setText(field_->title());
 
   // if the current name is not there, then this will change the list!
   const Data::Field::FieldMap& fieldMap = Data::Field::typeMap();
   int idx = m_typeCombo->findText(fieldMap[field_->type()]);
   m_typeCombo->setCurrentIndex(idx);
   slotTypeChanged(fieldMap[field_->type()]); // just setting the text doesn't emit the activated signal
 
   if(field_->type() == Data::Field::Choice) {
     m_allowEdit->setText(field_->allowed().join(FieldFormat::delimiterString()));
   } else {
     m_allowEdit->clear();
   }
 
   idx = m_catCombo->findText(field_->category());
   if(idx > -1) {
     m_catCombo->setCurrentIndex(idx); // have to do this here
   } else {
     m_catCombo->lineEdit()->setText(field_->category());
   }
   m_descEdit->setText(field_->description());
   if(field_->hasFlag(Data::Field::Derived)) {
     m_derivedEdit->setText(field_->property(QStringLiteral("template")));
     m_derived->setChecked(true);
     m_defaultEdit->clear();
   } else {
     m_derivedEdit->clear();
     m_derived->setChecked(false);
     m_defaultEdit->setText(field_->defaultValue());
   }
   slotDerivedChecked(m_derived->isChecked());
 
   m_formatCombo->setCurrentData(field_->formatType());
 
   m_complete->setChecked(field_->hasFlag(Data::Field::AllowCompletion));
   m_multiple->setChecked(field_->hasFlag(Data::Field::AllowMultiple));
   m_grouped->setChecked(field_->hasFlag(Data::Field::AllowGrouped));
 
   m_btnDelete->setEnabled(!field_->hasFlag(Data::Field::NoDelete));
 }
 
 // only certain type changes are allowed
 QStringList CollectionFieldsDialog::newTypesAllowed(int type_ /*=0*/) {
   // Undef means return all
   if(type_ == Data::Field::Undef) {
     return Data::Field::typeTitles();
   }
 
   const Data::Field::FieldMap& fieldMap = Data::Field::typeMap();
 
   QStringList newTypes;
   switch(type_) {
     case Data::Field::Line: // might not work if converted to a number or URL, but ok
     case Data::Field::Number:
     case Data::Field::URL:
       newTypes += fieldMap[Data::Field::Line];
       newTypes += fieldMap[Data::Field::Para];
       newTypes += fieldMap[Data::Field::Number];
       newTypes += fieldMap[Data::Field::URL];
       newTypes += fieldMap[Data::Field::Table];
       break;
 
     case Data::Field::Date:
       newTypes += fieldMap[Data::Field::Line];
       newTypes += fieldMap[Data::Field::Date];
       break;
 
     case Data::Field::Bool: // doesn't really make sense, but can't hurt
       newTypes += fieldMap[Data::Field::Line];
       newTypes += fieldMap[Data::Field::Para];
       newTypes += fieldMap[Data::Field::Bool];
       newTypes += fieldMap[Data::Field::Number];
       newTypes += fieldMap[Data::Field::URL];
       newTypes += fieldMap[Data::Field::Table];
       break;
 
     case Data::Field::Choice:
       newTypes += fieldMap[Data::Field::Line];
       newTypes += fieldMap[Data::Field::Para];
       newTypes += fieldMap[Data::Field::Choice];
       newTypes += fieldMap[Data::Field::Number];
       newTypes += fieldMap[Data::Field::URL];
       newTypes += fieldMap[Data::Field::Table];
       newTypes += fieldMap[Data::Field::Rating];
       break;
 
     case Data::Field::Table: // not really a good idea since the row delimiter will be exposed, but allow it
     case Data::Field::Table2:
       newTypes += fieldMap[Data::Field::Line];
       newTypes += fieldMap[Data::Field::Number];
       newTypes += fieldMap[Data::Field::Table];
       break;
 
     case Data::Field::Para:
       newTypes += fieldMap[Data::Field::Line];
       newTypes += fieldMap[Data::Field::Para];
       break;
 
     case Data::Field::Rating:
       newTypes += fieldMap[Data::Field::Choice];
       newTypes += fieldMap[Data::Field::Rating];
       break;
 
     // these can never be changed
     case Data::Field::Image:
       newTypes += fieldMap[static_cast<Data::Field::Type>(type_)];
       break;
 
     default:
       myDebug() << "no match for " << type_;
       newTypes = Data::Field::typeTitles();
       break;
   }
   return newTypes;
 }
diff --git a/src/configdialog.cpp b/src/configdialog.cpp
index da9ae1a1..dbf5ebff 100644
--- a/src/configdialog.cpp
+++ b/src/configdialog.cpp
@@ -1,1174 +1,1173 @@
 /***************************************************************************
     Copyright (C) 2001-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include <config.h>
 
 #include "configdialog.h"
 #include "field.h"
 #include "collection.h"
 #include "collectionfactory.h"
 #include "fetch/execexternalfetcher.h"
 #include "fetch/fetchmanager.h"
 #include "fetch/configwidget.h"
 #include "controller.h"
 #include "fetcherconfigdialog.h"
 #include "tellico_kernel.h"
 #include "utils/tellico_utils.h"
 #include "utils/string_utils.h"
 #include "config/tellico_config.h"
 #include "images/imagefactory.h"
 #include "gui/combobox.h"
 #include "gui/collectiontypecombo.h"
 #include "gui/previewdialog.h"
 #include "newstuff/manager.h"
 #include "fieldformat.h"
 #include "tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfig>
 #include <KAcceleratorManager>
 #include <KHTMLView>
 #include <KColorCombo>
 #include <KHelpClient>
 #include <KRecentDirs>
 
 #ifdef ENABLE_KNEWSTUFF3
 #include <KNS3/DownloadDialog>
 #endif
 
 #include <QSpinBox>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QSize>
 #include <QLayout>
 #include <QLabel>
 #include <QCheckBox>
 #include <QPixmap>
 #include <QRegExp>
 #include <QFileInfo>
 #include <QRadioButton>
 #include <QFrame>
 #include <QFontComboBox>
 #include <QGroupBox>
 #include <QButtonGroup>
 #include <QInputDialog>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QApplication>
 #include <QTimer>
 #include <QFileDialog>
 
 namespace {
   static const int CONFIG_MIN_WIDTH = 640;
   static const int CONFIG_MIN_HEIGHT = 420;
 }
 
 using Tellico::ConfigDialog;
 
 ConfigDialog::ConfigDialog(QWidget* parent_)
     : KPageDialog(parent_)
     , m_initializedPages(0)
     , m_modifying(false)
     , m_okClicked(false) {
   setFaceType(List);
   setModal(true);
   setWindowTitle(i18n("Configure Tellico"));
   setStandardButtons(QDialogButtonBox::Help |
                      QDialogButtonBox::Ok |
                      QDialogButtonBox::Apply |
                      QDialogButtonBox::Cancel |
                      QDialogButtonBox::RestoreDefaults);
 
   setupGeneralPage();
   setupPrintingPage();
   setupTemplatePage();
   setupFetchPage();
 
   updateGeometry();
   QSize s = sizeHint();
   resize(qMax(s.width(), CONFIG_MIN_WIDTH), qMax(s.height(), CONFIG_MIN_HEIGHT));
 
   // OK button is connected to buttonBox accepted() signal which is already connected to accept() slot
-  connect(button(QDialogButtonBox::Apply), SIGNAL(clicked()), SLOT(slotApply()));
-  connect(button(QDialogButtonBox::Help), SIGNAL(clicked()), SLOT(slotHelp()));
-  connect(button(QDialogButtonBox::RestoreDefaults), SIGNAL(clicked()), SLOT(slotDefault()));
+  connect(button(QDialogButtonBox::Apply), &QAbstractButton::clicked, this, &ConfigDialog::slotApply);
+  connect(button(QDialogButtonBox::Help), &QAbstractButton::clicked, this, &ConfigDialog::slotHelp);
+  connect(button(QDialogButtonBox::RestoreDefaults), &QAbstractButton::clicked, this, &ConfigDialog::slotDefault);
 
   button(QDialogButtonBox::Ok)->setEnabled(false);
   button(QDialogButtonBox::Apply)->setEnabled(false);
   button(QDialogButtonBox::Ok)->setDefault(true);
   button(QDialogButtonBox::Ok)->setShortcut(Qt::CTRL | Qt::Key_Return);
 
-  connect(this, SIGNAL(currentPageChanged(KPageWidgetItem*, KPageWidgetItem*)), SLOT(slotInitPage(KPageWidgetItem*)));
+  connect(this, &KPageDialog::currentPageChanged, this, &ConfigDialog::slotInitPage);
 }
 
 ConfigDialog::~ConfigDialog() {
   foreach(Fetch::ConfigWidget* widget, m_newStuffConfigWidgets) {
     widget->removed();
   }
 }
 
 void ConfigDialog::slotInitPage(KPageWidgetItem* item_) {
   Q_ASSERT(item_);
   // every page item has a frame
   // if the frame has no layout, then we need to initialize the itme
   QFrame* frame = ::qobject_cast<QFrame*>(item_->widget());
   Q_ASSERT(frame);
   if(frame->layout()) {
     return;
   }
 
   const QString name = item_->name();
   // these names must be kept in sync with the page names
   if(name == i18n("General")) {
     initGeneralPage(frame);
   } else if(name == i18n("Printing")) {
     initPrintingPage(frame);
   } else if(name == i18n("Templates")) {
     initTemplatePage(frame);
   } else if(name == i18n("Data Sources")) {
     initFetchPage(frame);
   }
 }
 
 void ConfigDialog::accept() {
   m_okClicked = true;
   slotApply();
   KPageDialog::accept();
   m_okClicked = false;
 }
 
 void ConfigDialog::slotApply() {
   emit signalConfigChanged();
   button(QDialogButtonBox::Apply)->setEnabled(false);
 }
 
 void ConfigDialog::slotDefault() {
   // only change the defaults on the active page
   Config::self()->useDefaults(true);
   const QString name = currentPage()->name();
   if(name == i18n("General")) {
     readGeneralConfig();
   } else if(name == i18n("Printing")) {
     readPrintingConfig();
   } else if(name == i18n("Templates")) {
     readTemplateConfig();
   }
   Config::self()->useDefaults(false);
   slotModified();
 }
 
 void ConfigDialog::slotHelp() {
   const QString name = currentPage()->name();
   // these names must be kept in sync with the page names
   if(name == i18n("General")) {
     KHelpClient::invokeHelp(QStringLiteral("general-options"));
   } else if(name == i18n("Printing")) {
     KHelpClient::invokeHelp(QStringLiteral("printing-options"));
   } else if(name == i18n("Templates")) {
     KHelpClient::invokeHelp(QStringLiteral("template-options"));
   } else if(name == i18n("Data Sources")) {
     KHelpClient::invokeHelp(QStringLiteral("internet-sources-options"));
   }
 }
 
 bool ConfigDialog::isPageInitialized(Page page_) const {
   return m_initializedPages & page_;
 }
 
 void ConfigDialog::setupGeneralPage() {
   QFrame* frame = new QFrame(this);
   KPageWidgetItem* page = new KPageWidgetItem(frame, i18n("General"));
   page->setHeader(i18n("General Options"));
   page->setIcon(QIcon::fromTheme(QStringLiteral("tellico"), QIcon(QLatin1String(":/icons/tellico"))));
   addPage(page);
 
   // since this is the first page, go ahead and lay it out
   initGeneralPage(frame);
 }
 
 void ConfigDialog::initGeneralPage(QFrame* frame) {
   QVBoxLayout* l = new QVBoxLayout(frame);
 
   m_cbOpenLastFile = new QCheckBox(i18n("&Reopen file at startup"), frame);
   m_cbOpenLastFile->setWhatsThis(i18n("If checked, the file that was last open "
                                       "will be re-opened at program start-up."));
   l->addWidget(m_cbOpenLastFile);
-  connect(m_cbOpenLastFile, SIGNAL(clicked()), SLOT(slotModified()));
+  connect(m_cbOpenLastFile, &QAbstractButton::clicked, this, &ConfigDialog::slotModified);
 
   m_cbShowTipDay = new QCheckBox(i18n("&Show \"Tip of the Day\" at startup"), frame);
   m_cbShowTipDay->setWhatsThis(i18n("If checked, the \"Tip of the Day\" will be "
                                     "shown at program start-up."));
   l->addWidget(m_cbShowTipDay);
-  connect(m_cbShowTipDay, SIGNAL(clicked()), SLOT(slotModified()));
+  connect(m_cbShowTipDay, &QAbstractButton::clicked, this, &ConfigDialog::slotModified);
 
   m_cbEnableWebcam = new QCheckBox(i18n("&Enable webcam for barcode scanning"), frame);
   m_cbEnableWebcam->setWhatsThis(i18n("If checked, the input from a webcam will be used "
                                       "to scan barcodes for searching."));
   l->addWidget(m_cbEnableWebcam);
-  connect(m_cbEnableWebcam, SIGNAL(clicked()), SLOT(slotModified()));
+  connect(m_cbEnableWebcam, &QAbstractButton::clicked, this, &ConfigDialog::slotModified);
 
   QGroupBox* imageGroupBox = new QGroupBox(i18n("Image Storage Options"), frame);
   l->addWidget(imageGroupBox);
   m_rbImageInFile = new QRadioButton(i18n("Store images in data file"), imageGroupBox);
   m_rbImageInAppDir = new QRadioButton(i18n("Store images in common application directory"), imageGroupBox);
   m_rbImageInLocalDir = new QRadioButton(i18n("Store images in directory relative to data file"), imageGroupBox);
   imageGroupBox->setWhatsThis(i18n("Images may be saved in the data file itself, which can "
                                    "cause Tellico to run slowly, stored in the Tellico "
                                    "application directory, or stored in a directory in the "
                                    "same location as the data file."));
   QVBoxLayout* imageGroupLayout = new QVBoxLayout(imageGroupBox);
   imageGroupLayout->addWidget(m_rbImageInFile);
   imageGroupLayout->addWidget(m_rbImageInAppDir);
   imageGroupLayout->addWidget(m_rbImageInLocalDir);
   imageGroupBox->setLayout(imageGroupLayout);
 
   QButtonGroup* imageGroup = new QButtonGroup(frame);
   imageGroup->addButton(m_rbImageInFile);
   imageGroup->addButton(m_rbImageInAppDir);
   imageGroup->addButton(m_rbImageInLocalDir);
-  connect(imageGroup, SIGNAL(buttonClicked(int)), SLOT(slotModified()));
+  void (QButtonGroup::* buttonClicked)(int) = &QButtonGroup::buttonClicked;
+  connect(imageGroup, buttonClicked, this, &ConfigDialog::slotModified);
 
   QGroupBox* formatGroup = new QGroupBox(i18n("Formatting Options"), frame);
   l->addWidget(formatGroup);
   QVBoxLayout* formatGroupLayout = new QVBoxLayout(formatGroup);
   formatGroup->setLayout(formatGroupLayout);
 
   m_cbCapitalize = new QCheckBox(i18n("Auto capitalize &titles and names"), formatGroup);
   m_cbCapitalize->setWhatsThis(i18n("If checked, titles and names will "
                                     "be automatically capitalized."));
-  connect(m_cbCapitalize, SIGNAL(clicked()), SLOT(slotModified()));
+  connect(m_cbCapitalize, &QAbstractButton::clicked, this, &ConfigDialog::slotModified);
   formatGroupLayout->addWidget(m_cbCapitalize);
 
   m_cbFormat = new QCheckBox(i18n("Auto &format titles and names"), formatGroup);
   m_cbFormat->setWhatsThis(i18n("If checked, titles and names will "
                                 "be automatically formatted."));
-  connect(m_cbFormat, SIGNAL(clicked()), SLOT(slotModified()));
+  connect(m_cbFormat, &QAbstractButton::clicked, this, &ConfigDialog::slotModified);
   formatGroupLayout->addWidget(m_cbFormat);
 
   QWidget* g1 = new QWidget(formatGroup);
   QGridLayout* g1Layout = new QGridLayout(g1);
   g1->setLayout(g1Layout);
   formatGroupLayout->addWidget(g1);
 
   QLabel* lab = new QLabel(i18n("No capitali&zation:"), g1);
   g1Layout->addWidget(lab, 0, 0);
   m_leCapitals = new QLineEdit(g1);
   g1Layout->addWidget(m_leCapitals, 0, 1);
   lab->setBuddy(m_leCapitals);
   QString whats = i18n("<qt>A list of words which should not be capitalized. Multiple values "
                        "should be separated by a semi-colon.</qt>");
   lab->setWhatsThis(whats);
   m_leCapitals->setWhatsThis(whats);
-  connect(m_leCapitals, SIGNAL(textChanged(const QString&)), SLOT(slotModified()));
+  connect(m_leCapitals, &QLineEdit::textChanged, this, &ConfigDialog::slotModified);
 
   lab = new QLabel(i18n("Artic&les:"), g1);
   g1Layout->addWidget(lab, 1, 0);
   m_leArticles = new QLineEdit(g1);
   g1Layout->addWidget(m_leArticles, 1, 1);
   lab->setBuddy(m_leArticles);
   whats = i18n("<qt>A list of words which should be considered as articles "
                "if they are the first word in a title. Multiple values "
                "should be separated by a semi-colon.</qt>");
   lab->setWhatsThis(whats);
   m_leArticles->setWhatsThis(whats);
-  connect(m_leArticles, SIGNAL(textChanged(const QString&)), SLOT(slotModified()));
+  connect(m_leArticles, &QLineEdit::textChanged, this, &ConfigDialog::slotModified);
 
   lab = new QLabel(i18n("Personal suffi&xes:"), g1);
   g1Layout->addWidget(lab, 2, 0);
   m_leSuffixes = new QLineEdit(g1);
   g1Layout->addWidget(m_leSuffixes, 2, 1);
   lab->setBuddy(m_leSuffixes);
   whats = i18n("<qt>A list of suffixes which might be used in personal names. Multiple values "
                "should be separated by a semi-colon.</qt>");
   lab->setWhatsThis(whats);
   m_leSuffixes->setWhatsThis(whats);
-  connect(m_leSuffixes, SIGNAL(textChanged(const QString&)), SLOT(slotModified()));
+  connect(m_leSuffixes, &QLineEdit::textChanged, this, &ConfigDialog::slotModified);
 
   lab = new QLabel(i18n("Surname &prefixes:"), g1);
   g1Layout->addWidget(lab, 3, 0);
   m_lePrefixes = new QLineEdit(g1);
   g1Layout->addWidget(m_lePrefixes, 3, 1);
   lab->setBuddy(m_lePrefixes);
   whats = i18n("<qt>A list of prefixes which might be used in surnames. Multiple values "
                "should be separated by a semi-colon.</qt>");
   lab->setWhatsThis(whats);
   m_lePrefixes->setWhatsThis(whats);
-  connect(m_lePrefixes, SIGNAL(textChanged(const QString&)), SLOT(slotModified()));
+  connect(m_lePrefixes, &QLineEdit::textChanged, this, &ConfigDialog::slotModified);
 
   // stretch to fill lower area
   l->addStretch(1);
   m_initializedPages |= General;
   readGeneralConfig();
 }
 
 void ConfigDialog::setupPrintingPage() {
   QFrame* frame = new QFrame(this);
   KPageWidgetItem* page = new KPageWidgetItem(frame, i18n("Printing"));
   page->setHeader(i18n("Printing Options"));
   page->setIcon(QIcon::fromTheme(QStringLiteral("printer")));
   addPage(page);
 }
 
 void ConfigDialog::initPrintingPage(QFrame* frame) {
   QVBoxLayout* l = new QVBoxLayout(frame);
 
   QGroupBox* formatOptions = new QGroupBox(i18n("Formatting Options"), frame);
   l->addWidget(formatOptions);
   QVBoxLayout* formatLayout = new QVBoxLayout(formatOptions);
   formatOptions->setLayout(formatLayout);
 
   m_cbPrintFormatted = new QCheckBox(i18n("&Format titles and names"), formatOptions);
   m_cbPrintFormatted->setWhatsThis(i18n("If checked, titles and names will be automatically formatted."));
-  connect(m_cbPrintFormatted, SIGNAL(clicked()), SLOT(slotModified()));
+  connect(m_cbPrintFormatted, &QAbstractButton::clicked, this, &ConfigDialog::slotModified);
   formatLayout->addWidget(m_cbPrintFormatted);
 
   m_cbPrintHeaders = new QCheckBox(i18n("&Print field headers"), formatOptions);
   m_cbPrintHeaders->setWhatsThis(i18n("If checked, the field names will be printed as table headers."));
-  connect(m_cbPrintHeaders, SIGNAL(clicked()), SLOT(slotModified()));
+  connect(m_cbPrintHeaders, &QAbstractButton::clicked, this, &ConfigDialog::slotModified);
   formatLayout->addWidget(m_cbPrintHeaders);
 
   QGroupBox* groupOptions = new QGroupBox(i18n("Grouping Options"), frame);
   l->addWidget(groupOptions);
   QVBoxLayout* groupLayout = new QVBoxLayout(groupOptions);
   groupOptions->setLayout(groupLayout);
 
   m_cbPrintGrouped = new QCheckBox(i18n("&Group the entries"), groupOptions);
   m_cbPrintGrouped->setWhatsThis(i18n("If checked, the entries will be grouped by the selected field."));
-  connect(m_cbPrintGrouped, SIGNAL(clicked()), SLOT(slotModified()));
+  connect(m_cbPrintGrouped, &QAbstractButton::clicked, this, &ConfigDialog::slotModified);
   groupLayout->addWidget(m_cbPrintGrouped);
 
   QGroupBox* imageOptions = new QGroupBox(i18n("Image Options"), frame);
   l->addWidget(imageOptions);
 
   QGridLayout* gridLayout = new QGridLayout(imageOptions);
   imageOptions->setLayout(gridLayout);
 
   QLabel* lab = new QLabel(i18n("Maximum image &width:"), imageOptions);
   gridLayout->addWidget(lab, 0, 0);
   m_imageWidthBox = new QSpinBox(imageOptions);
   m_imageWidthBox->setMaximum(999);
   m_imageWidthBox->setMinimum(0);
   m_imageWidthBox->setValue(50);
   gridLayout->addWidget(m_imageWidthBox, 0, 1);
   m_imageWidthBox->setSuffix(QStringLiteral(" px"));
   lab->setBuddy(m_imageWidthBox);
   QString whats = i18n("The maximum width of the images in the printout. The aspect ratio is preserved.");
   lab->setWhatsThis(whats);
   m_imageWidthBox->setWhatsThis(whats);
-  connect(m_imageWidthBox, SIGNAL(valueChanged(int)), SLOT(slotModified()));
-  // QSpinBox doesn't emit valueChanged if you edit the value with
-  // the lineEdit until you change the keyboard focus
-//  connect(m_imageWidthBox->child("qt_spinbox_edit"), SIGNAL(textChanged(const QString&)), SLOT(slotModified()));
+  void (QSpinBox::* valueChanged)(int) = &QSpinBox::valueChanged;
+  connect(m_imageWidthBox, valueChanged, this, &ConfigDialog::slotModified);
 
   lab = new QLabel(i18n("&Maximum image height:"), imageOptions);
   gridLayout->addWidget(lab, 1, 0);
   m_imageHeightBox = new QSpinBox(imageOptions);
   m_imageHeightBox->setMaximum(999);
   m_imageHeightBox->setMinimum(0);
   m_imageHeightBox->setValue(50);
   gridLayout->addWidget(m_imageHeightBox, 1, 1);
   m_imageHeightBox->setSuffix(QStringLiteral(" px"));
   lab->setBuddy(m_imageHeightBox);
   whats = i18n("The maximum height of the images in the printout. The aspect ratio is preserved.");
   lab->setWhatsThis(whats);
   m_imageHeightBox->setWhatsThis(whats);
-  connect(m_imageHeightBox, SIGNAL(valueChanged(int)), SLOT(slotModified()));
-  // QSpinBox doesn't emit valueChanged if you edit the value with
-  // the lineEdit until you change the keyboard focus
-//  connect(m_imageHeightBox->child("qt_spinbox_edit"), SIGNAL(textChanged(const QString&)), SLOT(slotModified()));
+  connect(m_imageHeightBox, valueChanged, this, &ConfigDialog::slotModified);
 
   // stretch to fill lower area
   l->addStretch(1);
   m_initializedPages |= Printing;
   readPrintingConfig();
 }
 
 void ConfigDialog::setupTemplatePage() {
   QFrame* frame = new QFrame(this);
   KPageWidgetItem* page = new KPageWidgetItem(frame, i18n("Templates"));
   page->setHeader(i18n("Template Options"));
   // odd icon, I know, matches KMail, though...
   page->setIcon(QIcon::fromTheme(QStringLiteral("preferences-desktop-theme")));
   addPage(page);
 }
 
 void ConfigDialog::initTemplatePage(QFrame* frame) {
   QVBoxLayout* l = new QVBoxLayout(frame);
 
   QGridLayout* gridLayout = new QGridLayout();
   l->addLayout(gridLayout);
 
   int row = -1;
   // so I can reuse an i18n string, a plain label can't have an '&'
   QString s = KLocalizedString::removeAcceleratorMarker(i18n("Collection &type:"));
   QLabel* lab = new QLabel(s, frame);
   gridLayout->addWidget(lab, ++row, 0);
   const int collType = Kernel::self()->collectionType();
   lab = new QLabel(CollectionFactory::nameHash().value(collType), frame);
   gridLayout->addWidget(lab, row, 1, 1, 2);
 
   lab = new QLabel(i18n("Template:"), frame);
   m_templateCombo = new GUI::ComboBox(frame);
-  connect(m_templateCombo, SIGNAL(activated(int)), SLOT(slotModified()));
+  void (QComboBox::* activatedInt)(int) = &QComboBox::activated;
+  connect(m_templateCombo, activatedInt, this, &ConfigDialog::slotModified);
   lab->setBuddy(m_templateCombo);
   QString whats = i18n("Select the template to use for the current type of collections. "
                        "Not all templates will use the font and color settings.");
   lab->setWhatsThis(whats);
   m_templateCombo->setWhatsThis(whats);
   gridLayout->addWidget(lab, ++row, 0);
   gridLayout->addWidget(m_templateCombo, row, 1);
 
   QPushButton* btn = new QPushButton(i18n("&Preview..."), frame);
   btn->setWhatsThis(i18n("Show a preview of the template"));
   btn->setIcon(QIcon::fromTheme(QStringLiteral("zoom-original")));
   gridLayout->addWidget(btn, row, 2);
-  connect(btn, SIGNAL(clicked()), SLOT(slotShowTemplatePreview()));
+  connect(btn, &QAbstractButton::clicked, this, &ConfigDialog::slotShowTemplatePreview);
 
   // so the button is squeezed small
   gridLayout->setColumnStretch(0, 10);
   gridLayout->setColumnStretch(1, 10);
 
   loadTemplateList();
 
 //  QLabel* l1 = new QLabel(i18n("The options below will be passed to the template, but not "
 //                               "all templates will use them. Some fonts and colors may be "
 //                               "specified directly in the template."), frame);
 //  l1->setTextFormat(Qt::RichText);
 //  l->addWidget(l1);
 
   QGroupBox* fontGroup = new QGroupBox(i18n("Font Options"), frame);
   l->addWidget(fontGroup);
 
   row = -1;
   QGridLayout* fontLayout = new QGridLayout();
   fontGroup->setLayout(fontLayout);
 
   lab = new QLabel(i18n("Font:"), fontGroup);
   fontLayout->addWidget(lab, ++row, 0);
   m_fontCombo = new QFontComboBox(fontGroup);
   fontLayout->addWidget(m_fontCombo, row, 1);
-  connect(m_fontCombo, SIGNAL(activated(int)), SLOT(slotModified()));
+  connect(m_fontCombo, activatedInt, this, &ConfigDialog::slotModified);
   lab->setBuddy(m_fontCombo);
   whats = i18n("This font is passed to the template used in the Entry View.");
   lab->setWhatsThis(whats);
   m_fontCombo->setWhatsThis(whats);
 
   fontLayout->addWidget(new QLabel(i18n("Size:"), fontGroup), ++row, 0);
   m_fontSizeInput = new QSpinBox(fontGroup);
   m_fontSizeInput->setMaximum(30); // 30 is same max as konq config
   m_fontSizeInput->setMinimum(5);
   m_fontSizeInput->setSuffix(QStringLiteral("pt"));
   fontLayout->addWidget(m_fontSizeInput, row, 1);
-  connect(m_fontSizeInput, SIGNAL(valueChanged(int)), SLOT(slotModified()));
+  void (QSpinBox::* valueChangedInt)(int) = &QSpinBox::valueChanged;
+  connect(m_fontSizeInput, valueChangedInt, this, &ConfigDialog::slotModified);
   lab->setBuddy(m_fontSizeInput);
   lab->setWhatsThis(whats);
   m_fontSizeInput->setWhatsThis(whats);
 
   QGroupBox* colGroup = new QGroupBox(i18n("Color Options"), frame);
   l->addWidget(colGroup);
 
   row = -1;
   QGridLayout* colLayout = new QGridLayout();
   colGroup->setLayout(colLayout);
 
   lab = new QLabel(i18n("Background color:"), colGroup);
   colLayout->addWidget(lab, ++row, 0);
   m_baseColorCombo = new KColorCombo(colGroup);
   colLayout->addWidget(m_baseColorCombo, row, 1);
-  connect(m_baseColorCombo, SIGNAL(activated(int)), SLOT(slotModified()));
+  connect(m_baseColorCombo, activatedInt, this, &ConfigDialog::slotModified);
   lab->setBuddy(m_baseColorCombo);
   whats = i18n("This color is passed to the template used in the Entry View.");
   lab->setWhatsThis(whats);
   m_baseColorCombo->setWhatsThis(whats);
 
   lab = new QLabel(i18n("Text color:"), colGroup);
   colLayout->addWidget(lab, ++row, 0);
   m_textColorCombo = new KColorCombo(colGroup);
   colLayout->addWidget(m_textColorCombo, row, 1);
-  connect(m_textColorCombo, SIGNAL(activated(int)), SLOT(slotModified()));
+  connect(m_textColorCombo, activatedInt, this, &ConfigDialog::slotModified);
   lab->setBuddy(m_textColorCombo);
   lab->setWhatsThis(whats);
   m_textColorCombo->setWhatsThis(whats);
 
   lab = new QLabel(i18n("Highlight color:"), colGroup);
   colLayout->addWidget(lab, ++row, 0);
   m_highBaseColorCombo = new KColorCombo(colGroup);
   colLayout->addWidget(m_highBaseColorCombo, row, 1);
-  connect(m_highBaseColorCombo, SIGNAL(activated(int)), SLOT(slotModified()));
+  connect(m_highBaseColorCombo, activatedInt, this, &ConfigDialog::slotModified);
   lab->setBuddy(m_highBaseColorCombo);
   lab->setWhatsThis(whats);
   m_highBaseColorCombo->setWhatsThis(whats);
 
   lab = new QLabel(i18n("Highlighted text color:"), colGroup);
   colLayout->addWidget(lab, ++row, 0);
   m_highTextColorCombo = new KColorCombo(colGroup);
   colLayout->addWidget(m_highTextColorCombo, row, 1);
-  connect(m_highTextColorCombo, SIGNAL(activated(int)), SLOT(slotModified()));
+  connect(m_highTextColorCombo, activatedInt, this, &ConfigDialog::slotModified);
   lab->setBuddy(m_highTextColorCombo);
   lab->setWhatsThis(whats);
   m_highTextColorCombo->setWhatsThis(whats);
 
   QGroupBox* groupBox = new QGroupBox(i18n("Manage Templates"), frame);
   l->addWidget(groupBox);
   QVBoxLayout* vlay = new QVBoxLayout(groupBox);
   groupBox->setLayout(vlay);
 
   QWidget* box1 = new QWidget(groupBox);
   QHBoxLayout* box1HBoxLayout = new QHBoxLayout(box1);
   box1HBoxLayout->setMargin(0);
   vlay->addWidget(box1);
   box1HBoxLayout->setSpacing(QApplication::style()->pixelMetric(QStyle::PM_DefaultLayoutSpacing));
 
   QPushButton* b1 = new QPushButton(i18n("Install..."), box1);
   box1HBoxLayout->addWidget(b1);
   b1->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));
-  connect(b1, SIGNAL(clicked()), SLOT(slotInstallTemplate()));
+  connect(b1, &QAbstractButton::clicked, this, &ConfigDialog::slotInstallTemplate);
   whats = i18n("Click to install a new template directly.");
   b1->setWhatsThis(whats);
 
   QPushButton* b2 = new QPushButton(i18n("Download..."), box1);
   box1HBoxLayout->addWidget(b2);
   b2->setIcon(QIcon::fromTheme(QStringLiteral("get-hot-new-stuff")));
-  connect(b2, SIGNAL(clicked()), SLOT(slotDownloadTemplate()));
+  connect(b2, &QAbstractButton::clicked, this, &ConfigDialog::slotDownloadTemplate);
   whats = i18n("Click to download additional templates.");
   b2->setWhatsThis(whats);
 
   QPushButton* b3 = new QPushButton(i18n("Delete..."), box1);
   box1HBoxLayout->addWidget(b3);
   b3->setIcon(QIcon::fromTheme(QStringLiteral("list-remove")));
-  connect(b3, SIGNAL(clicked()), SLOT(slotDeleteTemplate()));
+  connect(b3, &QAbstractButton::clicked, this, &ConfigDialog::slotDeleteTemplate);
   whats = i18n("Click to select and remove installed templates.");
   b3->setWhatsThis(whats);
 
   // stretch to fill lower area
   l->addStretch(1);
 
   // purely for aesthetics make all widgets line up
   QList<QWidget*> widgets;
   widgets.append(m_fontCombo);
   widgets.append(m_fontSizeInput);
   widgets.append(m_baseColorCombo);
   widgets.append(m_textColorCombo);
   widgets.append(m_highBaseColorCombo);
   widgets.append(m_highTextColorCombo);
   int w = 0;
   foreach(QWidget* widget, widgets) {
     widget->ensurePolished();
     w = qMax(w, widget->sizeHint().width());
   }
   foreach(QWidget* widget, widgets) {
     widget->setMinimumWidth(w);
   }
 
   KAcceleratorManager::manage(frame);
   m_initializedPages |= Template;
   readTemplateConfig();
 }
 
 void ConfigDialog::setupFetchPage() {
   QFrame* frame = new QFrame(this);
   KPageWidgetItem* page = new KPageWidgetItem(frame, i18n("Data Sources"));
   page->setHeader(i18n("Data Sources Options"));
   page->setIcon(QIcon::fromTheme(QStringLiteral("network-wired")));
   addPage(page);
 }
 
 void ConfigDialog::initFetchPage(QFrame* frame) {
   QHBoxLayout* l = new QHBoxLayout(frame);
 
   QVBoxLayout* leftLayout = new QVBoxLayout();
   l->addLayout(leftLayout);
   m_sourceListWidget = new QListWidget(frame);
   m_sourceListWidget->setSortingEnabled(false); // no sorting
   m_sourceListWidget->setSelectionMode(QAbstractItemView::SingleSelection);
   leftLayout->addWidget(m_sourceListWidget, 1);
-  connect(m_sourceListWidget, SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*)), SLOT(slotSelectedSourceChanged(QListWidgetItem*)));
-  connect(m_sourceListWidget, SIGNAL(itemDoubleClicked(QListWidgetItem*)), SLOT(slotModifySourceClicked()));
+  connect(m_sourceListWidget, &QListWidget::currentItemChanged, this, &ConfigDialog::slotSelectedSourceChanged);
+  connect(m_sourceListWidget, &QListWidget::itemDoubleClicked, this, &ConfigDialog::slotModifySourceClicked);
 
   QWidget* hb = new QWidget(frame);
   QHBoxLayout* hbHBoxLayout = new QHBoxLayout(hb);
   hbHBoxLayout->setMargin(0);
   leftLayout->addWidget(hb);
   m_moveUpSourceBtn = new QPushButton(i18n("Move &Up"), hb);
   hbHBoxLayout->addWidget(m_moveUpSourceBtn);
   m_moveUpSourceBtn->setIcon(QIcon::fromTheme(QStringLiteral("go-up")));
   m_moveUpSourceBtn->setWhatsThis(i18n("The order of the data sources sets the order "
                                        "that Tellico uses when entries are automatically updated."));
   m_moveDownSourceBtn = new QPushButton(i18n("Move &Down"), hb);
   hbHBoxLayout->addWidget(m_moveDownSourceBtn);
   m_moveDownSourceBtn->setIcon(QIcon::fromTheme(QStringLiteral("go-down")));
   m_moveDownSourceBtn->setWhatsThis(i18n("The order of the data sources sets the order "
                                          "that Tellico uses when entries are automatically updated."));
 
   QWidget* hb2 = new QWidget(frame);
   QHBoxLayout* hb2HBoxLayout = new QHBoxLayout(hb2);
   hb2HBoxLayout->setMargin(0);
   leftLayout->addWidget(hb2);
   m_cbFilterSource = new QCheckBox(i18n("Filter by type:"), hb2);
   hb2HBoxLayout->addWidget(m_cbFilterSource);
-  connect(m_cbFilterSource, SIGNAL(clicked()), SLOT(slotSourceFilterChanged()));
+  connect(m_cbFilterSource, &QAbstractButton::clicked, this, &ConfigDialog::slotSourceFilterChanged);
   m_sourceTypeCombo = new GUI::CollectionTypeCombo(hb2);
   hb2HBoxLayout->addWidget(m_sourceTypeCombo);
-  connect(m_sourceTypeCombo, SIGNAL(currentIndexChanged(int)), SLOT(slotSourceFilterChanged()));
+  void (QComboBox::* currentIndexChanged)(int) = &QComboBox::currentIndexChanged;
+  connect(m_sourceTypeCombo, currentIndexChanged, this, &ConfigDialog::slotSourceFilterChanged);
   // we want to remove the item for a custom collection
   int index = m_sourceTypeCombo->findData(Data::Collection::Base);
   if(index > -1) {
     m_sourceTypeCombo->removeItem(index);
   }
   // disable until check box is checked
   m_sourceTypeCombo->setEnabled(false);
 
   // these icons are rather arbitrary, but seem to vaguely fit
   QVBoxLayout* vlay = new QVBoxLayout();
   l->addLayout(vlay);
   QPushButton* newSourceBtn = new QPushButton(i18n("&New..."), frame);
   newSourceBtn->setIcon(QIcon::fromTheme(QStringLiteral("document-new")));
   newSourceBtn->setWhatsThis(i18n("Click to add a new data source."));
   m_modifySourceBtn = new QPushButton(i18n("&Modify..."), frame);
   m_modifySourceBtn->setIcon(QIcon::fromTheme(QStringLiteral("network-wired")));
   m_modifySourceBtn->setWhatsThis(i18n("Click to modify the selected data source."));
   m_removeSourceBtn = new QPushButton(i18n("&Delete"), frame);
   m_removeSourceBtn->setIcon(QIcon::fromTheme(QStringLiteral("list-remove")));
   m_removeSourceBtn->setWhatsThis(i18n("Click to delete the selected data source."));
   m_newStuffBtn = new QPushButton(i18n("Download..."), frame);
   m_newStuffBtn->setIcon(QIcon::fromTheme(QStringLiteral("get-hot-new-stuff")));
   m_newStuffBtn->setWhatsThis(i18n("Click to download additional data sources."));
   // checksum and signature checking are no longer possible with knewstuff2
   // disable button for now
   m_newStuffBtn->setEnabled(false);
 
   vlay->addWidget(newSourceBtn);
   vlay->addWidget(m_modifySourceBtn);
   vlay->addWidget(m_removeSourceBtn);
   // separate newstuff button from the rest
   vlay->addSpacing(16);
   vlay->addWidget(m_newStuffBtn);
   vlay->addStretch(1);
 
-  connect(newSourceBtn, SIGNAL(clicked()), SLOT(slotNewSourceClicked()));
-  connect(m_modifySourceBtn, SIGNAL(clicked()), SLOT(slotModifySourceClicked()));
-  connect(m_moveUpSourceBtn, SIGNAL(clicked()), SLOT(slotMoveUpSourceClicked()));
-  connect(m_moveDownSourceBtn, SIGNAL(clicked()), SLOT(slotMoveDownSourceClicked()));
-  connect(m_removeSourceBtn, SIGNAL(clicked()), SLOT(slotRemoveSourceClicked()));
-  connect(m_newStuffBtn, SIGNAL(clicked()), SLOT(slotNewStuffClicked()));
+  connect(newSourceBtn, &QAbstractButton::clicked, this, &ConfigDialog::slotNewSourceClicked);
+  connect(m_modifySourceBtn, &QAbstractButton::clicked, this, &ConfigDialog::slotModifySourceClicked);
+  connect(m_moveUpSourceBtn, &QAbstractButton::clicked, this, &ConfigDialog::slotMoveUpSourceClicked);
+  connect(m_moveDownSourceBtn, &QAbstractButton::clicked, this, &ConfigDialog::slotMoveDownSourceClicked);
+  connect(m_removeSourceBtn, &QAbstractButton::clicked, this, &ConfigDialog::slotRemoveSourceClicked);
+  connect(m_newStuffBtn, &QAbstractButton::clicked, this, &ConfigDialog::slotNewStuffClicked);
 
   KAcceleratorManager::manage(frame);
   m_initializedPages |= Fetch;
   readFetchConfig();
 }
 
 void ConfigDialog::readGeneralConfig() {
   m_modifying = true;
 
   m_cbShowTipDay->setChecked(Config::showTipOfDay());
   m_cbOpenLastFile->setChecked(Config::reopenLastFile());
 #ifdef ENABLE_WEBCAM
   m_cbEnableWebcam->setChecked(Config::enableWebcam());
 #else
   m_cbEnableWebcam->setChecked(false);
   m_cbEnableWebcam->setEnabled(false);
 #endif
 
   switch(Config::imageLocation()) {
     case Config::ImagesInFile: m_rbImageInFile->setChecked(true); break;
     case Config::ImagesInAppDir: m_rbImageInAppDir->setChecked(true); break;
     case Config::ImagesInLocalDir: m_rbImageInLocalDir->setChecked(true); break;
   }
 
   bool autoCapitals = Config::autoCapitalization();
   m_cbCapitalize->setChecked(autoCapitals);
 
   bool autoFormat = Config::autoFormat();
   m_cbFormat->setChecked(autoFormat);
 
   const QRegExp comma(QLatin1String("\\s*,\\s*"));
 
   m_leCapitals->setText(Config::noCapitalizationString().replace(comma, FieldFormat::delimiterString()));
   m_leArticles->setText(Config::articlesString().replace(comma, FieldFormat::delimiterString()));
   m_leSuffixes->setText(Config::nameSuffixesString().replace(comma, FieldFormat::delimiterString()));
   m_lePrefixes->setText(Config::surnamePrefixesString().replace(comma, FieldFormat::delimiterString()));
 
   m_modifying = false;
 }
 
 void ConfigDialog::readPrintingConfig() {
   m_modifying = true;
 
   m_cbPrintHeaders->setChecked(Config::printFieldHeaders());
   m_cbPrintFormatted->setChecked(Config::printFormatted());
   m_cbPrintGrouped->setChecked(Config::printGrouped());
   m_imageWidthBox->setValue(Config::maxImageWidth());
   m_imageHeightBox->setValue(Config::maxImageHeight());
 
   m_modifying = false;
 }
 
 void ConfigDialog::readTemplateConfig() {
   m_modifying = true;
 
   // entry template selection
   const int collType = Kernel::self()->collectionType();
   QString file = Config::templateName(collType);
   file.replace(QLatin1Char('_'), QLatin1Char(' '));
   QString fileContext = file + QLatin1String(" XSL Template");
   m_templateCombo->setCurrentItem(i18nc(fileContext.toUtf8().constData(), file.toUtf8().constData()));
 
   m_fontCombo->setCurrentFont(QFont(Config::templateFont(collType).family()));
   m_fontSizeInput->setValue(Config::templateFont(collType).pointSize());
   m_baseColorCombo->setColor(Config::templateBaseColor(collType));
   m_textColorCombo->setColor(Config::templateTextColor(collType));
   m_highBaseColorCombo->setColor(Config::templateHighlightedBaseColor(collType));
   m_highTextColorCombo->setColor(Config::templateHighlightedTextColor(collType));
 
   m_modifying = false;
 }
 
 void ConfigDialog::readFetchConfig() {
   m_modifying = true;
 
   m_sourceListWidget->clear();
   m_configWidgets.clear();
 
   m_sourceListWidget->setUpdatesEnabled(false);
   foreach(Fetch::Fetcher::Ptr fetcher, Fetch::Manager::self()->fetchers()) {
     Fetch::FetcherInfo info(fetcher->type(), fetcher->source(),
                             fetcher->updateOverwrite(), fetcher->uuid());
     FetcherInfoListItem* item = new FetcherInfoListItem(m_sourceListWidget, info);
     item->setFetcher(fetcher);
   }
   m_sourceListWidget->setUpdatesEnabled(true);
 
   if(m_sourceListWidget->count() == 0) {
     m_modifySourceBtn->setEnabled(false);
     m_removeSourceBtn->setEnabled(false);
   } else {
     // go ahead and select the first one
     m_sourceListWidget->setCurrentItem(m_sourceListWidget->item(0));
   }
 
   m_modifying = false;
-  QTimer::singleShot(500, this, SLOT(slotCreateConfigWidgets()));
+  QTimer::singleShot(500, this, &ConfigDialog::slotCreateConfigWidgets);
 }
 
 void ConfigDialog::saveConfiguration() {
   if(isPageInitialized(General)) saveGeneralConfig();
   if(isPageInitialized(Printing)) savePrintingConfig();
   if(isPageInitialized(Template)) saveTemplateConfig();
   if(isPageInitialized(Fetch)) saveFetchConfig();
 }
 
 void ConfigDialog::saveGeneralConfig() {
   Config::setShowTipOfDay(m_cbShowTipDay->isChecked());
   Config::setEnableWebcam(m_cbEnableWebcam->isChecked());
 
   int imageLocation;
   if(m_rbImageInFile->isChecked()) {
     imageLocation = Config::ImagesInFile;
   } else if(m_rbImageInAppDir->isChecked()) {
     imageLocation = Config::ImagesInAppDir;
   } else {
     imageLocation = Config::ImagesInLocalDir;
   }
   Config::setImageLocation(imageLocation);
   Config::setReopenLastFile(m_cbOpenLastFile->isChecked());
 
   Config::setAutoCapitalization(m_cbCapitalize->isChecked());
   Config::setAutoFormat(m_cbFormat->isChecked());
 
   const QRegExp semicolon(QLatin1String("\\s*;\\s*"));
   const QChar comma = QLatin1Char(',');
 
   Config::setNoCapitalizationString(m_leCapitals->text().replace(semicolon, comma));
   Config::setArticlesString(m_leArticles->text().replace(semicolon, comma));
   Config::setNameSuffixesString(m_leSuffixes->text().replace(semicolon, comma));
   Config::setSurnamePrefixesString(m_lePrefixes->text().replace(semicolon, comma));
 }
 
 void ConfigDialog::savePrintingConfig() {
   Config::setPrintFieldHeaders(m_cbPrintHeaders->isChecked());
   Config::setPrintFormatted(m_cbPrintFormatted->isChecked());
   Config::setPrintGrouped(m_cbPrintGrouped->isChecked());
   Config::setMaxImageWidth(m_imageWidthBox->value());
   Config::setMaxImageHeight(m_imageHeightBox->value());
 }
 
 void ConfigDialog::saveTemplateConfig() {
   const int collType = Kernel::self()->collectionType();
   Config::setTemplateName(collType, m_templateCombo->currentData().toString());
   QFont font(m_fontCombo->currentFont().family(), m_fontSizeInput->value());
   Config::setTemplateFont(collType, font);
   Config::setTemplateBaseColor(collType, m_baseColorCombo->color());
   Config::setTemplateTextColor(collType, m_textColorCombo->color());
   Config::setTemplateHighlightedBaseColor(collType, m_highBaseColorCombo->color());
   Config::setTemplateHighlightedTextColor(collType, m_highTextColorCombo->color());
 }
 
 void ConfigDialog::saveFetchConfig() {
   // first, tell config widgets they got deleted
   foreach(Fetch::ConfigWidget* widget, m_removedConfigWidgets) {
     widget->removed();
   }
   m_removedConfigWidgets.clear();
 
   bool reloadFetchers = false;
   int count = 0; // start group numbering at 0
   for( ; count < m_sourceListWidget->count(); ++count) {
     FetcherInfoListItem* item = static_cast<FetcherInfoListItem*>(m_sourceListWidget->item(count));
     Fetch::ConfigWidget* cw = m_configWidgets[item];
     if(!cw || (!cw->shouldSave() && !item->isNewSource())) {
       continue;
     }
     m_newStuffConfigWidgets.removeAll(cw);
     QString group = QStringLiteral("Data Source %1").arg(count);
     // in case we later change the order, clear the group now
     KSharedConfig::openConfig()->deleteGroup(group);
     KConfigGroup configGroup(KSharedConfig::openConfig(), group);
     configGroup.writeEntry("Name", item->data(Qt::DisplayRole).toString());
     configGroup.writeEntry("Type", int(item->fetchType()));
     configGroup.writeEntry("UpdateOverwrite", item->updateOverwrite());
     configGroup.writeEntry("Uuid", item->uuid());
     cw->saveConfig(configGroup);
     item->setNewSource(false);
     // in case the ordering changed
     item->setConfigGroup(group);
     reloadFetchers = true;
   }
   // now update total number of sources
   KConfigGroup sourceGroup(KSharedConfig::openConfig(), "Data Sources");
   sourceGroup.writeEntry("Sources Count", count);
   // and purge old config groups
   QString group = QStringLiteral("Data Source %1").arg(count);
   while(KSharedConfig::openConfig()->hasGroup(group)) {
     KSharedConfig::openConfig()->deleteGroup(group);
     ++count;
     group = QStringLiteral("Data Source %1").arg(count);
   }
 
   Config::self()->save();
 
   if(reloadFetchers) {
     Fetch::Manager::self()->loadFetchers();
     Controller::self()->updatedFetchers();
     // reload fetcher items if OK was not clicked
     // meaning apply was clicked
     if(!m_okClicked) {
       QString currentSource;
       if(m_sourceListWidget->currentItem()) {
         currentSource = m_sourceListWidget->currentItem()->data(Qt::DisplayRole).toString();
       }
       readFetchConfig();
       if(!currentSource.isEmpty()) {
         QList<QListWidgetItem*> items = m_sourceListWidget->findItems(currentSource, Qt::MatchExactly);
         if(!items.isEmpty()) {
           m_sourceListWidget->setCurrentItem(items.first());
           m_sourceListWidget->scrollToItem(items.first());
         }
       }
     }
   }
 }
 
 void ConfigDialog::slotModified() {
   if(m_modifying) {
     return;
   }
   button(QDialogButtonBox::Ok)->setEnabled(true);
   button(QDialogButtonBox::Apply)->setEnabled(true);
 }
 
 void ConfigDialog::slotNewSourceClicked() {
   FetcherConfigDialog dlg(this);
   if(dlg.exec() != QDialog::Accepted) {
     return;
   }
 
   Fetch::Type type = dlg.sourceType();
   if(type == Fetch::Unknown) {
     return;
   }
 
   Fetch::FetcherInfo info(type, dlg.sourceName(), dlg.updateOverwrite());
   FetcherInfoListItem* item = new FetcherInfoListItem(m_sourceListWidget, info);
   m_sourceListWidget->scrollToItem(item);
   m_sourceListWidget->setCurrentItem(item);
   Fetch::ConfigWidget* cw = dlg.configWidget();
   if(cw) {
     cw->setAccepted(true);
     cw->slotSetModified();
     cw->setParent(this); // keep the config widget around
     m_configWidgets.insert(item, cw);
   }
   m_modifySourceBtn->setEnabled(true);
   m_removeSourceBtn->setEnabled(true);
   slotModified(); // toggle apply button
 }
 
 void ConfigDialog::slotModifySourceClicked() {
   FetcherInfoListItem* item = static_cast<FetcherInfoListItem*>(m_sourceListWidget->currentItem());
   if(!item) {
     return;
   }
 
   Fetch::ConfigWidget* cw = nullptr;
   if(m_configWidgets.contains(item)) {
     cw = m_configWidgets[item];
   } else {
     // grab the config widget, taking ownership
     cw = item->fetcher()->configWidget(this);
     if(cw) { // might return 0 when no widget available for fetcher type
       m_configWidgets.insert(item, cw);
       // there's weird layout bug if it's not hidden
       cw->hide();
     }
   }
   if(!cw) {
     // no config widget for this one
     // might be because support was compiled out
     myDebug() << "no config widget for source" << item->data(Qt::DisplayRole).toString();
     return;
   }
   FetcherConfigDialog dlg(item->data(Qt::DisplayRole).toString(), item->fetchType(), item->updateOverwrite(), cw, this);
 
   if(dlg.exec() == QDialog::Accepted) {
     cw->setAccepted(true); // mark to save
     QString newName = dlg.sourceName();
     if(newName != item->data(Qt::DisplayRole).toString()) {
       item->setData(Qt::DisplayRole, newName);
       cw->slotSetModified();
     }
     item->setUpdateOverwrite(dlg.updateOverwrite());
     slotModified(); // toggle apply button
   }
   cw->setParent(this); // keep the config widget around
 }
 
 void ConfigDialog::slotRemoveSourceClicked() {
   FetcherInfoListItem* item = static_cast<FetcherInfoListItem*>(m_sourceListWidget->currentItem());
   if(!item) {
     return;
   }
 
   Tellico::NewStuff::Manager::self()->removeScriptByName(item->text());
 
   Fetch::ConfigWidget* cw = m_configWidgets[item];
   if(cw) {
     m_removedConfigWidgets.append(cw);
     // it gets deleted by the parent
   }
   m_configWidgets.remove(item);
   delete item;
 //  m_sourceListWidget->setCurrentItem(m_sourceListWidget->currentItem());
   slotModified(); // toggle apply button
 }
 
 void ConfigDialog::slotMoveUpSourceClicked() {
   int row = m_sourceListWidget->currentRow();
   if(row < 1) {
     return;
   }
   QListWidgetItem* item = m_sourceListWidget->takeItem(row);
   m_sourceListWidget->insertItem(row-1, item);
   m_sourceListWidget->setCurrentItem(item);
   slotModified(); // toggle apply button
 }
 
 void ConfigDialog::slotMoveDownSourceClicked() {
   int row = m_sourceListWidget->currentRow();
   if(row > m_sourceListWidget->count()-2) {
     return;
   }
   QListWidgetItem* item = m_sourceListWidget->takeItem(row);
   m_sourceListWidget->insertItem(row+1, item);
   m_sourceListWidget->setCurrentItem(item);
   slotModified(); // toggle apply button
 }
 
 void ConfigDialog::slotSourceFilterChanged() {
   m_sourceTypeCombo->setEnabled(m_cbFilterSource->isChecked());
   const bool showAll = !m_sourceTypeCombo->isEnabled();
   const int type = m_sourceTypeCombo->currentType();
   for(int count = 0; count < m_sourceListWidget->count(); ++count) {
     FetcherInfoListItem* item = static_cast<FetcherInfoListItem*>(m_sourceListWidget->item(count));
     item->setHidden(!showAll && item->fetcher() && !item->fetcher()->canFetch(type));
   }
 }
 
 void ConfigDialog::slotSelectedSourceChanged(QListWidgetItem* item_) {
   int row = m_sourceListWidget->row(item_);
   m_moveUpSourceBtn->setEnabled(row > 0);
   m_moveDownSourceBtn->setEnabled(row < m_sourceListWidget->count()-1);
 }
 
 void ConfigDialog::slotNewStuffClicked() {
 #ifdef ENABLE_KNEWSTUFF3
   KNS3::DownloadDialog dialog(QStringLiteral("tellico-script.knsrc"), this);
   dialog.exec();
 
   KNS3::Entry::List entries = dialog.installedEntries();
   if(!entries.isEmpty()) {
     Fetch::Manager::self()->loadFetchers();
     readFetchConfig();
   }
 #endif
 }
 
 Tellico::FetcherInfoListItem* ConfigDialog::findItem(const QString& path_) const {
   if(path_.isEmpty()) {
     myDebug() << "empty path";
     return nullptr;
   }
 
   // this is a bit ugly, loop over all items, find the execexternal one
   // that matches the path
   for(int i = 0; i < m_sourceListWidget->count(); ++i) {
     FetcherInfoListItem* item = static_cast<FetcherInfoListItem*>(m_sourceListWidget->item(i));
     if(item->fetchType() != Fetch::ExecExternal) {
       continue;
     }
     Fetch::ExecExternalFetcher* f = dynamic_cast<Fetch::ExecExternalFetcher*>(item->fetcher().data());
     if(f && f->execPath() == path_) {
       return item;
     }
   }
   myDebug() << "no matching item found";
   return nullptr;
 }
 
 void ConfigDialog::slotShowTemplatePreview() {
   GUI::PreviewDialog* dlg = new GUI::PreviewDialog(this);
 
   const QString templateName = m_templateCombo->currentData().toString();
   dlg->setXSLTFile(templateName + QLatin1String(".xsl"));
 
   StyleOptions options;
   options.fontFamily = m_fontCombo->currentFont().family();
   options.fontSize   = m_fontSizeInput->value();
   options.baseColor  = m_baseColorCombo->color();
   options.textColor  = m_textColorCombo->color();
   options.highlightedTextColor = m_highTextColorCombo->color();
   options.highlightedBaseColor = m_highBaseColorCombo->color();
   dlg->setXSLTOptions(Kernel::self()->collectionType(), options);
 
   Data::CollPtr c = CollectionFactory::collection(Kernel::self()->collectionType(), true);
   Data::EntryPtr e(new Data::Entry(c));
   foreach(Data::FieldPtr f, c->fields()) {
     if(f->name() == QLatin1String("title")) {
       e->setField(f->name(), m_templateCombo->currentText());
     } else if(f->type() == Data::Field::Image) {
       continue;
     } else if(f->type() == Data::Field::Choice) {
       e->setField(f->name(), f->allowed().front());
     } else if(f->type() == Data::Field::Number) {
       e->setField(f->name(), QStringLiteral("1"));
     } else if(f->type() == Data::Field::Bool) {
       e->setField(f->name(), QStringLiteral("true"));
     } else if(f->type() == Data::Field::Rating) {
       e->setField(f->name(), QStringLiteral("5"));
     } else {
       e->setField(f->name(), f->title());
     }
   }
 
   dlg->showEntry(e);
   dlg->show();
   // dlg gets deleted by itself
   // the finished() signal is connected in its constructor to delayedDestruct
 }
 
 void ConfigDialog::loadTemplateList() {
   QStringList files = Tellico::locateAllFiles(QStringLiteral("tellico/entry-templates/*.xsl"));
   QMap<QString, QString> templates; // a QMap will have them values sorted by key
   foreach(const QString& file, files) {
     QFileInfo fi(file);
     QString lfile = fi.fileName().section(QLatin1Char('.'), 0, -2);
     QString name = lfile;
     name.replace(QLatin1Char('_'), QLatin1Char(' '));
     QString title = i18nc((name + QLatin1String(" XSL Template")).toUtf8().constData(), name.toUtf8().constData());
     templates.insert(title, lfile);
   }
 
   QString s = m_templateCombo->currentText();
   m_templateCombo->clear();
   for(QMap<QString, QString>::ConstIterator it2 = templates.constBegin(); it2 != templates.constEnd(); ++it2) {
     m_templateCombo->addItem(it2.key(), it2.value());
   }
   m_templateCombo->setCurrentItem(s);
 }
 
 void ConfigDialog::slotInstallTemplate() {
   QString filter = i18n("XSL Files") + QLatin1String(" (*.xsl)") + QLatin1String(";;");
   filter += i18n("Template Packages") + QLatin1String(" (*.tar.gz *.tgz)") + QLatin1String(";;");
   filter += i18n("All Files") + QLatin1String(" (*)");
 
   const QString fileClass(QStringLiteral(":InstallTemplate"));
   const QString f = QFileDialog::getOpenFileName(this, QString(), KRecentDirs::dir(fileClass), filter);
   if(f.isEmpty()) {
     return;
   }
   KRecentDirs::add(fileClass, QFileInfo(f).dir().canonicalPath());
 
   if(Tellico::NewStuff::Manager::self()->installTemplate(f)) {
     loadTemplateList();
   }
 }
 
 void ConfigDialog::slotDownloadTemplate() {
 #ifdef ENABLE_KNEWSTUFF3
   KNS3::DownloadDialog dialog(QStringLiteral("tellico-template.knsrc"), this);
   dialog.exec();
 
   KNS3::Entry::List entries = dialog.installedEntries();
   if(!entries.isEmpty()) {
     loadTemplateList();
   }
 #endif
 }
 
 void ConfigDialog::slotDeleteTemplate() {
   bool ok;
   QString name = QInputDialog::getItem(this,
                                        i18n("Delete Template"),
                                        i18n("Select template to delete:"),
                                        Tellico::NewStuff::Manager::self()->userTemplates().keys(),
                                        0, false, &ok);
   if(ok && !name.isEmpty()) {
     Tellico::NewStuff::Manager::self()->removeTemplateByName(name);
     loadTemplateList();
   }
 }
 
 void ConfigDialog::slotCreateConfigWidgets() {
   for(int count = 0; count < m_sourceListWidget->count(); ++count) {
     FetcherInfoListItem* item = static_cast<FetcherInfoListItem*>(m_sourceListWidget->item(count));
     // only create a new config widget if we don't have one already
     if(!m_configWidgets.contains(item)) {
       Fetch::ConfigWidget* cw = item->fetcher()->configWidget(this);
       if(cw) { // might return 0 when no widget available for fetcher type
         m_configWidgets.insert(item, cw);
         // there's weird layout bug if it's not hidden
         cw->hide();
       }
     }
   }
 }
diff --git a/src/detailedlistview.cpp b/src/detailedlistview.cpp
index 449c38cd..5f1bb106 100644
--- a/src/detailedlistview.cpp
+++ b/src/detailedlistview.cpp
@@ -1,639 +1,639 @@
 /***************************************************************************
     Copyright (C) 2001-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "detailedlistview.h"
 #include "collection.h"
 #include "collectionfactory.h"
 #include "controller.h"
 #include "field.h"
 #include "entry.h"
 #include "tellico_debug.h"
 #include "tellico_kernel.h"
 #include "config/tellico_config.h"
 #include "models/entrymodel.h"
 #include "models/entrysortmodel.h"
 #include "models/modelmanager.h"
 #include "gui/detailedentryitemdelegate.h"
 #include "gui/ratingdelegate.h"
 #include "utils/string_utils.h"
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 #include <QMenu>
 #include <QMouseEvent>
 #include <QHeaderView>
 #include <QContextMenuEvent>
 
 using namespace Tellico;
 using Tellico::DetailedListView;
 
 DetailedListView::DetailedListView(QWidget* parent_) : GUI::TreeView(parent_)
     , m_loadingCollection(false), m_currentContextColumn(-1) {
   setHeaderHidden(false);
   setSelectionMode(QAbstractItemView::ExtendedSelection);
   setAlternatingRowColors(true);
   setRootIsDecorated(false);
   setUniformRowHeights(true);
 
-  connect(this, SIGNAL(doubleClicked(const QModelIndex&)), SLOT(slotDoubleClicked(const QModelIndex&)));
+  connect(this, &QAbstractItemView::doubleClicked, this, &DetailedListView::slotDoubleClicked);
 
   // header menu
   header()->installEventFilter(this);
   header()->setMinimumSectionSize(20);
 
   m_headerMenu = new QMenu(this);
   m_columnMenu = new QMenu(this);
-  connect(m_columnMenu, SIGNAL(triggered(QAction*)),
-          SLOT(slotColumnMenuActivated(QAction*)));
+  connect(m_columnMenu, &QMenu::triggered,
+          this, &DetailedListView::slotColumnMenuActivated);
 
   EntryModel* entryModel = new EntryModel(this);
   EntrySortModel* sortModel = new EntrySortModel(this);
   sortModel->setSortRole(EntryPtrRole);
   sortModel->setSourceModel(entryModel);
   setModel(sortModel);
   setItemDelegate(new DetailedEntryItemDelegate(this));
 
   ModelManager::self()->setEntryModel(sortModel);
 
-  connect(model(), SIGNAL(headerDataChanged(Qt::Orientation, int, int)), SLOT(updateHeaderMenu()));
-  connect(model(), SIGNAL(headerDataChanged(Qt::Orientation, int, int)), SLOT(updateColumnDelegates()));
-  connect(model(), SIGNAL(columnsInserted(const QModelIndex&, int, int)), SLOT(hideNewColumn(const QModelIndex&, int, int)));
-  connect(header(), SIGNAL(sectionCountChanged(int, int)), SLOT(updateHeaderMenu()));
+  connect(model(), &QAbstractItemModel::headerDataChanged, this, &DetailedListView::updateHeaderMenu);
+  connect(model(), &QAbstractItemModel::headerDataChanged, this, &DetailedListView::updateColumnDelegates);
+  connect(model(), &QAbstractItemModel::columnsInserted, this, &DetailedListView::hideNewColumn);
+  connect(header(), &QHeaderView::sectionCountChanged, this, &DetailedListView::updateHeaderMenu);
 }
 
 DetailedListView::~DetailedListView() {
 }
 
 Tellico::EntryModel* DetailedListView::sourceModel() const {
   return static_cast<EntryModel*>(sortModel()->sourceModel());
 }
 
 void DetailedListView::addCollection(Tellico::Data::CollPtr coll_) {
   if(!coll_) {
     return;
   }
 
   const QString configGroup = QStringLiteral("Options - %1").arg(CollectionFactory::typeName(coll_));
   KConfigGroup config(KSharedConfig::openConfig(), configGroup);
 
   QString configN;
   if(coll_->type() == Data::Collection::Base) {
     QUrl url = Kernel::self()->URL();
     for(int i = 0; i < Config::maxCustomURLSettings(); ++i) {
       QUrl u = config.readEntry(QStringLiteral("URL_%1").arg(i), QUrl());
       if(u == url) {
         configN = QStringLiteral("_%1").arg(i);
         break;
       }
     }
   }
 
   // we don't want to immediately hide all these columns when adding fields
-  disconnect(model(), SIGNAL(columnsInserted(const QModelIndex&, int, int)),
-             this, SLOT(hideNewColumn(const QModelIndex&, int, int)));
+  disconnect(model(), &QAbstractItemModel::columnsInserted,
+             this, &DetailedListView::hideNewColumn);
   sourceModel()->setImagesAreAvailable(false);
   sourceModel()->setFields(coll_->fields());
-  connect(model(), SIGNAL(columnsInserted(const QModelIndex&, int, int)),
-          this, SLOT(hideNewColumn(const QModelIndex&, int, int)));
+  connect(model(), &QAbstractItemModel::columnsInserted,
+          this, &DetailedListView::hideNewColumn);
 
   // we're not using saveState() and restoreState() since our columns are variable
   QStringList columnNames = config.readEntry(QLatin1String("ColumnNames") + configN, QStringList());
   QList<int> columnWidths = config.readEntry(QLatin1String("ColumnWidths") + configN, QList<int>());
   QList<int> columnOrder = config.readEntry(QLatin1String("ColumnOrder") + configN, QList<int>());
 
   // just a broken-world check
   while(columnWidths.size() < columnNames.size()) {
     columnWidths << 0;
   }
   while(columnOrder.size() < columnNames.size()) {
     columnOrder << columnOrder.size();
   }
   QList<int> currentColumnOrder;
   // now restore widths and order
   for(int ncol = 0; ncol < header()->count(); ++ncol) {
     int idx = columnNames.indexOf(columnFieldName(ncol));
     // column width of 0 means hidden
     if(idx < 0 || columnWidths.at(idx) <= 0) {
       hideColumn(ncol);
       if(idx > -1) {
         currentColumnOrder << ncol;
       }
     } else {
       setColumnWidth(ncol, columnWidths.at(idx));
       currentColumnOrder << ncol;
     }
   }
   const int maxCount = qMin(currentColumnOrder.size(), columnOrder.size());
   for(int i = 0; i < maxCount; ++i) {
     header()->moveSection(header()->visualIndex(currentColumnOrder.at(i)), columnOrder.at(i));
   }
 
   // always hide tables and paragraphs
   for(int ncol = 0; ncol < coll_->fields().count(); ++ncol) {
     Data::FieldPtr field = model()->headerData(ncol, Qt::Horizontal, FieldPtrRole).value<Data::FieldPtr>();
     if(field) {
       if(field->type() == Data::Field::Table || field->type() == Data::Field::Para) {
         hideColumn(ncol);
       }
     } else {
       myDebug() << "no field for col" << ncol;
     }
   }
 
   // because some of the fields got hidden...
   updateColumnDelegates();
   updateHeaderMenu();
   checkHeader();
 
   sortModel()->setSortColumn(config.readEntry(QLatin1String("SortColumn") + configN, -1));
   sortModel()->setSecondarySortColumn(config.readEntry(QLatin1String("PrevSortColumn") + configN, -1));
   sortModel()->setTertiarySortColumn(config.readEntry(QLatin1String("Prev2SortColumn") + configN, -1));
   const int order = config.readEntry(QLatin1String("SortOrder") + configN, static_cast<int>(Qt::AscendingOrder));
   sortModel()->setSortOrder(static_cast<Qt::SortOrder>(order));
 
   setUpdatesEnabled(false);
   m_loadingCollection = true;
   addEntries(coll_->entries());
   m_loadingCollection = false;
   setUpdatesEnabled(true);
 
   header()->setSortIndicator(sortModel()->sortColumn(), sortModel()->sortOrder());
 }
 
 void DetailedListView::slotReset() {
   //clear() does not remove columns
   sourceModel()->clear();
 }
 
 void DetailedListView::addEntries(Tellico::Data::EntryList entries_) {
   if(entries_.isEmpty()) {
     return;
   }
   sourceModel()->addEntries(entries_);
   if(!m_loadingCollection) {
     setState(entries_, NewState);
   }
 }
 
 void DetailedListView::modifyEntries(Tellico::Data::EntryList entries_) {
   if(entries_.isEmpty()) {
     return;
   }
   sourceModel()->modifyEntries(entries_);
   setState(entries_, ModifiedState);
 }
 
 void DetailedListView::removeEntries(Tellico::Data::EntryList entries_) {
   if(entries_.isEmpty()) {
     return;
   }
   sourceModel()->removeEntries(entries_);
 }
 
 void DetailedListView::setState(Tellico::Data::EntryList entries_, int state) {
   foreach(Data::EntryPtr entry, entries_) {
     QModelIndex index = sourceModel()->indexFromEntry(entry);
     if(index.isValid()) {
       sourceModel()->setData(index, state, SaveStateRole);
     } else {
       myWarning() << "no index found for" << entry->id() << entry->title();
     }
   }
 }
 
 void DetailedListView::removeCollection(Tellico::Data::CollPtr coll_) {
   if(!coll_) {
     myWarning() << "null coll pointer!";
     return;
   }
 
   sourceModel()->clear();
 }
 
 void DetailedListView::contextMenuEvent(QContextMenuEvent* event_) {
   QModelIndex index = indexAt(event_->pos());
   if(!index.isValid()) {
     return;
   }
 
   QMenu menu(this);
   Controller::self()->plugEntryActions(&menu);
   menu.exec(event_->globalPos());
 }
 
 // don't shadow QListView::setSelected
 void DetailedListView::setEntriesSelected(Data::EntryList entries_) {
   if(entries_.isEmpty()) {
     // don't move this one outside the block since it calls setCurrentItem(0)
     clearSelection();
     return;
   }
 
   clearSelection();
   EntrySortModel* proxyModel = static_cast<EntrySortModel*>(model());
   foreach(Data::EntryPtr entry, entries_) {
     QModelIndex index = sourceModel()->indexFromEntry(entry);
     if(!proxyModel->mapFromSource(index).isValid()) {
       // clear the filter if we're trying to select an entry that is currently filtered out
       Controller::self()->clearFilter();
       break;
     }
   }
   blockSignals(true);
   foreach(Data::EntryPtr entry, entries_) {
     QModelIndex index = sourceModel()->indexFromEntry(entry);
     selectionModel()->select(proxyModel->mapFromSource(index), QItemSelectionModel::Select | QItemSelectionModel::Rows);
   }
   //setCurrentIndex(index);
   blockSignals(false);
   QModelIndex index = sourceModel()->indexFromEntry(entries_.first());
   scrollTo(proxyModel->mapFromSource(index));
 }
 
 bool DetailedListView::eventFilter(QObject* obj_, QEvent* event_) {
   if(event_->type() == QEvent::ContextMenu
      && obj_ == header()) {
     m_currentContextColumn = header()->logicalIndexAt(static_cast<QContextMenuEvent*>(event_)->pos());
     m_headerMenu->exec(static_cast<QContextMenuEvent*>(event_)->globalPos());
     return true;
   }
   return GUI::TreeView::eventFilter(obj_, event_);
 }
 
 void DetailedListView::slotDoubleClicked(const QModelIndex& index_) {
   Data::EntryPtr entry = index_.data(EntryPtrRole).value<Data::EntryPtr>();
   if(entry) {
     Controller::self()->editEntry(entry);
   }
 }
 
 void DetailedListView::slotColumnMenuActivated(QAction* action_) {
   const int col = action_->data().toInt();
   if(col > -1) { // only column actions have data
     const bool isChecked = action_->isChecked();
     setColumnHidden(col, !isChecked);
     // if we're showing a column, resize all sections
     if(isChecked) {
       resizeColumnToContents(col);
       adjustColumnWidths();
     }
   }
   checkHeader();
 }
 
 void DetailedListView::showAllColumns() {
   foreach(QAction* action, m_columnMenu->actions()) {
     if(action->isCheckable() && !action->isChecked()) {
       action->trigger();
     }
   }
 }
 
 void DetailedListView::hideAllColumns() {
   for(int ncol = 0; ncol < header()->count(); ++ncol) {
     hideColumn(ncol);
   }
   foreach(QAction* action, m_columnMenu->actions()) {
     if(action->isCheckable()) {
       action->setChecked(false);
     }
   }
   checkHeader();
 }
 
 void DetailedListView::hideCurrentColumn() {
   setColumnHidden(m_currentContextColumn, true);
   checkHeader();
 }
 
 void DetailedListView::slotRefresh() {
   sortModel()->invalidate();
 }
 
 void DetailedListView::setFilter(Tellico::FilterPtr filter_) {
   static_cast<EntrySortModel*>(sortModel())->setFilter(filter_);
 }
 
 Tellico::FilterPtr DetailedListView::filter() const {
   return static_cast<EntrySortModel*>(sortModel())->filter();
 }
 
 void DetailedListView::addField(Tellico::Data::CollPtr, Tellico::Data::FieldPtr field) {
   sourceModel()->addFields(Data::FieldList() << field);
 }
 
 void DetailedListView::modifyField(Tellico::Data::CollPtr, Tellico::Data::FieldPtr oldField_, Tellico::Data::FieldPtr newField_) {
   Q_UNUSED(oldField_)
   sourceModel()->modifyField(oldField_, newField_);
 }
 
 void DetailedListView::removeField(Tellico::Data::CollPtr, Tellico::Data::FieldPtr field_) {
   sourceModel()->removeFields(Data::FieldList() << field_);
 }
 
 void DetailedListView::reorderFields(const Tellico::Data::FieldList& fields_) {
   QStringList columnNames;
   QList<int> columnWidths, columnOrder;
   for(int ncol = 0; ncol < header()->count(); ++ncol) {
     // ignore hidden columns
     if(!isColumnHidden(ncol)) {
       columnNames << columnFieldName(ncol);
       columnWidths << columnWidth(ncol);
       columnOrder << header()->visualIndex(ncol);
     }
   }
 
   sourceModel()->setFields(fields_);
 
   QList<int> currentColumnOrder;
   // now restore widths and order
   for(int ncol = 0; ncol < header()->count(); ++ncol) {
     int idx = columnNames.indexOf(columnFieldName(ncol));
     // column width of 0 means hidden
     if(idx < 0 || columnWidths.at(idx) <= 0) {
       hideColumn(ncol);
       if(idx > -1) {
         currentColumnOrder << ncol;
       }
     } else {
       setColumnWidth(ncol, columnWidths.at(idx));
       currentColumnOrder << ncol;
     }
   }
   const int maxCount = qMin(currentColumnOrder.size(), columnOrder.size());
   for(int i = 0; i < maxCount; ++i) {
     header()->moveSection(header()->visualIndex(currentColumnOrder.at(i)), columnOrder.at(i));
   }
   updateHeaderMenu();
 }
 
 void DetailedListView::saveConfig(Tellico::Data::CollPtr coll_, int configIndex_) {
   const QString configGroup = QStringLiteral("Options - %1").arg(CollectionFactory::typeName(coll_));
   KConfigGroup config(KSharedConfig::openConfig(), configGroup);
 
   // all of this is to have custom settings on a per file basis
   QString configN;
   if(coll_->type() == Data::Collection::Base) {
     QList<ConfigInfo> info;
     for(int i = 0; i < Config::maxCustomURLSettings(); ++i) {
       QUrl u(config.readEntry(QStringLiteral("URL_%1").arg(i)));
       if(!u.isEmpty() && i != configIndex_) {
         configN = QStringLiteral("_%1").arg(i);
         ConfigInfo ci;
         ci.cols      = config.readEntry(QLatin1String("ColumnNames") + configN, QStringList());
         ci.widths    = config.readEntry(QLatin1String("ColumnWidths") + configN, QList<int>());
         ci.order     = config.readEntry(QLatin1String("ColumnOrder") + configN, QList<int>());
         ci.prevSort  = config.readEntry(QLatin1String("PrevSortColumn") + configN, 0);
         ci.prev2Sort = config.readEntry(QLatin1String("Prev2SortColumn") + configN, 0);
         ci.sortOrder = config.readEntry(QLatin1String("SortOrder") + configN, static_cast<int>(Qt::AscendingOrder));
         info.append(ci);
       }
     }
     // subtract one since we're writing the current settings, too
     int limit = qMin(info.count(), Config::maxCustomURLSettings()-1);
     for(int i = 0; i < limit; ++i) {
       // starts at one since the current config will be written below
       configN = QStringLiteral("_%1").arg(i+1);
       config.writeEntry(QLatin1String("ColumnNames")     + configN, info[i].cols);
       config.writeEntry(QLatin1String("ColumnWidths")    + configN, info[i].widths);
       config.writeEntry(QLatin1String("ColumnOrder")     + configN, info[i].order);
       config.writeEntry(QLatin1String("PrevSortColumn")  + configN, info[i].prevSort);
       config.writeEntry(QLatin1String("Prev2SortColumn") + configN, info[i].prev2Sort);
       config.writeEntry(QLatin1String("SortOrder")       + configN, info[i].sortOrder);
       // legacy entry item
       config.deleteEntry(QLatin1String("ColumnState")    + configN);
     }
     configN = QStringLiteral("_0");
   }
 
   QStringList colNames;
   QList<int> widths, order;
   for(int ncol = 0; ncol < header()->count(); ++ncol) {
     // ignore hidden columns
     if(!isColumnHidden(ncol)) {
       colNames << columnFieldName(ncol);
       widths << columnWidth(ncol);
       order << header()->visualIndex(ncol);
     }
   }
 
   config.writeEntry(QLatin1String("ColumnNames") + configN, colNames);
   config.writeEntry(QLatin1String("ColumnWidths") + configN, widths);
   config.writeEntry(QLatin1String("ColumnOrder") + configN, order);
 
   const int sortCol1 = sortModel()->sortColumn();
   const int sortCol2 = sortModel()->secondarySortColumn();
   const int sortCol3 = sortModel()->tertiarySortColumn();
   const int sortOrder = static_cast<int>(sortModel()->sortOrder());
   config.writeEntry(QLatin1String("SortColumn")      + configN, sortCol1);
   config.writeEntry(QLatin1String("PrevSortColumn")  + configN, sortCol2);
   config.writeEntry(QLatin1String("Prev2SortColumn") + configN, sortCol3);
   config.writeEntry(QLatin1String("SortOrder")       + configN, sortOrder);
   // remove old entry item
   config.deleteEntry(QLatin1String("ColumnState")    + configN);
 }
 
 QString DetailedListView::sortColumnTitle1() const {
   return model()->headerData(header()->sortIndicatorSection(), Qt::Horizontal).toString();
 }
 
 QString DetailedListView::sortColumnTitle2() const {
   return model()->headerData(sortModel()->secondarySortColumn(), Qt::Horizontal).toString();
 }
 
 QString DetailedListView::sortColumnTitle3() const {
   return model()->headerData(sortModel()->tertiarySortColumn(), Qt::Horizontal).toString();
 }
 
 QStringList DetailedListView::visibleColumns() const {
   // we want the visual order, so use a QMap and sort by visualIndex
   QMap<int, QString> titleMap;
   for(int i = 0; i < header()->count(); ++i) {
     if(!isColumnHidden(i)) {
       titleMap.insert(header()->visualIndex(i), model()->headerData(i, Qt::Horizontal).toString());
     }
   }
   return titleMap.values();
 }
 
 // can't be const
 Tellico::Data::EntryList DetailedListView::visibleEntries() {
   // We could just return the full collection entry list if the filter is 0
   // but printing depends on the sorted order
   Data::EntryList entries;
   for(int i = 0; i < model()->rowCount(); ++i) {
     Data::EntryPtr tmp = model()->data(model()->index(i, 0), EntryPtrRole).value<Data::EntryPtr>();
     if(tmp) {
       entries += tmp;
     }
   }
   return entries;
 }
 
 void DetailedListView::selectAllVisible() {
   QModelIndex topLeft = model()->index(0, 0);
   QModelIndex bottomRight = model()->index(model()->rowCount()-1, model()->columnCount()-1);
   QItemSelection selection(topLeft, bottomRight);
   selectionModel()->select(selection, QItemSelectionModel::Select);
 }
 
 int DetailedListView::visibleItems() const {
   return model()->rowCount();
 }
 
 void DetailedListView::resetEntryStatus() {
   sourceModel()->clearSaveState();
 }
 
 void DetailedListView::updateHeaderMenu() {
   // we only want to update the menu when the header count and model count agree
   if(model()->columnCount() != header()->count()) {
     myDebug() << "column counts disagree";
     return;
   }
   m_headerMenu->clear();
   m_headerMenu->addSection(i18n("View Columns"));
 
   m_columnMenu->clear();
 
   for(int ncol = 0; ncol < header()->count(); ++ncol) {
     Data::FieldPtr field = model()->headerData(ncol, Qt::Horizontal, FieldPtrRole).value<Data::FieldPtr>();
     if(field && (field->type() == Data::Field::Table || field->type() == Data::Field::Para)) {
       continue;
     }
     QAction* act = m_columnMenu->addAction(model()->headerData(ncol, Qt::Horizontal).toString());
     act->setData(ncol);
     act->setCheckable(true);
     act->setChecked(!isColumnHidden(ncol));
   }
   QAction* columnAction = m_headerMenu->addMenu(m_columnMenu);
   columnAction->setText(i18nc("Noun, Menu name", "Columns"));
   columnAction->setIcon(QIcon::fromTheme(QStringLiteral("view-file-columns")));
 
   QAction* actHideThis = m_headerMenu->addAction(i18n("Hide This Column"));
-  connect(actHideThis, SIGNAL(triggered(bool)), this, SLOT(hideCurrentColumn()));
+  connect(actHideThis, &QAction::triggered, this, &DetailedListView::hideCurrentColumn);
   QAction* actResize = m_headerMenu->addAction(QIcon::fromTheme(QStringLiteral("zoom-fit-width")), i18n("Resize to Content"));
-  connect(actResize, SIGNAL(triggered(bool)), this, SLOT(resizeColumnsToContents()));
+  connect(actResize, &QAction::triggered, this, &DetailedListView::resizeColumnsToContents);
 
   m_headerMenu->addSeparator();
 
   QAction* actShowAll = m_headerMenu->addAction(i18n("Show All Columns"));
-  connect(actShowAll, SIGNAL(triggered(bool)), this, SLOT(showAllColumns()));
+  connect(actShowAll, &QAction::triggered, this, &DetailedListView::showAllColumns);
   QAction* actHideAll = m_headerMenu->addAction(i18n("Hide All Columns"));
-  connect(actHideAll, SIGNAL(triggered(bool)), this, SLOT(hideAllColumns()));
+  connect(actHideAll, &QAction::triggered, this, &DetailedListView::hideAllColumns);
 }
 
 void DetailedListView::updateColumnDelegates() {
   for(int ncol = 0; ncol < header()->count(); ++ncol) {
     Data::FieldPtr field = model()->headerData(ncol, Qt::Horizontal, FieldPtrRole).value<Data::FieldPtr>();
     if(field && field->type() == Data::Field::Rating) {
       /// if we're not using the overall delegate, delete the delegate since we're setting a new on
       if(itemDelegateForColumn(ncol) != itemDelegate()) {
         delete itemDelegateForColumn(ncol);
       }
       RatingDelegate* delegate = new RatingDelegate(this);
       bool ok; // not used
       delegate->setMaxRating(Tellico::toUInt(field->property(QStringLiteral("maximum")), &ok));
       setItemDelegateForColumn(ncol, delegate);
     } else {
       // reset column delegate to overall delegate
       setItemDelegateForColumn(ncol, itemDelegate());
     }
   }
 }
 
 void DetailedListView::slotRefreshImages() {
   sourceModel()->setImagesAreAvailable(true);
 }
 
 void DetailedListView::adjustColumnWidths() {
   // this function is called when a column is shown
   // reduce all visible columns to their size hint, if they are wider than that
   for(int ncol = 0; ncol < header()->count(); ++ncol) {
     if(!isColumnHidden(ncol)) {
       const int width = sizeHintForColumn(ncol);
       if(columnWidth(ncol) > width) {
         resizeColumnToContents(ncol);
       }
     }
   }
 }
 
 void DetailedListView::resizeColumnsToContents() {
   for(int ncol = 0; ncol < header()->count(); ++ncol) {
     if(!isColumnHidden(ncol)) {
       resizeColumnToContents(ncol);
     }
   }
 }
 
 void DetailedListView::hideNewColumn(const QModelIndex& index_, int start_, int end_) {
   Q_UNUSED(index_);
   for(int ncol = start_; ncol <= end_; ++ncol) {
     hideColumn(ncol);
   }
   updateHeaderMenu(); // make sure to update checkable actions
 }
 
 void DetailedListView::checkHeader() {
   // the header disappears if all columns are hidden, so if the user hides all
   // columns, we turn around and show the title
   //
   // normally, I would expect a check like header()->count() == header()->hiddenSectionCount()
   // to tell me if all sections are hidden, but it often doesn't work, with the hiddenSectionCount()
   // being greater than count()! From testing, if the sizeHint() width is 0, then the header is hidden
   if(!header()->sizeHint().isEmpty()) {
     return;
   }
   // find title action in menu and activate it
   QAction* action = nullptr;
   QAction* fallbackAction = nullptr;
   foreach(QAction* tryAction, m_columnMenu->actions()) {
     const int ncol = tryAction->data().toInt();
     if(ncol > -1 && columnFieldName(ncol) == QLatin1String("title")) {
       action = tryAction;
       break;
     } else if(ncol > -1 && !fallbackAction) {
       fallbackAction = tryAction;
     }
   }
   if(!action) {
     action = fallbackAction;
   }
   if(action) {
     action->setChecked(true);
     const int col = action->data().toInt();
     // calling slotColumnMenuActivated() would be infinite loop
     setColumnHidden(col, false);
     resizeColumnToContents(col);
   } else {
     myDebug() << "found no action to show, still empty header!";
   }
 }
 
 QString DetailedListView::columnFieldName(int ncol_) const {
   Data::FieldPtr field = model()->headerData(ncol_, Qt::Horizontal, FieldPtrRole).value<Data::FieldPtr>();
   return field ? field->name() : QString();
 }
diff --git a/src/document.cpp b/src/document.cpp
index 266fdb51..28052ad1 100644
--- a/src/document.cpp
+++ b/src/document.cpp
@@ -1,855 +1,855 @@
 /***************************************************************************
     Copyright (C) 2001-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "document.h"
 #include "collectionfactory.h"
 #include "translators/tellicoimporter.h"
 #include "translators/tellicozipexporter.h"
 #include "translators/tellicoxmlexporter.h"
 #include "collection.h"
 #include "core/filehandler.h"
 #include "borrower.h"
 #include "fieldformat.h"
 #include "core/tellico_strings.h"
 #include "images/imagefactory.h"
 #include "images/imagedirectory.h"
 #include "images/image.h"
 #include "images/imageinfo.h"
 #include "utils/stringset.h"
 #include "progressmanager.h"
 #include "config/tellico_config.h"
 #include "entrycomparison.h"
 #include "utils/guiproxy.h"
 #include "tellico_debug.h"
 
 #include <KMessageBox>
 #include <KLocalizedString>
 
 #include <QRegExp>
 #include <QTimer>
 #include <QApplication>
 
 #include <unistd.h>
 
 using namespace Tellico;
 using Tellico::Data::Document;
 Document* Document::s_self = nullptr;
 
 Document::Document() : QObject(), m_coll(nullptr), m_isModified(false),
     m_loadAllImages(false), m_validFile(false), m_importer(nullptr), m_cancelImageWriting(true),
     m_fileFormat(Import::TellicoImporter::Unknown) {
   m_allImagesOnDisk = Config::imageLocation() != Config::ImagesInFile;
   newDocument(Collection::Book);
 }
 
 Document::~Document() {
   delete m_importer;
   m_importer = nullptr;
 }
 
 Tellico::Data::CollPtr Document::collection() const {
   return m_coll;
 }
 
 void Document::setURL(const QUrl& url_) {
   m_url = url_;
   if(m_url.fileName() != i18n(Tellico::untitledFilename)) {
     ImageFactory::setLocalDirectory(m_url);
     EntryComparison::setDocumentUrl(m_url);
   }
 }
 
 void Document::setModified(bool modified_) {
   if(modified_ != m_isModified) {
     m_isModified = modified_;
     emit signalModified(m_isModified);
   }
 }
 
 void Document::slotSetModified() {
   setModified(true);
 }
 
 /**
  * Since QUndoStack emits cleanChanged(), the behavior is opposite
  * the document modified flag
  */
 void Document::slotSetClean(bool clean_) {
   setModified(!clean_);
 }
 
 bool Document::newDocument(int type_) {
   if(m_importer) {
     m_importer->deleteLater();
     m_importer = nullptr;
   }
   deleteContents();
 
   m_coll = CollectionFactory::collection(type_, true);
   m_coll->setTrackGroups(true);
 
   emit signalCollectionAdded(m_coll);
   emit signalCollectionImagesLoaded(m_coll);
 
   setModified(false);
   QUrl url = QUrl::fromLocalFile(i18n(Tellico::untitledFilename));
   setURL(url);
   m_validFile = false;
   m_fileFormat = Import::TellicoImporter::Unknown;
 
   return true;
 }
 
 bool Document::openDocument(const QUrl& url_) {
   MARK;
   m_loadAllImages = false;
   // delayed image loading only works for local files
   if(!url_.isLocalFile()) {
     m_loadAllImages = true;
   }
 
   if(m_importer) {
     m_importer->deleteLater();
   }
   m_importer = new Import::TellicoImporter(url_, m_loadAllImages);
 
   ProgressItem& item = ProgressManager::self()->newProgressItem(m_importer, m_importer->progressLabel(), true);
   connect(m_importer, &Import::Importer::signalTotalSteps,
           ProgressManager::self(), &ProgressManager::setTotalSteps);
   connect(m_importer, &Import::Importer::signalProgress,
           ProgressManager::self(), &ProgressManager::setProgress);
   connect(&item, &ProgressItem::signalCancelled, m_importer, &Import::Importer::slotCancel);
   ProgressItem::Done done(m_importer);
 
   CollPtr coll = m_importer->collection();
   if(!m_importer) {
     myDebug() << "The importer was deleted out from under us";
     return false;
   }
   // delayed image loading only works for zip files
   // format is only known AFTER collection() is called
 
   m_fileFormat = m_importer->format();
   m_allImagesOnDisk = !m_importer->hasImages();
   if(!m_importer->hasImages() || m_fileFormat != Import::TellicoImporter::Zip) {
     m_loadAllImages = true;
   }
   ImageFactory::setZipArchive(m_importer->takeImages());
 
   if(!coll) {
 //    myDebug() << "returning false";
     GUI::Proxy::sorry(m_importer->statusMessage());
     m_validFile = false;
     return false;
   }
   deleteContents();
   m_coll = coll;
   m_coll->setTrackGroups(true);
   setURL(url_);
   m_validFile = true;
 
   emit signalCollectionAdded(m_coll);
 
   // m_importer might have been deleted?
   setModified(m_importer && m_importer->modifiedOriginal());
 //  if(pruneImages()) {
 //    slotSetModified(true);
 //  }
   if(m_importer && m_importer->hasImages()) {
     m_cancelImageWriting = false;
-    QTimer::singleShot(500, this, SLOT(slotLoadAllImages()));
+    QTimer::singleShot(500, this, &Document::slotLoadAllImages);
   } else {
     emit signalCollectionImagesLoaded(m_coll);
     if(m_importer) {
       m_importer->deleteLater();
       m_importer = nullptr;
     }
   }
   return true;
 }
 
 bool Document::saveDocument(const QUrl& url_, bool force_) {
   // FileHandler::queryExists calls FileHandler::writeBackupFile
   // so the only reason to check queryExists() is if the url to write to is different than the current one
   if(url_ == m_url) {
     if(!FileHandler::writeBackupFile(url_)) {
       return false;
     }
   } else {
     if(!force_ && !FileHandler::queryExists(url_)) {
       return false;
     }
   }
 
   // in case we're still loading images, give that a chance to cancel
   m_cancelImageWriting = true;
   qApp->processEvents();
 
   ProgressItem& item = ProgressManager::self()->newProgressItem(this, i18n("Saving file..."), false);
   ProgressItem::Done done(this);
 
   // will always save as zip file, no matter if has images or not
   int imageLocation = Config::imageLocation();
   bool includeImages = imageLocation == Config::ImagesInFile;
   int totalSteps;
   // write all images to disk cache if needed
   // have to do this before executing exporter in case
   // the user changed the imageInFile setting from Yes to No, in which
   // case saving will overwrite the old file that has the images in it!
   if(includeImages) {
     totalSteps = 10;
     item.setTotalSteps(totalSteps);
     // since TellicoZipExporter uses 100 steps, then it will get 100/110 of the total progress
   } else {
     totalSteps = 100;
     item.setTotalSteps(totalSteps);
     m_cancelImageWriting = false;
     writeAllImages(imageLocation == Config::ImagesInAppDir ? ImageFactory::DataDir : ImageFactory::LocalDir, url_);
   }
   QScopedPointer<Export::Exporter> exporter;
   if(m_fileFormat == Import::TellicoImporter::XML) {
     exporter.reset(new Export::TellicoXMLExporter(m_coll));
     static_cast<Export::TellicoXMLExporter*>(exporter.data())->setIncludeImages(includeImages);
   } else {
     exporter.reset(new Export::TellicoZipExporter(m_coll));
     static_cast<Export::TellicoZipExporter*>(exporter.data())->setIncludeImages(includeImages);
   }
   item.setProgress(int(0.8*totalSteps));
   exporter->setEntries(m_coll->entries());
   exporter->setURL(url_);
   // since we already asked about overwriting the file, force the save
   long opt = exporter->options() | Export::ExportForce | Export::ExportComplete | Export::ExportProgress;
   // only write the image sizes if they're known already
   opt &= ~Export::ExportImageSize;
   exporter->setOptions(opt);
   const bool success = exporter->exec();
   item.setProgress(int(0.9*totalSteps));
 
   if(success) {
     setURL(url_);
     // if successful, doc is no longer modified
     setModified(false);
   } else {
     myDebug() << "Document::saveDocument() - not successful saving to" << url_.url();
   }
   return success;
 }
 
 bool Document::closeDocument() {
   if(m_importer) {
     m_importer->deleteLater();
     m_importer = nullptr;
   }
   deleteContents();
   return true;
 }
 
 void Document::deleteContents() {
   if(m_coll) {
     emit signalCollectionDeleted(m_coll);
   }
   // don't delete the m_importer here, bad things will happen
 
   // since the collection holds a pointer to each entry and each entry
   // hold a pointer to the collection, and they're both sharedptrs,
   // neither will ever get deleted, unless the entries are removed from the collection
   if(m_coll) {
     m_coll->clear();
   }
   m_coll = nullptr; // old collection gets deleted as refcount goes to 0
   m_cancelImageWriting = true;
 }
 
 void Document::appendCollection(Tellico::Data::CollPtr coll_) {
   appendCollection(m_coll, coll_);
 }
 
 void Document::appendCollection(Tellico::Data::CollPtr coll1_, Tellico::Data::CollPtr coll2_) {
   if(!coll1_ || !coll2_) {
     return;
   }
 
   coll1_->blockSignals(true);
 
   foreach(FieldPtr field, coll2_->fields()) {
     coll1_->mergeField(field);
   }
 
   Data::EntryList newEntries;
   foreach(EntryPtr entry, coll2_->entries()) {
     Data::EntryPtr newEntry(new Data::Entry(*entry));
     newEntry->setCollection(coll1_);
     newEntries << newEntry;
   }
   coll1_->addEntries(newEntries);
   // TODO: merge filters and loans
   coll1_->blockSignals(false);
 }
 
 Tellico::Data::MergePair Document::mergeCollection(Tellico::Data::CollPtr coll_) {
   return mergeCollection(m_coll, coll_);
 }
 
 Tellico::Data::MergePair Document::mergeCollection(Tellico::Data::CollPtr coll1_, Tellico::Data::CollPtr coll2_) {
   MergePair pair;
   if(!coll1_ || !coll2_) {
     return pair;
   }
 
   coll1_->blockSignals(true);
   Data::FieldList fields = coll2_->fields();
   foreach(FieldPtr field, fields) {
     coll1_->mergeField(field);
   }
 
   EntryList currEntries = coll1_->entries();
   EntryList newEntries = coll2_->entries();
   std::sort(currEntries.begin(), currEntries.end(), Data::EntryCmp(QStringLiteral("title")));
   std::sort(newEntries.begin(), newEntries.end(), Data::EntryCmp(QStringLiteral("title")));
 
   const int currTotal = currEntries.count();
   int lastMatchId = 0;
   bool checkSameId = false; // if the matching entries have the same id, then check that first for later comparisons
   foreach(EntryPtr newEntry, newEntries) {
     int bestMatch = 0;
     Data::EntryPtr matchEntry, currEntry;
     // first, if we're checking against same ID
     if(checkSameId) {
       currEntry = coll1_->entryById(newEntry->id());
       if(currEntry && coll1_->sameEntry(currEntry, newEntry) >= EntryComparison::ENTRY_PERFECT_MATCH) {
         // only have to compare against perfect match
         matchEntry = currEntry;
       }
     }
     if(!matchEntry) {
       // alternative is to loop over them all
       for(int i = 0; i < currTotal; ++i) {
         // since we're sorted by title, track the index of the previous match and start comparison there
         currEntry = currEntries.at((i+lastMatchId) % currTotal);
         const int match = coll1_->sameEntry(currEntry, newEntry);
         if(match >= EntryComparison::ENTRY_PERFECT_MATCH) {
           matchEntry = currEntry;
           lastMatchId = (i+lastMatchId) % currTotal;
           break;
         } else if(match >= EntryComparison::ENTRY_GOOD_MATCH && match > bestMatch) {
           bestMatch = match;
           matchEntry = currEntry;
           lastMatchId = (i+lastMatchId) % currTotal;
           // don't break, keep looking for better one
         }
       }
     }
     if(matchEntry) {
       checkSameId = checkSameId || (matchEntry->id() == newEntry->id());
       mergeEntry(matchEntry, newEntry);
     } else {
       Data::EntryPtr e(new Data::Entry(*newEntry));
       e->setCollection(coll1_);
       // keep track of which entries got added
       pair.first.append(e);
     }
   }
   coll1_->addEntries(pair.first);
   // TODO: merge filters and loans
   coll1_->blockSignals(false);
   return pair;
 }
 
 void Document::replaceCollection(Tellico::Data::CollPtr coll_) {
   if(!coll_) {
     return;
   }
 
   QUrl url = QUrl::fromLocalFile(i18n(Tellico::untitledFilename));
   setURL(url);
   m_validFile = false;
 
   // the collection gets cleared by the CollectionCommand that called this function
   // no need to do it here
 
   m_coll = coll_;
   m_coll->setTrackGroups(true);
   m_cancelImageWriting = true;
   // CollectionCommand takes care of calling Controller signals
 }
 
 void Document::unAppendCollection(Tellico::Data::CollPtr coll_, Tellico::Data::FieldList origFields_) {
   if(!coll_) {
     return;
   }
 
   m_coll->blockSignals(true);
 
   StringSet origFieldNames;
   foreach(FieldPtr field, origFields_) {
     m_coll->modifyField(field);
     origFieldNames.add(field->name());
   }
 
   EntryList entries = coll_->entries();
   foreach(EntryPtr entry, entries) {
     // probably don't need to do this, but on the safe side...
     entry->setCollection(coll_);
   }
   m_coll->removeEntries(entries);
 
   // since Collection::removeField() iterates over all entries to reset the value of the field
   // don't removeField() until after removeEntry() is done
   FieldList currFields = m_coll->fields();
   foreach(FieldPtr field, currFields) {
     if(!origFieldNames.has(field->name())) {
       m_coll->removeField(field);
     }
   }
   m_coll->blockSignals(false);
 }
 
 void Document::unMergeCollection(Tellico::Data::CollPtr coll_, Tellico::Data::FieldList origFields_, Tellico::Data::MergePair entryPair_) {
   if(!coll_) {
     return;
   }
 
   m_coll->blockSignals(true);
 
   QStringList origFieldNames;
   foreach(FieldPtr field, origFields_) {
     m_coll->modifyField(field);
     origFieldNames << field->name();
   }
 
   // first item in pair are the entries added by the operation, remove them
   EntryList entries = entryPair_.first;
   m_coll->removeEntries(entries);
 
   // second item in pair are the entries which got modified by the original merge command
   const QString track = QStringLiteral("track");
   PairVector trackChanges = entryPair_.second;
   // need to go through them in reverse since one entry may have been modified multiple times
   // first item in the pair is the entry pointer
   // second item is the old value of the track field
   for(int i = trackChanges.count()-1; i >= 0; --i) {
     trackChanges[i].first->setField(track, trackChanges[i].second);
   }
 
   // since Collection::removeField() iterates over all entries to reset the value of the field
   // don't removeField() until after removeEntry() is done
   FieldList currFields = m_coll->fields();
   foreach(FieldPtr field, currFields) {
     if(origFieldNames.indexOf(field->name()) == -1) {
       m_coll->removeField(field);
     }
   }
   m_coll->blockSignals(false);
 }
 
 bool Document::isEmpty() const {
   //an empty doc may contain a collection, but no entries
   return (!m_coll || m_coll->entries().isEmpty());
 }
 
 bool Document::loadAllImagesNow() const {
 //  DEBUG_LINE;
   if(!m_coll || !m_validFile) {
     return false;
   }
   if(m_loadAllImages) {
     myDebug() << "Document::loadAllImagesNow() - all valid images should already be loaded!";
     return false;
   }
   return Import::TellicoImporter::loadAllImages(m_url);
 }
 
 Tellico::Data::EntryList Document::filteredEntries(Tellico::FilterPtr filter_) const {
   Data::EntryList matches;
   Data::EntryList entries = m_coll->entries();
   foreach(EntryPtr entry, entries) {
     if(filter_->matches(entry)) {
       matches.append(entry);
     }
   }
   return matches;
 }
 
 void Document::checkOutEntry(Tellico::Data::EntryPtr entry_) {
   if(!entry_) {
     return;
   }
 
   const QString loaned = QStringLiteral("loaned");
   if(!m_coll->hasField(loaned)) {
     FieldPtr f(new Field(loaned, i18n("Loaned"), Field::Bool));
     f->setFlags(Field::AllowGrouped);
     f->setCategory(i18n("Personal"));
     m_coll->addField(f);
   }
   entry_->setField(loaned, QStringLiteral("true"));
   EntryList vec;
   vec.append(entry_);
   m_coll->updateDicts(vec, QStringList() << loaned);
 }
 
 void Document::checkInEntry(Tellico::Data::EntryPtr entry_) {
   if(!entry_) {
     return;
   }
 
   const QString loaned = QStringLiteral("loaned");
   if(!m_coll->hasField(loaned)) {
     return;
   }
   entry_->setField(loaned, QString());
   m_coll->updateDicts(EntryList() << entry_, QStringList() << loaned);
 }
 
 void Document::renameCollection(const QString& newTitle_) {
   m_coll->setTitle(newTitle_);
 }
 
 // this only gets called when a zip file with images is opened
 // by loading every image, it gets pulled out of the zip file and
 // copied to disk. Then the zip file can be closed and not retained in memory
 void Document::slotLoadAllImages() {
   QString id;
   StringSet images;
   foreach(EntryPtr entry, m_coll->entries()) {
     foreach(FieldPtr field, m_coll->imageFields()) {
       id = entry->field(field);
       if(id.isEmpty() || images.has(id)) {
         continue;
       }
       // this is the early loading, so just by calling imageById()
       // the image gets sucked from the zip file and written to disk
       // by ImageFactory::imageById()
       // TODO:: does this need to check against images with link only?
       if(ImageFactory::imageById(id).isNull()) {
         myDebug() << "Null image for entry:" << entry->title() << id;
       }
       images.add(id);
       if(m_cancelImageWriting) {
         break;
       }
     }
     if(m_cancelImageWriting) {
       break;
     }
     // stay responsive, do this in the background
     qApp->processEvents();
   }
 
   if(m_cancelImageWriting) {
     myLog() << "slotLoadAllImages() - cancel image writing";
   } else {
     emit signalCollectionImagesLoaded(m_coll);
   }
 
   m_cancelImageWriting = false;
   if(m_importer) {
     m_importer->deleteLater();
     m_importer = nullptr;
   }
 }
 
 // cacheDir_ is the location dir to write the images
 // localDir_ provide the new file location which is only needed if cacheDir == LocalDir
 void Document::writeAllImages(int cacheDir_, const QUrl& localDir_) {
   // images get 80 steps in saveDocument()
   const uint stepSize = 1 + qMax(1, m_coll->entryCount()/80); // add 1 since it could round off
   uint j = 1;
 
   ImageFactory::CacheDir cacheDir = static_cast<ImageFactory::CacheDir>(cacheDir_);
   QScopedPointer<ImageDirectory> imgDir;
   if(cacheDir == ImageFactory::LocalDir) {
     imgDir.reset(new ImageDirectory(ImageFactory::localDirectory(localDir_)));
   }
 
   QString id;
   StringSet images;
   EntryList entries = m_coll->entries();
   FieldList imageFields = m_coll->imageFields();
   foreach(EntryPtr entry, entries) {
     foreach(FieldPtr field, imageFields) {
       id = entry->field(field);
       if(id.isEmpty() || images.has(id)) {
         continue;
       }
       images.add(id);
       if(ImageFactory::imageInfo(id).linkOnly) {
         continue;
       }
       // careful here, if we're writing to LocalDir, need to read from the old LocalDir and write to new
       bool success;
       if(cacheDir == ImageFactory::LocalDir) {
         success = ImageFactory::writeCachedImage(id, imgDir.data());
       } else {
         success = ImageFactory::writeCachedImage(id, cacheDir);
       }
       if(!success) {
         myDebug() << "did not write image for entry title:" << entry->title();
       }
       if(m_cancelImageWriting) {
         break;
       }
     }
     if(j%stepSize == 0) {
       ProgressManager::self()->setProgress(this, j/stepSize);
       qApp->processEvents();
     }
     ++j;
     if(m_cancelImageWriting) {
       break;
     }
   }
 
   if(m_cancelImageWriting) {
     myDebug() << "Document::writeAllImages() - cancel image writing";
   }
 
   m_cancelImageWriting = false;
 }
 
 bool Document::pruneImages() {
   bool found = false;
   QString id;
   StringSet images;
   Data::EntryList entries = m_coll->entries();
   Data::FieldList imageFields = m_coll->imageFields();
   foreach(EntryPtr entry, entries) {
     foreach(FieldPtr field, imageFields) {
       id = entry->field(field);
       if(id.isEmpty() || images.has(id)) {
         continue;
       }
       const Data::Image& img = ImageFactory::imageById(id);
       if(img.isNull()) {
         entry->setField(field, QString());
         found = true;
         myDebug() << "removing null image for" << entry->title() << ":" << id;
       } else {
         images.add(id);
       }
     }
   }
   return found;
 }
 
 int Document::imageCount() const {
   if(!m_coll) {
     return 0;
   }
   StringSet images;
   FieldList fields = m_coll->imageFields();
   EntryList entries = m_coll->entries();
   foreach(FieldPtr field, fields) {
     foreach(EntryPtr entry, entries) {
       images.add(entry->field(field->name()));
     }
   }
   return images.count();
 }
 
 void Document::removeImagesNotInCollection(Tellico::Data::EntryList entries_, Tellico::Data::EntryList entriesToKeep_) {
   // first get list of all images in collection
   StringSet images;
   FieldList fields = m_coll->imageFields();
   EntryList allEntries = m_coll->entries();
   foreach(FieldPtr field, fields) {
     foreach(EntryPtr entry, allEntries) {
       images.add(entry->field(field->name()));
     }
     foreach(EntryPtr entry, entriesToKeep_) {
       images.add(entry->field(field->name()));
     }
   }
 
   // now for all images not in the cache, we can clear them
   StringSet imagesToCheck = ImageFactory::imagesNotInCache();
 
   // if entries_ is not empty, that means we want to limit the images removed
   // to those that are referenced in those entries
   StringSet imagesToRemove;
   foreach(FieldPtr field, fields) {
     foreach(EntryPtr entry, entries_) {
       QString id = entry->field(field->name());
       if(!id.isEmpty() && imagesToCheck.has(id) && !images.has(id)) {
         imagesToRemove.add(id);
       }
     }
   }
 
   const QStringList realImagesToRemove = imagesToRemove.toList();
   for(QStringList::ConstIterator it = realImagesToRemove.begin(); it != realImagesToRemove.end(); ++it) {
     ImageFactory::removeImage(*it, false); // doesn't delete, just remove link
   }
 }
 
 bool Document::mergeEntry(Data::EntryPtr e1, Data::EntryPtr e2, MergeConflictResolver* resolver_) {
   if(!e1 || !e2) {
     myDebug() << "bad entry pointer";
     return false;
   }
   bool ret = true;
   foreach(FieldPtr field, e1->collection()->fields()) {
     if(e2->field(field).isEmpty()) {
       continue;
     }
     // never try to merge entry id, creation date or mod date. Those are unique to each entry
     if(field->name() == QLatin1String("id") ||
        field->name() == QLatin1String("cdate") ||
        field->name() == QLatin1String("mdate")) {
       continue;
     }
 //    myLog() << "reading field: " << field->name();
     if(e1->field(field) == e2->field(field)) {
       continue;
     } else if(e1->field(field).isEmpty()) {
 //      myLog() << e1->title() << ": updating field(" << field->name() << ") to " << e2->field(field);
       e1->setField(field, e2->field(field));
       ret = true;
     } else if(field->type() == Data::Field::Table) {
       // if field F is a table-type field (album tracks, files, etc.), merge rows (keep their position)
       // if e1's F val in [row i, column j] empty, replace with e2's val at same position
       // if different (non-empty) vals at same position, CONFLICT!
       QStringList vals1 = FieldFormat::splitTable(e1->field(field));
       QStringList vals2 = FieldFormat::splitTable(e2->field(field));
       while(vals1.count() < vals2.count()) {
         vals1 += QString();
       }
       for(int i = 0; i < vals2.count(); ++i) {
         if(vals2[i].isEmpty()) {
           continue;
         }
         if(vals1[i].isEmpty()) {
           vals1[i] = vals2[i];
           ret = true;
         } else {
           QStringList parts1 = FieldFormat::splitRow(vals1[i]);
           QStringList parts2 = FieldFormat::splitRow(vals2[i]);
           bool changedPart = false;
           while(parts1.count() < parts2.count()) {
             parts1 += QString();
           }
           for(int j = 0; j < parts2.count(); ++j) {
             if(parts2[j].isEmpty()) {
               continue;
             }
             if(parts1[j].isEmpty()) {
               parts1[j] = parts2[j];
               changedPart = true;
             } else if(resolver_ && parts1[j] != parts2[j]) {
               int resolverResponse = resolver_->resolve(e1, e2, field, parts1[j], parts2[j]);
               if(resolverResponse == MergeConflictResolver::CancelMerge) {
                 ret = false;
                 return false; // cancel all the merge right now
               } else if(resolverResponse == MergeConflictResolver::KeepSecond) {
                 parts1[j] = parts2[j];
                 changedPart = true;
               }
             }
           }
           if(changedPart) {
             vals1[i] = parts1.join(FieldFormat::columnDelimiterString());
             ret = true;
           }
         }
       }
       if(ret) {
         e1->setField(field, vals1.join(FieldFormat::rowDelimiterString()));
       }
 // remove the merging due to user comments
 // maybe in the future have a more intelligent way
 #if 0
     } else if(field->hasFlag(Data::Field::AllowMultiple)) {
       // if field F allows multiple values and not a Table (see above case),
       // e1's F values = (e1's F values) U (e2's F values) (union)
       // replace e1's field with union of e1's and e2's values for this field
       QStringList items1 = e1->fields(field, false);
       QStringList items2 = e2->fields(field, false);
       foreach(const QString& item2, items2) {
         // possible to have one value formatted and the other one not...
         if(!items1.contains(item2) && !items1.contains(Field::format(item2, field->formatType()))) {
           items1.append(item2);
         }
       }
 // not sure if I think it should be sorted or not
 //      items1.sort();
       e1->setField(field, items1.join(FieldFormat::delimiterString()));
       ret = true;
 #endif
     } else if(resolver_) {
       const int resolverResponse = resolver_->resolve(e1, e2, field);
       if(resolverResponse == MergeConflictResolver::CancelMerge) {
         ret = false; // we got cancelled
         return false; // cancel all the merge right now
       } else if(resolverResponse == MergeConflictResolver::KeepSecond) {
         e1->setField(field, e2->field(field));
       }
     } else {
 //      myDebug() << "Keeping value of" << field->name() << "for" << e1->field(QStringLiteral("title"));
     }
   }
   return ret;
 }
 
 //static
 QPair<Tellico::Data::FieldList, Tellico::Data::FieldList> Document::mergeFields(Data::CollPtr coll_,
                                                                                 Data::FieldList fields_,
                                                                                 Data::EntryList entries_) {
   Data::FieldList modified, created;
   foreach(Data::FieldPtr field, fields_) {
     // don't add a field if it's a default field and not in the current collection
     if(coll_->hasField(field->name()) || CollectionFactory::isDefaultField(coll_->type(), field->name())) {
       // special case for choice fields, since we might want to add a value
       if(field->type() == Data::Field::Choice && coll_->hasField(field->name())) {
         // a2 are the existing fields in the collection, keep them in the same order
         QStringList a1 = coll_->fieldByName(field->name())->allowed();
         foreach(const QString& newAllowedValue, field->allowed()) {
           if(!a1.contains(newAllowedValue)) {
             // could be slow for large merges, but we do only want to add new value
             // IF that value is actually used by an entry
             foreach(Data::EntryPtr entry, entries_) {
               if(entry->field(field->name()) == newAllowedValue) {
                 a1 += newAllowedValue;
                 break;
               }
             }
           }
         }
         if(a1.count() != coll_->fieldByName(field->name())->allowed().count()) {
           Data::FieldPtr f(new Data::Field(*coll_->fieldByName(field->name())));
           f->setAllowed(a1);
           modified.append(f);
         }
       }
       continue;
     }
     // add field if any values are not empty
     foreach(Data::EntryPtr entry, entries_) {
       if(!entry->field(field).isEmpty()) {
         created.append(Data::FieldPtr(new Data::Field(*field)));
         break;
       }
     }
   }
   return qMakePair(modified, created);
 }
diff --git a/src/entryeditdialog.cpp b/src/entryeditdialog.cpp
index f02238fe..b516133d 100644
--- a/src/entryeditdialog.cpp
+++ b/src/entryeditdialog.cpp
@@ -1,791 +1,791 @@
 /***************************************************************************
     Copyright (C) 2001-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "entryeditdialog.h"
 #include "gui/tabwidget.h"
 #include "collection.h"
 #include "controller.h"
 #include "field.h"
 #include "entry.h"
 #include "fieldformat.h"
 #include "tellico_kernel.h"
 #include "utils/cursorsaver.h"
 #include "tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KAcceleratorManager>
 #include <KSharedConfig>
 #include <KWindowConfig>
 #include <KHelpClient>
 
 #include <QStringList>
 #include <QObject>
 #include <QStyle>
 #include <QApplication>
 #include <QGridLayout>
 #include <QCloseEvent>
 #include <QVBoxLayout>
 #include <QPushButton>
 #include <QDialogButtonBox>
 #include <QTimer>
 
 namespace {
   // must be an even number
   static const int NCOLS = 2; // number of columns of GUI::FieldWidgets
   static const char* dialogOptionsString = "Edit Dialog Options";
 }
 
 using Tellico::EntryEditDialog;
 
 EntryEditDialog::EntryEditDialog(QWidget* parent_)
     : QDialog(parent_),
       m_tabs(new GUI::TabWidget(this)),
       m_modified(false),
       m_isOrphan(false),
       m_isWorking(false),
       m_needReset(false) {
   setWindowTitle(i18n("Edit Entry"));
 
   QVBoxLayout* mainLayout = new QVBoxLayout();
   setLayout(mainLayout);
   mainLayout->addWidget(m_tabs);
 
   QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Help|
                                                      QDialogButtonBox::Close|
                                                      QDialogButtonBox::Apply);
-  connect(buttonBox, SIGNAL(helpRequested()), this, SLOT(slotHelp()));
+  connect(buttonBox, &QDialogButtonBox::helpRequested, this, &EntryEditDialog::slotHelp);
   mainLayout->addWidget(buttonBox);
 
   m_newButton = new QPushButton();
   buttonBox->addButton(m_newButton, QDialogButtonBox::ActionRole);
   m_newButton->setDefault(true);
   KGuiItem::assign(m_newButton, KGuiItem(i18n("&New Entry")));
 
   m_saveButton = buttonBox->button(QDialogButtonBox::Apply);
   m_saveButton->setEnabled(false);
   KGuiItem save = KStandardGuiItem::save();
   save.setText(i18n("Sa&ve Entry"));
   KGuiItem::assign(m_saveButton, save);
 
-  connect(buttonBox->button(QDialogButtonBox::Close), SIGNAL(clicked()), SLOT(slotClose()));
-  connect(m_saveButton, SIGNAL(clicked()), SLOT(slotHandleSave()));
-  connect(m_newButton, SIGNAL(clicked()), SLOT(slotHandleNew()));
+  connect(buttonBox->button(QDialogButtonBox::Close), &QAbstractButton::clicked, this, &EntryEditDialog::slotClose);
+  connect(m_saveButton, &QAbstractButton::clicked, this, &EntryEditDialog::slotHandleSave);
+  connect(m_newButton, &QAbstractButton::clicked, this, &EntryEditDialog::slotHandleNew);
 }
 
 EntryEditDialog::~EntryEditDialog() {
 }
 
 void EntryEditDialog::reject() {
   slotClose();
 }
 
 void EntryEditDialog::slotHelp() {
   KHelpClient::invokeHelp(QStringLiteral("entry-editor"));
 }
 
 void EntryEditDialog::slotClose() {
   // check to see if an entry should be saved before hiding
   // block signals so the entry view and selection isn't cleared
   if(m_modified && queryModified()) {
     accept();
     // make sure to reset values in the dialog
     m_needReset = true;
     setContents(m_currEntries);
     slotSetModified(false);
   } else if(!m_modified) {
     accept();
   }
 }
 
 void EntryEditDialog::slotReset() {
   if(m_isWorking) {
     return;
   }
 
   slotSetModified(false);
   m_saveButton->setEnabled(false);
   m_saveButton->setText(i18n("Sa&ve Entry"));
   m_currColl = nullptr;
   m_currEntries.clear();
 
   while(m_tabs->count() > 0) {
     QWidget* widget = m_tabs->widget(0);
     m_tabs->removeTab(0);
     delete widget;
   }
   m_widgetDict.clear();
 }
 
 void EntryEditDialog::resetLayout(Tellico::Data::CollPtr coll_) {
   if(!coll_ || m_isWorking) {
     return;
   }
 
   m_newButton->setIcon(QIcon(QLatin1String(":/icons/") + Kernel::self()->collectionTypeName()));
 
   setUpdatesEnabled(false);
   if(m_tabs->count() > 0) {
 //    myDebug() << "resetting contents.";
     slotReset();
   }
   m_isWorking = true;
 
   m_currColl = coll_;
 
   int maxHeight = 0;
   QList<QWidget*> gridList;
   bool noChoices = true;
 
   bool focusedFirst = false;
   QStringList catList = m_currColl->fieldCategories();
   for(QStringList::ConstIterator catIt = catList.constBegin(); catIt != catList.constEnd(); ++catIt) {
     Data::FieldList allCategoryfields = m_currColl->fieldsByCategory(*catIt);
     Data::FieldList fields;
     // remove fields which we don't plan to show
     foreach(Data::FieldPtr field, allCategoryfields) {
       // uneditabled and fields with derived values don't get widgets
       if(field->hasFlag(Data::Field::NoEdit) ||
          field->hasFlag(Data::Field::Derived)) {
         continue;
       }
       fields << field;
     }
 
     if(fields.isEmpty()) { // sanity check
       continue;
     }
 
     // if this layout model is changed, be sure to check slotUpdateField()
     QWidget* page = new QWidget(m_tabs);
     QBoxLayout* boxLayout = new QVBoxLayout(page);
 
     QWidget* grid = new QWidget(page);
     gridList.append(grid);
     // spacing gets a bit weird, if there are absolutely no Choice fields,
     // then spacing should be 5, which is set later
     QGridLayout* layout = new QGridLayout(grid);
 
     boxLayout->addWidget(grid, 0);
     // those with multiple, get a stretch
     if(fields.count() > 1 || !fields[0]->isSingleCategory()) {
       boxLayout->addStretch(1);
     }
 
     // keep track of which should expand
     QVector<bool> expands(NCOLS, false);
     QVector<int> maxWidth(NCOLS, 0);
 
     int count = 0;
     foreach(Data::FieldPtr field, fields) {
       if(field->type() == Data::Field::Choice) {
         noChoices = false;
       }
 
       GUI::FieldWidget* widget = GUI::FieldWidget::create(field, grid);
       if(!widget) {
         continue;
       }
       widget->insertDefault();
-      connect(widget, SIGNAL(valueChanged(Tellico::Data::FieldPtr)), SLOT(fieldValueChanged(Tellico::Data::FieldPtr)));
+      connect(widget, &GUI::FieldWidget::valueChanged, this, &EntryEditDialog::fieldValueChanged);
       if(!focusedFirst && widget->focusPolicy() != Qt::NoFocus) {
         widget->setFocus();
         focusedFirst = true;
       }
 
       int r = count/NCOLS;
       int c = count%NCOLS;
       layout->addWidget(widget, r, c);
       layout->setRowStretch(r, 1);
 
       m_widgetDict.insert(QString::number(m_currColl->id()) + field->name(), widget);
 
       maxWidth[count%NCOLS] = qMax(maxWidth[count%NCOLS], widget->labelWidth());
       if(widget->expands()) {
         expands[count%NCOLS] = true;
       }
       widget->updateGeometry();
       if(!field->isSingleCategory()) {
         maxHeight = qMax(maxHeight, widget->minimumSizeHint().height());
       }
       ++count;
     }
 
     // now, the labels in a column should all be the same width
     count = 0;
     foreach(Data::FieldPtr field, fields) {
       GUI::FieldWidget* widget = m_widgetDict.value(QString::number(m_currColl->id()) + field->name());
       if(widget) {
         widget->setLabelWidth(maxWidth[count%NCOLS]);
         ++count;
       }
     }
 
     // update stretch factors for columns with a line edit
     for(int col = 0; col < NCOLS; ++col) {
       if(expands[col]) {
         layout->setColumnStretch(col, 1);
       }
     }
 
     m_tabs->addTab(page, *catIt);
   }
 
   // Now, go through and set all the field widgets to the same height
   foreach(QWidget* grid, gridList) {
     QGridLayout* l = static_cast<QGridLayout*>(grid->layout());
     if(noChoices) {
       l->setSpacing(5);
     }
     for(int row = 0; row < l->rowCount() && grid->children().count() > 1; ++row) {
       l->setRowMinimumHeight(row, maxHeight);
     }
     // I don't want anything to be hidden, Keramik has a bug if I don't do this
     grid->setMinimumHeight(grid->sizeHint().height());
     // the parent of the grid is the page that got added to the tabs
     grid->parentWidget()->layout()->invalidate();
     grid->parentWidget()->setMinimumHeight(grid->parentWidget()->sizeHint().height());
 
     // also, no accels for the field widgets
     KAcceleratorManager::setNoAccel(grid);
   }
 
   setUpdatesEnabled(true);
 // this doesn't seem to work
 //  setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Minimum);
 // so do this instead
 //  layout()->invalidate(); // needed so the sizeHint() gets recalculated
   m_tabs->setMinimumHeight(m_tabs->minimumSizeHint().height());
   m_tabs->setMinimumWidth(m_tabs->sizeHint().width());
 
   m_tabs->setCurrentIndex(0);
 
   m_isWorking = false;
   slotHandleNew();
 }
 
 void EntryEditDialog::slotHandleNew() {
   if(!m_currColl || !queryModified()) {
     return;
   }
 
   m_tabs->setCurrentIndex(0);
   m_tabs->setFocusToFirstChild();
   clear();
   m_isWorking = true; // clear() will get called again
   if(!signalsBlocked()) {
     Controller::self()->slotClearSelection();
   }
   m_isWorking = false;
 
   Data::EntryPtr entry(new Data::Entry(m_currColl));
   m_currEntries.append(entry);
   m_isOrphan = true;
 }
 
 void EntryEditDialog::slotHandleSave() {
   if(!m_currColl || m_isWorking) {
     return;
   }
 
   m_isWorking = true;
 
   if(m_currEntries.isEmpty()) {
     myDebug() << "creating new entry";
     m_currEntries.append(Data::EntryPtr(new Data::Entry(m_currColl)));
     m_isOrphan = true;
   }
 
   // add a message box if multiple items are selected
   if(m_currEntries.count() > 1) {
     QStringList names;
     foreach(Data::EntryPtr entry, m_currEntries) {
       names += entry->title();
     }
     QString str(i18n("Do you really want to modify these entries?"));
     QString dontAsk = QStringLiteral("SaveMultipleBooks"); // don't change 'books', invisible anyway
     int ret = KMessageBox::questionYesNoList(this, str, names, i18n("Modify Multiple Entries"),
                                              KStandardGuiItem::yes(), KStandardGuiItem::no(), dontAsk);
     if(ret != KMessageBox::Yes) {
       m_isWorking = false;
       return;
     }
   }
 
   GUI::CursorSaver cs;
 
   Data::EntryList oldEntries;
   Data::FieldList fieldsRequiringValues;
   // boolean to keep track if any field gets changed
   bool modified = false;
   foreach(Data::EntryPtr entry, m_currEntries) {
     // if the entry is owned, then we're modifying an existing entry, keep a copy of the old one
     if(entry->isOwned()) {
       oldEntries.append(Data::EntryPtr(new Data::Entry(*entry)));
     }
     foreach(Data::FieldPtr field, m_modifiedFields) {
       QString key = QString::number(m_currColl->id()) + field->name();
       GUI::FieldWidget* widget = m_widgetDict.value(key);
       if(widget && widget->isEnabled()) {
         const QString temp = widget->text();
         // ok to set field empty string, just not all of them
         if(modified == false && entry->field(field) != temp) {
           modified = true;
         }
         entry->setField(field, temp);
         if(temp.isEmpty()) {
           const QString prop = field->property(QStringLiteral("required")).toLower();
           if(prop == QLatin1String("1") || prop == QLatin1String("true")) {
             fieldsRequiringValues.append(field);
           }
         }
       }
     }
   }
 
   if(!fieldsRequiringValues.isEmpty()) {
     GUI::CursorSaver cs2(Qt::ArrowCursor);
     QString str = i18n("A value is required for the following fields. Do you want to continue?");
     QStringList titles;
     foreach(Data::FieldPtr it, fieldsRequiringValues) {
       titles << it->title();
     }
     QString dontAsk = QStringLiteral("SaveWithoutRequired");
     int ret = KMessageBox::questionYesNoList(this, str, titles, i18n("Modify Entries"),
                                              KStandardGuiItem::yes(), KStandardGuiItem::no(), dontAsk);
     if(ret != KMessageBox::Yes) {
       m_isWorking = false;
       return;
     }
   }
 
   // if something was not empty, signal a save
   if(modified) {
     m_isOrphan = false;
     if(oldEntries.isEmpty()) {
       Kernel::self()->addEntries(m_currEntries, false);
     } else {
       QStringList fieldNames;
       foreach(Data::FieldPtr field, m_modifiedFields) {
         fieldNames << field->name();
       }
       Kernel::self()->modifyEntries(oldEntries, m_currEntries, fieldNames);
     }
     if(!m_currEntries.isEmpty() && !m_currEntries[0]->title().isEmpty()) {
       setWindowTitle(i18n("Edit Entry") + QLatin1String(" - ") + m_currEntries[0]->title());
     }
   }
 
   m_isWorking = false;
   slotSetModified(false);
 //  slotHandleNew();
 }
 
 void EntryEditDialog::clear() {
   if(m_isWorking) {
     return;
   }
 
   m_isWorking = true;
   // clear the widgets
   foreach(GUI::FieldWidget* widget, m_widgetDict) {
     widget->setEnabled(true);
     widget->clear();
     widget->insertDefault();
   }
   m_modifiedFields.clear();
 
   setWindowTitle(i18n("Edit Entry"));
 
   if(m_isOrphan) {
     if(m_currEntries.count() > 1) {
       myWarning() << "is an orphan, but more than one";
     }
     m_isOrphan = false;
   }
   m_currEntries.clear();
 
   m_saveButton->setText(i18n("Sa&ve Entry"));
 
   m_isWorking = false;
   slotSetModified(false);
 }
 
 void EntryEditDialog::setContents(Tellico::Data::EntryList entries_) {
   // this slot might get called if we try to save multiple items, so just return
   if(m_isWorking) {
     return;
   }
 
   if(entries_.isEmpty()) {
     if(queryModified()) {
       blockSignals(true);
       slotHandleNew();
       blockSignals(false);
     }
     return;
   }
 
   // if some entries get selected in one view, then in another, don't reset
   if(!m_needReset && entries_ == m_currEntries) {
     return;
   }
   m_needReset = false;
 
   // first set contents to first item
   setEntry(entries_.front());
   // something weird...if list count can actually be 1 before the setContents call
   // and 0 after it. Why is that? It's const!
   if(entries_.count() < 2) {
     return;
   }
 
   // multiple entries, so don't set caption
   setWindowTitle(i18n("Edit Entries"));
 
   m_currEntries = entries_;
   m_isWorking = true;
   blockSignals(true);
 
   foreach(Data::FieldPtr fIt, m_currColl->fields()) {
     QString key = QString::number(m_currColl->id()) + fIt->name();
     GUI::FieldWidget* widget = m_widgetDict.value(key);
     if(!widget) { // probably read-only
       continue;
     }
     widget->editMultiple(true);
 
     QString value = entries_[0]->field(fIt);
     for(int i = 1; i < entries_.count(); ++i) {  // skip checking the first one
       if(entries_[i]->field(fIt) != value) {
         widget->setEnabled(false);
         break;
       }
     }
   } // end field loop
 
   blockSignals(false);
   m_isWorking = false;
 
   m_saveButton->setText(i18n("Sa&ve Entries"));
 }
 
 void EntryEditDialog::setEntry(Tellico::Data::EntryPtr entry_) {
   if(m_isWorking || !queryModified()) {
     return;
   }
 
   if(!entry_) {
     myDebug() << "null entry pointer";
     slotHandleNew();
     return;
   }
 
 //  myDebug() << entry_->title();
   blockSignals(true);
   clear();
   blockSignals(false);
 
   m_isWorking = true;
   m_currEntries.append(entry_);
 
   if(!entry_->title().isEmpty()) {
     setWindowTitle(i18n("Edit Entry") + QLatin1String(" - ") + entry_->title());
   }
 
   if(m_currColl != entry_->collection()) {
     myDebug() << "collections don't match";
     m_currColl = entry_->collection();
   }
 
   foreach(Data::FieldPtr field, m_currColl->fields()) {
     QString key = QString::number(m_currColl->id()) + field->name();
     GUI::FieldWidget* widget = m_widgetDict.value(key);
     if(!widget) { // is probably read-only
       continue;
     }
 
     widget->setText(entry_->field(field));
     widget->setEnabled(true);
     widget->editMultiple(false);
   } // end field loop
 
   if(entry_->isOwned()) {
     m_saveButton->setText(i18n("Sa&ve Entry"));
     slotSetModified(false);
   } else {
     // saving is necessary for unowned entries
     slotSetModified(true);
   }
   m_isWorking = false;
 }
 
 void EntryEditDialog::removeField(Tellico::Data::CollPtr, Tellico::Data::FieldPtr field_) {
   if(!field_) {
     return;
   }
 
 //  myDebug() << "name = " << field_->name();
   QString key = QString::number(m_currColl->id()) + field_->name();
   GUI::FieldWidget* widget = m_widgetDict.value(key);
   if(widget) {
     m_widgetDict.remove(key);
     // if this is the last field in the category, need to remove the tab page
     // this function is called after the field has been removed from the collection,
     // so the category should be gone from the category list
     if(m_currColl->fieldCategories().indexOf(field_->category()) == -1) {
 //      myDebug() << "last field in the category";
       // fragile, widget's parent is the grid, whose parent is the tab page
       QWidget* w = widget->parentWidget()->parentWidget();
       m_tabs->removeTab(m_tabs->indexOf(w));
       delete w; // automatically deletes child widget
     } else {
       // much of this replicates code in resetLayout()
       QGridLayout* layout = static_cast<QGridLayout*>(widget->parentWidget()->layout());
       delete widget; // automatically removes from layout
 
       QVector<bool> expands(NCOLS, false);
       QVector<int> maxWidth(NCOLS, 0);
 
       Data::FieldList vec = m_currColl->fieldsByCategory(field_->category());
       int count = 0;
       foreach(Data::FieldPtr field, vec) {
         GUI::FieldWidget* widget = m_widgetDict.value(QString::number(m_currColl->id()) + field->name());
         if(widget) {
           layout->removeWidget(widget);
           layout->addWidget(widget, count/NCOLS, count%NCOLS);
 
           maxWidth[count%NCOLS] = qMax(maxWidth[count%NCOLS], widget->labelWidth());
           if(widget->expands()) {
             expands[count%NCOLS] = true;
           }
           widget->updateGeometry();
           ++count;
         }
       }
 
       // now, the labels in a column should all be the same width
       count = 0;
       foreach(Data::FieldPtr field, vec) {
         GUI::FieldWidget* widget = m_widgetDict.value(QString::number(m_currColl->id()) + field->name());
         if(widget) {
           widget->setLabelWidth(maxWidth[count%NCOLS]);
           ++count;
         }
       }
 
       // update stretch factors for columns with a line edit
       for(int col = 0; col < NCOLS; ++col) {
         if(expands[col]) {
           layout->setColumnStretch(col, 1);
         }
       }
     }
   }
 }
 
 void EntryEditDialog::updateCompletions(Tellico::Data::EntryPtr entry_) {
 #ifndef NDEBUG
   if(m_currColl != entry_->collection()) {
     myDebug() << "inconsistent collection pointers!";
 //    m_currColl = entry_->collection();
   }
 #endif
 
   foreach(Data::FieldPtr f, m_currColl->fields()) {
     if(f->type() != Data::Field::Line
        || !f->hasFlag(Data::Field::AllowCompletion)) {
       continue;
     }
 
     QString key = QString::number(m_currColl->id()) + f->name();
     GUI::FieldWidget* widget = m_widgetDict.value(key);
     if(!widget) {
       continue;
     }
     if(f->hasFlag(Data::Field::AllowMultiple)) {
       QStringList items = FieldFormat::splitValue(entry_->field(f));
       for(QStringList::ConstIterator it = items.constBegin(); it != items.constEnd(); ++it) {
         widget->addCompletionObjectItem(*it);
       }
     } else {
       widget->addCompletionObjectItem(entry_->field(f));
     }
   }
 }
 
 void EntryEditDialog::slotSetModified(bool mod_/*=true*/) {
   m_modified = mod_;
   m_saveButton->setEnabled(mod_);
 }
 
 bool EntryEditDialog::queryModified() {
   bool ok = true;
   // assume that if the dialog is hidden, we shouldn't ask the user to modify changes
   if(!isVisible()) {
     m_modified = false;
   }
   if(m_modified) {
     QString str(i18n("The current entry has been modified.\n"
                       "Do you want to enter the changes?"));
     KGuiItem item = KStandardGuiItem::save();
     item.setText(i18n("Save Entry"));
     int want_save = KMessageBox::warningYesNoCancel(this, str, i18n("Unsaved Changes"),
                                                     item, KStandardGuiItem::discard());
     switch(want_save) {
       case KMessageBox::Yes:
         slotHandleSave();
         ok = true;
         break;
 
       case KMessageBox::No:
         m_modified = false;
         ok = true;
         break;
 
       case KMessageBox::Cancel:
         ok = false;
         break;
     }
   }
   return ok;
 }
 
 void EntryEditDialog::addField(Tellico::Data::CollPtr coll_, Tellico::Data::FieldPtr field_) {
   Q_ASSERT(coll_ == m_currColl);
   Q_UNUSED(field_);
   resetLayout(coll_);
 }
 
 // modified fields will always have the same name
 void EntryEditDialog::modifyField(Tellico::Data::CollPtr coll_, Tellico::Data::FieldPtr oldField_, Tellico::Data::FieldPtr newField_) {
 //  myDebug() << newField_->name();
 
   if(coll_ != m_currColl) {
     myDebug() << "wrong collection pointer!";
     m_currColl = coll_;
   }
 
   // if the field type changed, go ahead and redo the whole layout
   // also if the category changed for a non-single field, since a new tab must be created
   if(oldField_->type() != newField_->type()
      || (oldField_->category() != newField_->category() && !newField_->isSingleCategory())) {
     bool modified = m_modified;
     resetLayout(coll_);
     setContents(m_currEntries);
     m_modified = modified;
     return;
   }
 
   QString key = QString::number(coll_->id()) + oldField_->name();
   GUI::FieldWidget* widget = m_widgetDict.value(key);
   if(widget) {
     widget->updateField(oldField_, newField_);
     // need to update label widths
     if(newField_->title() != oldField_->title()) {
       int maxWidth = 0;
       QList<GUI::FieldWidget*> childList = widget->parentWidget()->findChildren<GUI::FieldWidget*>();
       foreach(GUI::FieldWidget* obj, childList) {
         maxWidth = qMax(maxWidth, obj->labelWidth());
       }
       foreach(GUI::FieldWidget* obj, childList) {
         obj->setLabelWidth(maxWidth);
       }
     }
     // this is very fragile!
     // field widgets's parent is the grid, whose parent is the tab page
     // this is for singleCategory fields
     if(newField_->category() != oldField_->category()) {
       int idx = m_tabs->indexOf(widget->parentWidget()->parentWidget());
       if(idx > -1) {
         m_tabs->setTabText(idx, newField_->category());
       }
     }
   }
 }
 
 void EntryEditDialog::addEntries(Tellico::Data::EntryList entries_) {
   foreach(Data::EntryPtr entry, entries_) {
     updateCompletions(entry);
   }
 }
 
 void EntryEditDialog::modifyEntries(Tellico::Data::EntryList entries_) {
   bool updateContents = false;
   foreach(Data::EntryPtr entry, entries_) {
     updateCompletions(entry);
     if(!updateContents && m_currEntries.contains(entry)) {
       updateContents = true;
     }
   }
   if(updateContents) {
     m_needReset = true;
     setContents(m_currEntries);
   }
 }
 
 void EntryEditDialog::fieldValueChanged(Data::FieldPtr field_) {
   if(!m_modifiedFields.contains(field_)) {
     m_modifiedFields.append(field_);
   }
   slotSetModified(true);
 }
 
 void EntryEditDialog::showEvent(QShowEvent* event_) {
   QDialog::showEvent(event_);
 /*
   I attempted to read and restore window size here, but it didn't work (July 2016)
   I discovered that I had to put it in a timer. Somewhere, the resize event or something
   was overriding any size changes I did here. Calling this->resize() would work but
   windowHandle()->resize() would not (as KWindowConfig::restoreWindowSize uses)
 */
-  QTimer::singleShot(0, this, SLOT(slotUpdateSize()));
+  QTimer::singleShot(0, this, &EntryEditDialog::slotUpdateSize);
 }
 
 void EntryEditDialog::slotUpdateSize() {
   KConfigGroup config(KSharedConfig::openConfig(), QLatin1String(dialogOptionsString));
   KWindowConfig::restoreWindowSize(windowHandle(), config);
 }
 
 void EntryEditDialog::hideEvent(QHideEvent* event_) {
   KConfigGroup config(KSharedConfig::openConfig(), QLatin1String(dialogOptionsString));
   KWindowConfig::saveWindowSize(windowHandle(), config);
   config.sync();
 
   if(queryModified()) {
     QDialog::hideEvent(event_);
   } else {
     event_->ignore();
   }
 }
 
 void EntryEditDialog::closeEvent(QCloseEvent* event_) {
   // check to see if an entry should be saved before hiding
   // block signals so the entry view and selection isn't cleared
   if(queryModified()) {
     QDialog::closeEvent(event_);
   } else {
     event_->ignore();
   }
 }
diff --git a/src/entrymatchdialog.cpp b/src/entrymatchdialog.cpp
index bd622166..03045469 100644
--- a/src/entrymatchdialog.cpp
+++ b/src/entrymatchdialog.cpp
@@ -1,139 +1,139 @@
 /***************************************************************************
     Copyright (C) 2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "entrymatchdialog.h"
 #include "entryview.h"
 #include "entry.h"
 #include "fetch/fetchmanager.h"
 
 #include <KLocalizedString>
 #include <KTextEdit>
 #include <KIconLoader>
 
 #include <QSplitter>
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QTreeWidget>
 #include <QDialogButtonBox>
 #include <QPushButton>
 
 namespace {
   static const int DIALOG_MIN_WIDTH = 600;
 }
 
 using namespace Tellico;
 using Tellico::EntryMatchDialog;
 
 EntryMatchDialog::EntryMatchDialog(QWidget* parent_, Data::EntryPtr entryToUpdate_,
                                    Fetch::Fetcher::Ptr fetcher_, const EntryUpdater::ResultList& matchResults_)
     : QDialog(parent_) {
   Q_ASSERT(entryToUpdate_);
   Q_ASSERT(fetcher_);
 
   setModal(true);
   setWindowTitle(i18n("Select Match"));
 
   QVBoxLayout* mainLayout = new QVBoxLayout(this);
   setLayout(mainLayout);
 
   QWidget* mainWidget = new QWidget(this);
   mainLayout->addWidget(mainWidget);
 
   QWidget* hbox = new QWidget(mainWidget);
   mainLayout->addWidget(hbox);
   QHBoxLayout* hboxHBoxLayout = new QHBoxLayout(hbox);
   hboxHBoxLayout->setMargin(0);
   hboxHBoxLayout->setSpacing(10);
 
   QLabel* icon = new QLabel(hbox);
   hboxHBoxLayout->addWidget(icon);
   icon->setPixmap(Fetch::Manager::fetcherIcon(fetcher_, KIconLoader::Panel, 48));
   icon->setAlignment(Qt::Alignment(Qt::AlignLeft) | Qt::AlignTop);
 
   QString s = i18n("<qt><b>%1</b> returned multiple results which could match <b>%2</b>, "
                    "the entry currently in the collection. Please select the correct match.</qt>",
                    fetcher_->source(),
                    entryToUpdate_->title());
 
   KTextEdit* l = new KTextEdit(hbox);
   hboxHBoxLayout->addWidget(l);
   l->setHtml(s);
   l->setReadOnly(true);
   l->setMaximumHeight(48);
   l->setFrameStyle(0);
 
   QSplitter* split = new QSplitter(Qt::Vertical, mainWidget);
   mainLayout->addWidget(split);
   split->setMinimumHeight(400);
 
   m_treeWidget = new QTreeWidget(split);
   m_treeWidget->setAllColumnsShowFocus(true);
   m_treeWidget->setSortingEnabled(true);
   m_treeWidget->setHeaderLabels(QStringList() << i18n("Title") << i18n("Description"));
-  connect(m_treeWidget, SIGNAL(itemSelectionChanged()), SLOT(slotShowEntry()));
+  connect(m_treeWidget, &QTreeWidget::itemSelectionChanged, this, &EntryMatchDialog::slotShowEntry);
 
   foreach(const EntryUpdater::UpdateResult& res, matchResults_) {
     Data::EntryPtr matchingEntry = res.first->fetchEntry();
     QTreeWidgetItem* item = new QTreeWidgetItem(m_treeWidget, QStringList() << matchingEntry->title() << res.first->desc);
     m_itemResults.insert(item, res);
     m_itemEntries.insert(item, matchingEntry);
   }
 
   m_entryView = new EntryView(split);
   // don't bother creating funky gradient images for compact view
   m_entryView->setUseGradientImages(false);
   // set the xslt file AFTER setting the gradient image option
   m_entryView->setXSLTFile(QStringLiteral("Compact.xsl"));
   m_entryView->addXSLTStringParam("skip-fields", "id,mdate,cdate");
 
   QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
   QPushButton* okButton = buttonBox->button(QDialogButtonBox::Ok);
   okButton->setDefault(true);
   okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
-  connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
-  connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
+  connect(buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
+  connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
   mainLayout->addWidget(buttonBox);
 
   setMinimumWidth(qMax(minimumWidth(), DIALOG_MIN_WIDTH));
   // have the entry view be taller than the tree widget
   split->setStretchFactor(1, 10);
 }
 
 void EntryMatchDialog::slotShowEntry() {
   QTreeWidgetItem* item = m_treeWidget->currentItem();
   if(!item) {
     return;
   }
 
   m_entryView->showEntry(m_itemEntries[item]);
 }
 
 Tellico::EntryUpdater::UpdateResult EntryMatchDialog::updateResult() const {
   QTreeWidgetItem* item = m_treeWidget->currentItem();
   if(!item) {
     return EntryUpdater::UpdateResult(nullptr, false);
   }
   return m_itemResults[item];
 }
diff --git a/src/entrymerger.cpp b/src/entrymerger.cpp
index 4244a12d..28af7028 100644
--- a/src/entrymerger.cpp
+++ b/src/entrymerger.cpp
@@ -1,134 +1,134 @@
 /***************************************************************************
     Copyright (C) 2007-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "entrymerger.h"
 #include "entry.h"
 #include "entrycomparison.h"
 #include "collection.h"
 #include "tellico_kernel.h"
 #include "controller.h"
 #include "progressmanager.h"
 #include "gui/statusbar.h"
 #include "tellico_debug.h"
 
 #include <KLocalizedString>
 
 #include <QTimer>
 
 using namespace Tellico;
 using Tellico::AskUserResolver;
 using Tellico::EntryMerger;
 
 Tellico::MergeConflictResolver::Result AskUserResolver::resolve(Data::EntryPtr entry1, Data::EntryPtr entry2, Data::FieldPtr field,
                                                                 const QString& value1, const QString& value2) {
   return static_cast<MergeConflictResolver::Result>(Kernel::self()->askAndMerge(entry1, entry2, field, value1, value2));
 }
 
 EntryMerger::EntryMerger(Tellico::Data::EntryList entries_, QObject* parent_)
     : QObject(parent_), m_entriesToCheck(entries_), m_origCount(entries_.count()), m_cancelled(false)
     , m_resolver(new AskUserResolver) {
 
   m_entriesLeft = m_entriesToCheck;
   Kernel::self()->beginCommandGroup(i18n("Merge Entries"));
 
   QString label = i18n("Merging entries...");
   ProgressItem& item = ProgressManager::self()->newProgressItem(this, label, true /*canCancel*/);
   item.setTotalSteps(m_origCount);
   connect(&item, &Tellico::ProgressItem::signalCancelled,
           this, &Tellico::EntryMerger::slotCancel);
 
   // done if no entries to merge
   if(m_origCount < 2) {
-    QTimer::singleShot(500, this, SLOT(slotCleanup()));
+    QTimer::singleShot(500, this, &EntryMerger::slotCleanup);
   } else {
     slotStartNext(); // starts fetching
   }
 }
 
 EntryMerger::~EntryMerger() {
   delete m_resolver;
 }
 
 void EntryMerger::slotStartNext() {
   QString statusMsg = i18n("Total merged/scanned entries: %1/%2",
                            m_entriesToRemove.count(),
                            m_origCount - m_entriesToCheck.count());
   StatusBar::self()->setStatus(statusMsg);
   ProgressManager::self()->setProgress(this, m_origCount - m_entriesToCheck.count());
 
   Data::EntryPtr baseEntry = m_entriesToCheck[0];
   for(int i = 1; i < m_entriesToCheck.count(); ++i) {  // skip checking against first
     Data::EntryPtr it = m_entriesToCheck[i];
     bool match = cleanMerge(baseEntry, it);
     if(!match) {
       int score = baseEntry->collection()->sameEntry(baseEntry, it);
       match = score >= EntryComparison::ENTRY_GOOD_MATCH;
     }
     if(match) {
       bool merge_ok = Data::Document::mergeEntry(baseEntry, it, m_resolver);
       if(merge_ok) {
         m_entriesToRemove.append(it);
         m_entriesLeft.removeAll(it);
       }
     }
   }
   m_entriesToCheck.removeAll(baseEntry);
 
   if(m_cancelled || m_entriesToCheck.count() < 2) {
-    QTimer::singleShot(0, this, SLOT(slotCleanup()));
+    QTimer::singleShot(0, this, &EntryMerger::slotCleanup);
   } else {
-    QTimer::singleShot(0, this, SLOT(slotStartNext()));
+    QTimer::singleShot(0, this, &EntryMerger::slotStartNext);
   }
 }
 
 void EntryMerger::slotCancel() {
   m_cancelled = true;
 }
 
 void EntryMerger::slotCleanup() {
   Kernel::self()->removeEntries(m_entriesToRemove);
   Controller::self()->slotUpdateSelection(m_entriesLeft);
   StatusBar::self()->clearStatus();
   ProgressManager::self()->setDone(this);
   Kernel::self()->endCommandGroup();
   deleteLater();
 }
 
 bool EntryMerger::cleanMerge(Tellico::Data::EntryPtr e1, Tellico::Data::EntryPtr e2) const {
   // figure out if there's a clean merge possible
   foreach(Data::FieldPtr field, e1->collection()->fields()) {
     // do not care about id and dates
     if(field->name() == QLatin1String("id") ||
        field->name() == QLatin1String("cdate") ||
        field->name() == QLatin1String("mdate")) {
       continue;
     }
     QString val1 = e1->field(field);
     QString val2 = e2->field(field);
     if(val1 != val2 && !val1.isEmpty() && !val2.isEmpty()) {
       return false;
     }
   }
   return true;
 }
diff --git a/src/entryupdatejob.cpp b/src/entryupdatejob.cpp
index 81f3015e..d6403e84 100644
--- a/src/entryupdatejob.cpp
+++ b/src/entryupdatejob.cpp
@@ -1,88 +1,88 @@
 /***************************************************************************
     Copyright (C) 2005-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "entryupdatejob.h"
 #include "entrycomparison.h"
 #include "document.h"
 #include "entry.h"
 #include "collection.h"
 #include "tellico_debug.h"
 
 #include <QTimer>
 
 using namespace Tellico;
 using Tellico::EntryUpdateJob;
 
 EntryUpdateJob::EntryUpdateJob(QObject* parent_, Data::EntryPtr entry_, Fetch::Fetcher::Ptr fetcher_, Mode mode_)
     : KJob(parent_), m_entry(entry_), m_fetcher(fetcher_), m_mode(mode_), m_bestMatchScore(-1) {
  setCapabilities(KJob::Killable);
- connect(m_fetcher.data(), SIGNAL(signalResultFound(Tellico::Fetch::FetchResult*)),
-         SLOT(slotResult(Tellico::Fetch::FetchResult*)));
- connect(m_fetcher.data(), SIGNAL(signalDone(Tellico::Fetch::Fetcher*)),
-         SLOT(slotDone()));
+ connect(m_fetcher.data(), &Fetch::Fetcher::signalResultFound,
+         this, &EntryUpdateJob::slotResult);
+ connect(m_fetcher.data(), &Fetch::Fetcher::signalDone,
+         this, &EntryUpdateJob::slotDone);
 }
 
 void EntryUpdateJob::start() {
-  QTimer::singleShot(0, this, SLOT(startUpdate()));
+  QTimer::singleShot(0, this, &EntryUpdateJob::startUpdate);
 }
 
 void EntryUpdateJob::startUpdate() {
   m_fetcher->startUpdate(m_entry);
 }
 
 void EntryUpdateJob::slotResult(Tellico::Fetch::FetchResult* result_) {
   if(!result_) {
     myDebug() << "null result";
     return;
   }
 
   Data::EntryPtr entry = result_->fetchEntry();
   Q_ASSERT(entry);
 
   const int match = m_entry->collection()->sameEntry(m_entry, entry);
   if(match > m_bestMatchScore) {
     m_bestMatchScore = match;
     m_bestMatchEntry = entry;
   }
   // if perfect match, go ahead and top
   if(match > EntryComparison::ENTRY_PERFECT_MATCH) {
     doKill();
   }
 }
 
 void EntryUpdateJob::slotDone() {
   if(m_bestMatchEntry) {
     const int matchToBeat = (m_mode == PerfectMatchOnly ? EntryComparison::ENTRY_PERFECT_MATCH
                                                         : EntryComparison::ENTRY_GOOD_MATCH);
     if(m_bestMatchScore > matchToBeat) {
       Data::Document::mergeEntry(m_entry, m_bestMatchEntry);
     }
   }
   emitResult();
 }
 
 bool EntryUpdateJob::doKill() {
   m_fetcher->stop();
   return true;
 }
diff --git a/src/entryview.cpp b/src/entryview.cpp
index f798daf4..198afa97 100644
--- a/src/entryview.cpp
+++ b/src/entryview.cpp
@@ -1,419 +1,421 @@
 /***************************************************************************
     Copyright (C) 2003-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "entryview.h"
 #include "entry.h"
 #include "field.h"
 #include "translators/xslthandler.h"
 #include "translators/tellicoxmlexporter.h"
 #include "collection.h"
 #include "images/imagefactory.h"
 #include "images/imageinfo.h"
 #include "tellico_kernel.h"
 #include "utils/tellico_utils.h"
 #include "utils/datafileregistry.h"
 #include "core/filehandler.h"
 #include "config/tellico_config.h"
 #include "gui/drophandler.h"
 #include "document.h"
 #include "tellico_debug.h"
 
 #include <KMessageBox>
 #include <KHTMLView>
 #include <dom/dom_element.h>
 #include <KLocalizedString>
 
 #include <QFile>
 #include <QTextStream>
 #include <QClipboard>
 #include <QDomDocument>
 #include <QTemporaryFile>
 #include <QApplication>
 #include <QDesktopServices>
 
 using Tellico::EntryView;
 using Tellico::EntryViewWidget;
 
 EntryViewWidget::EntryViewWidget(EntryView* part, QWidget* parent)
     : KHTMLView(part, parent) {}
 
 // for the life of me, I could not figure out how to call the actual
 // KHTMLPartBrowserExtension::copy() slot, so this will have to do
 void EntryViewWidget::copy() {
   QApplication::clipboard()->setText(part()->selectedText(), QClipboard::Clipboard);
 }
 
 void EntryViewWidget::changeEvent(QEvent* event_) {
   // this will delete and reread the default colors, assuming they changed
   if(event_->type() == QEvent::PaletteChange ||
      event_->type() == QEvent::FontChange ||
      event_->type() == QEvent::ApplicationFontChange) {
     static_cast<EntryView*>(part())->resetView();
   }
   KHTMLView::changeEvent(event_);
 }
 
 EntryView::EntryView(QWidget* parent_) : KHTMLPart(new EntryViewWidget(this, parent_), parent_),
     m_handler(nullptr), m_tempFile(nullptr), m_useGradientImages(true), m_checkCommonFile(true) {
   setJScriptEnabled(false);
   setJavaEnabled(false);
   setMetaRefreshEnabled(false);
   setPluginsEnabled(false);
   clear(); // needed for initial layout
 
   view()->setAcceptDrops(true);
   DropHandler* drophandler = new DropHandler(this);
   view()->installEventFilter(drophandler);
 
-  connect(browserExtension(), SIGNAL(openUrlRequestDelayed(const QUrl&, const KParts::OpenUrlArguments&, const KParts::BrowserArguments&)),
-          SLOT(slotOpenURL(const QUrl&)));
+  connect(browserExtension(), &KParts::BrowserExtension::openUrlRequestDelayed,
+          this, &EntryView::slotOpenURL);
 }
 
 EntryView::~EntryView() {
   delete m_handler;
   m_handler = nullptr;
   delete m_tempFile;
   m_tempFile = nullptr;
 }
 
 void EntryView::clear() {
   m_entry = nullptr;
 
   // just clear the view
   begin();
   if(!m_textToShow.isEmpty()) {
     write(m_textToShow);
   }
   end();
   view()->layout(); // I need this because some of the margins and widths may get messed up
 }
 
 void EntryView::showEntries(Tellico::Data::EntryList entries_) {
   if(!entries_.isEmpty()) {
     showEntry(entries_.first());
   }
 }
 
 void EntryView::showEntry(Tellico::Data::EntryPtr entry_) {
   if(!entry_) {
     clear();
     return;
   }
 
   m_textToShow.clear();
 #if 0
   myWarning() << "turn me off!";
   m_entry = 0;
   setXSLTFile(m_xsltFile);
 #endif
   if(!m_handler || !m_handler->isValid()) {
     setXSLTFile(m_xsltFile);
   }
   if(!m_handler || !m_handler->isValid()) {
     myWarning() << "no xslt handler";
     return;
   }
 
   m_entry = entry_;
 
   // by setting the xslt file as the URL, any images referenced in the xslt "theme" can be found
   // by simply using a relative path in the xslt file
   QUrl u = QUrl::fromLocalFile(m_xsltFile);
   begin(u);
 
   Export::TellicoXMLExporter exporter(entry_->collection());
   exporter.setEntries(Data::EntryList() << entry_);
   long opt = exporter.options();
   // verify images for the view
   opt |= Export::ExportVerifyImages;
   // on second thought, don't auto-format everything, just clean it
 //  if(Data::Field::autoFormat()) {
 //    opt = Export::ExportFormatted;
 //  }
   if(entry_->collection()->type() == Data::Collection::Bibtex) {
     opt |= Export::ExportClean;
   }
   exporter.setOptions(opt);
   QDomDocument dom = exporter.exportXML();
 
 //  myDebug() << dom.toString();
 #if 0
   myWarning() << "turn me off!";
   QFile f1(QLatin1String("/tmp/test.xml"));
   if(f1.open(QIODevice::WriteOnly)) {
     QTextStream t(&f1);
     t << dom.toString();
   }
   f1.close();
 #endif
 
   QString html = m_handler->applyStylesheet(dom.toString());
   // write out image files
   Data::FieldList fields = entry_->collection()->imageFields();
   foreach(Data::FieldPtr field, fields) {
     QString id = entry_->field(field);
     if(id.isEmpty()) {
       continue;
     }
     // only write out image if it's not linked only
     if(!ImageFactory::imageInfo(id).linkOnly) {
       if(Data::Document::self()->allImagesOnDisk()) {
         ImageFactory::writeCachedImage(id, ImageFactory::cacheDir());
       } else {
         ImageFactory::writeCachedImage(id, ImageFactory::TempDir);
       }
     }
   }
 
 #if 0
   myWarning() << "turn me off!";
   QFile f2(QLatin1String("/tmp/test.html"));
   if(f2.open(QIODevice::WriteOnly)) {
     QTextStream t(&f2);
     t << html;
   }
   f2.close();
 #endif
 
 //  myDebug() << html;
   write(html);
   end();
   // not need anymore?
   view()->layout(); // I need this because some of the margins and widths may get messed up
 }
 
 void EntryView::showText(const QString& text_) {
   m_textToShow = text_;
   begin();
   write(text_);
   end();
 }
 
 void EntryView::setXSLTFile(const QString& file_) {
   if(file_.isEmpty()) {
     myWarning() << "empty xslt file";
     return;
   }
   QString oldFile = m_xsltFile;
   // if starts with slash, then absolute path
   if(file_.at(0) == QLatin1Char('/')) {
     m_xsltFile = file_;
   } else {
     const QString templateDir = QStringLiteral("entry-templates/");
     m_xsltFile = DataFileRegistry::self()->locate(templateDir + file_);
     if(m_xsltFile.isEmpty()) {
       if(!file_.isEmpty()) {
         myWarning() << "can't locate" << file_;
       }
       m_xsltFile = DataFileRegistry::self()->locate(templateDir + QLatin1String("Fancy.xsl"));
       if(m_xsltFile.isEmpty()) {
         QString str = QStringLiteral("<qt>");
         str += i18n("Tellico is unable to locate the default entry stylesheet.");
         str += QLatin1Char(' ');
         str += i18n("Please check your installation.");
         str += QLatin1String("</qt>");
         KMessageBox::error(view(), str);
         clear();
         return;
       }
     }
   }
 
   const int type = m_entry ? m_entry->collection()->type() : Kernel::self()->collectionType();
 
   // we need to know if the colors changed from last time, in case
   // we need to do that ugly hack to reload the cache
   bool reloadImages = m_useGradientImages;
   // if m_useGradientImages is false, then we don't even need to check
   // if there's no handler, there there's _no way_ to check
   if(m_handler && reloadImages) {
     // the only two colors that matter for the gradients are the base color
     // and highlight base color
     QByteArray oldBase = m_handler->param("bgcolor");
     QByteArray oldHigh = m_handler->param("color2");
     // remember the string params have apostrophes on either side, so we can start search at pos == 1
     reloadImages = oldBase.indexOf(Config::templateBaseColor(type).name().toLatin1(), 1) == -1
                 || oldHigh.indexOf(Config::templateHighlightedBaseColor(type).name().toLatin1(), 1) == -1;
   }
 
   if(!m_handler || m_xsltFile != oldFile) {
     delete m_handler;
     // must read the file name to get proper context
     m_handler = new XSLTHandler(QFile::encodeName(m_xsltFile));
     if(m_checkCommonFile && !m_handler->isValid()) {
       Tellico::checkCommonXSLFile();
       m_checkCommonFile = false;
       delete m_handler;
       m_handler = new XSLTHandler(QFile::encodeName(m_xsltFile));
     }
     if(!m_handler->isValid()) {
       myWarning() << "invalid xslt handler";
       clear();
       delete m_handler;
       m_handler = nullptr;
       return;
     }
   }
 
   m_handler->addStringParam("font",     Config::templateFont(type).family().toLatin1());
   m_handler->addStringParam("fontsize", QByteArray().setNum(Config::templateFont(type).pointSize()));
   m_handler->addStringParam("bgcolor",  Config::templateBaseColor(type).name().toLatin1());
   m_handler->addStringParam("fgcolor",  Config::templateTextColor(type).name().toLatin1());
   m_handler->addStringParam("color1",   Config::templateHighlightedTextColor(type).name().toLatin1());
   m_handler->addStringParam("color2",   Config::templateHighlightedBaseColor(type).name().toLatin1());
 
   if(Data::Document::self()->allImagesOnDisk()) {
     m_handler->addStringParam("imgdir", QFile::encodeName(ImageFactory::imageDir()));
   } else {
     m_handler->addStringParam("imgdir", QFile::encodeName(ImageFactory::tempDir()));
   }
 
   m_handler->addStringParam("datadir", QFile::encodeName(Tellico::installationDir()));
 
   // if we don't have to reload the images, then just show the entry and we're done
   if(reloadImages) {
     // now, have to recreate images and refresh khtml cache
     resetColors();
   } else {
     showEntry(m_entry);
   }
 }
 
 void EntryView::slotRefresh() {
   setXSLTFile(m_xsltFile);
   showEntry(m_entry);
   view()->repaint();
 }
 
 // do some contortions in case the url is relative
 // need to interpret it relative to document URL instead of xslt file
 // the current node under the mouse would be the text node inside
 // the anchor node, so iterate up the parents
 void EntryView::slotOpenURL(const QUrl& url_) {
   if(url_.scheme() == QLatin1String("tc")) {
     // handle this internally
     emit signalAction(url_);
     return;
   }
 
   QUrl u = url_;
   for(DOM::Node node = nodeUnderMouse(); !node.isNull(); node = node.parentNode()) {
     if(node.nodeType() == DOM::Node::ELEMENT_NODE && static_cast<DOM::Element>(node).tagName() == "a") {
       QString href = static_cast<DOM::Element>(node).getAttribute("href").string();
       if(!href.isEmpty()) {
         // interpret url relative to document url
         u = Kernel::self()->URL().resolved(QUrl(href));
       }
       break;
     }
   }
   // open the url
   QDesktopServices::openUrl(u);
 }
 
 void EntryView::slotReloadEntry() {
   // this slot should only be connected in setXSLTFile()
   // must disconnect the signal first, otherwise, get an infinite loop
-  disconnect(SIGNAL(completed()));
+  void (EntryView::* completed)() = &EntryView::completed;
+  disconnect(this, completed, this, &EntryView::slotReloadEntry);
   closeUrl(); // this is needed to stop everything, for some reason
   view()->setUpdatesEnabled(true);
 
   if(m_entry) {
     showEntry(m_entry);
   } else {
     // setXSLTFile() writes some html to clear the image cache
     // but we don't want to see that, so just clear everything
     clear();
   }
   delete m_tempFile;
   m_tempFile = nullptr;
 }
 
 void EntryView::addXSLTStringParam(const QByteArray& name_, const QByteArray& value_) {
   if(!m_handler) {
     return;
   }
   m_handler->addStringParam(name_, value_);
 }
 
 void EntryView::setXSLTOptions(const Tellico::StyleOptions& opt_) {
   if(!m_handler) {
     return;
   }
   m_handler->addStringParam("font",     opt_.fontFamily.toLatin1());
   m_handler->addStringParam("fontsize", QByteArray().setNum(opt_.fontSize));
   m_handler->addStringParam("bgcolor",  opt_.baseColor.name().toLatin1());
   m_handler->addStringParam("fgcolor",  opt_.textColor.name().toLatin1());
   m_handler->addStringParam("color1",   opt_.highlightedTextColor.name().toLatin1());
   m_handler->addStringParam("color2",   opt_.highlightedBaseColor.name().toLatin1());
   m_handler->addStringParam("imgdir",   QFile::encodeName(opt_.imgDir));
 }
 
 void EntryView::resetView() {
   delete m_handler;
   m_handler = nullptr;
   setXSLTFile(m_xsltFile); // this ends up calling resetColors()
 }
 
 void EntryView::resetColors() {
   // recreate gradients
   ImageFactory::createStyleImages(m_entry ? m_entry->collection()->type() : Data::Collection::Base);
 
   QString dir = m_handler ? QFile::decodeName(m_handler->param("imgdir")) : QString();
   if(dir.isEmpty()) {
     dir = Data::Document::self()->allImagesOnDisk() ? ImageFactory::imageDir() : ImageFactory::tempDir();
   } else {
     // it's a string param, so it has quotes on both sides
     dir = dir.mid(1);
     dir.truncate(dir.length()-1);
   }
 
   // this is a rather bad hack to get around the fact that the image cache is not reloaded when
   // the gradient files are changed on disk. Setting the URLArgs for write() calls doesn't seem to
   // work. So force a reload with a temp file, then catch the completed signal and repaint
   QString s = QStringLiteral("<html><body><img src=\"%1\"><img src=\"%2\"></body></html>")
                              .arg(dir + QLatin1String("gradient_bg.png"),
                                   dir + QLatin1String("gradient_header.png"));
 
   delete m_tempFile;
   m_tempFile = new QTemporaryFile();
   if(!m_tempFile->open()) {
     myDebug() << "failed to open temp file";
     delete m_tempFile;
     m_tempFile = nullptr;
     return;
   }
   QTextStream stream(m_tempFile);
   stream << s;
   stream.flush();
 
   KParts::OpenUrlArguments args = arguments();
   args.setReload(true); // tell the cache to reload images
   setArguments(args);
 
   // don't flicker
   view()->setUpdatesEnabled(false);
   openUrl(QUrl::fromLocalFile(m_tempFile->fileName()));
-  connect(this, SIGNAL(completed()), SLOT(slotReloadEntry()));
+  void (EntryView::* completed)() = &EntryView::completed;
+  connect(this, completed, this, &EntryView::slotReloadEntry);
 }
diff --git a/src/exportdialog.cpp b/src/exportdialog.cpp
index 287adec3..d1bf76f3 100644
--- a/src/exportdialog.cpp
+++ b/src/exportdialog.cpp
@@ -1,306 +1,306 @@
 /***************************************************************************
     Copyright (C) 2003-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "exportdialog.h"
 #include "collection.h"
 #include "core/filehandler.h"
 #include "controller.h"
 #include "tellico_debug.h"
 
 #include "translators/exporter.h"
 #include "translators/tellicoxmlexporter.h"
 #include "translators/tellicozipexporter.h"
 #include "translators/htmlexporter.h"
 #include "translators/csvexporter.h"
 #include "translators/bibtexexporter.h"
 #include "translators/bibtexmlexporter.h"
 #include "translators/xsltexporter.h"
 #include "translators/alexandriaexporter.h"
 #include "translators/onixexporter.h"
 #include "translators/gcstarexporter.h"
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KConfigGroup>
 
 #include <QLayout>
 #include <QCheckBox>
 #include <QGroupBox>
 #include <QButtonGroup>
 #include <QRadioButton>
 #include <QTextCodec>
 #include <QVBoxLayout>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QScopedPointer>
 
 using namespace Tellico;
 using Tellico::ExportDialog;
 
 ExportDialog::ExportDialog(Tellico::Export::Format format_, Tellico::Data::CollPtr coll_, QWidget* parent_)
     : QDialog(parent_),
       m_format(format_), m_coll(coll_), m_exporter(exporter(format_, coll_)) {
   setModal(true);
   setWindowTitle(i18n("Export Options"));
 
   QWidget* widget = new QWidget(this);
   QVBoxLayout* topLayout = new QVBoxLayout(widget);
   setLayout(topLayout);
   topLayout->addWidget(widget);
 
   QGroupBox* group1 = new QGroupBox(i18n("Formatting"), widget);
   topLayout->addWidget(group1, 0);
   QVBoxLayout* vlay = new QVBoxLayout(group1);
 
   m_formatFields = new QCheckBox(i18n("Format all fields"), group1);
   m_formatFields->setChecked(false);
   m_formatFields->setWhatsThis(i18n("If checked, the values of the fields will be "
                                     "automatically formatted according to their format type."));
   vlay->addWidget(m_formatFields);
 
   m_exportSelected = new QCheckBox(i18n("Export selected entries only"), group1);
   m_exportSelected->setChecked(false);
   m_exportSelected->setWhatsThis(i18n("If checked, only the currently selected entries will "
                                       "be exported."));
   vlay->addWidget(m_exportSelected);
 
   m_exportFields = new QCheckBox(i18n("Export visible fields only"), group1);
   m_exportFields->setChecked(false);
   m_exportFields->setWhatsThis(i18n("If checked, only the fields currently visible in the view will "
                                     "be exported."));
   vlay->addWidget(m_exportFields);
 
   QGroupBox* group2 = new QGroupBox(i18n("Encoding"), widget);
   topLayout->addWidget(group2, 0);
 
   QVBoxLayout* vlay2 = new QVBoxLayout(group2);
 
   m_encodeUTF8 = new QRadioButton(i18n("Encode in Unicode (UTF-8)"), group2);
   m_encodeUTF8->setChecked(true);
   m_encodeUTF8->setWhatsThis(i18n("Encode the exported file in Unicode (UTF-8)."));
   vlay2->addWidget(m_encodeUTF8);
 
   QString localStr = i18n("Encode in user locale (%1)",
                           QLatin1String(QTextCodec::codecForLocale()->name()));
   m_encodeLocale = new QRadioButton(localStr, group2);
   m_encodeLocale->setWhatsThis(i18n("Encode the exported file in the local encoding."));
   vlay2->addWidget(m_encodeLocale);
 
   if(QTextCodec::codecForLocale()->name() == "UTF-8") {
     m_encodeUTF8->setEnabled(false);
     m_encodeLocale->setChecked(true);
   }
 
   QButtonGroup* bg = new QButtonGroup(widget);
   bg->addButton(m_encodeUTF8);
   bg->addButton(m_encodeLocale);
 
   QWidget* w = m_exporter->widget(widget);
   if(w) {
     w->layout()->setMargin(0);
     topLayout->addWidget(w, 0);
   }
 
   topLayout->addStretch();
 
   QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
   QPushButton* okButton = buttonBox->button(QDialogButtonBox::Ok);
   okButton->setDefault(true);
   okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
-  connect(okButton, SIGNAL(clicked()), SLOT(slotSaveOptions()));
-  connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
-  connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
+  connect(okButton, &QAbstractButton::clicked, this, &ExportDialog::slotSaveOptions);
+  connect(buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
+  connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
   topLayout->addWidget(buttonBox);
 
   readOptions();
   if(format_ == Export::Alexandria) {
     // no encoding options enabled
     group2->setEnabled(false);
   }
 }
 
 ExportDialog::~ExportDialog() {
   delete m_exporter;
   m_exporter = nullptr;
 }
 
 QString ExportDialog::fileFilter() {
   return m_exporter ? m_exporter->fileFilter() : QString();
 }
 
 void ExportDialog::readOptions() {
   KConfigGroup config(KSharedConfig::openConfig(), "ExportOptions");
   bool format = config.readEntry("FormatFields", false);
   m_formatFields->setChecked(format);
   bool selected = config.readEntry("ExportSelectedOnly", false);
   m_exportSelected->setChecked(selected);
   bool encode = config.readEntry("EncodeUTF8", true);
   if(encode && m_encodeUTF8->isEnabled()) {
     m_encodeUTF8->setChecked(true);
   } else {
     m_encodeLocale->setChecked(true);
   }
 }
 
 void ExportDialog::slotSaveOptions() {
   KSharedConfigPtr config = KSharedConfig::openConfig();
   // each exporter sets its own group
   m_exporter->saveOptions(config);
 
   KConfigGroup configGroup(config, "ExportOptions");
   configGroup.writeEntry("FormatFields", m_formatFields->isChecked());
   configGroup.writeEntry("ExportSelectedOnly", m_exportSelected->isChecked());
   configGroup.writeEntry("EncodeUTF8", m_encodeUTF8->isChecked());
 }
 
 // static
 Tellico::Export::Exporter* ExportDialog::exporter(Tellico::Export::Format format_, Data::CollPtr coll_) {
   Export::Exporter* exporter = nullptr;
 
   switch(format_) {
     case Export::TellicoXML:
       exporter = new Export::TellicoXMLExporter(coll_);
       break;
 
     case Export::TellicoZip:
       exporter = new Export::TellicoZipExporter(coll_);
       break;
 
     case Export::HTML:
       {
         Export::HTMLExporter* htmlExp = new Export::HTMLExporter(coll_);
         htmlExp->setGroupBy(Controller::self()->expandedGroupBy());
         htmlExp->setSortTitles(Controller::self()->sortTitles());
         htmlExp->setColumns(Controller::self()->visibleColumns());
         exporter = htmlExp;
       }
       break;
 
     case Export::CSV:
       exporter = new Export::CSVExporter(coll_);
       break;
 
     case Export::Bibtex:
       exporter = new Export::BibtexExporter(coll_);
       break;
 
     case Export::Bibtexml:
       exporter = new Export::BibtexmlExporter(coll_);
       break;
 
     case Export::XSLT:
       exporter = new Export::XSLTExporter(coll_);
       break;
 
     case Export::Alexandria:
       exporter = new Export::AlexandriaExporter(coll_);
       break;
 
     case Export::ONIX:
       exporter = new Export::ONIXExporter(coll_);
       break;
 
     case Export::GCstar:
       exporter = new Export::GCstarExporter(coll_);
       break;
 
     default:
       myDebug() << "not implemented!";
       break;
   }
   if(exporter) {
     exporter->readOptions(KSharedConfig::openConfig());
   }
   return exporter;
 }
 
 bool ExportDialog::exportURL(const QUrl& url_/*=QUrl()*/) const {
   if(!m_exporter) {
     return false;
   }
 
   // exporter might need to know final URL, say for writing images or something
   m_exporter->setURL(url_);
   if(m_exportSelected->isChecked()) {
     m_exporter->setEntries(Controller::self()->selectedEntries());
   } else {
     m_exporter->setEntries(m_coll->entries());
   }
   if(m_exportFields->isChecked()) {
     Data::FieldList fields;
     foreach(const QString& title, Controller::self()->visibleColumns()) {
       Data::FieldPtr field = m_coll->fieldByTitle(title);
       if(field) {
         fields << field;
       }
     }
     m_exporter->setFields(fields);
   } else {
     m_exporter->setFields(m_coll->fields());
   }
   long opt = Export::ExportImages | Export::ExportComplete | Export::ExportProgress; // for now, always export images
   if(m_formatFields->isChecked()) {
     opt |= Export::ExportFormatted;
   }
   if(m_encodeUTF8->isChecked()) {
     opt |= Export::ExportUTF8;
   }
   // since we already asked about overwriting the file, force the save
   opt |= Export::ExportForce;
 
   m_exporter->setOptions(opt);
 
   return m_exporter->exec();
 }
 
 // static
 // alexandria is exported to known directory
 // all others are files
 Tellico::Export::Target ExportDialog::exportTarget(Tellico::Export::Format format_) {
   switch(format_) {
     case Export::Alexandria:
       return Export::None;
     default:
       return Export::File;
   }
 }
 
 // static
 bool ExportDialog::exportCollection(Data::CollPtr coll_, Data::EntryList entries_, Export::Format format_, const QUrl& url_) {
   QScopedPointer<Export::Exporter> exp(exporter(format_, coll_));
   exp->setURL(url_);
   exp->setEntries(entries_);
 
   KConfigGroup config(KSharedConfig::openConfig(), "ExportOptions");
   long options = 0;
   if(config.readEntry("FormatFields", false)) {
     options |= Export::ExportFormatted;
   }
   if(config.readEntry("EncodeUTF8", true)) {
     options |= Export::ExportUTF8;
   }
   exp->setOptions(options | Export::ExportForce);
 
   return exp->exec();
 }
diff --git a/src/fetch/allocinefetcher.cpp b/src/fetch/allocinefetcher.cpp
index 5762b2f8..4ddc3047 100644
--- a/src/fetch/allocinefetcher.cpp
+++ b/src/fetch/allocinefetcher.cpp
@@ -1,502 +1,503 @@
 /***************************************************************************
     Copyright (C) 2012-2013 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include <config.h> // for TELLICO_VERSION
 
 #include "allocinefetcher.h"
 #include "../collections/videocollection.h"
 #include "../images/imagefactory.h"
 #include "../entry.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../core/filehandler.h"
 #include "../tellico_debug.h"
 
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KLocalizedString>
 #include <KJobWidgets/KJobWidgets>
 #include <KConfigGroup>
 
 #include <QSpinBox>
 #include <QUrl>
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QGridLayout>
 #include <QTextCodec>
 #include <QCryptographicHash>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QUrlQuery>
 
 namespace {
   static const char* ALLOCINE_API_KEY = "100043982026";
   static const char* ALLOCINE_API_URL = "http://api.allocine.fr/rest/v3/";
   static const char* ALLOCINE_PARTNER_KEY = "29d185d98c984a359e6e6f26a0474269";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::AbstractAllocineFetcher;
 using Tellico::Fetch::AllocineFetcher;
 
 AbstractAllocineFetcher::AbstractAllocineFetcher(QObject* parent_, const QString& baseUrl_)
     : Fetcher(parent_)
     , m_started(false)
     , m_apiKey(QLatin1String(ALLOCINE_API_KEY))
     , m_baseUrl(baseUrl_)
     , m_numCast(10) {
   Q_ASSERT(!m_baseUrl.isEmpty());
 }
 
 AbstractAllocineFetcher::~AbstractAllocineFetcher() {
 }
 
 bool AbstractAllocineFetcher::canSearch(FetchKey k) const {
   return k == Keyword;
 }
 
 bool AbstractAllocineFetcher::canFetch(int type) const {
   return type == Data::Collection::Video;
 }
 
 void AbstractAllocineFetcher::readConfigHook(const KConfigGroup& config_) {
   QString k = config_.readEntry("API Key", ALLOCINE_API_KEY);
   if(!k.isEmpty()) {
     m_apiKey = k;
   }
   m_numCast = config_.readEntry("Max Cast", 10);
 }
 
 void AbstractAllocineFetcher::search() {
   m_started = true;
 
   QUrl u(m_baseUrl);
   u = u.adjusted(QUrl::StripTrailingSlash);
   u.setPath(u.path() + QLatin1Char('/') + QStringLiteral("search"));
 //  myDebug() << u;
 
   // the order of the parameters appears to matter
   QList<QPair<QString, QString> > params;
   params.append(qMakePair(QStringLiteral("partner"), m_apiKey));
 
   // I can't figure out how to encode accent marks, but they don't
   // seem to be necessary
   QString q = removeAccents(request().value);
   // should I just remove all non alphabetical characters?
   // see https://bugs.kde.org/show_bug.cgi?id=337432
   q.remove(QRegExp(QStringLiteral("[,:!?;\\(\\)]")));
   q.replace(QLatin1Char('\''), QLatin1Char('+'));
   q.replace(QLatin1Char(' '), QLatin1Char('+'));
 
   switch(request().key) {
     case Keyword:
       params.append(qMakePair(QStringLiteral("q"), q));
       break;
 
     default:
       myWarning() << "key not recognized: " << request().key;
       return;
   }
 
   params.append(qMakePair(QStringLiteral("format"), QStringLiteral("json")));
   params.append(qMakePair(QStringLiteral("filter"), QStringLiteral("movie")));
 
   const QString sed = QDateTime::currentDateTimeUtc().toString(QStringLiteral("yyyyMMdd"));
   params.append(qMakePair(QStringLiteral("sed"), sed));
 
   const QByteArray sig = calculateSignature(params);
 
   QUrlQuery query;
   query.setQueryItems(params);
   query.addQueryItem(QStringLiteral("sig"), QLatin1String(sig));
   u.setQuery(query);
 //  myDebug() << u;
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   // 10/8/17: UserAgent appears necessary to receive data
   m_job->addMetaData(QStringLiteral("UserAgent"), QStringLiteral("Tellico/%1")
                                                                 .arg(QStringLiteral(TELLICO_VERSION)));
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result, this, &AbstractAllocineFetcher::slotComplete);
 }
 
 void AbstractAllocineFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
   }
   m_started = false;
   emit signalDone(this);
 }
 
 Tellico::Data::EntryPtr AbstractAllocineFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entries.value(uid_);
   if(!entry) {
     myWarning() << "no entry in dict";
     return Data::EntryPtr();
   }
 
   QString code = entry->field(QStringLiteral("allocine-code"));
   if(code.isEmpty()) {
     // could mean we already updated the entry
     myDebug() << "no allocine release found";
     return entry;
   }
 
   QUrl u(m_baseUrl);
   u = u.adjusted(QUrl::StripTrailingSlash);
   u.setPath(u.path() + QLatin1Char('/') + QStringLiteral("movie"));
 
   // the order of the parameters appears to matter
   QList<QPair<QString, QString> > params;
   params.append(qMakePair(QStringLiteral("partner"), m_apiKey));
   params.append(qMakePair(QStringLiteral("code"), code));
   params.append(qMakePair(QStringLiteral("profile"), QStringLiteral("large")));
   params.append(qMakePair(QStringLiteral("filter"), QStringLiteral("movie")));
   params.append(qMakePair(QStringLiteral("format"), QStringLiteral("json")));
 
   const QString sed = QDateTime::currentDateTimeUtc().toString(QStringLiteral("yyyyMMdd"));
   params.append(qMakePair(QStringLiteral("sed"), sed));
 
   const QByteArray sig = calculateSignature(params);
 
   QUrlQuery query;
   query.setQueryItems(params);
   query.addQueryItem(QStringLiteral("sig"), QLatin1String(sig));
   u.setQuery(query);
 //  myDebug() << "url: " << u;
   // 10/8/17: UserAgent appears necessary to receive data
 //  QByteArray data = FileHandler::readDataFile(u, true);
   KIO::StoredTransferJob* dataJob = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   dataJob->addMetaData(QStringLiteral("UserAgent"), QStringLiteral("Tellico/%1")
                                                                   .arg(QStringLiteral(TELLICO_VERSION)));
   if(!dataJob->exec()) {
     myDebug() << "Failed to load" << u;
     return entry;
   }
   const QByteArray data = dataJob->data();
 
 #if 0
   myWarning() << "Remove debug2 from allocinefetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/test2.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   QJsonParseError error;
   QJsonDocument doc = QJsonDocument::fromJson(data, &error);
   QVariantMap result = doc.object().toVariantMap().value(QStringLiteral("movie")).toMap();
   if(error.error != QJsonParseError::NoError) {
     myDebug() << "Bad JSON results";
 #if 0
     myWarning() << "Remove debug3 from allocinefetcher.cpp";
     QFile f2(QString::fromLatin1("/tmp/test3.json"));
     if(f2.open(QIODevice::WriteOnly)) {
       QTextStream t(&f2);
       t.setCodec("UTF-8");
       t << data;
     }
     f2.close();
 #endif
     return entry;
   }
   populateEntry(entry, result);
 
   // image might still be a URL
   const QString image_id = entry->field(QStringLiteral("cover"));
   if(image_id.contains(QLatin1Char('/'))) {
     const QString id = ImageFactory::addImage(QUrl::fromUserInput(image_id), true /* quiet */);
     if(id.isEmpty()) {
       message(i18n("The cover image could not be loaded."), MessageHandler::Warning);
     }
     // empty image ID is ok
     entry->setField(QStringLiteral("cover"), id);
   }
 
   // don't want to include id
   entry->collection()->removeField(QStringLiteral("allocine-code"));
   QStringList castRows = FieldFormat::splitTable(entry->field(QStringLiteral("cast")));
   while(castRows.count() > m_numCast) {
     castRows.removeLast();
   }
   entry->setField(QStringLiteral("cast"), castRows.join(FieldFormat::rowDelimiterString()));
   return entry;
 }
 
 void AbstractAllocineFetcher::slotComplete(KJob*) {
   if(m_job->error()) {
     myDebug() << "Error:" << m_job->errorString();
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from allocinefetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/test.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   QVariantMap result = doc.object().toVariantMap().value(QStringLiteral("feed")).toMap();
 //  myDebug() << "total:" << result.value(QLatin1String("totalResults"));
 
   QVariantList resultList = result.value(QStringLiteral("movie")).toList();
   if(resultList.isEmpty()) {
     myDebug() << "no results";
     stop();
     return;
   }
 
   foreach(const QVariant& result, resultList) {
   //  myDebug() << "found result:" << result;
 
     //create a new collection for every result since we end up removing the allocine code field
     // when fetchEntryHook is called. See bug 338389
     Data::EntryPtr entry(new Data::Entry(createCollection()));
     populateEntry(entry, result.toMap());
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
   }
 
   m_hasMoreResults = false;
   stop();
 }
 
 Tellico::Data::CollPtr AbstractAllocineFetcher::createCollection() const {
   Data::CollPtr coll(new Data::VideoCollection(true));
   // always add the allocine release code for fetchEntryHook
   Data::FieldPtr field(new Data::Field(QStringLiteral("allocine-code"), QStringLiteral("Allocine Code"), Data::Field::Number));
   field->setCategory(i18n("General"));
   coll->addField(field);
 
   // add new fields
   if(optionalFields().contains(QStringLiteral("allocine"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("allocine"), i18n("Allocine Link"), Data::Field::URL));
     field->setCategory(i18n("General"));
     coll->addField(field);
   }
   if(optionalFields().contains(QStringLiteral("origtitle"))) {
     Data::FieldPtr f(new Data::Field(QStringLiteral("origtitle"), i18n("Original Title")));
     f->setFormatType(FieldFormat::FormatTitle);
     coll->addField(f);
   }
 
   return coll;
 }
 
 void AbstractAllocineFetcher::populateEntry(Data::EntryPtr entry, const QVariantMap& resultMap) {
   if(entry->collection()->hasField(QStringLiteral("allocine-code"))) {
     entry->setField(QStringLiteral("allocine-code"), mapValue(resultMap, "code"));
   }
 
   entry->setField(QStringLiteral("title"), mapValue(resultMap, "title"));
   if(optionalFields().contains(QStringLiteral("origtitle"))) {
     entry->setField(QStringLiteral("origtitle"), mapValue(resultMap, "originalTitle"));
   }
   if(entry->title().isEmpty()) {
     entry->setField(QStringLiteral("title"), mapValue(resultMap,  "originalTitle"));
   }
   entry->setField(QStringLiteral("year"), mapValue(resultMap, "productionYear"));
   entry->setField(QStringLiteral("plot"), mapValue(resultMap, "synopsis"));
 
   const int runTime = mapValue(resultMap, "runtime").toInt();
   entry->setField(QStringLiteral("running-time"), QString::number(runTime/60));
 
   const QVariantList castList = resultMap.value(QStringLiteral("castMember")).toList();
   QStringList actors, directors, producers, composers;
   foreach(const QVariant& castVariant, castList) {
     const QVariantMap castMap = castVariant.toMap();
     const int code = mapValue(castMap, "activity", "code").toInt();
     switch(code) {
       case 8001:
         actors << (mapValue(castMap, "person", "name") + FieldFormat::columnDelimiterString() + mapValue(castMap, "role"));
         break;
       case 8002:
         directors << mapValue(castMap, "person", "name");
         break;
       case 8029:
         producers << mapValue(castMap, "person", "name");
         break;
       case 8003:
         composers << mapValue(castMap, "person", "name");
         break;
     }
   }
   entry->setField(QStringLiteral("cast"), actors.join(FieldFormat::rowDelimiterString()));
   entry->setField(QStringLiteral("director"), directors.join(FieldFormat::delimiterString()));
   entry->setField(QStringLiteral("producer"), producers.join(FieldFormat::delimiterString()));
   entry->setField(QStringLiteral("composer"), composers.join(FieldFormat::delimiterString()));
 
   const QVariantMap releaseMap = resultMap.value(QStringLiteral("release")).toMap();
   entry->setField(QStringLiteral("studio"), mapValue(releaseMap, "distributor", "name"));
 
   QStringList genres;
   foreach(const QVariant& variant, resultMap.value(QLatin1String("genre")).toList()) {
     genres << i18n(mapValue(variant.toMap(), "$").toUtf8().constData());
   }
   entry->setField(QStringLiteral("genre"), genres.join(FieldFormat::delimiterString()));
 
   QStringList nats;
   foreach(const QVariant& variant, resultMap.value(QLatin1String("nationality")).toList()) {
     nats << mapValue(variant.toMap(), "$");
   }
   entry->setField(QStringLiteral("nationality"), nats.join(FieldFormat::delimiterString()));
 
   QStringList langs;
   foreach(const QVariant& variant, resultMap.value(QLatin1String("language")).toList()) {
     langs << mapValue(variant.toMap(), "$");
   }
   entry->setField(QStringLiteral("language"), langs.join(FieldFormat::delimiterString()));
 
   const QVariantMap colorMap = resultMap.value(QLatin1String("color")).toMap();
   if(colorMap.value(QStringLiteral("code")) == QLatin1String("12001")) {
     entry->setField(QStringLiteral("color"), i18n("Color"));
   }
 
   entry->setField(QStringLiteral("cover"), mapValue(resultMap, "poster", "href"));
 
   if(optionalFields().contains(QStringLiteral("allocine"))) {
     entry->setField(QStringLiteral("allocine"), mapValue(resultMap, "link", "href"));
   }
 }
 
 Tellico::Fetch::FetchRequest AbstractAllocineFetcher::updateRequest(Data::EntryPtr entry_) {
   QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Keyword, title);
   }
   return FetchRequest();
 }
 
 AbstractAllocineFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const AbstractAllocineFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
 
   QLabel* label = new QLabel(i18n("&Maximum cast: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_numCast = new QSpinBox(optionsWidget());
   m_numCast->setMaximum(99);
   m_numCast->setMinimum(0);
   m_numCast->setValue(10);
-  connect(m_numCast, SIGNAL(valueChanged(QString)), SLOT(slotSetModified()));
+  void (QSpinBox::* valueChanged)(const QString&) = &QSpinBox::valueChanged;
+  connect(m_numCast, valueChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_numCast, row, 1);
   QString w = i18n("The list of cast members may include many people. Set the maximum number returned from the search.");
   label->setWhatsThis(w);
   m_numCast->setWhatsThis(w);
   label->setBuddy(m_numCast);
 
   l->setRowStretch(++row, 10);
 
   m_numCast->setValue(fetcher_ ? fetcher_->m_numCast : 10);
 }
 
 void AbstractAllocineFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   config_.writeEntry("Max Cast", m_numCast->value());
 }
 
 QByteArray AbstractAllocineFetcher::calculateSignature(const QList<QPair<QString, QString> >& params_) {
   typedef QPair<QString, QString> StringPair;
   QByteArray queryString;
   foreach(const StringPair& pair, params_) {
     queryString.append(pair.first.toUtf8().toPercentEncoding("+"));
     queryString.append('=');
     queryString.append(pair.second.toUtf8().toPercentEncoding("+"));
     queryString.append('&');
   }
   // remove final '&'
   queryString.chop(1);
 
   const QByteArray toSign = ALLOCINE_PARTNER_KEY + queryString;
   const QByteArray hash = QCryptographicHash::hash(toSign, QCryptographicHash::Sha1);
   QByteArray sig = hash.toBase64();
   return sig;
 }
 
 /**********************************************************************************************/
 
 AllocineFetcher::AllocineFetcher(QObject* parent_)
     : AbstractAllocineFetcher(parent_, QLatin1String(ALLOCINE_API_URL)) {
 }
 
 QString AllocineFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 Tellico::Fetch::ConfigWidget* AllocineFetcher::configWidget(QWidget* parent_) const {
   return new AllocineFetcher::ConfigWidget(parent_, this);
 }
 
 QString AllocineFetcher::defaultName() {
   return QStringLiteral("AlloCiné.fr");
 }
 
 QString AllocineFetcher::defaultIcon() {
   return favIcon("http://www.allocine.fr");
 }
 
 Tellico::StringHash AllocineFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("origtitle")] = i18n("Original Title");
   hash[QStringLiteral("allocine")]  = i18n("Allocine Link");
   return hash;
 }
 
 AllocineFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const AbstractAllocineFetcher* fetcher_)
     : AbstractAllocineFetcher::ConfigWidget(parent_, fetcher_) {
   // now add additional fields widget
   addFieldsWidget(AllocineFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 QString AllocineFetcher::ConfigWidget::preferredName() const {
   return AllocineFetcher::defaultName();
 }
diff --git a/src/fetch/amazonfetcher.cpp b/src/fetch/amazonfetcher.cpp
index aac403bc..4995933c 100644
--- a/src/fetch/amazonfetcher.cpp
+++ b/src/fetch/amazonfetcher.cpp
@@ -1,1087 +1,1089 @@
 /***************************************************************************
     Copyright (C) 2004-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include <config.h>
 
 #include "amazonfetcher.h"
 #include "amazonrequest.h"
 #include "../translators/xslthandler.h"
 #include "../translators/tellicoimporter.h"
 #include "../images/imagefactory.h"
 #include "../utils/guiproxy.h"
 #include "../collection.h"
 #include "../entry.h"
 #include "../field.h"
 #include "../fieldformat.h"
 #include "../utils/string_utils.h"
 #include "../utils/isbnvalidator.h"
 #include "../utils/datafileregistry.h"
 #include "../gui/combobox.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KSeparator>
 #include <KComboBox>
 #include <KAcceleratorManager>
 #include <KConfigGroup>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QLineEdit>
 #include <QDomDocument>
 #include <QLabel>
 #include <QCheckBox>
 #include <QFile>
 #include <QTextStream>
 #include <QTextCodec>
 #include <QGridLayout>
 #include <QStandardPaths>
 
 namespace {
   static const int AMAZON_RETURNS_PER_REQUEST = 10;
   static const int AMAZON_MAX_RETURNS_TOTAL = 20;
   static const char* AMAZON_ASSOC_TOKEN = "tellico-20";
   // need to have these in the translation file
   static const char* linkText = I18N_NOOP("Amazon Link");
 }
 
 using namespace Tellico;
 using Tellico::Fetch::AmazonFetcher;
 
 // static
 const AmazonFetcher::SiteData& AmazonFetcher::siteData(int site_) {
   Q_ASSERT(site_ >= 0);
   Q_ASSERT(site_ < 15);
   static SiteData dataVector[14] = {
     {
       i18n("Amazon (US)"),
       QUrl(QLatin1String("http://webservices.amazon.com/onca/xml")),
       QLatin1String("us"),
       i18n("United States")
     }, {
       i18n("Amazon (UK)"),
       QUrl(QLatin1String("http://webservices.amazon.co.uk/onca/xml")),
       QLatin1String("gb"),
       i18n("United Kingdom")
     }, {
       i18n("Amazon (Germany)"),
       QUrl(QLatin1String("http://webservices.amazon.de/onca/xml")),
       QLatin1String("de"),
       i18n("Germany")
     }, {
       i18n("Amazon (Japan)"),
       QUrl(QLatin1String("http://webservices.amazon.co.jp/onca/xml")),
       QLatin1String("jp"),
       i18n("Japan")
     }, {
       i18n("Amazon (France)"),
       QUrl(QLatin1String("http://webservices.amazon.fr/onca/xml")),
       QLatin1String("fr"),
       i18n("France")
     }, {
       i18n("Amazon (Canada)"),
       QUrl(QLatin1String("http://webservices.amazon.ca/onca/xml")),
       QLatin1String("ca"),
       i18n("Canada")
     }, {
       i18n("Amazon (China)"),
       QUrl(QLatin1String("http://webservices.amazon.cn/onca/xml")),
       QLatin1String("ch"),
       i18n("China")
     }, {
       i18n("Amazon (Spain)"),
       QUrl(QLatin1String("http://webservices.amazon.es/onca/xml")),
       QLatin1String("es"),
       i18n("Spain")
     }, {
       i18n("Amazon (Italy)"),
       QUrl(QLatin1String("http://webservices.amazon.it/onca/xml")),
       QLatin1String("it"),
       i18n("Italy")
     }, {
       i18n("Amazon (Brazil)"),
       QUrl(QLatin1String("http://webservices.amazon.com.br/onca/xml")),
       QLatin1String("br"),
       i18n("Brazil")
     }, {
       i18n("Amazon (Australia)"),
       QUrl(QLatin1String("http://webservices.amazon.com.au/onca/xml")),
       QLatin1String("au"),
       i18n("Australia")
     }, {
       i18n("Amazon (India)"),
       QUrl(QLatin1String("http://webservices.amazon.in/onca/xml")),
       QLatin1String("in"),
       i18n("India")
     }, {
       i18n("Amazon (Mexico)"),
       QUrl(QLatin1String("http://webservices.amazon.com.mx/onca/xml")),
       QLatin1String("mx"),
       i18n("Mexico")
     }, {
       i18n("Amazon (Turkey)"),
       QUrl(QLatin1String("http://webservices.amazon.com.tr/onca/xml")),
       QLatin1String("tr"),
       i18n("Turkey")
     }
   };
 
   return dataVector[qBound(0, site_, static_cast<int>(sizeof(dataVector)/sizeof(SiteData)))];
 }
 
 AmazonFetcher::AmazonFetcher(QObject* parent_)
     : Fetcher(parent_), m_xsltHandler(nullptr), m_site(Unknown), m_imageSize(MediumImage),
       m_assoc(QLatin1String(AMAZON_ASSOC_TOKEN)), m_addLinkField(true), m_limit(AMAZON_MAX_RETURNS_TOTAL),
       m_countOffset(0), m_page(1), m_total(-1), m_numResults(0), m_job(nullptr), m_started(false) {
   (void)linkText; // just to shut up the compiler
 }
 
 AmazonFetcher::~AmazonFetcher() {
   delete m_xsltHandler;
   m_xsltHandler = nullptr;
 }
 
 QString AmazonFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 QString AmazonFetcher::attribution() const {
   return i18n("This data is licensed under <a href=""%1"">specific terms</a>.",
               QLatin1String("https://affiliate-program.amazon.com/gp/advertising/api/detail/agreement.html"));
 }
 
 bool AmazonFetcher::canFetch(int type) const {
   return type == Data::Collection::Book
          || type == Data::Collection::ComicBook
          || type == Data::Collection::Bibtex
          || type == Data::Collection::Album
          || type == Data::Collection::Video
          || type == Data::Collection::Game
          || type == Data::Collection::BoardGame;
 }
 
 bool AmazonFetcher::canSearch(FetchKey k) const {
   // no UPC in Canada
   return k == Title
          || k == Person
          || k == ISBN
          || (k == UPC && m_site != CA)
          || k == Keyword;
 }
 
 void AmazonFetcher::readConfigHook(const KConfigGroup& config_) {
   const int site = config_.readEntry("Site", int(Unknown));
   Q_ASSERT(site != Unknown);
   m_site = static_cast<Site>(site);
   if(m_name.isEmpty()) {
     m_name = siteData(m_site).title;
   }
   QString s = config_.readEntry("AccessKey");
   if(!s.isEmpty()) {
     m_access = s;
   } else {
     myWarning() << "No Amazon access key";
   }
   s = config_.readEntry("AssocToken");
   if(!s.isEmpty()) {
     m_assoc = s;
   }
   s = config_.readEntry("SecretKey");
   if(!s.isEmpty()) {
     m_amazonKey = s.toUtf8();
   } else {
     myWarning() << "No Amazon secret key";
   }
   int imageSize = config_.readEntry("Image Size", -1);
   if(imageSize > -1) {
     m_imageSize = static_cast<ImageSize>(imageSize);
   }
 }
 
 void AmazonFetcher::search() {
   m_started = true;
   m_page = 1;
   m_total = -1;
   m_countOffset = 0;
   m_numResults = 0;
   doSearch();
 }
 
 void AmazonFetcher::continueSearch() {
   m_started = true;
   m_limit += AMAZON_MAX_RETURNS_TOTAL;
   doSearch();
 }
 
 void AmazonFetcher::doSearch() {
   // calling secretKey() ensures that we try to read it first
   if(secretKey().isEmpty() || m_access.isEmpty()) {
     if(m_access.isEmpty()) {
       myWarning() << "No Amazon access key";
     }
     // this message is split in two since the first half is reused later
     message(i18n("Access to data from Amazon.com requires an AWS Access Key ID and a Secret Key.") +
             QLatin1Char(' ') +
             i18n("Those values must be entered in the data source settings."), MessageHandler::Error);
     stop();
     return;
   }
 
 //  myDebug() << "value = " << request().value;
 //  myDebug() << "getting page " << m_page;
 
   QMap<QString, QString> params;
   params.insert(QStringLiteral("Service"),        QStringLiteral("AWSECommerceService"));
   params.insert(QStringLiteral("AssociateTag"),   m_assoc);
   params.insert(QStringLiteral("AWSAccessKeyId"), m_access);
   params.insert(QStringLiteral("Operation"),      QStringLiteral("ItemSearch"));
   params.insert(QStringLiteral("ResponseGroup"),  QStringLiteral("Large"));
   params.insert(QStringLiteral("ItemPage"),       QString::number(m_page));
   // this should match the namespace in amazon2tellico.xsl
   params.insert(QStringLiteral("Version"),        QStringLiteral("2011-08-01"));
 
   const int type = collectionType();
   switch(type) {
     case Data::Collection::Book:
     case Data::Collection::ComicBook:
     case Data::Collection::Bibtex:
       params.insert(QStringLiteral("SearchIndex"), QStringLiteral("Books"));
       params.insert(QStringLiteral("SortIndex"), QStringLiteral("relevancerank"));
       break;
 
     case Data::Collection::Album:
       params.insert(QStringLiteral("SearchIndex"), QStringLiteral("Music"));
       break;
 
     case Data::Collection::Video:
       // CA and JP appear to have a bug where Video only returns VHS or Music results
       // DVD will return DVD, Blu-ray, etc. so just ignore VHS for those users
       if(m_site == CA || m_site == JP || m_site == IT || m_site == ES) {
         params.insert(QStringLiteral("SearchIndex"), QStringLiteral("DVD"));
       } else {
         params.insert(QStringLiteral("SearchIndex"), QStringLiteral("Video"));
       }
       params.insert(QStringLiteral("SortIndex"), QStringLiteral("relevancerank"));
       break;
 
     case Data::Collection::Game:
       params.insert(QStringLiteral("SearchIndex"), QStringLiteral("VideoGames"));
       break;
 
     case Data::Collection::BoardGame:
       params.insert(QStringLiteral("SearchIndex"), QStringLiteral("Toys"));
       params.insert(QStringLiteral("SortIndex"), QStringLiteral("relevancerank"));
       break;
 
     case Data::Collection::Coin:
     case Data::Collection::Stamp:
     case Data::Collection::Wine:
     case Data::Collection::Base:
     case Data::Collection::Card:
       myDebug() << "can't fetch this type:" << collectionType();
       stop();
       return;
   }
 
   QString value = request().value;
 
   switch(request().key) {
     case Title:
       params.insert(QStringLiteral("Title"), value);
       break;
 
     case Person:
       if(type == Data::Collection::Video) {
         params.insert(QStringLiteral("Actor"),        value);
         params.insert(QStringLiteral("Director"),     value);
       } else if(type == Data::Collection::Album) {
         params.insert(QStringLiteral("Artist"),       value);
       } else if(type == Data::Collection::Game) {
         params.insert(QStringLiteral("Manufacturer"), value);
       } else { // books and bibtex
         QString s = QStringLiteral("author:%1 or publisher:%2").arg(value, value);
 //        params.insert(QLatin1String("Author"),       value, mib);
 //        params.insert(QLatin1String("Publisher"),    value, mib);
         params.insert(QStringLiteral("Power"),    s);
       }
       break;
 
     case ISBN:
       {
         params.insert(QStringLiteral("Operation"), QStringLiteral("ItemLookup"));
 
         QString cleanValue = value;
         cleanValue.remove(QLatin1Char('-'));
         // ISBN only get digits or 'X'
         QStringList isbns = FieldFormat::splitValue(cleanValue);
         // Amazon isbn13 search is still very flaky, so if possible, we're going to convert
         // all of them to isbn10. If we run into a 979 isbn13, then we're forced to do an
         // isbn13 search
         bool isbn13 = false;
         for(QStringList::Iterator it = isbns.begin(); it != isbns.end(); ) {
           if((*it).startsWith(QLatin1String("979"))) {
             if(m_site == JP) { // never works for JP
               myWarning() << "ISBN-13 searching not implemented for Japan";
               it = isbns.erase(it);
               continue;
             }
             isbn13 = true;
             break;
           }
           ++it;
         }
         // if we want isbn10, then convert all
         if(!isbn13) {
           for(QStringList::Iterator it = isbns.begin(); it != isbns.end(); ++it) {
             if((*it).length() > 12) {
               (*it) = ISBNValidator::isbn10(*it);
               (*it).remove(QLatin1Char('-'));
             }
           }
           // the default search is by ASIN, which prohibits SearchIndex
           params.remove(QStringLiteral("SearchIndex"));
         }
         // limit to first 10
         while(isbns.size() > 10) {
           isbns.pop_back();
         }
         params.insert(QStringLiteral("ItemId"), isbns.join(QLatin1String(",")));
         if(isbn13) {
           params.insert(QStringLiteral("IdType"), QStringLiteral("EAN"));
         }
       }
       break;
 
     case UPC:
       {
         QString cleanValue = value;
         cleanValue.remove(QLatin1Char('-'));
         // for EAN values, add 0 to beginning if not 13 characters
         // in order to assume US country code from UPC value
         QStringList values;
         foreach(const QString& splitValue, cleanValue.split(FieldFormat::delimiterString())) {
           QString tmpValue = splitValue;
           if(m_site != US && tmpValue.length() == 12) {
             tmpValue.prepend(QLatin1Char('0'));
           }
           values << tmpValue;
           // limit to first 10 values
           if(values.length() >= 10) {
             break;
           }
         }
 
         params.insert(QStringLiteral("Operation"), QStringLiteral("ItemLookup"));
         // US allows UPC, all others are EAN
         if(m_site == US) {
           params.insert(QStringLiteral("IdType"), QStringLiteral("UPC"));
         } else {
           params.insert(QStringLiteral("IdType"), QStringLiteral("EAN"));
         }
         params.insert(QStringLiteral("ItemId"), values.join(QLatin1String(",")));
       }
       break;
 
     case Keyword:
       params.insert(QStringLiteral("Keywords"), value);
       break;
 
     case Raw:
       {
         QString key = value.section(QLatin1Char('='), 0, 0).trimmed();
         QString str = value.section(QLatin1Char('='), 1).trimmed();
         params.insert(key, str);
       }
       break;
 
     default:
       myWarning() << "key not recognized: " << request().key;
       stop();
       return;
   }
 
   AmazonRequest request(siteData(m_site).url, m_amazonKey);
   QUrl newUrl = request.signedRequest(params);
 //  myDebug() << newUrl;
 
   m_job = KIO::storedGet(newUrl, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)),
-          SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result,
+          this, &AmazonFetcher::slotComplete);
 }
 
 void AmazonFetcher::stop() {
   if(!m_started) {
     return;
   }
 //  myDebug();
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 void AmazonFetcher::slotComplete(KJob*) {
 //  myDebug();
 
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
 
   // since the fetch is done, don't worry about holding the job pointer
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from amazonfetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/test%1.xml").arg(m_page));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   QStringList errors;
   if(m_total == -1) {
     QDomDocument dom;
     if(!dom.setContent(data, false)) {
       myWarning() << "server did not return valid XML.";
       stop();
       return;
     }
     // check for ItemSearchErrorResponse
     if(dom.documentElement().tagName() == QLatin1String("ItemSearchErrorResponse")) {
       QDomNode n = dom.documentElement().namedItem(QStringLiteral("Error")).namedItem(QStringLiteral("Message"));
       if(!n.isNull()) {
         message(n.toElement().text(), MessageHandler::Error);
         stop();
         return;
       }
     }
     // find TotalResults element
     // it's in the first level under the root element
     //ItemSearchResponse/Items/TotalResults
     QDomNode n = dom.documentElement().namedItem(QStringLiteral("Items"))
                                       .namedItem(QStringLiteral("TotalResults"));
     QDomElement e = n.toElement();
     if(!e.isNull()) {
       m_total = e.text().toInt();
     }
     n = dom.documentElement().namedItem(QStringLiteral("Items"))
                              .namedItem(QStringLiteral("Request"))
                              .namedItem(QStringLiteral("Errors"));
     e = n.toElement();
     if(!e.isNull()) {
       QDomNodeList nodes = e.elementsByTagName(QStringLiteral("Error"));
       for(int i = 0; i < nodes.count(); ++i) {
         e = nodes.item(i).toElement().namedItem(QStringLiteral("Code")).toElement();
         if(!e.isNull() && e.text() == QLatin1String("AWS.ECommerceService.NoExactMatches")) {
           // no exact match, not a real error, so skip
           continue;
         }
         // for some reason, Amazon will return an error simply when a valid ISBN is not found
         // I really want to ignore that, so check the IsValid element in the Request element
         QDomNode isValidNode = n.parentNode().namedItem(QStringLiteral("IsValid"));
         if(request().key == ISBN && isValidNode.toElement().text().toLower() == QLatin1String("true")) {
           continue;
         }
         e = nodes.item(i).toElement().namedItem(QStringLiteral("Message")).toElement();
         if(!e.isNull()) {
           errors << e.text();
         }
       }
     }
   }
 
   if(!m_xsltHandler) {
     initXSLTHandler();
     if(!m_xsltHandler) { // probably an error somewhere in the stylesheet loading
       stop();
       return;
     }
   }
 
 //  QRegExp stripHTML(QLatin1String("<.*>"), true);
 //  stripHTML.setMinimal(true);
 
   // assume amazon is always utf-8
   QString str = m_xsltHandler->applyStylesheet(QString::fromUtf8(data.constData(), data.size()));
   Import::TellicoImporter imp(str);
   // be quiet when loading images
   imp.setOptions(imp.options() ^ Import::ImportShowImageErrors);
   Data::CollPtr coll = imp.collection();
   if(!coll) {
     myDebug() << "no collection pointer";
     stop();
     return;
   }
 
   if(!m_addLinkField) {
     // remove amazon field if it's not to be added
     coll->removeField(QStringLiteral("amazon"));
   }
 
   Data::EntryList entries = coll->entries();
   if(entries.isEmpty() && !errors.isEmpty()) {
     for(QStringList::ConstIterator it = errors.constBegin(); it != errors.constEnd(); ++it) {
       myDebug() << "AmazonFetcher::" << *it;
     }
     message(errors[0], MessageHandler::Error);
     stop();
     return;
   }
 
   int count = -1;
   foreach(Data::EntryPtr entry, entries) {
     ++count;
     if(m_numResults >= m_limit) {
       break;
     }
     if(count < m_countOffset) {
       continue;
     }
     if(!m_started) {
       // might get aborted
       break;
     }
 
     // special case book author
     // amazon is really bad about not putting spaces after periods
     if(coll->type() == Data::Collection::Book) {
       QRegExp rx(QLatin1String("\\.([^\\s])"));
       QStringList values = FieldFormat::splitValue(entry->field(QStringLiteral("author")));
       for(QStringList::Iterator it = values.begin(); it != values.end(); ++it) {
         (*it).replace(rx, QStringLiteral(". \\1"));
       }
       entry->setField(QStringLiteral("author"), values.join(FieldFormat::delimiterString()));
     }
 
     // UK puts the year in the title for some reason
     if(m_site == UK && coll->type() == Data::Collection::Video) {
       QRegExp rx(QLatin1String("\\[(\\d{4})\\]"));
       QString t = entry->title();
       if(rx.indexIn(t) > -1) {
         QString y = rx.cap(1);
         t = t.remove(rx).simplified();
         entry->setField(QStringLiteral("title"), t);
         if(entry->field(QStringLiteral("year")).isEmpty()) {
           entry->setField(QStringLiteral("year"), y);
         }
       }
     }
 
     // strip HTML from comments, or plot in movies
     // tentatively don't do this, looks like ECS 4 cleaned everything up
 /*
     if(coll->type() == Data::Collection::Video) {
       QString plot = entry->field(QLatin1String("plot"));
       plot.remove(stripHTML);
       entry->setField(QLatin1String("plot"), plot);
     } else if(coll->type() == Data::Collection::Game) {
       QString desc = entry->field(QLatin1String("description"));
       desc.remove(stripHTML);
       entry->setField(QLatin1String("description"), desc);
     } else {
       QString comments = entry->field(QLatin1String("comments"));
       comments.remove(stripHTML);
       entry->setField(QLatin1String("comments"), comments);
     }
 */
 //    myDebug() << entry->title();
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
     ++m_numResults;
   }
 
   // we might have gotten aborted
   if(!m_started) {
     return;
   }
 
   // are there any additional results to get?
   m_hasMoreResults = m_page * AMAZON_RETURNS_PER_REQUEST < m_total;
 
   const int currentTotal = qMin(m_total, m_limit);
   if(m_page * AMAZON_RETURNS_PER_REQUEST < currentTotal) {
     int foundCount = (m_page-1) * AMAZON_RETURNS_PER_REQUEST + coll->entryCount();
     message(i18n("Results from %1: %2/%3", source(), foundCount, m_total), MessageHandler::Status);
     ++m_page;
     m_countOffset = 0;
     doSearch();
   } else if(request().value.count(QLatin1Char(';')) > 9) {
     // start new request after cutting off first 10 isbn values
     FetchRequest newRequest = request();
     newRequest.value = request().value.section(QLatin1Char(';'), 10);
     startSearch(newRequest);
   } else {
     m_countOffset = m_entries.count() % AMAZON_RETURNS_PER_REQUEST;
     if(m_countOffset == 0) {
       ++m_page; // need to go to next page
     }
     stop();
   }
 }
 
 Tellico::Data::EntryPtr AmazonFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entries[uid_];
   if(!entry) {
     myWarning() << "no entry in dict";
     return entry;
   }
 
   // do what we can to remove useless keywords
   const int type = collectionType();
   switch(type) {
     case Data::Collection::Book:
     case Data::Collection::ComicBook:
     case Data::Collection::Bibtex:
       if(optionalFields().contains(QStringLiteral("keyword"))) {
         StringSet newWords;
         const QStringList keywords = FieldFormat::splitValue(entry->field(QStringLiteral("keyword")));
         foreach(const QString& keyword, keywords) {
           // the amazon2tellico stylesheet separates keywords with '/'
           const QStringList words = keyword.split(QLatin1Char('/'));
           foreach(const QString& word, words) {
             if(word == QLatin1String("General") ||
                word == QLatin1String("Subjects") ||
                word == QLatin1String("Par prix") || // french stuff
                word == QLatin1String("Divers") || // french stuff
                word.startsWith(QLatin1Char('(')) ||
                word.startsWith(QLatin1String("Authors"))) {
               continue;
             }
             newWords.add(word);
           }
         }
         entry->setField(QStringLiteral("keyword"), newWords.toList().join(FieldFormat::delimiterString()));
       }
       entry->setField(QStringLiteral("comments"), Tellico::decodeHTML(entry->field(QStringLiteral("comments"))));
       break;
 
     case Data::Collection::Video:
       {
         const QString genres = QStringLiteral("genre");
         QStringList oldWords = FieldFormat::splitValue(entry->field(genres));
         StringSet words;
         // only care about genres that have "Genres" in the amazon response
         // and take the first word after that
         for(QStringList::Iterator it = oldWords.begin(); it != oldWords.end(); ++it) {
           if((*it).indexOf(QLatin1String("Genres")) == -1) {
             continue;
           }
 
           // the amazon2tellico stylesheet separates words with '/'
           QStringList nodes = (*it).split(QLatin1Char('/'));
           for(QStringList::Iterator it2 = nodes.begin(); it2 != nodes.end(); ++it2) {
             if(*it2 != QLatin1String("Genres")) {
               continue;
             }
             ++it2;
             if(it2 != nodes.end() && *it2 != QLatin1String("General")) {
               words.add(*it2);
             }
             break; // we're done
           }
         }
         entry->setField(genres, words.toList().join(FieldFormat::delimiterString()));
         // language tracks get duplicated, too
         words.clear();
         words.add(FieldFormat::splitValue(entry->field(QStringLiteral("language"))));
         entry->setField(QStringLiteral("language"), words.toList().join(FieldFormat::delimiterString()));
       }
       entry->setField(QStringLiteral("plot"), Tellico::decodeHTML(entry->field(QStringLiteral("plot"))));
       break;
 
     case Data::Collection::Album:
       {
         const QString genres = QStringLiteral("genre");
         QStringList oldWords = FieldFormat::splitValue(entry->field(genres));
         StringSet words;
         // only care about genres that have "Styles" in the amazon response
         // and take the first word after that
         for(QStringList::Iterator it = oldWords.begin(); it != oldWords.end(); ++it) {
           if((*it).indexOf(QLatin1String("Styles")) == -1) {
             continue;
           }
 
           // the amazon2tellico stylesheet separates words with '/'
           QStringList nodes = (*it).split(QLatin1Char('/'));
           bool isStyle = false;
           for(QStringList::Iterator it2 = nodes.begin(); it2 != nodes.end(); ++it2) {
             if(!isStyle) {
               if(*it2 == QLatin1String("Styles")) {
                 isStyle = true;
               }
               continue;
             }
             if(*it2 != QLatin1String("General")) {
               words.add(*it2);
             }
           }
         }
         entry->setField(genres, words.toList().join(FieldFormat::delimiterString()));
       }
       entry->setField(QStringLiteral("comments"), Tellico::decodeHTML(entry->field(QStringLiteral("comments"))));
       break;
 
     case Data::Collection::Game:
       entry->setField(QStringLiteral("description"), Tellico::decodeHTML(entry->field(QStringLiteral("description"))));
       break;
   }
 
   // clean up the title
   parseTitle(entry);
 
   // also sometimes table fields have rows but no values
   Data::FieldList fields = entry->collection()->fields();
   QRegExp blank(QLatin1String("[\\s") +
                 FieldFormat::columnDelimiterString() +
                 FieldFormat::delimiterString() +
                 QLatin1String("]+")); // only white space, column separators and value separators
   foreach(Data::FieldPtr fIt, fields) {
     if(fIt->type() != Data::Field::Table) {
       continue;
     }
     if(blank.exactMatch(entry->field(fIt))) {
       entry->setField(fIt, QString());
     }
   }
 
   QString imageURL;
   switch(m_imageSize) {
     case SmallImage:
       imageURL = entry->field(QStringLiteral("small-image"));
       break;
     case MediumImage:
       imageURL = entry->field(QStringLiteral("medium-image"));
       break;
     case LargeImage:
       imageURL = entry->field(QStringLiteral("large-image"));
       break;
     case NoImage:
     default:
       break;
   }
 //  myDebug() << "grabbing " << imageURL.toDisplayString();
   if(!imageURL.isEmpty()) {
     QString id = ImageFactory::addImage(QUrl::fromUserInput(imageURL), true);
     if(id.isEmpty()) {
       message(i18n("The cover image could not be loaded."), MessageHandler::Warning);
     } else { // amazon serves up 1x1 gifs occasionally, but that's caught in the image constructor
       // all relevant collection types have cover fields
       entry->setField(QStringLiteral("cover"), id);
     }
   }
 
   // don't want to show image urls in the fetch dialog
   entry->setField(QStringLiteral("small-image"),  QString());
   entry->setField(QStringLiteral("medium-image"), QString());
   entry->setField(QStringLiteral("large-image"),  QString());
   return entry;
 }
 
 void AmazonFetcher::initXSLTHandler() {
   QString xsltfile = DataFileRegistry::self()->locate(QStringLiteral("amazon2tellico.xsl"));
   if(xsltfile.isEmpty()) {
     myWarning() << "can not locate amazon2tellico.xsl.";
     return;
   }
 
   QUrl u = QUrl::fromLocalFile(xsltfile);
 
   delete m_xsltHandler;
   m_xsltHandler = new XSLTHandler(u);
   if(!m_xsltHandler->isValid()) {
     myWarning() << "error in amazon2tellico.xsl.";
     delete m_xsltHandler;
     m_xsltHandler = nullptr;
     return;
   }
 }
 
 Tellico::Fetch::FetchRequest AmazonFetcher::updateRequest(Data::EntryPtr entry_) {
   const int type = entry_->collection()->type();
   const QString t = entry_->field(QStringLiteral("title"));
   if(type == Data::Collection::Book || type == Data::Collection::ComicBook || type == Data::Collection::Bibtex) {
     const QString isbn = entry_->field(QStringLiteral("isbn"));
     if(!isbn.isEmpty()) {
       return FetchRequest(Fetch::ISBN, isbn);
     }
     const QString a = entry_->field(QStringLiteral("author"));
     if(!a.isEmpty()) {
       return t.isEmpty() ? FetchRequest(Fetch::Person, a)
                          : FetchRequest(Fetch::Keyword, t + QLatin1Char('-') + a);
     }
   } else if(type == Data::Collection::Album) {
     const QString a = entry_->field(QStringLiteral("artist"));
     if(!a.isEmpty()) {
       return t.isEmpty() ? FetchRequest(Fetch::Person, a)
                          : FetchRequest(Fetch::Keyword, t + QLatin1Char('-') + a);
     }
   }
 
   // optimistically try searching for title and rely on Collection::sameEntry() to figure things out
   if(!t.isEmpty()) {
     return FetchRequest(Fetch::Title, t);
   }
 
   return FetchRequest();
 }
 
 void AmazonFetcher::parseTitle(Tellico::Data::EntryPtr entry_) {
   // assume that everything in brackets or parentheses is extra
   QRegExp rx(QLatin1String("[\\(\\[](.*)[\\)\\]]"));
   rx.setMinimal(true);
   QString title = entry_->field(QStringLiteral("title"));
   int pos = rx.indexIn(title);
   while(pos > -1) {
     if(parseTitleToken(entry_, rx.cap(1))) {
       title.remove(pos, rx.matchedLength());
       --pos; // search again there
     }
     pos = rx.indexIn(title, pos+1);
   }
   entry_->setField(QStringLiteral("title"), title.trimmed());
 }
 
 bool AmazonFetcher::parseTitleToken(Tellico::Data::EntryPtr entry_, const QString& token_) {
 //  myDebug() << "title token:" << token_;
   // if res = true, then the token gets removed from the title
   bool res = false;
   if(token_.indexOf(QLatin1String("widescreen"), 0, Qt::CaseInsensitive) > -1 ||
      token_.indexOf(i18n("Widescreen"), 0, Qt::CaseInsensitive) > -1) {
     entry_->setField(QStringLiteral("widescreen"), QStringLiteral("true"));
     // res = true; leave it in the title
   } else if(token_.indexOf(QLatin1String("full screen"), 0, Qt::CaseInsensitive) > -1) {
     // skip, but go ahead and remove from title
     res = true;
   } else if(token_.indexOf(QLatin1String("import"), 0, Qt::CaseInsensitive) > -1) {
     // skip, but go ahead and remove from title
     res = true;
   }
   if(token_.indexOf(QLatin1String("blu-ray"), 0, Qt::CaseInsensitive) > -1) {
     entry_->setField(QStringLiteral("medium"), i18n("Blu-ray"));
     res = true;
   } else if(token_.indexOf(QLatin1String("hd dvd"), 0, Qt::CaseInsensitive) > -1) {
     entry_->setField(QStringLiteral("medium"), i18n("HD DVD"));
     res = true;
   } else if(token_.indexOf(QLatin1String("vhs"), 0, Qt::CaseInsensitive) > -1) {
     entry_->setField(QStringLiteral("medium"), i18n("VHS"));
     res = true;
   }
   if(token_.indexOf(QLatin1String("director's cut"), 0, Qt::CaseInsensitive) > -1 ||
      token_.indexOf(i18n("Director's Cut"), 0, Qt::CaseInsensitive) > -1) {
     entry_->setField(QStringLiteral("directors-cut"), QStringLiteral("true"));
     // res = true; leave it in the title
   }
   if(token_.toLower() == QLatin1String("ntsc")) {
     entry_->setField(QStringLiteral("format"), i18n("NTSC"));
     res = true;
   }
   if(token_.toLower() == QLatin1String("dvd")) {
     entry_->setField(QStringLiteral("medium"), i18n("DVD"));
     res = true;
   }
   static QRegExp regionRx(QLatin1String("Region [1-9]"));
   if(regionRx.indexIn(token_) > -1) {
     entry_->setField(QStringLiteral("region"), i18n(regionRx.cap(0).toUtf8().constData()));
     res = true;
   }
   if(entry_->collection()->type() == Data::Collection::Game) {
     Data::FieldPtr f = entry_->collection()->fieldByName(QStringLiteral("platform"));
     if(f && f->allowed().contains(token_)) {
       res = true;
     }
   }
   return res;
 }
 
 QString AmazonFetcher::secretKey() const {
   return QString::fromUtf8(m_amazonKey);
 }
 
 //static
 QString AmazonFetcher::defaultName() {
   return i18n("Amazon.com Web Services");
 }
 
 QString AmazonFetcher::defaultIcon() {
   return favIcon("http://www.amazon.com");
 }
 
 Tellico::StringHash AmazonFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("keyword")] = i18n("Keywords");
   return hash;
 }
 
 Tellico::Fetch::ConfigWidget* AmazonFetcher::configWidget(QWidget* parent_) const {
   return new AmazonFetcher::ConfigWidget(parent_, this);
 }
 
 AmazonFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const AmazonFetcher* fetcher_/*=0*/)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
 
   QLabel* al = new QLabel(i18n("Registration is required for accessing the %1 data source. "
                                "If you agree to the terms and conditions, <a href='%2'>sign "
                                "up for an account</a>, and enter your information below.",
                                 AmazonFetcher::defaultName(),
                                 QLatin1String("https://affiliate-program.amazon.com/gp/flex/advertising/api/sign-in.html")),
                           optionsWidget());
   al->setOpenExternalLinks(true);
   al->setWordWrap(true);
   ++row;
   l->addWidget(al, row, 0, 1, 2);
   // richtext gets weird with size
   al->setMinimumWidth(al->sizeHint().width());
 
   QLabel* label = new QLabel(i18n("Access key: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_accessEdit = new QLineEdit(optionsWidget());
-  connect(m_accessEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_accessEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_accessEdit, row, 1);
   QString w = i18n("Access to data from Amazon.com requires an AWS Access Key ID and a Secret Key.");
   label->setWhatsThis(w);
   m_accessEdit->setWhatsThis(w);
   label->setBuddy(m_accessEdit);
 
   label = new QLabel(i18n("Secret key: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_secretKeyEdit = new QLineEdit(optionsWidget());
 //  m_secretKeyEdit->setEchoMode(QLineEdit::PasswordEchoOnEdit);
-  connect(m_secretKeyEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_secretKeyEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_secretKeyEdit, row, 1);
   label->setWhatsThis(w);
   m_secretKeyEdit->setWhatsThis(w);
   label->setBuddy(m_secretKeyEdit);
 
   label = new QLabel(i18n("Country: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_siteCombo = new GUI::ComboBox(optionsWidget());
   for(int i = 0; i < XX; ++i) {
     const AmazonFetcher::SiteData& siteData = AmazonFetcher::siteData(i);
     QIcon icon(QStandardPaths::locate(QStandardPaths::GenericDataLocation,
                                       QStringLiteral("kf5/locale/countries/%1/flag.png").arg(siteData.country)));
     m_siteCombo->addItem(icon, siteData.countryName, i);
     m_siteCombo->model()->sort(0);
   }
 
-  connect(m_siteCombo, SIGNAL(activated(int)), SLOT(slotSetModified()));
-  connect(m_siteCombo, SIGNAL(activated(int)), SLOT(slotSiteChanged()));
+  void (GUI::ComboBox::* activatedInt)(int) = &GUI::ComboBox::activated;
+  connect(m_siteCombo, activatedInt, this, &ConfigWidget::slotSetModified);
+  connect(m_siteCombo, activatedInt, this, &ConfigWidget::slotSiteChanged);
   l->addWidget(m_siteCombo, row, 1);
   w = i18n("Amazon.com provides data from several different localized sites. Choose the one "
            "you wish to use for this data source.");
   label->setWhatsThis(w);
   m_siteCombo->setWhatsThis(w);
   label->setBuddy(m_siteCombo);
 
   label = new QLabel(i18n("&Image size: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_imageCombo = new GUI::ComboBox(optionsWidget());
   m_imageCombo->addItem(i18n("Small Image"), SmallImage);
   m_imageCombo->addItem(i18n("Medium Image"), MediumImage);
   m_imageCombo->addItem(i18n("Large Image"), LargeImage);
   m_imageCombo->addItem(i18n("No Image"), NoImage);
-  connect(m_imageCombo, SIGNAL(activated(int)), SLOT(slotSetModified()));
+  connect(m_imageCombo, activatedInt, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_imageCombo, row, 1);
   w = i18n("The cover image may be downloaded as well. However, too many large images in the "
            "collection may degrade performance.");
   label->setWhatsThis(w);
   m_imageCombo->setWhatsThis(w);
   label->setBuddy(m_imageCombo);
 
   label = new QLabel(i18n("&Associate's ID: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_assocEdit = new QLineEdit(optionsWidget());
-  connect(m_assocEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  void (QLineEdit::* textChanged)(const QString&) = &QLineEdit::textChanged;
+  connect(m_assocEdit, textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_assocEdit, row, 1);
   w = i18n("The associate's id identifies the person accessing the Amazon.com Web Services, and is included "
            "in any links to the Amazon.com site.");
   label->setWhatsThis(w);
   m_assocEdit->setWhatsThis(w);
   label->setBuddy(m_assocEdit);
 
   l->setRowStretch(++row, 10);
 
   if(fetcher_) {
     m_siteCombo->setCurrentData(fetcher_->m_site);
     m_accessEdit->setText(fetcher_->m_access);
     m_secretKeyEdit->setText(fetcher_->secretKey());
     m_assocEdit->setText(fetcher_->m_assoc);
     m_imageCombo->setCurrentData(fetcher_->m_imageSize);
   } else { // defaults
     m_assocEdit->setText(QLatin1String(AMAZON_ASSOC_TOKEN));
     m_imageCombo->setCurrentData(MediumImage);
   }
 
   addFieldsWidget(AmazonFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 
   KAcceleratorManager::manage(optionsWidget());
 }
 
 void AmazonFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   int n = m_siteCombo->currentData().toInt();
   config_.writeEntry("Site", n);
   QString s = m_accessEdit->text().trimmed();
   if(!s.isEmpty()) {
     config_.writeEntry("AccessKey", s);
   }
   QByteArray b = m_secretKeyEdit->text().trimmed().toUtf8();
   if(!b.isEmpty()) {
     config_.writeEntry("SecretKey", b);
   }
   s = m_assocEdit->text().trimmed();
   if(!s.isEmpty()) {
     config_.writeEntry("AssocToken", s);
   }
   n = m_imageCombo->currentData().toInt();
   config_.writeEntry("Image Size", n);
 }
 
 QString AmazonFetcher::ConfigWidget::preferredName() const {
   return AmazonFetcher::siteData(m_siteCombo->currentData().toInt()).title;
 }
 
 void AmazonFetcher::ConfigWidget::slotSiteChanged() {
   emit signalName(preferredName());
 }
diff --git a/src/fetch/animenfofetcher.cpp b/src/fetch/animenfofetcher.cpp
index c6b292c8..c9956341 100644
--- a/src/fetch/animenfofetcher.cpp
+++ b/src/fetch/animenfofetcher.cpp
@@ -1,514 +1,514 @@
 /***************************************************************************
     Copyright (C) 2006-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "animenfofetcher.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../collections/bookcollection.h"
 #include "../collections/videocollection.h"
 #include "../entry.h"
 #include "../fieldformat.h"
 #include "../core/filehandler.h"
 #include "../images/imagefactory.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfig>
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QRegExp>
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QVBoxLayout>
 #include <QUrlQuery>
 
 namespace {
   static const char* ANIMENFO_BASE_URL = "http://www.animenfo.com/search.php";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::AnimeNfoFetcher;
 
 AnimeNfoFetcher::AnimeNfoFetcher(QObject* parent_)
     : Fetcher(parent_), m_started(false) {
 }
 
 AnimeNfoFetcher::~AnimeNfoFetcher() {
 }
 
 QString AnimeNfoFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool AnimeNfoFetcher::canFetch(int type) const {
   return type == Data::Collection::Book ||
          type == Data::Collection::Bibtex ||
          type == Data::Collection::Video;
 }
 
 void AnimeNfoFetcher::readConfigHook(const KConfigGroup& config_) {
   Q_UNUSED(config_);
 }
 
 void AnimeNfoFetcher::search() {
   m_started = true;
   m_matches.clear();
 
   QUrl u(QString::fromLatin1(ANIMENFO_BASE_URL));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("action"),   QStringLiteral("Go"));
   q.addQueryItem(QStringLiteral("option"),   QStringLiteral("keywords"));
 
   switch(request().collectionType) {
     case Data::Collection::Book:
       q.addQueryItem(QStringLiteral("queryin"),  QStringLiteral("manga_titles"));
       break;
 
     case Data::Collection::Video:
       q.addQueryItem(QStringLiteral("queryin"),  QStringLiteral("anime_titles"));
       break;
 
     default:
       myWarning() << "collection type not valid:" << request().collectionType;
       stop();
       return;
   }
 
   switch(request().key) {
     case Keyword:
       q.addQueryItem(QStringLiteral("query"), request().value);
       break;
 
     default:
       myWarning() << "key not recognized: " << request().key;
       stop();
       return;
   }
   u.setQuery(q);
 //  myDebug() << "url:" << u;
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)),
-          SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result,
+          this, &AnimeNfoFetcher::slotComplete);
 }
 
 void AnimeNfoFetcher::stop() {
   if(!m_started) {
     return;
   }
 
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 void AnimeNfoFetcher::slotComplete(KJob*) {
 //  myDebug();
 
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   const QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
 
   // since the fetch is done, don't worry about holding the job pointer
   m_job = nullptr;
 
   QString s = Tellico::decodeHTML(data);
 #if 0
   myWarning() << "Remove debug from animenfofetcher.cpp";
   QFile f(QLatin1String("/tmp/test.html"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << s;
   }
   f.close();
 #endif
 
   QRegExp infoRx(QLatin1String("<td\\s+[^>]*class\\s*=\\s*[\"']anime_info[\"'][^>]*>(.*)</td>"), Qt::CaseInsensitive);
   infoRx.setMinimal(true);
   QRegExp anchorRx(QLatin1String("<a\\s+[^>]*href\\s*=\\s*[\"'](.*)[\"'][^>]*>(.*)</a>"), Qt::CaseInsensitive);
   anchorRx.setMinimal(true);
   QRegExp yearRx(QLatin1String("\\d{4}"));
 
   // search page comes in groups of threes
   int n = 0;
   QString u, t, y;
 
   for(int pos = infoRx.indexIn(s); m_started && pos > -1; pos = infoRx.indexIn(s, pos+1)) {
     if(n == 0 && !u.isEmpty()) {
       FetchResult* r = new FetchResult(Fetcher::Ptr(this), t, y);
       QUrl url = QUrl(QString::fromLatin1(ANIMENFO_BASE_URL)).resolved(QUrl(u));
       url.setQuery(QString());
       m_matches.insert(r->uid, url);
       // don't emit signal until after putting url in matches hash
       emit signalResultFound(r);
 
       u.clear();
       t.clear();
       y.clear();
     }
     switch(n) {
       case 0: // title and url
         {
           int pos2 = anchorRx.indexIn(infoRx.cap(1));
           if(pos2 > -1) {
             u = anchorRx.cap(1);
             t = anchorRx.cap(2);
           }
         }
         break;
       case 1: // don't case
         break;
       case 2:
         if(yearRx.exactMatch(infoRx.cap(1))) {
           y = infoRx.cap(1);
         }
         break;
     }
 
     n = (n+1)%3;
   }
 
   // grab last response
   if(!u.isEmpty()) {
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), t, y, QString());
     QUrl url = QUrl(QString::fromLatin1(ANIMENFO_BASE_URL)).resolved(QUrl(u));
     url.setQuery(QString());
     m_matches.insert(r->uid, url);
     // don't emit signal until after putting url in matches hash
     emit signalResultFound(r);
   }
 
   stop();
 }
 
 Tellico::Data::EntryPtr AnimeNfoFetcher::fetchEntryHook(uint uid_) {
   // if we already grabbed this one, then just pull it out of the dict
   Data::EntryPtr entry = m_entries[uid_];
   if(entry) {
     return entry;
   }
 
   QUrl url = m_matches[uid_];
   if(url.isEmpty()) {
     myWarning() << "no url in map";
     return Data::EntryPtr();
   }
 
   QString results = Tellico::decodeHTML(FileHandler::readTextFile(url, true, true));
   if(results.isEmpty()) {
     myDebug() << "no text results";
     return Data::EntryPtr();
   }
 
 #if 0
   myWarning() << "Remove debug from animenfofetcher.cpp";
   QFile f(QLatin1String("/tmp/test.html"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << results;
   }
   f.close();
 #endif
 
   entry = parseEntry(results, url);
   if(!entry) {
     myDebug() << "error in processing entry";
     return Data::EntryPtr();
   }
   m_entries.insert(uid_, entry); // keep for later
   return entry;
 }
 
 Tellico::Data::EntryPtr AnimeNfoFetcher::parseEntry(const QString& str_, const QUrl& url_) {
  // myDebug();
  // class might be anime_info_top
   QRegExp infoRx(QLatin1String("<td\\s+[^>]*class\\s*=\\s*[\"']anime_info[^>]*>(.*)</td>"), Qt::CaseInsensitive);
   infoRx.setMinimal(true);
   QRegExp tagRx(QLatin1String("<.*>"));
   tagRx.setMinimal(true);
   QRegExp anchorRx(QLatin1String("<a\\s+[^>]*href\\s*=\\s*[\"'](.*)[\"'][^>]*>(.*)</a>"), Qt::CaseInsensitive);
   anchorRx.setMinimal(true);
   QRegExp jsRx(QLatin1String("<script.*</script>"), Qt::CaseInsensitive);
   jsRx.setMinimal(true);
 
   QString s = str_;
   s.remove(jsRx);
 
   Data::CollPtr coll;
   switch(request().collectionType) {
     case Data::Collection::Book:
     case Data::Collection::Bibtex:
       coll = Data::CollPtr(new Data::BookCollection(true));
       break;
 
     case Data::Collection::Video:
       coll = Data::CollPtr(new Data::VideoCollection(true));
       break;
 
     default:
       return Data::EntryPtr();
   }
 
   // add new fields
   Data::FieldPtr f(new Data::Field(QStringLiteral("origtitle"), i18n("Original Title")));
   coll->addField(f);
 
   f = new Data::Field(QStringLiteral("alttitle"), i18n("Alternative Titles"), Data::Field::Table);
   f->setFormatType(FieldFormat::FormatTitle);
   coll->addField(f);
 
   f = new Data::Field(QStringLiteral("distributor"), i18n("Distributor"));
   f->setCategory(i18n("Other People"));
   f->setFlags(Data::Field::AllowCompletion | Data::Field::AllowMultiple | Data::Field::AllowGrouped);
   f->setFormatType(FieldFormat::FormatPlain);
   coll->addField(f);
 
   f = new Data::Field(QStringLiteral("episodes"), i18n("Episodes"), Data::Field::Number);
   f->setCategory(i18n("Features"));
   coll->addField(f);
 
   f = new Data::Field(QStringLiteral("animenfo"), i18n("AnimeNfo Link"), Data::Field::URL);
   f->setCategory(i18n("General"));
   coll->addField(f);
 
   f = new Data::Field(QStringLiteral("animenfo-rating"), i18n("AnimeNfo Rating"), Data::Field::Rating);
   f->setCategory(i18n("General"));
   f->setProperty(QStringLiteral("maximum"), QStringLiteral("10"));
   coll->addField(f);
 
  // map captions in HTML to field names
   QHash<QString, QString> fieldMap;
   fieldMap.insert(QStringLiteral("Title"), QStringLiteral("title"));
   fieldMap.insert(QStringLiteral("Japanese Title"), QStringLiteral("origtitle"));
   fieldMap.insert(QStringLiteral("Total Episodes"), QStringLiteral("episodes"));
   fieldMap.insert(QStringLiteral("Category"), QStringLiteral("keyword"));
   fieldMap.insert(QStringLiteral("Genres"), QStringLiteral("genre"));
   fieldMap.insert(QStringLiteral("Genre"), QStringLiteral("genre"));
   fieldMap.insert(QStringLiteral("Studio"), QStringLiteral("studio"));
   fieldMap.insert(QStringLiteral("US Distribution"), QStringLiteral("distributor"));
   fieldMap.insert(QStringLiteral("Author"), QStringLiteral("author"));
   fieldMap.insert(QStringLiteral("Publisher"), QStringLiteral("publisher"));
   fieldMap.insert(QStringLiteral("Director"), QStringLiteral("director"));
   fieldMap.insert(QStringLiteral("Script"), QStringLiteral("writer"));
   fieldMap.insert(QStringLiteral("Music"), QStringLiteral("composer"));
   fieldMap.insert(QStringLiteral("User Rating"), QStringLiteral("animenfo-rating"));
 
   switch(request().collectionType) {
     case Data::Collection::Book:
     case Data::Collection::Bibtex:
       fieldMap.insert(QStringLiteral("Year Published"), QStringLiteral("pub_year"));
       break;
     case Data::Collection::Video:
       fieldMap.insert(QStringLiteral("Year Published"), QStringLiteral("year"));
       break;
     default:
       break;
   }
 
   Data::EntryPtr entry(new Data::Entry(coll));
 
   QString fullTitle;
 
   int n = 0;
   QString key, value;
   for(int pos = infoRx.indexIn(s); pos > -1; pos = infoRx.indexIn(s, pos+1)) {
     if(n == 0 && !key.isEmpty()) {
       if(fieldMap.contains(key)) {
         value = value.simplified();
         if(value.endsWith(QLatin1Char(';'))) {
           value.chop(1);
         }
         if(!value.isEmpty() && value != QLatin1String("-")) {
           const QString fieldName = fieldMap.value(key);
           if(key == QLatin1String("Title")) {
             // strip possible trailing year, etc.
             fullTitle = value;
             value.remove(QRegExp(QLatin1String("\\s*\\([^)]*\\)$")));
             entry->setField(fieldName, value);
           } else if(key == QLatin1String("Total Episodes")) {
             // strip possible trailing text
             value.remove(QRegExp(QLatin1String("[\\D].*$")));
             entry->setField(fieldName, value);
           } else if(key == QLatin1String("User Rating")) {
             QRegExp rating(QLatin1String("^(.*)/10"));
             if(rating.indexIn(value) > -1) {
               const double d = rating.cap(1).toDouble();
               entry->setField(fieldName, QString::number(static_cast<int>(d+0.5)));
             }
           } else if(key == QLatin1String("Year Published")) {
             // strip possible trailing text
             value.remove(QRegExp(QLatin1String("[\\D;].*$")));
             entry->setField(fieldName, value);
           } else {
             entry->setField(fieldName, value);
           }
           if(fieldName == QLatin1String("studio") ||
              fieldName == QLatin1String("genre") ||
              fieldName == QLatin1String("script") ||
              fieldName == QLatin1String("distributor") ||
              fieldName == QLatin1String("director") ||
              fieldName == QLatin1String("writer") ||
              fieldName == QLatin1String("author") ||
              fieldName == QLatin1String("publisher") ||
              fieldName == QLatin1String("composer")) {
             QStringList values = entry->field(fieldName).split(QRegExp(QLatin1String("\\s*,\\s*")));
             entry->setField(fieldName, values.join(FieldFormat::delimiterString()));
           }
         }
       }
       key.clear();
       value.clear();
     }
     switch(n) {
       case 0:
         key = infoRx.cap(1).remove(tagRx);
         break;
       case 1:
         value = infoRx.cap(1).replace(QLatin1String("<br />"), QLatin1String("; ")).remove(tagRx);
         break;
     }
     n = (n+1)%2;
   }
   entry->setField(QStringLiteral("animenfo"), url_.url());
 
   // image
   QRegExp imgRx(QStringLiteral("<img\\s+[^>]*src\\s*=\\s*[\"']([^>]*)[\"']\\s+[^>]*alt\\s*=\\s*[\"']%1[\"']")
                                     .arg(QRegExp::escape(fullTitle)), Qt::CaseInsensitive);
   imgRx.setMinimal(true);
   int pos = imgRx.indexIn(s);
   if(pos > -1) {
     QUrl imgURL = QUrl(QLatin1String(ANIMENFO_BASE_URL)).resolved(QUrl(imgRx.cap(1)));
     QString id = ImageFactory::addImage(imgURL, true);
     if(!id.isEmpty()) {
       entry->setField(QStringLiteral("cover"), id);
     } else {
       myDebug() << "bad cover" << imgURL.url();
     }
   }
 
   // now look for alternative titles and plot
   const QString a = QStringLiteral("Alternative titles");
   pos = s.indexOf(a, 0, Qt::CaseInsensitive);
   if(pos > -1) {
     pos += a.length();
     int pos2 = s.indexOf(QLatin1String("<td class=\"anime_cat_left"), pos+1);
     if(pos2 > -1) {
       value = s.mid(pos, pos2-pos).simplified();
       value.replace(QLatin1String("<br />"), FieldFormat::rowDelimiterString());
       value = value.remove(tagRx).trimmed();
       entry->setField(QStringLiteral("alttitle"), value);
     }
   }
 
   pos = s.indexOf(QLatin1String("Description"), pos > -1 ? pos : 0);
   if(pos > -1) {
     QRegExp descRx(QLatin1String("<td\\s[^>]*class\\s*=\\s*[\"']description[\"'].*>(.*)</td"), Qt::CaseInsensitive);
     descRx.setMinimal(true);
     pos = descRx.indexIn(s, pos+1);
     if(pos > -1) {
       entry->setField(QStringLiteral("plot"), descRx.cap(1).remove(tagRx).simplified());
     }
   }
 
   pos = s.indexOf(QLatin1String("Voice Talent"));
   if(pos > -1) {
     QRegExp charRx(QLatin1String("<a href=['\"]/anime/character/display.php.*>(.*)</a>"), Qt::CaseInsensitive);
     charRx.setMinimal(true);
     QRegExp voiceRx(QLatin1String("<a href=['\"]animeseiyuu.*>(.*)</a>"), Qt::CaseInsensitive);
     voiceRx.setMinimal(true);
     QStringList castLines;
     for(pos = s.indexOf(charRx, pos); pos > -1; pos = s.indexOf(charRx, pos+1)) {
       if(voiceRx.indexIn(s, pos) > -1) {
         castLines << voiceRx.cap(1) + FieldFormat::columnDelimiterString() + charRx.cap(1);
       }
     }
     entry->setField(QStringLiteral("cast"), castLines.join(FieldFormat::rowDelimiterString()));
   }
 
   return entry;
 }
 
 Tellico::Fetch::FetchRequest AnimeNfoFetcher::updateRequest(Data::EntryPtr entry_) {
   QString t = entry_->field(QStringLiteral("title"));
   if(!t.isEmpty()) {
     return FetchRequest(Fetch::Keyword, t);
   }
   return FetchRequest();
 }
 
 Tellico::Fetch::ConfigWidget* AnimeNfoFetcher::configWidget(QWidget* parent_) const {
   return new AnimeNfoFetcher::ConfigWidget(parent_, this);
 }
 
 QString AnimeNfoFetcher::defaultName() {
   return QStringLiteral("AnimeNfo.com");
 }
 
 QString AnimeNfoFetcher::defaultIcon() {
   return favIcon("http://animenfo.com");
 }
 
 //static
 Tellico::StringHash AnimeNfoFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("distributor")]     = i18n("Distributor");
   hash[QStringLiteral("episodes")]        = i18n("Episodes");
   hash[QStringLiteral("origtitle")]       = i18n("Original Title");
   hash[QStringLiteral("alttitle")]        = i18n("Alternative Titles");
   hash[QStringLiteral("animenfo-rating")] = i18n("AnimeNfo Rating");
   hash[QStringLiteral("animenfo")]        = i18n("AnimeNfo Link");
   return hash;
 }
 
 AnimeNfoFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const AnimeNfoFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 
   // now add additional fields widget
   addFieldsWidget(AnimeNfoFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 QString AnimeNfoFetcher::ConfigWidget::preferredName() const {
   return AnimeNfoFetcher::defaultName();
 }
diff --git a/src/fetch/arxivfetcher.cpp b/src/fetch/arxivfetcher.cpp
index 92462d8b..85e6754e 100644
--- a/src/fetch/arxivfetcher.cpp
+++ b/src/fetch/arxivfetcher.cpp
@@ -1,337 +1,337 @@
 /***************************************************************************
     Copyright (C) 2007-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "arxivfetcher.h"
 #include "../translators/xslthandler.h"
 #include "../translators/tellicoimporter.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../utils/datafileregistry.h"
 #include "../collection.h"
 #include "../entry.h"
 #include "../core/netaccess.h"
 #include "../images/imagefactory.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KConfigGroup>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QDomDocument>
 #include <QLabel>
 #include <QTextStream>
 #include <QPixmap>
 #include <QVBoxLayout>
 #include <QFile>
 #include <QUrlQuery>
 
 namespace {
   static const int ARXIV_RETURNS_PER_REQUEST = 20;
   static const char* ARXIV_BASE_URL = "http://export.arxiv.org/api/query";
 }
 
 using namespace Tellico;
 using namespace Tellico::Fetch;
 using Tellico::Fetch::ArxivFetcher;
 
 ArxivFetcher::ArxivFetcher(QObject* parent_)
     : Fetcher(parent_), m_xsltHandler(nullptr), m_start(0), m_total(-1), m_job(nullptr), m_started(false) {
 }
 
 ArxivFetcher::~ArxivFetcher() {
   delete m_xsltHandler;
   m_xsltHandler = nullptr;
 }
 
 QString ArxivFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool ArxivFetcher::canFetch(int type) const {
   return type == Data::Collection::Bibtex;
 }
 
 void ArxivFetcher::readConfigHook(const KConfigGroup&) {
 }
 
 void ArxivFetcher::search() {
   m_started = true;
   m_start = 0;
   m_total = -1;
   doSearch();
 }
 
 void ArxivFetcher::continueSearch() {
   m_started = true;
   doSearch();
 }
 
 void ArxivFetcher::doSearch() {
   QUrl u = searchURL(request().key, request().value);
   if(u.isEmpty()) {
     stop();
     return;
   }
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)),
-          SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result,
+          this, &ArxivFetcher::slotComplete);
 }
 
 void ArxivFetcher::stop() {
   if(!m_started) {
     return;
   }
 //  myDebug();
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 void ArxivFetcher::slotComplete(KJob*) {
 //  myDebug();
 
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
 
   // since the fetch is done, don't worry about holding the job pointer
   m_job = nullptr;
 #if 0
   myWarning() << "Remove debug from arxivfetcher.cpp";
   QFile f(QLatin1String("/tmp/test.xml"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   if(!m_xsltHandler) {
     initXSLTHandler();
     if(!m_xsltHandler) { // probably an error somewhere in the stylesheet loading
       stop();
       return;
     }
   }
 
   if(m_total == -1) {
     QDomDocument dom;
     if(!dom.setContent(data, true /*namespace*/)) {
       myWarning() << "server did not return valid XML.";
       stop();
       return;
     }
     // total is top level element, with attribute totalResultsAvailable
     QDomNodeList list = dom.elementsByTagNameNS(QStringLiteral("http://a9.com/-/spec/opensearch/1.1/"),
                                                 QStringLiteral("totalResults"));
     if(list.count() > 0) {
       m_total = list.item(0).toElement().text().toInt();
     }
   }
 
   // assume result is always utf-8
   QString str = m_xsltHandler->applyStylesheet(QString::fromUtf8(data.constData(), data.size()));
   Import::TellicoImporter imp(str);
   Data::CollPtr coll = imp.collection();
 
   if(!coll) {
     myDebug() << "no valid result";
     stop();
     return;
   }
 
   foreach(Data::EntryPtr entry, coll->entries()) {
     if(!m_started) {
       // might get aborted
       break;
     }
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
   }
 
   m_start = m_entries.count();
   m_hasMoreResults = m_start < m_total;
   stop(); // required
 }
 
 Tellico::Data::EntryPtr ArxivFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entries[uid_];
   // if URL but no cover image, fetch it
   if(!entry->field(QStringLiteral("url")).isEmpty()) {
     Data::CollPtr coll = entry->collection();
     Data::FieldPtr field = coll->fieldByName(QStringLiteral("cover"));
     if(!field && !coll->imageFields().isEmpty()) {
       field = coll->imageFields().front();
     } else if(!field) {
       field = new Data::Field(QStringLiteral("cover"), i18n("Front Cover"), Data::Field::Image);
       coll->addField(field);
     }
     if(entry->field(field).isEmpty()) {
       QPixmap pix = NetAccess::filePreview(QUrl::fromUserInput(entry->field(QStringLiteral("url"))));
       if(!pix.isNull()) {
         QString id = ImageFactory::addImage(pix, QStringLiteral("PNG"));
         if(!id.isEmpty()) {
           entry->setField(field, id);
         }
       }
     }
   }
   QRegExp versionRx(QLatin1String("v\\d+$"));
   // if the original search was not for a versioned ID, remove it
   if(request().key != ArxivID || !request().value.contains(versionRx)) {
     QString arxiv = entry->field(QStringLiteral("arxiv"));
     arxiv.remove(versionRx);
     entry->setField(QStringLiteral("arxiv"), arxiv);
   }
   return entry;
 }
 
 void ArxivFetcher::initXSLTHandler() {
   QString xsltfile = DataFileRegistry::self()->locate(QStringLiteral("arxiv2tellico.xsl"));
   if(xsltfile.isEmpty()) {
     myWarning() << "can not locate arxiv2tellico.xsl.";
     return;
   }
 
   QUrl u = QUrl::fromLocalFile(xsltfile);
 
   delete m_xsltHandler;
   m_xsltHandler = new XSLTHandler(u);
   if(!m_xsltHandler->isValid()) {
     myWarning() << "error in arxiv2tellico.xsl.";
     delete m_xsltHandler;
     m_xsltHandler = nullptr;
     return;
   }
 }
 
 QUrl ArxivFetcher::searchURL(FetchKey key_, const QString& value_) const {
   QUrl u(QString::fromLatin1(ARXIV_BASE_URL));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("start"), QString::number(m_start));
   q.addQueryItem(QStringLiteral("max_results"), QString::number(ARXIV_RETURNS_PER_REQUEST));
 
   // quotes should be used if spaces are present
   QString value = value_;
   value.replace(QLatin1Char(' '), QLatin1Char('+'));
   // seems to have problems with dashes, too
   value.replace(QLatin1Char('-'), QLatin1Char('+'));
 
   QString query;
   switch(key_) {
     case Title:
       query = QStringLiteral("ti:%1").arg(value);
       break;
 
     case Person:
       query = QStringLiteral("au:%1").arg(value);
       break;
 
     case Keyword:
       // keyword gets to use all the words without being quoted
       query = QStringLiteral("all:%1").arg(value);
       break;
 
     case ArxivID:
       {
       // remove prefix and/or version number
       QString value = value_;
       value.remove(QRegExp(QLatin1String("^arxiv:"), Qt::CaseInsensitive));
       value.remove(QRegExp(QLatin1String("v\\d+$")));
       query = QStringLiteral("id:%1").arg(value);
       }
       break;
 
     default:
       myWarning() << "key not recognized: " << request().key;
       return QUrl();
   }
   q.addQueryItem(QStringLiteral("search_query"), query);
   u.setQuery(q);
 
 //  myDebug() << "url: " << u;
   return u;
 }
 
 Tellico::Fetch::FetchRequest ArxivFetcher::updateRequest(Data::EntryPtr entry_) {
   QString id = entry_->field(QStringLiteral("arxiv"));
   if(!id.isEmpty()) {
     // remove prefix and/or version number
     id.remove(QRegExp(QLatin1String("^arxiv:"), Qt::CaseInsensitive));
     id.remove(QRegExp(QLatin1String("v\\d+$")));
     return FetchRequest(Fetch::ArxivID, id);
   }
 
   // optimistically try searching for title and rely on Collection::sameEntry() to figure things out
   QString t = entry_->field(QStringLiteral("title"));
   if(!t.isEmpty()) {
     return FetchRequest(Fetch::Title, t);
   }
 
   return FetchRequest();
 }
 
 Tellico::Fetch::ConfigWidget* ArxivFetcher::configWidget(QWidget* parent_) const {
   return new ArxivFetcher::ConfigWidget(parent_, this);
 }
 
 QString ArxivFetcher::defaultName() {
   return QStringLiteral("arXiv.org"); // no translation
 }
 
 QString ArxivFetcher::defaultIcon() {
   return favIcon("http://arxiv.org");
 }
 
 ArxivFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const ArxivFetcher*)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 }
 
 void ArxivFetcher::ConfigWidget::saveConfigHook(KConfigGroup&) {
 }
 
 QString ArxivFetcher::ConfigWidget::preferredName() const {
   return ArxivFetcher::defaultName();
 }
diff --git a/src/fetch/bedethequefetcher.cpp b/src/fetch/bedethequefetcher.cpp
index 1174b2e4..f150dea2 100644
--- a/src/fetch/bedethequefetcher.cpp
+++ b/src/fetch/bedethequefetcher.cpp
@@ -1,474 +1,474 @@
 /***************************************************************************
     Copyright (C) 2016 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "bedethequefetcher.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../utils/isbnvalidator.h"
 #include "../collections/comicbookcollection.h"
 #include "../entry.h"
 #include "../fieldformat.h"
 #include "../core/filehandler.h"
 #include "../images/imagefactory.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KJobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QRegExp>
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QVBoxLayout>
 #include <QUrlQuery>
 
 namespace {
   static const char* BD_BASE_URL = "https://m.bedetheque.com/album";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::BedethequeFetcher;
 
 BedethequeFetcher::BedethequeFetcher(QObject* parent_)
     : Fetcher(parent_), m_total(0), m_started(false) {
 }
 
 BedethequeFetcher::~BedethequeFetcher() {
 }
 
 QString BedethequeFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 Fetch::Type BedethequeFetcher::type() const {
   return Bedetheque;
 }
 
 bool BedethequeFetcher::canFetch(int type) const {
   return type == Data::Collection::ComicBook;
 }
 
 // No UPC or Raw for now.
 bool BedethequeFetcher::canSearch(FetchKey k) const {
   return k == Title || k == Keyword || k == ISBN;
 }
 
 void BedethequeFetcher::readConfigHook(const KConfigGroup& config_) {
   Q_UNUSED(config_);
 }
 
 void BedethequeFetcher::search() {
   m_started = true;
   m_matches.clear();
 
   // special case for updates which include the BD link as Raw request
   if(request().key == Raw) {
     QUrl u(request().value);
     u.setHost(QStringLiteral("m.bedetheque.com")); // use mobile site for easier parsing
     m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
     m_job->addMetaData(QStringLiteral("referrer"), QString::fromLatin1(BD_BASE_URL));
     KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
     // different slot here
-    connect(m_job, SIGNAL(result(KJob*)), SLOT(slotLinkComplete(KJob*)));
+    connect(m_job.data(), &KJob::result, this, &BedethequeFetcher::slotLinkComplete);
     return;
   }
 
   QUrl u(QString::fromLatin1(BD_BASE_URL));
 
 /*
   fetchToken();
   if(m_token.isEmpty()) {
     myDebug() << "empty token";
     stop();
     return;
   }
 */
 
   QUrlQuery q;
   switch(request().key) {
     case Title:
       q.addQueryItem(QStringLiteral("RechTitre"), request().value);
       break;
 
     case Keyword:
       q.addQueryItem(QStringLiteral("RechSerie"), request().value);
       break;
 
     case ISBN:
       q.addQueryItem(QStringLiteral("RechISBN"), ISBNValidator::cleanValue(request().value));
       break;
 
     default:
       myWarning() << "key not recognized: " << request().key;
       stop();
       return;
   }
 //  q.addQueryItem(QLatin1String("csrf_token_bedetheque"), m_token);
   u.setQuery(q);
 //  myDebug() << "url: " << u.url();
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   m_job->addMetaData(QStringLiteral("referrer"), QString::fromLatin1(BD_BASE_URL));
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result, this, &BedethequeFetcher::slotComplete);
 }
 
 void BedethequeFetcher::stop() {
   if(!m_started) {
     return;
   }
 
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 void BedethequeFetcher::slotComplete(KJob*) {
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
 
   // since the fetch is done, don't worry about holding the job pointer
   m_job = nullptr;
 
   QString output = Tellico::decodeHTML(data);
 #if 0
   myWarning() << "Remove debug from bedethequefetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/testbd.html"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t << output;
   }
   f.close();
 #endif
 
   const int pos_list = output.indexOf(QLatin1String("<li data-role=\"list-divider\" role=\"heading\">"), 0, Qt::CaseInsensitive);
   if(pos_list == -1) {
     myDebug() << "No results found";
     stop();
     return;
   }
   const int pos_end = output.indexOf(QLatin1String("</ul>"), pos_list+1, Qt::CaseInsensitive);
   output = output.mid(pos_list, pos_end-pos_list);
 
   QString pat = QStringLiteral("https://m.bedetheque.com/BD");
   QRegExp anchorRx(QLatin1String("<a\\s+[^>]*href\\s*=\\s*[\"'](") +
                    QRegExp::escape(pat) +
                    QLatin1String("[^\"']*)\"[^>]*>(.*)</a"), Qt::CaseInsensitive);
   anchorRx.setMinimal(true);
 
   QRegExp spanRx(QLatin1String("\\sclass\\s*=\\s*\"(.*)\">(.*)<"));
   spanRx.setMinimal(true);
 
   for(int pos = anchorRx.indexIn(output); m_started && pos > -1; pos = anchorRx.indexIn(output, pos+anchorRx.matchedLength())) {
     QString url = anchorRx.cap(1);
     if(url.isEmpty()) {
       continue;
     }
 
     const QString result = anchorRx.cap(2);
     if(result.isEmpty()) {
       continue;
     }
 
     QString title;
     QStringList desc;
     for(int pos2 = spanRx.indexIn(result); pos2 > -1; pos2 = spanRx.indexIn(result, pos2+spanRx.matchedLength())) {
       QString cname = spanRx.cap(1);
       QString value = spanRx.cap(2);
       if(cname == QLatin1String("serie")) {
         desc += value;
       } else if(cname == QLatin1String("titre")) {
         title = value;
       } else if(cname == QLatin1String("dl")) {
         desc += value;
       }
     }
 
     if(!title.isEmpty() && !url.isEmpty()) {
       FetchResult* r = new FetchResult(Fetcher::Ptr(this), title, desc.join(QLatin1String(" ")));
       m_matches.insert(r->uid, QUrl(url));
       emit signalResultFound(r);
     }
   }
 
   stop();
 }
 
 // slot called after downloading the exact link
 void BedethequeFetcher::slotLinkComplete(KJob*) {
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
   QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
 
   // since the fetch is done, don't worry about holding the job pointer
   m_job = nullptr;
 
   QString output = Tellico::decodeHTML(data);
   Data::EntryPtr entry = parseEntry(output);
   if(!entry) {
     myDebug() << "error in processing entry";
     stop();
     return;
   }
 
   FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
   m_matches.insert(r->uid, QUrl(request().value));
   m_entries.insert(r->uid, entry); // keep for later
 
   emit signalResultFound(r);
   stop();
 }
 
 Tellico::Data::EntryPtr BedethequeFetcher::fetchEntryHook(uint uid_) {
   // if we already grabbed this one, then just pull it out of the dict
   Data::EntryPtr entry = m_entries[uid_];
   if(entry) {
     return entry;
   }
 
   QUrl url = m_matches[uid_];
   if(url.isEmpty()) {
     myWarning() << "no url in map";
     return Data::EntryPtr();
   }
 
   QString results = Tellico::decodeHTML(FileHandler::readDataFile(url, true));
   if(results.isEmpty()) {
     myDebug() << "no text results";
     return Data::EntryPtr();
   }
 
 //  myDebug() << url.url();
 #if 0
   myWarning() << "Remove debug from bedethequefetcher.cpp";
   QFile f(QLatin1String("/tmp/testbditem.html"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << results;
   }
   f.close();
 #endif
 
   entry = parseEntry(results);
   if(!entry) {
     myDebug() << "error in processing entry";
     return Data::EntryPtr();
   }
   m_entries.insert(uid_, entry); // keep for later
   return entry;
 }
 
 Tellico::Data::EntryPtr BedethequeFetcher::parseEntry(const QString& str_) {
   Data::CollPtr coll(new Data::ComicBookCollection(true));
 
  // map captions in HTML to field names
   QHash<QString, QString> fieldMap;
   fieldMap.insert(QStringLiteral("Série"),       QStringLiteral("series"));
   fieldMap.insert(QStringLiteral("Titre"),           QStringLiteral("title"));
   fieldMap.insert(QStringLiteral("Origine"),         QStringLiteral("country"));
 //  fieldMap.insert(QLatin1String("Format"),          QLatin1String("binding"));
   fieldMap.insert(QStringLiteral("Scénario"),    QStringLiteral("writer"));
   fieldMap.insert(QStringLiteral("Dessin"),          QStringLiteral("artist"));
   fieldMap.insert(QStringLiteral("Dépot légal"), QStringLiteral("pub_year"));
   fieldMap.insert(QStringLiteral("Editeur"),         QStringLiteral("publisher"));
   fieldMap.insert(QStringLiteral("Planches"),        QStringLiteral("pages"));
   fieldMap.insert(QStringLiteral("Style"),           QStringLiteral("genre"));
   fieldMap.insert(QStringLiteral("Tome"),            QStringLiteral("issue"));
   fieldMap.insert(QStringLiteral("Collection"),      QStringLiteral("edition"));
 
   if(optionalFields().contains(QStringLiteral("isbn"))) {
     Data::FieldPtr field = Data::Field::createDefaultField(Data::Field::IsbnField);
     coll->addField(field);
     fieldMap.insert(QStringLiteral("ISBN"), field->name());
   }
   if(optionalFields().contains(QStringLiteral("colorist"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("colorist"), i18n("Colorist")));
     field->setCategory(i18n("General"));
     field->setFlags(Data::Field::AllowCompletion | Data::Field::AllowMultiple | Data::Field::AllowGrouped);
     field->setFormatType(FieldFormat::FormatName);
     coll->addField(field);
     fieldMap.insert(QStringLiteral("Couleurs"), QStringLiteral("colorist"));
   }
   if(optionalFields().contains(QStringLiteral("lien-bel"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("lien-bel"), i18n("Bedetheque Link"), Data::Field::URL));
     field->setCategory(i18n("General"));
     coll->addField(field);
   }
 
   QRegExp tagRx(QLatin1String("<.*>"));
   tagRx.setMinimal(true);
 
   QRegExp yearRx(QLatin1String("\\d{4}"));
   // the negative lookahead with "no-border" is for multiple values
   QString pat = QStringLiteral("<label>%1.*</label>(.+)</li>(?!\\s*<li class=\"no-border)");
 
   Data::EntryPtr entry(new Data::Entry(coll));
 
   for(QHash<QString, QString>::Iterator it = fieldMap.begin(); it != fieldMap.end(); ++it) {
     QRegExp infoRx(pat.arg(it.key()));
     infoRx.setMinimal(true);
     if(infoRx.indexIn(str_) == -1) {
       continue;
     }
     if(it.value() == QLatin1String("pub_year")) {
       QString data = infoRx.cap(1).remove(tagRx).simplified();
       if(yearRx.indexIn(data) > -1) {
         entry->setField(it.value(), yearRx.cap(0));
       }
     } else if(it.value() == QLatin1String("writer") ||
               it.value() == QLatin1String("artist") ||
               it.value() == QLatin1String("publisher") ||
               it.value() == QLatin1String("colorist")) {
       // catch multiple people
       QString value = infoRx.cap(1);
       // split the values with the "no-border" CSS
       value.replace(QLatin1String("<li class=\"no-border\">"), FieldFormat::delimiterString());
       value = FieldFormat::fixupValue(value.remove(tagRx).simplified());
       entry->setField(it.value(), value);
     } else if(it.value() == QLatin1String("genre")) {
       // replace comma with semi-colons to effectively split string values
       QString value = infoRx.cap(1).remove(tagRx).simplified();
       value.replace(QLatin1String(", "), FieldFormat::delimiterString());
       entry->setField(it.value(), value);
     } else {
       entry->setField(it.value(), infoRx.cap(1).remove(tagRx).simplified());
     }
     // myDebug() << it.value() << entry->field(it.value());
   }
 
   QRegExp imgRx(QLatin1String("<img[^<]*src\\s*=\\s*\"([^\"]+)\"\\s+alt\\s*=\\s*\"Couverture"));
   imgRx.setMinimal(true);
   if(imgRx.indexIn(str_) > -1) {
     QUrl u(imgRx.cap(1));
     QString id = ImageFactory::addImage(u, true);
     if(!id.isEmpty()) {
       entry->setField(QStringLiteral("cover"), id);
     }
   }
 
   if(optionalFields().contains(QStringLiteral("comments"))) {
     QRegExp chronRx(QLatin1String("La chronique\\s*</li>\\s*<li[^>]*>(.*)</ul>"));
     chronRx.setMinimal(true);
     if(chronRx.indexIn(str_) > -1) {
       entry->setField(QStringLiteral("comments"), chronRx.cap(1).trimmed());
     }
   }
 
   if(optionalFields().contains(QStringLiteral("lien-bel"))) {
     QRegExp linkRx(QLatin1String("<link\\s+rel\\s*=\\s*\"canonical\"\\s+href\\s*=\\s*\"([^\"]+)\""));
     linkRx.setMinimal(true);
     if(linkRx.indexIn(str_) > -1) {
       entry->setField(QStringLiteral("lien-bel"), linkRx.cap(1));
     }
   }
 
   return entry;
 }
 
 Tellico::Fetch::FetchRequest BedethequeFetcher::updateRequest(Data::EntryPtr entry_) {
   QString l = entry_->field(QStringLiteral("lien-bel"));
   if(!l.isEmpty()) {
     return FetchRequest(Fetch::Raw, l);
   }
   QString i = entry_->field(QStringLiteral("isbn"));
   if(!i.isEmpty()) {
     return FetchRequest(Fetch::ISBN, i);
   }
   QString t = entry_->field(QStringLiteral("title"));
   if(!t.isEmpty()) {
     return FetchRequest(Fetch::Title, t);
   }
   return FetchRequest();
 }
 
 void BedethequeFetcher::fetchToken() {
   QRegExp tokenRx(QLatin1String("name\\s*=\\s*\"csrf_token_bedetheque\"\\s*value\\s*=\\s*\"([^\"]+)\""));
 
   const QUrl url(QStringLiteral("https://www.bedetheque.com/search/albums"));
   const QString text = FileHandler::readTextFile(url, true /*quiet*/);
   if(tokenRx.indexIn(text) > -1) {
     m_token = tokenRx.cap(1);
   }
 }
 
 Tellico::Fetch::ConfigWidget* BedethequeFetcher::configWidget(QWidget* parent_) const {
   return new BedethequeFetcher::ConfigWidget(parent_, this);
 }
 
 QString BedethequeFetcher::defaultName() {
   return QStringLiteral("Bedetheque");
 }
 
 QString BedethequeFetcher::defaultIcon() {
   return favIcon("http://www.bedetheque.com");
 }
 
 //static
 Tellico::StringHash BedethequeFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("colorist")]     = i18n("Colorist");
   hash[QStringLiteral("comments")]     = i18n("Comments");
   hash[QStringLiteral("isbn")]         = i18n("ISBN#");
   // use the field name that the bedetheque.py script did, to maintain backwards compatibility
   hash[QStringLiteral("lien-bel")]     = i18n("Bedetheque Link");
   return hash;
 }
 
 BedethequeFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const BedethequeFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 
   // now add additional fields widget
   addFieldsWidget(BedethequeFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 QString BedethequeFetcher::ConfigWidget::preferredName() const {
   return BedethequeFetcher::defaultName();
 }
diff --git a/src/fetch/bibliosharefetcher.cpp b/src/fetch/bibliosharefetcher.cpp
index 1033c244..e6e69390 100644
--- a/src/fetch/bibliosharefetcher.cpp
+++ b/src/fetch/bibliosharefetcher.cpp
@@ -1,215 +1,215 @@
 /***************************************************************************
     Copyright (C) 2011 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "bibliosharefetcher.h"
 #include "../utils/isbnvalidator.h"
 #include "../entry.h"
 #include "../images/imagefactory.h"
 #include "../images/imageinfo.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 
 #include <QLineEdit>
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QUrlQuery>
 
 namespace {
   static const char* BIBLIOSHARE_BASE_URL = "http://www.biblioshare.org/BNCServices/BNCServices.asmx/";
   static const char* BIBLIOSHARE_TOKEN = "nsnqwebh87kstlty";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::BiblioShareFetcher;
 
 BiblioShareFetcher::BiblioShareFetcher(QObject* parent_)
     : XMLFetcher(parent_)
     , m_token(QLatin1String(BIBLIOSHARE_TOKEN)) {
   setLimit(1);
   setXSLTFilename(QStringLiteral("biblioshare2tellico.xsl"));
 }
 
 BiblioShareFetcher::~BiblioShareFetcher() {
 }
 
 QString BiblioShareFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 // https://www.booknetcanada.ca/get-a-token
 QString BiblioShareFetcher::attribution() const {
   return i18n("Data provided by <a href=\"https://www.booknetcanada.ca/biblioshare\">BNC BiblioShare</a>.");
 }
 
 bool BiblioShareFetcher::canFetch(int type) const {
   return type == Data::Collection::Book || type == Data::Collection::Bibtex;
 }
 
 void BiblioShareFetcher::readConfigHook(const KConfigGroup& config_) {
   QString k = config_.readEntry("Token", BIBLIOSHARE_TOKEN);
   if(!k.isEmpty()) {
     m_token = k;
   }
 }
 
 QUrl BiblioShareFetcher::searchUrl() {
   QUrl u(QString::fromLatin1(BIBLIOSHARE_BASE_URL));
   u.setPath(u.path() + QStringLiteral("BiblioSimple"));
 
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("Token"), m_token);
 
   switch(request().key) {
     case ISBN:
       {
         // only grab first value
         QString v = request().value.section(QLatin1Char(';'), 0);
         v = ISBNValidator::isbn13(v);
         v.remove(QLatin1Char('-'));
         q.addQueryItem(QStringLiteral("EAN"), v);
       }
       break;
 
     default:
       return QUrl();
   }
   u.setQuery(q);
 //  myDebug() << "url:" << u.url();
   return u;
 }
 
 Tellico::Data::EntryPtr BiblioShareFetcher::fetchEntryHookData(Data::EntryPtr entry_) {
   Q_ASSERT(entry_);
 
   if(!entry_) {
     myWarning() << "no entry";
     return entry_;
   }
 
   // if the entry cover is not set, go ahead and try to fetch it
   if(entry_->field(QStringLiteral("cover")).isEmpty()) {
     QString isbn = ISBNValidator::cleanValue(entry_->field(QStringLiteral("isbn")));
     if(!isbn.isEmpty()) {
       isbn = ISBNValidator::isbn13(isbn);
       isbn.remove(QLatin1Char('-'));
 
       QUrl imageUrl(QString::fromLatin1(BIBLIOSHARE_BASE_URL));
       imageUrl.setPath(imageUrl.path() + QStringLiteral("Images"));
       QUrlQuery q;
       q.addQueryItem(QStringLiteral("Token"), m_token);
       q.addQueryItem(QStringLiteral("EAN"), isbn);
       // the actual values for SAN Thumbnail don't seem to matter, they just can't be empty
       q.addQueryItem(QStringLiteral("SAN"), QStringLiteral("string"));
       q.addQueryItem(QStringLiteral("Thumbnail"), QStringLiteral("cover"));
       imageUrl.setQuery(q);
       const QString id = ImageFactory::addImage(imageUrl, true);
       if(!id.isEmpty()) {
         // placeholder images are 120x120 or 1x1
         Data::ImageInfo info = ImageFactory::imageInfo(id);
         if((info.width() != 120 || info.height() != 120) &&
            (info.width() != 1 || info.height() != 1)) {
           entry_->setField(QStringLiteral("cover"), id);
         }
       }
     }
   }
 
   return entry_;
 }
 
 Tellico::Fetch::FetchRequest BiblioShareFetcher::updateRequest(Data::EntryPtr entry_) {
   const QString isbn = entry_->field(QStringLiteral("isbn"));
   if(!isbn.isEmpty()) {
     return FetchRequest(Fetch::ISBN, isbn);
   }
 
   return FetchRequest();
 }
 
 Tellico::Fetch::ConfigWidget* BiblioShareFetcher::configWidget(QWidget* parent_) const {
   return new BiblioShareFetcher::ConfigWidget(parent_, this);
 }
 
 QString BiblioShareFetcher::defaultName() {
   return QStringLiteral("BiblioShare");
 }
 
 QString BiblioShareFetcher::defaultIcon() {
   return favIcon("https://www.booknetcanada.ca/biblioshare");
 }
 
 BiblioShareFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const BiblioShareFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
   QLabel* al = new QLabel(i18n("Registration is required for accessing the %1 data source. "
                                "If you agree to the terms and conditions, <a href='%2'>sign "
                                "up for an account</a>, and enter your information below.",
                                 preferredName(),
                                 QStringLiteral("https://www.booknetcanada.ca/get-a-token")),
                           optionsWidget());
   al->setOpenExternalLinks(true);
   al->setWordWrap(true);
   ++row;
   l->addWidget(al, row, 0, 1, 2);
   // richtext gets weird with size
   al->setMinimumWidth(al->sizeHint().width());
 
   QLabel* label = new QLabel(i18n("Access key: "), optionsWidget());
   l->addWidget(label, ++row, 0);
 
   m_tokenEdit = new QLineEdit(optionsWidget());
-  connect(m_tokenEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_tokenEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_tokenEdit, row, 1);
   QString w = i18n("The default Tellico key may be used, but searching may fail due to reaching access limits.");
   label->setWhatsThis(w);
   m_tokenEdit->setWhatsThis(w);
   label->setBuddy(m_tokenEdit);
 
   l->setRowStretch(++row, 10);
 
   if(fetcher_) {
     // only show the key if it is not the default Tellico one...
     // that way the user is prompted to apply for their own
     if(fetcher_->m_token != QLatin1String(BIBLIOSHARE_TOKEN)) {
       m_tokenEdit->setText(fetcher_->m_token);
     }
   }
 }
 
 void BiblioShareFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   QString token = m_tokenEdit->text().trimmed();
   if(!token.isEmpty()) {
     config_.writeEntry("Token", token);
   }
 }
 
 QString BiblioShareFetcher::ConfigWidget::preferredName() const {
   return BiblioShareFetcher::defaultName();
 }
diff --git a/src/fetch/bibsonomyfetcher.cpp b/src/fetch/bibsonomyfetcher.cpp
index 01390f77..139058e5 100644
--- a/src/fetch/bibsonomyfetcher.cpp
+++ b/src/fetch/bibsonomyfetcher.cpp
@@ -1,195 +1,195 @@
 /***************************************************************************
     Copyright (C) 2007-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "bibsonomyfetcher.h"
 #include "../translators/bibteximporter.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../collection.h"
 #include "../entry.h"
 #include "../core/netaccess.h"
 #include "../core/filehandler.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QUrlQuery>
 
 namespace {
   // always bibtex
   static const char* BIBSONOMY_BASE_URL = "http://bibsonomy.org/";
   static const int BIBSONOMY_MAX_RESULTS = 20;
 }
 
 using namespace Tellico;
 using Tellico::Fetch::BibsonomyFetcher;
 
 BibsonomyFetcher::BibsonomyFetcher(QObject* parent_)
     : Fetcher(parent_), m_job(nullptr), m_started(false) {
 }
 
 BibsonomyFetcher::~BibsonomyFetcher() {
 }
 
 QString BibsonomyFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool BibsonomyFetcher::canFetch(int type) const {
   return type == Data::Collection::Bibtex;
 }
 
 void BibsonomyFetcher::readConfigHook(const KConfigGroup&) {
 }
 
 void BibsonomyFetcher::search() {
   m_started = true;
 
 //  myDebug() << "value = " << value_;
 
   QUrl u(QString::fromLatin1(BIBSONOMY_BASE_URL));
   u.setPath(QStringLiteral("/bib/"));
 
   switch(request().key) {
     case Person:
       u.setPath(u.path() + QStringLiteral("author/%1").arg(request().value));
       break;
 
     case Keyword:
       u.setPath(u.path() + QStringLiteral("search/%1").arg(request().value));
       break;
 
     default:
       myWarning() << "key not recognized: " << request().key;
       stop();
       return;
   }
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("items"), QString::number(BIBSONOMY_MAX_RESULTS));
   u.setQuery(q);
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)),
-          SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result,
+          this, &BibsonomyFetcher::slotComplete);
 }
 
 void BibsonomyFetcher::stop() {
   if(!m_started) {
     return;
   }
 //  myDebug();
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 void BibsonomyFetcher::slotComplete(KJob*) {
 //  myDebug();
 
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
 
   // since the fetch is done, don't worry about holding the job pointer
   m_job = nullptr;
 
   Import::BibtexImporter imp(QString::fromUtf8(data.constData(), data.size()));
   Data::CollPtr coll = imp.collection();
 
   if(!coll) {
     myDebug() << "no valid result";
     stop();
     return;
   }
 
   Data::EntryList entries = coll->entries();
   foreach(Data::EntryPtr entry, entries) {
     if(!m_started) {
       // might get aborted
       break;
     }
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, Data::EntryPtr(entry));
     emit signalResultFound(r);
   }
 
   stop(); // required
 }
 
 Tellico::Data::EntryPtr BibsonomyFetcher::fetchEntryHook(uint uid_) {
   return m_entries[uid_];
 }
 
 Tellico::Fetch::FetchRequest BibsonomyFetcher::updateRequest(Data::EntryPtr entry_) {
   QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Fetch::Keyword, title);
   }
   return FetchRequest();
 }
 
 Tellico::Fetch::ConfigWidget* BibsonomyFetcher::configWidget(QWidget* parent_) const {
   return new BibsonomyFetcher::ConfigWidget(parent_, this);
 }
 
 QString BibsonomyFetcher::defaultName() {
   return QStringLiteral("Bibsonomy");
 }
 
 QString BibsonomyFetcher::defaultIcon() {
   return favIcon("https://www.bibsonomy.org");
 }
 
 BibsonomyFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const BibsonomyFetcher*)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 }
 
 void BibsonomyFetcher::ConfigWidget::saveConfigHook(KConfigGroup&) {
 }
 
 QString BibsonomyFetcher::ConfigWidget::preferredName() const {
   return BibsonomyFetcher::defaultName();
 }
diff --git a/src/fetch/comicvinefetcher.cpp b/src/fetch/comicvinefetcher.cpp
index 2ba3b24e..6bd8df18 100644
--- a/src/fetch/comicvinefetcher.cpp
+++ b/src/fetch/comicvinefetcher.cpp
@@ -1,278 +1,278 @@
 /***************************************************************************
     Copyright (C) 2019 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "comicvinefetcher.h"
 #include "../translators/xslthandler.h"
 #include "../translators/tellicoimporter.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QGridLayout>
 #include <QDomDocument>
 #include <QTextCodec>
 #include <QUrlQuery>
 #include <QJsonDocument>
 #include <QJsonObject>
 
 namespace {
   static const int COMICVINE_MAX_RETURNS_TOTAL = 20;
   static const char* COMICVINE_API_URL = "https://www.comicvine.com/api";
   static const char* COMICVINE_API_KEY = "6e4b19eeb8ccec8e2f026169d19adf57850d378e";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::ComicVineFetcher;
 
 ComicVineFetcher::ComicVineFetcher(QObject* parent_)
     : XMLFetcher(parent_)
     , m_total(-1)
     , m_apiKey(QLatin1String(COMICVINE_API_KEY)) {
   setLimit(COMICVINE_MAX_RETURNS_TOTAL);
   setXSLTFilename(QStringLiteral("comicvine2tellico.xsl"));
 }
 
 ComicVineFetcher::~ComicVineFetcher() {
 }
 
 QString ComicVineFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 QString ComicVineFetcher::attribution() const {
   return i18n("This information was freely provided by <a href=\"https://comicvine.gamespot.com/\">Comic Vine</a>.");
 }
 
 bool ComicVineFetcher::canFetch(int type) const {
   return type == Data::Collection::ComicBook;
 }
 
 void ComicVineFetcher::readConfigHook(const KConfigGroup& config_) {
   QString k = config_.readEntry("API Key", COMICVINE_API_KEY);
   if(!k.isEmpty()) {
     m_apiKey = k;
   }
 }
 
 void ComicVineFetcher::resetSearch() {
   m_total = -1;
 }
 
 QUrl ComicVineFetcher::searchUrl() {
   QUrl u(QString::fromLatin1(COMICVINE_API_URL));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("format"), QStringLiteral("xml"));
   q.addQueryItem(QStringLiteral("api_key"), m_apiKey);
 
   switch(request().key) {
     case Keyword:
       u.setPath(u.path() + QStringLiteral("/search"));
       q.addQueryItem(QStringLiteral("query"), request().value);
       q.addQueryItem(QStringLiteral("resources"), QStringLiteral("issue"));
       break;
 
     default:
       myWarning() << "key not recognized: " << request().key;
       return QUrl();
   }
   u.setQuery(q);
 
 //  myDebug() << "url: " << u.url();
   return u;
 }
 
 void ComicVineFetcher::parseData(QByteArray& data_) {
   Q_UNUSED(data_);
 }
 
 Tellico::Data::EntryPtr ComicVineFetcher::fetchEntryHookData(Data::EntryPtr entry_) {
   Q_ASSERT(entry_);
 
   const QString url = entry_->field(QStringLiteral("comicvine-api"));
   if(url.isEmpty()) {
     myDebug() << "no comicvine api url found";
     return entry_;
   }
 
   QUrl u(url);
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("format"), QStringLiteral("xml"));
   q.addQueryItem(QStringLiteral("api_key"), m_apiKey);
   u.setQuery(q);
 //  myDebug() << "url: " << u;
 
   // quiet
   QString output = FileHandler::readXMLFile(u, true);
 
 #if 0
   myWarning() << "Remove output debug from comicvinefetcher.cpp";
   QFile f(QStringLiteral("/tmp/test2.xml"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << output;
   }
   f.close();
 #endif
 
   Import::TellicoImporter imp(xsltHandler()->applyStylesheet(output));
   // be quiet when loading images
   imp.setOptions(imp.options() ^ Import::ImportShowImageErrors);
   Data::CollPtr coll = imp.collection();
   if(!coll || coll->entryCount() == 0) {
     myWarning() << "no collection pointer";
     return entry_;
   }
 
   if(coll->entryCount() > 1) {
     myDebug() << "weird, more than one entry found";
   }
 
   // grab the publisher from the volume link
   const QString volUrl = entry_->field(QStringLiteral("comicvine-volume-api"));
   if(!volUrl.isEmpty()) {
     QUrl vu(volUrl);
     // easier to use JSON here
     QUrlQuery q;
     q.addQueryItem(QStringLiteral("format"), QStringLiteral("json"));
     q.addQueryItem(QStringLiteral("api_key"), m_apiKey);
     vu.setQuery(q);
 //    myDebug() << "volume url: " << vu;
 
     QByteArray data = FileHandler::readDataFile(vu, true /* quiet */);
 #if 0
     myWarning() << "Remove JSON output debug from comicvinefetcher.cpp";
     QFile f2(QStringLiteral("/tmp/test2.json"));
     if(f2.open(QIODevice::WriteOnly)) {
       QTextStream t(&f2);
       t << data;
     }
     f2.close();
 #endif
     QJsonDocument doc = QJsonDocument::fromJson(data);
     QVariantMap map = doc.object().toVariantMap().value(QLatin1String("results")).toMap();
     const QString pub = mapValue(map, "publisher", "name");
     if(!pub.isEmpty()) {
       Data::EntryPtr e = coll->entries().front();
       if(e) {
         e->setField(QStringLiteral("publisher"), pub);
       }
     }
   }
 
   // don't want to include api link
   coll->removeField(QStringLiteral("comicvine-api"));
   coll->removeField(QStringLiteral("comicvine-volume-api"));
   return coll->entries().front();
 }
 
 Tellico::Fetch::FetchRequest ComicVineFetcher::updateRequest(Data::EntryPtr entry_) {
   QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Keyword, title);
   }
   return FetchRequest();
 }
 
 Tellico::Fetch::ConfigWidget* ComicVineFetcher::configWidget(QWidget* parent_) const {
   return new ComicVineFetcher::ConfigWidget(parent_, this);
 }
 
 QString ComicVineFetcher::defaultName() {
   return QStringLiteral("Comic Vine");
 }
 
 QString ComicVineFetcher::defaultIcon() {
   return favIcon("https://comicvine.gamespot.com");
 }
 
 Tellico::StringHash ComicVineFetcher::allOptionalFields() {
   StringHash hash;
 //  hash[QStringLiteral("colorist")]  = i18n("Colorist");
   hash[QStringLiteral("comicvine")] = i18n("Comic Vine Link");
   return hash;
 }
 
 ComicVineFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const ComicVineFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
 
   QLabel* al = new QLabel(i18n("Registration is required for accessing the %1 data source. "
                                "If you agree to the terms and conditions, <a href='%2'>sign "
                                "up for an account</a>, and enter your information below.",
                                 preferredName(),
                                 QLatin1String("http://api.comicvine.com")),
                           optionsWidget());
   al->setOpenExternalLinks(true);
   al->setWordWrap(true);
   ++row;
   l->addWidget(al, row, 0, 1, 2);
   // richtext gets weird with size
   al->setMinimumWidth(al->sizeHint().width());
 
   QLabel* label = new QLabel(i18n("Access key: "), optionsWidget());
   l->addWidget(label, ++row, 0);
 
   m_apiKeyEdit = new QLineEdit(optionsWidget());
-  connect(m_apiKeyEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_apiKeyEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_apiKeyEdit, row, 1);
   QString w = i18n("The default Tellico key may be used, but searching may fail due to reaching access limits.");
   label->setWhatsThis(w);
   m_apiKeyEdit->setWhatsThis(w);
   label->setBuddy(m_apiKeyEdit);
 
   l->setRowStretch(++row, 10);
 
   // now add additional fields widget
   addFieldsWidget(ComicVineFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 
   if(fetcher_) {
     // only show the key if it is not the default Tellico one...
     // that way the user is prompted to apply for their own
     if(fetcher_->m_apiKey != QLatin1String(COMICVINE_API_KEY)) {
       m_apiKeyEdit->setText(fetcher_->m_apiKey);
     }
   }
 }
 
 void ComicVineFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   QString apiKey = m_apiKeyEdit->text().trimmed();
   if(!apiKey.isEmpty()) {
     config_.writeEntry("API Key", apiKey);
   }
 }
 
 QString ComicVineFetcher::ConfigWidget::preferredName() const {
   return ComicVineFetcher::defaultName();
 }
diff --git a/src/fetch/configwidget.cpp b/src/fetch/configwidget.cpp
index cae95b3d..0631521a 100644
--- a/src/fetch/configwidget.cpp
+++ b/src/fetch/configwidget.cpp
@@ -1,102 +1,102 @@
 /***************************************************************************
     Copyright (C) 2003-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "configwidget.h"
 
 #include <KLocalizedString>
 #include <KAcceleratorManager>
 #include <KConfigGroup>
 
 #include <QGroupBox>
 #include <QHBoxLayout>
 
 using Tellico::Fetch::ConfigWidget;
 
 ConfigWidget::ConfigWidget(QWidget* parent_) : QWidget(parent_), m_modified(false), m_accepted(false) {
   QHBoxLayout* boxLayout = new QHBoxLayout(this);
   boxLayout->setSpacing(10);
   boxLayout->setMargin(0);
 
   QGroupBox* gvbox = new QGroupBox(i18n("Source Options"), this);
   boxLayout->addWidget(gvbox, 10 /*stretch*/);
 
   QVBoxLayout* vbox = new QVBoxLayout();
   m_optionsWidget = new QWidget(gvbox);
   vbox->addWidget(m_optionsWidget);
   vbox->addStretch(1);
   gvbox->setLayout(vbox);
 }
 
 bool ConfigWidget::shouldSave() const {
   return m_modified && m_accepted;
 }
 
 void ConfigWidget::setAccepted(bool accepted_) {
   m_accepted = accepted_;
 }
 
-void ConfigWidget::slotSetModified(bool modified_) {
-  m_modified = modified_;
+void ConfigWidget::slotSetModified() {
+  m_modified = true;;
 }
 
 void ConfigWidget::addFieldsWidget(const Tellico::StringHash& customFields_, const QStringList& fieldsToAdd_) {
   if(customFields_.isEmpty()) {
     return;
   }
 
   QGroupBox* gbox = new QGroupBox(i18n("Available Fields"), this);
   static_cast<QBoxLayout*>(layout())->addWidget(gbox);
 
   QVBoxLayout* vbox = new QVBoxLayout();
   for(StringHash::ConstIterator it = customFields_.begin(); it != customFields_.end(); ++it) {
     QCheckBox* cb = new QCheckBox(it.value(), gbox);
     m_fields.insert(it.key(), cb);
     if(fieldsToAdd_.contains(it.key())) {
       cb->setChecked(true);
     }
-    connect(cb, SIGNAL(clicked()), SLOT(slotSetModified()));
+    connect(cb, &QAbstractButton::clicked, this, &ConfigWidget::slotSetModified);
     vbox->addWidget(cb);
   }
   vbox->addStretch(1);
   gbox->setLayout(vbox);
 
   KAcceleratorManager::manage(this);
 }
 
 void ConfigWidget::saveConfig(KConfigGroup& config_) {
   QStringList fields;
   QHash<QString, QCheckBox*>::const_iterator it = m_fields.constBegin();
   for( ; it != m_fields.constEnd(); ++it) {
     if(it.value()->isChecked()) {
       fields << it.key();
     }
   }
   config_.writeEntry(QStringLiteral("Custom Fields"), fields);
   saveConfigHook(config_);
-  slotSetModified(false);
+  m_modified = false;
 }
 
 QWidget* ConfigWidget::optionsWidget() {
   return m_optionsWidget;
 }
diff --git a/src/fetch/configwidget.h b/src/fetch/configwidget.h
index dc4352e4..9c5fa215 100644
--- a/src/fetch/configwidget.h
+++ b/src/fetch/configwidget.h
@@ -1,90 +1,90 @@
 /***************************************************************************
     Copyright (C) 2003-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef TELLICO_FETCHCONFIGWIDGET_H
 #define TELLICO_FETCHCONFIGWIDGET_H
 
 #include "../datavectors.h"
 
 #include <QWidget>
 #include <QCheckBox>
 #include <QHash>
 
 class KConfigGroup;
 class QStringList;
 
 namespace Tellico {
   namespace Fetch {
 
 /**
  * @author Robby Stephenson
  */
 class ConfigWidget : public QWidget {
 Q_OBJECT
 
 public:
   ConfigWidget(QWidget* parent);
   virtual ~ConfigWidget() {}
 
   bool shouldSave() const;
   void setAccepted(bool accepted);
   virtual void readConfig(const KConfigGroup&) {}
   /**
    * Saves any configuration options. The config group must be
    * set before calling this function.
    *
    * @param config_ The KConfig pointer
    */
   void saveConfig(KConfigGroup& config);
   /**
    * Called when a fetcher data source is removed. Useful for any cleanup work necessary.
    * The ExecExternalFetcher might need to remove the script, for example.
    * Because of the way the ConfigDialog is setup, easier to have that in the ConfigWidget
    * class than in the Fetcher class itself
    */
   virtual void removed() {}
   virtual QString preferredName() const = 0;
 
 Q_SIGNALS:
   void signalName(const QString& name);
 
 public Q_SLOTS:
-  void slotSetModified(bool modified = true);
+  void slotSetModified();
 
 protected:
   QWidget* optionsWidget();
   void addFieldsWidget(const StringHash& customFields, const QStringList& fieldsToAdd);
   virtual void saveConfigHook(KConfigGroup&) {}
 
 private:
   bool m_modified;
   bool m_accepted;
   QWidget* m_optionsWidget;
   QHash<QString, QCheckBox*> m_fields;
 };
 
   }
 }
 
 #endif
diff --git a/src/fetch/crossreffetcher.cpp b/src/fetch/crossreffetcher.cpp
index 8e5b7986..24fabb04 100644
--- a/src/fetch/crossreffetcher.cpp
+++ b/src/fetch/crossreffetcher.cpp
@@ -1,382 +1,380 @@
 /***************************************************************************
     Copyright (C) 2007-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "crossreffetcher.h"
 #include "../translators/xslthandler.h"
 #include "../translators/tellicoimporter.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../collection.h"
 #include "../entry.h"
 #include "../core/netaccess.h"
 #include "../images/imagefactory.h"
 #include "../utils/wallet.h"
 #include "../utils/datafileregistry.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KConfigGroup>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QLineEdit>
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QGridLayout>
 #include <QPixmap>
 #include <QTextCodec>
 #include <QUrlQuery>
 
 #define CROSSREF_USE_UNIXREF
 
 namespace {
   static const char* CROSSREF_BASE_URL = "http://www.crossref.org/openurl/";
 }
 
 using namespace Tellico;
 using namespace Tellico::Fetch;
 using Tellico::Fetch::CrossRefFetcher;
 
 CrossRefFetcher::CrossRefFetcher(QObject* parent_)
     : Fetcher(parent_), m_xsltHandler(nullptr), m_job(nullptr), m_started(false) {
 }
 
 CrossRefFetcher::~CrossRefFetcher() {
   delete m_xsltHandler;
   m_xsltHandler = nullptr;
 }
 
 QString CrossRefFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool CrossRefFetcher::canFetch(int type) const {
   return type == Data::Collection::Bibtex;
 }
 
 void CrossRefFetcher::readConfigHook(const KConfigGroup& config_) {
   m_user = config_.readEntry("User");
   m_password = config_.readEntry("Password");
   m_email = config_.readEntry("Email");
 }
 
 void CrossRefFetcher::search() {
   m_started = true;
 
   readWallet();
   if(m_email.isEmpty() && (m_user.isEmpty() || m_password.isEmpty())) {
     myDebug() << i18n("%1 requires a username and password.", source());
     message(i18n("%1 requires a username and password.", source()), MessageHandler::Error);
     stop();
     return;
   }
 
 //  myDebug() << "value = " << value_;
 
   QUrl u = searchURL(request().key, request().value);
   if(u.isEmpty()) {
     stop();
     return;
   }
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)),
-          SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result,
+          this, &CrossRefFetcher::slotComplete);
 }
 
 void CrossRefFetcher::stop() {
   if(!m_started) {
     return;
   }
 //  myDebug();
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 void CrossRefFetcher::slotComplete(KJob*) {
 //  myDebug();
 
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
 
   // since the fetch is done, don't worry about holding the job pointer
   m_job = nullptr;
 #if 0
   myWarning() << "Remove debug from crossreffetcher.cpp";
   QFile f(QLatin1String("/tmp/test.xml"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   if(!m_xsltHandler) {
     initXSLTHandler();
     if(!m_xsltHandler) { // probably an error somewhere in the stylesheet loading
       stop();
       return;
     }
   }
 
   // assume result is always utf-8
   QString str = m_xsltHandler->applyStylesheet(QString::fromUtf8(data.constData(), data.size()));
   Import::TellicoImporter imp(str);
   Data::CollPtr coll = imp.collection();
 
   if(!coll) {
     myDebug() << "no valid result";
     stop();
     return;
   }
 
   Data::EntryList entries = coll->entries();
   foreach(Data::EntryPtr entry, entries) {
     if(!m_started) {
       // might get aborted
       break;
     }
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, Data::EntryPtr(entry));
     emit signalResultFound(r);
   }
 
   stop(); // required
 }
 
 Tellico::Data::EntryPtr CrossRefFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entries[uid_];
   // if URL but no cover image, fetch it
   if(!entry->field(QStringLiteral("url")).isEmpty()) {
     Data::CollPtr coll = entry->collection();
     Data::FieldPtr field = coll->fieldByName(QStringLiteral("cover"));
     if(!field && !coll->imageFields().isEmpty()) {
       field = coll->imageFields().front();
     } else if(!field) {
       field = new Data::Field(QStringLiteral("cover"), i18n("Front Cover"), Data::Field::Image);
       coll->addField(field);
     }
     if(entry->field(field).isEmpty()) {
       QPixmap pix = NetAccess::filePreview(QUrl::fromUserInput(entry->field(QStringLiteral("url"))));
       if(!pix.isNull()) {
         QString id = ImageFactory::addImage(pix, QStringLiteral("PNG"));
         if(!id.isEmpty()) {
           entry->setField(field, id);
         }
       }
     }
   }
   return entry;
 }
 
 void CrossRefFetcher::initXSLTHandler() {
 #ifdef CROSSREF_USE_UNIXREF
   QString xsltfile = DataFileRegistry::self()->locate(QStringLiteral("unixref2tellico.xsl"));
 #else
   QString xsltfile = DataFileRegistry::self()->locate(QLatin1String("crossref2tellico.xsl"));
 #endif
   if(xsltfile.isEmpty()) {
 #ifdef CROSSREF_USE_UNIXREF
     myWarning() << "can not locate xslt file: unixref2tellico.xsl";
 #else
     myWarning() << "can not locate xslt file: crossref2tellico.xsl";
 #endif
     return;
   }
 
   QUrl u = QUrl::fromLocalFile(xsltfile);
 
   delete m_xsltHandler;
   m_xsltHandler = new XSLTHandler(u);
   if(!m_xsltHandler->isValid()) {
     myWarning() << "error in crossref2tellico.xsl.";
     delete m_xsltHandler;
     m_xsltHandler = nullptr;
     return;
   }
 }
 
 QUrl CrossRefFetcher::searchURL(FetchKey key_, const QString& value_) const {
   QUrl u(QString::fromLatin1(CROSSREF_BASE_URL));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("noredirect"), QStringLiteral("true"));
   q.addQueryItem(QStringLiteral("multihit"), QStringLiteral("true"));
 #ifdef CROSSREF_USE_UNIXREF
   q.addQueryItem(QStringLiteral("format"), QStringLiteral("unixref"));
 #endif
   if(m_email.isEmpty()) {
     q.addQueryItem(QStringLiteral("pid"), QStringLiteral("%1:%2").arg(m_user, m_password));
   } else {
     q.addQueryItem(QStringLiteral("pid"), m_email);
   }
 
   switch(key_) {
     case DOI:
       q.addQueryItem(QStringLiteral("rft_id"), QStringLiteral("info:doi/%1").arg(value_));
       break;
 
     default:
       myWarning() << "key not recognized: " << key_;
       return QUrl();
   }
   u.setQuery(q);
 //  myDebug() << "url: " << u.url();
   return u;
 }
 
 Tellico::Fetch::FetchRequest CrossRefFetcher::updateRequest(Data::EntryPtr entry_) {
   QString doi = entry_->field(QStringLiteral("doi"));
   if(!doi.isEmpty()) {
     return FetchRequest(Fetch::DOI, doi);
   }
 
 #if 0
   // optimistically try searching for title and rely on Collection::sameEntry() to figure things out
   QString t = entry_->field(QLatin1String("title"));
   if(!t.isEmpty()) {
     return FetchRequest(Fetch::Title, t);
   }
 #endif
   return FetchRequest();
 }
 
 void CrossRefFetcher::readWallet() const {
   if(m_user.isEmpty() || m_password.isEmpty()) {
     QMap<QString, QString> map = Wallet::self()->readWalletMap(QStringLiteral("crossref.org"));
     if(!map.isEmpty()) {
       m_user = map.value(QStringLiteral("username"));
       m_password = map.value(QStringLiteral("password"));
     }
   }
 }
 
 Tellico::Fetch::ConfigWidget* CrossRefFetcher::configWidget(QWidget* parent_) const {
   return new CrossRefFetcher::ConfigWidget(parent_, this);
 }
 
 QString CrossRefFetcher::defaultName() {
   return QStringLiteral("CrossRef"); // no translation
 }
 
 QString CrossRefFetcher::defaultIcon() {
   return favIcon("http://crossref.org");
 }
 
 CrossRefFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const CrossRefFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = 0;
 
   QLabel* al = new QLabel(i18n("Registration is required for accessing the %1 data source. "
                                "If you agree to the terms and conditions, <a href='%2'>sign "
                                "up for an account</a>, and enter your information below.",
                                 preferredName(),
                                 QLatin1String("http://www.crossref.org/requestaccount/")),
                           optionsWidget());
   al->setOpenExternalLinks(true);
   al->setWordWrap(true);
   l->addWidget(al, row, 0, 1, 2);
   // richtext gets weird with size
   al->setMinimumWidth(al->sizeHint().width());
 
   QLabel* label = new QLabel(i18n("&Username: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_userEdit = new QLineEdit(optionsWidget());
-  connect(m_userEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_userEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_userEdit, row, 1);
   QString w = i18n("A username and password is required to access the CrossRef service.");
   label->setWhatsThis(w);
   m_userEdit->setWhatsThis(w);
   label->setBuddy(m_userEdit);
 
   label = new QLabel(i18n("&Password: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_passEdit = new QLineEdit(optionsWidget());
 //  m_passEdit->setEchoMode(QLineEdit::PasswordEchoOnEdit);
-  connect(m_passEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_passEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_passEdit, row, 1);
   label->setWhatsThis(w);
   m_passEdit->setWhatsThis(w);
   label->setBuddy(m_passEdit);
 
   label = new QLabel(i18n("For some accounts, only an email address is required."), optionsWidget());
   l->addWidget(label, ++row, 0, 1, 2);
 
   label = new QLabel(i18n("Email: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_emailEdit = new QLineEdit(optionsWidget());
-  connect(m_emailEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_emailEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_emailEdit, row, 1);
   label->setBuddy(m_emailEdit);
 
   if(fetcher_) {
     fetcher_->readWallet(); // make sure that the wallet values are read
     m_userEdit->setText(fetcher_->m_user);
     m_passEdit->setText(fetcher_->m_password);
     m_emailEdit->setText(fetcher_->m_email);
   }
 }
 
 void CrossRefFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   QString s = m_userEdit->text().trimmed();
   if(!s.isEmpty()) {
     config_.writeEntry("User", s);
   }
   s = m_passEdit->text().trimmed();
   if(!s.isEmpty()) {
     config_.writeEntry("Password", s);
   }
   s = m_emailEdit->text().trimmed();
   if(!s.isEmpty()) {
     config_.writeEntry("Email", s);
   }
-
-  slotSetModified(false);
 }
 
 QString CrossRefFetcher::ConfigWidget::preferredName() const {
   return CrossRefFetcher::defaultName();
 }
diff --git a/src/fetch/discogsfetcher.cpp b/src/fetch/discogsfetcher.cpp
index cc12c1b5..01f9dfc5 100644
--- a/src/fetch/discogsfetcher.cpp
+++ b/src/fetch/discogsfetcher.cpp
@@ -1,466 +1,466 @@
 /***************************************************************************
     Copyright (C) 2008-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include <config.h> // for TELLICO_VERSION
 
 #include "discogsfetcher.h"
 #include "../collections/musiccollection.h"
 #include "../images/imagefactory.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../core/filehandler.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KIO/Job>
 #include <KJobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QLineEdit>
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QBoxLayout>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QUrlQuery>
 
 namespace {
   static const int DISCOGS_MAX_RETURNS_TOTAL = 20;
   static const char* DISCOGS_API_URL = "https://api.discogs.com";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::DiscogsFetcher;
 
 DiscogsFetcher::DiscogsFetcher(QObject* parent_)
     : Fetcher(parent_)
     , m_started(false) {
 }
 
 DiscogsFetcher::~DiscogsFetcher() {
 }
 
 QString DiscogsFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool DiscogsFetcher::canSearch(FetchKey k) const {
   return k == Title || k == Person || k == Keyword;
 }
 
 bool DiscogsFetcher::canFetch(int type) const {
   return type == Data::Collection::Album;
 }
 
 void DiscogsFetcher::readConfigHook(const KConfigGroup& config_) {
   QString k = config_.readEntry("API Key");
   if(!k.isEmpty()) {
     m_apiKey = k;
   }
 }
 
 void DiscogsFetcher::search() {
   m_started = true;
 
   if(m_apiKey.isEmpty()) {
     myDebug() << "empty API key";
     message(i18n("An access key is required to use this data source.")
             + QLatin1Char(' ') +
             i18n("Those values must be entered in the data source settings."), MessageHandler::Error);
     stop();
     return;
   }
 
   QUrl u(QString::fromLatin1(DISCOGS_API_URL));
 
   QUrlQuery q;
   switch(request().key) {
     case Title:
       u.setPath(QStringLiteral("/database/search"));
       q.addQueryItem(QStringLiteral("release_title"), request().value);
       q.addQueryItem(QStringLiteral("type"), QStringLiteral("release"));
       break;
 
     case Person:
       u.setPath(QStringLiteral("/database/search"));
       q.addQueryItem(QStringLiteral("artist"), request().value);
       q.addQueryItem(QStringLiteral("type"), QStringLiteral("release"));
       break;
 
     case Keyword:
       u.setPath(QStringLiteral("/database/search"));
       q.addQueryItem(QStringLiteral("q"), request().value);
       break;
 
     case Raw:
       u.setPath(QStringLiteral("/database/search"));
       q.setQuery(request().value);
       break;
 
     default:
       myWarning() << "key not recognized:" << request().key;
       stop();
       return;
   }
   q.addQueryItem(QStringLiteral("token"), m_apiKey);
   u.setQuery(q);
 
 //  myDebug() << "url: " << u.url();
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   m_job->addMetaData(QStringLiteral("UserAgent"), QStringLiteral("Tellico/%1")
                                                                 .arg(QStringLiteral(TELLICO_VERSION)));
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result, this, &DiscogsFetcher::slotComplete);
 }
 
 void DiscogsFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 Tellico::Data::EntryPtr DiscogsFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entries.value(uid_);
   if(!entry) {
     myWarning() << "no entry in dict";
     return Data::EntryPtr();
   }
 
   QString id = entry->field(QStringLiteral("discogs-id"));
   if(!id.isEmpty()) {
     // quiet
     QUrl u(QString::fromLatin1(DISCOGS_API_URL));
     u.setPath(QStringLiteral("/releases/%1").arg(id));
     QByteArray data = FileHandler::readDataFile(u, true);
 
 #if 0
     myWarning() << "Remove debug2 from discogsfetcher.cpp (/tmp/test2.json)";
     QFile f(QString::fromLatin1("/tmp/test2.json"));
     if(f.open(QIODevice::WriteOnly)) {
       QTextStream t(&f);
       t.setCodec("UTF-8");
       t << data;
     }
     f.close();
 #endif
 
     QJsonParseError error;
     QJsonDocument doc = QJsonDocument::fromJson(data, &error);
     if(error.error == QJsonParseError::NoError) {
       populateEntry(entry, doc.object().toVariantMap(), true);
     } else {
       myDebug() << "Bad JSON results";
     }
   }
 
   const QString image_id = entry->field(QStringLiteral("cover"));
   // if it's still a url, we need to load it
   if(image_id.contains(QLatin1Char('/'))) {
     const QString id = ImageFactory::addImage(QUrl::fromUserInput(image_id), true /* quiet */);
     if(id.isEmpty()) {
       myDebug() << "empty id for" << image_id;
       message(i18n("The cover image could not be loaded."), MessageHandler::Warning);
     }
     // empty image ID is ok
     entry->setField(QStringLiteral("cover"), id);
   }
 
   // don't want to include ID field
   entry->setField(QStringLiteral("discogs-id"), QString());
 
   return entry;
 }
 
 Tellico::Fetch::FetchRequest DiscogsFetcher::updateRequest(Data::EntryPtr entry_) {
   QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Title, title);
   }
 
   QString artist = entry_->field(QStringLiteral("artist"));
   if(!artist.isEmpty()) {
     return FetchRequest(Person, artist);
   }
   return FetchRequest();
 }
 
 void DiscogsFetcher::slotComplete(KJob*) {
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from discogsfetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/test.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   Data::CollPtr coll(new Data::MusicCollection(true));
   // always add ID for fetchEntryHook
   Data::FieldPtr field(new Data::Field(QStringLiteral("discogs-id"), QStringLiteral("Discogs ID"), Data::Field::Line));
   field->setCategory(i18n("General"));
   coll->addField(field);
 
   if(optionalFields().contains(QStringLiteral("discogs"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("discogs"), i18n("Discogs Link"), Data::Field::URL));
     field->setCategory(i18n("General"));
     coll->addField(field);
   }
   if(optionalFields().contains(QStringLiteral("nationality"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("nationality"), i18n("Nationality")));
     field->setCategory(i18n("General"));
     field->setFlags(Data::Field::AllowCompletion | Data::Field::AllowMultiple | Data::Field::AllowGrouped);
     field->setFormatType(FieldFormat::FormatPlain);
     coll->addField(field);
   }
   if(optionalFields().contains(QStringLiteral("producer"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("producer"), i18n("Producer")));
     field->setCategory(i18n("General"));
     field->setFlags(Data::Field::AllowCompletion | Data::Field::AllowMultiple | Data::Field::AllowGrouped);
     field->setFormatType(FieldFormat::FormatName);
     coll->addField(field);
   }
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
 //  const QVariantMap resultMap = doc.object().toVariantMap().value(QStringLiteral("feed")).toMap();
   const QVariantMap resultMap = doc.object().toVariantMap();
 
   if(mapValue(resultMap, "message").startsWith(QLatin1String("Invalid consumer token"))) {
     message(i18n("The Discogs.com server reports a token error."),
             MessageHandler::Error);
     stop();
     return;
   }
 
   int count = 0;
   foreach(const QVariant& result, resultMap.value(QLatin1String("results")).toList()) {
     if(count >= DISCOGS_MAX_RETURNS_TOTAL) {
       break;
     }
 
   //  myDebug() << "found result:" << result;
 
     Data::EntryPtr entry(new Data::Entry(coll));
     populateEntry(entry, result.toMap(), false);
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
     ++count;
   }
 
   stop();
 }
 
 void DiscogsFetcher::populateEntry(Data::EntryPtr entry_, const QVariantMap& resultMap_, bool fullData_) {
   entry_->setField(QStringLiteral("discogs-id"), mapValue(resultMap_, "id"));
   entry_->setField(QStringLiteral("title"), mapValue(resultMap_, "title"));
   entry_->setField(QStringLiteral("year"),  mapValue(resultMap_, "year"));
   entry_->setField(QStringLiteral("genre"),  mapValue(resultMap_, "genres"));
 
   QStringList artists;
   foreach(const QVariant& artist, resultMap_.value(QLatin1String("artists")).toList()) {
     artists << mapValue(artist.toMap(), "name");
   }
   entry_->setField(QStringLiteral("artist"), artists.join(FieldFormat::delimiterString()));
 
   QStringList labels;
   foreach(const QVariant& label, resultMap_.value(QLatin1String("labels")).toList()) {
     labels << mapValue(label.toMap(), "name");
   }
   entry_->setField(QStringLiteral("label"), labels.join(FieldFormat::delimiterString()));
 
   /* thumb value is not always in the full data, so go ahead and set it now */
   QString coverUrl = mapValue(resultMap_, "thumb");
   if(!coverUrl.isEmpty()) {
     entry_->setField(QStringLiteral("cover"), coverUrl);
   }
 
   // if we only need cursory data, then we're done
   if(!fullData_) {
     return;
   }
 
   // check the formats, it could have multiple
   // if there is a CD, prefer that in the track list
   bool hasCD = false;
   foreach(const QVariant& format, resultMap_.value(QLatin1String("formats")).toList()) {
     if(mapValue(format.toMap(), "name") == QLatin1String("CD")) {
       entry_->setField(QStringLiteral("medium"), i18n("Compact Disc"));
       hasCD = true;
     } else if(mapValue(format.toMap(), "name") == QLatin1String("Vinyl")) {
       entry_->setField(QStringLiteral("medium"), i18n("Vinyl"));
     } else if(mapValue(format.toMap(), "name") == QLatin1String("Cassette")) {
       entry_->setField(QStringLiteral("medium"), i18n("Cassette"));
     } else if(!hasCD && mapValue(format.toMap(), "name") == QLatin1String("DVD")) {
       // sometimes a CD and DVD both are included. If we're using the CD, ignore the DVD
       entry_->setField(QStringLiteral("medium"), i18n("DVD"));
     }
   }
 
   QStringList tracks;
   foreach(const QVariant& track, resultMap_.value(QLatin1String("tracklist")).toList()) {
     const QVariantMap trackMap = track.toMap();
     if(mapValue(trackMap, "type_") != QLatin1String("track")) {
       continue;
     }
 
     // Releases might include a CD and a DVD, for example
     // prefer only the tracks on the CD. Allow positions of just numbers
     if(hasCD && !(mapValue(trackMap, "position").at(0).isNumber() ||
                   mapValue(trackMap, "position").startsWith(QLatin1String("CD")))) {
       continue;
     }
 
     QStringList trackInfo;
     trackInfo << mapValue(trackMap, "title");
     if(trackMap.contains(QStringLiteral("artists"))) {
       QStringList artists;
       foreach(const QVariant& artist, trackMap.value(QLatin1String("artists")).toList()) {
         artists << mapValue(artist.toMap(), "name");
       }
       trackInfo << artists.join(FieldFormat::delimiterString());
     } else {
       trackInfo << entry_->field(QStringLiteral("artist"));
     }
     trackInfo << mapValue(trackMap, "duration");
     tracks << trackInfo.join(FieldFormat::columnDelimiterString());
   }
   entry_->setField(QStringLiteral("track"), tracks.join(FieldFormat::rowDelimiterString()));
 
   if(entry_->collection()->hasField(QStringLiteral("discogs"))) {
     entry_->setField(QStringLiteral("discogs"), mapValue(resultMap_, "uri"));
   }
 
   if(entry_->collection()->hasField(QStringLiteral("nationality"))) {
     entry_->setField(QStringLiteral("nationality"), mapValue(resultMap_, "country"));
   }
 
   if(entry_->collection()->hasField(QStringLiteral("producer"))) {
     QStringList producers;
     foreach(const QVariant& extraartist, resultMap_.value(QLatin1String("extraartists")).toList()) {
       if(mapValue(extraartist.toMap(), "role").contains(QStringLiteral("Producer"))) {
         producers << mapValue(extraartist.toMap(), "name");
       }
     }
     entry_->setField(QStringLiteral("producer"), producers.join(FieldFormat::delimiterString()));
   }
 
   entry_->setField(QStringLiteral("comments"), mapValue(resultMap_, "notes"));
 }
 
 Tellico::Fetch::ConfigWidget* DiscogsFetcher::configWidget(QWidget* parent_) const {
   return new DiscogsFetcher::ConfigWidget(parent_, this);
 }
 
 QString DiscogsFetcher::defaultName() {
   return i18n("Discogs Audio Search");
 }
 
 QString DiscogsFetcher::defaultIcon() {
   return favIcon("http://www.discogs.com");
 }
 
 Tellico::StringHash DiscogsFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("producer")] = i18n("Producer");
   hash[QStringLiteral("nationality")] = i18n("Nationality");
   hash[QStringLiteral("discogs")] = i18n("Discogs Link");
   return hash;
 }
 
 DiscogsFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const DiscogsFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
   QLabel* al = new QLabel(i18n("Registration is required for accessing the %1 data source. "
                                "If you agree to the terms and conditions, <a href='%2'>sign "
                                "up for an account</a>, and enter your information below.",
                                 preferredName(),
                                 QLatin1String("https://www.discogs.com/developers/#page:authentication")),
                           optionsWidget());
   al->setOpenExternalLinks(true);
   al->setWordWrap(true);
   ++row;
   l->addWidget(al, row, 0, 1, 2);
   // richtext gets weird with size
   al->setMinimumWidth(al->sizeHint().width());
 
   QLabel* label = new QLabel(i18n("User token: "), optionsWidget());
   l->addWidget(label, ++row, 0);
 
   m_apiKeyEdit = new QLineEdit(optionsWidget());
-  connect(m_apiKeyEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_apiKeyEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_apiKeyEdit, row, 1);
   label->setBuddy(m_apiKeyEdit);
 
   l->setRowStretch(++row, 10);
 
   if(fetcher_) {
     m_apiKeyEdit->setText(fetcher_->m_apiKey);
   }
 
   // now add additional fields widget
   addFieldsWidget(DiscogsFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 void DiscogsFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   QString apiKey = m_apiKeyEdit->text().trimmed();
   if(!apiKey.isEmpty()) {
     config_.writeEntry("API Key", apiKey);
   }
 }
 
 QString DiscogsFetcher::ConfigWidget::preferredName() const {
   return DiscogsFetcher::defaultName();
 }
diff --git a/src/fetch/doubanfetcher.cpp b/src/fetch/doubanfetcher.cpp
index 72e52633..b50f892b 100644
--- a/src/fetch/doubanfetcher.cpp
+++ b/src/fetch/doubanfetcher.cpp
@@ -1,529 +1,529 @@
 /***************************************************************************
     Copyright (C) 2011 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "doubanfetcher.h"
 #include "../collections/bookcollection.h"
 #include "../collections/videocollection.h"
 #include "../collections/musiccollection.h"
 #include "../images/imagefactory.h"
 #include "../core/filehandler.h"
 #include "../utils/guiproxy.h"
 #include "../utils/isbnvalidator.h"
 #include "../utils/string_utils.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KJob>
 #include <KJobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 #include <KIO/StoredTransferJob>
 
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QVBoxLayout>
 #include <QTextCodec>
 #include <QUrlQuery>
 #include <QJsonDocument>
 #include <QJsonObject>
 
 namespace {
   static const int DOUBAN_MAX_RETURNS_TOTAL = 20;
   static const char* DOUBAN_API_URL = "https://api.douban.com/v2/";
   // old and unused
   //static const char* DOUBAN_API_KEY = "0bd1672394eb1ebf2374356abec15c3d";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::DoubanFetcher;
 
 DoubanFetcher::DoubanFetcher(QObject* parent_)
     : Fetcher(parent_)
     , m_started(false) {
 }
 
 DoubanFetcher::~DoubanFetcher() {
 }
 
 QString DoubanFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool DoubanFetcher::canSearch(FetchKey k) const {
   return k == Keyword || k == ISBN;
 }
 
 bool DoubanFetcher::canFetch(int type) const {
   return type == Data::Collection::Book
       || type == Data::Collection::Bibtex
       || type == Data::Collection::Video
       || type == Data::Collection::Album;
 }
 
 void DoubanFetcher::readConfigHook(const KConfigGroup& config_) {
   Q_UNUSED(config_);
 }
 
 void DoubanFetcher::search() {
   m_started = true;
   QUrl u(QString::fromLatin1(DOUBAN_API_URL));
 
   switch(request().collectionType) {
     case Data::Collection::Book:
     case Data::Collection::Bibtex:
       u.setPath(u.path() + QLatin1String("book/"));
       break;
 
     case Data::Collection::Video:
       u.setPath(u.path() + QLatin1String("movie/"));
       break;
 
     case Data::Collection::Album:
       u.setPath(u.path() + QLatin1String("music/"));
       break;
 
     default:
       myWarning() << "bad collection type:" << request().collectionType;
   }
 
   QUrlQuery q;
   switch(request().key) {
     case ISBN:
       u.setPath(u.path() + QLatin1String("isbn/"));
       {
         QStringList isbns = FieldFormat::splitValue(request().value);
         if(!isbns.isEmpty()) {
           u.setPath(u.path() + ISBNValidator::cleanValue(isbns.front()));
         }
       }
       break;
 
     case Keyword:
       u.setPath(u.path() + QLatin1String("search"));
       q.addQueryItem(QStringLiteral("q"), request().value);
       q.addQueryItem(QStringLiteral("count"), QString::number(DOUBAN_MAX_RETURNS_TOTAL));
       break;
 
     default:
       myWarning() << "key not recognized:" << request().key;
   }
 
 //  q.addQueryItem(QLatin1String("start"), QString::number(0));
   u.setQuery(q);
 //  myDebug() << "url:" << u.url();
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
   if(request().key == ISBN) {
-    connect(m_job, SIGNAL(result(KJob*)), SLOT(slotCompleteISBN(KJob*)));
+    connect(m_job.data(), &KJob::result, this, &DoubanFetcher::slotCompleteISBN);
   } else {
-    connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+    connect(m_job.data(), &KJob::result, this, &DoubanFetcher::slotComplete);
   }
 }
 
 void DoubanFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 void DoubanFetcher::slotCompleteISBN(KJob* job_) {
   KIO::StoredTransferJob* job = static_cast<KIO::StoredTransferJob*>(job_);
 
   if(job->error()) {
     job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   const QVariantMap resultMap = doc.object().toVariantMap();
 
   // code == 6000 for no result
   if(mapValue(resultMap, "code") == QLatin1String("6000")) {
     message(mapValue(resultMap, "msg"), MessageHandler::Error);
   } else {
     Data::EntryPtr entry = createEntry(resultMap);
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     m_matches.insert(r->uid, QUrl(mapValue(resultMap, "url")));
     emit signalResultFound(r);
   }
 
   stop();
 }
 
 void DoubanFetcher::slotComplete(KJob* job_) {
   KIO::StoredTransferJob* job = static_cast<KIO::StoredTransferJob*>(job_);
 
   if(job->error()) {
     job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from doubanfetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/test-douban1.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   const QVariantMap resultsMap = doc.object().toVariantMap();
 
   switch(request().collectionType) {
     case Data::Collection::Book:
     case Data::Collection::Bibtex:
       foreach(const QVariant& v, resultsMap.value(QLatin1String("books")).toList()) {
         const QVariantMap resultMap = v.toMap();
         FetchResult* r = new FetchResult(Fetcher::Ptr(this), mapValue(resultMap, "title"),
                                          mapValue(resultMap, "author") + QLatin1Char('/') +
                                          mapValue(resultMap, "publisher") + QLatin1Char('/') +
                                          mapValue(resultMap, "pubdate").left(4));
         m_matches.insert(r->uid, QUrl(mapValue(resultMap, "url")));
         emit signalResultFound(r);
       }
       break;
 
     case Data::Collection::Video:
       foreach(const QVariant& v, resultsMap.value(QLatin1String("subjects")).toList()) {
         const QVariantMap resultMap = v.toMap();
         FetchResult* r = new FetchResult(Fetcher::Ptr(this), mapValue(resultMap, "title"),
                                          mapValue(resultMap, "directors", "name") + QLatin1Char('/') +
                                          mapValue(resultMap, "year"));
         // movie results don't appear to have a url field
         m_matches.insert(r->uid, QUrl(QLatin1String(DOUBAN_API_URL) +
                                       QLatin1String("movie/subject/") +
                                       mapValue(resultMap, "id")));
         emit signalResultFound(r);
       }
       break;
 
     case Data::Collection::Album:
       foreach(const QVariant& v, resultsMap.value(QLatin1String("musics")).toList()) {
         const QVariantMap resultMap = v.toMap();
         FetchResult* r = new FetchResult(Fetcher::Ptr(this), mapValue(resultMap, "title"),
                                          mapValue(resultMap, "attrs", "singer") + QLatin1Char('/') +
                                          mapValue(resultMap, "attrs", "publisher") + QLatin1Char('/') +
                                          mapValue(resultMap, "attrs", "pubdate").left(4));
         // movie results don't appear to have a url field
         m_matches.insert(r->uid, QUrl(QLatin1String(DOUBAN_API_URL) +
                                       QLatin1String("music/") +
                                       mapValue(resultMap, "id")));
         emit signalResultFound(r);
       }
       break;
 
     default:
       break;
   }
 
   stop();
 }
 
 Tellico::Data::EntryPtr DoubanFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entries.value(uid_);
   if(entry) {
     return entry;
   }
 
   QUrl url = m_matches.value(uid_);
   QByteArray data = FileHandler::readDataFile(url, true);
 #if 0
   myWarning() << "Remove output debug from doubanfetcher.cpp";
   QFile f(QLatin1String("/tmp/test-douban2.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   entry = createEntry(doc.object().toVariantMap());
 
   if(entry) {
     m_entries.insert(uid_, entry);
   }
   return entry;
 }
 
 Tellico::Data::EntryPtr DoubanFetcher::createEntry(const QVariantMap& resultMap_) {
   Data::CollPtr coll;
   Data::EntryPtr entry;
   switch(request().collectionType) {
     case Data::Collection::Book:
     case Data::Collection::Bibtex:
       coll = new Data::BookCollection(true);
       if(optionalFields().contains(QStringLiteral("origtitle")) &&
         !mapValue(resultMap_, "origin_title").isEmpty() &&
         !coll->hasField(QStringLiteral("origtitle"))) {
         Data::FieldPtr f(new Data::Field(QStringLiteral("origtitle"), i18n("Original Title")));
         f->setFormatType(FieldFormat::FormatTitle);
         coll->addField(f);
       }
       if(optionalFields().contains(QStringLiteral("douban")) &&
         !mapValue(resultMap_, "alt").isEmpty() &&
         !coll->hasField(QStringLiteral("douban"))) {
         Data::FieldPtr f(new Data::Field(QStringLiteral("douban"), i18n("Douban Link"), Data::Field::URL));
         f->setCategory(i18n("General"));
         coll->addField(f);
       }
       entry = new Data::Entry(coll);
       populateBookEntry(entry, resultMap_);
       break;
     case Data::Collection::Video:
       coll = new Data::VideoCollection(true);
       if(optionalFields().contains(QStringLiteral("origtitle")) &&
         !mapValue(resultMap_, "original_title").isEmpty() &&
         !coll->hasField(QStringLiteral("origtitle"))) {
         Data::FieldPtr f(new Data::Field(QStringLiteral("origtitle"), i18n("Original Title")));
         f->setFormatType(FieldFormat::FormatTitle);
         coll->addField(f);
       }
       if(optionalFields().contains(QStringLiteral("douban")) &&
         !mapValue(resultMap_, "alt").isEmpty() &&
         !coll->hasField(QStringLiteral("douban"))) {
         Data::FieldPtr f(new Data::Field(QStringLiteral("douban"), i18n("Douban Link"), Data::Field::URL));
         f->setCategory(i18n("General"));
         coll->addField(f);
       }
       entry = new Data::Entry(coll);
       populateVideoEntry(entry, resultMap_);
       break;
     case Data::Collection::Album:
       coll = new Data::MusicCollection(true);
       if(optionalFields().contains(QStringLiteral("origtitle")) &&
         !mapValue(resultMap_, "original_title").isEmpty() &&
         !coll->hasField(QStringLiteral("origtitle"))) {
         Data::FieldPtr f(new Data::Field(QStringLiteral("origtitle"), i18n("Original Title")));
         f->setFormatType(FieldFormat::FormatTitle);
         coll->addField(f);
       }
       if(optionalFields().contains(QStringLiteral("douban")) &&
         !mapValue(resultMap_, "alt").isEmpty() &&
         !coll->hasField(QStringLiteral("douban"))) {
         Data::FieldPtr f(new Data::Field(QStringLiteral("douban"), i18n("Douban Link"), Data::Field::URL));
         f->setCategory(i18n("General"));
         coll->addField(f);
       }
       entry = new Data::Entry(coll);
       populateMusicEntry(entry, resultMap_);
       break;
     default:
       break;
   }
 
   return entry;
 }
 
 void DoubanFetcher::populateBookEntry(Data::EntryPtr entry, const QVariantMap& resultMap_) {
   entry->setField(QStringLiteral("title"), mapValue(resultMap_, "title"));
   entry->setField(QStringLiteral("subtitle"), mapValue(resultMap_, "subtitle"));
   entry->setField(QStringLiteral("author"), mapValue(resultMap_, "author"));
   entry->setField(QStringLiteral("translator"), mapValue(resultMap_, "translator"));
   entry->setField(QStringLiteral("publisher"), mapValue(resultMap_, "publisher"));
 
   const QString binding = mapValue(resultMap_, "binding");
   if(binding == QStringLiteral("精装")) {
     entry->setField(QStringLiteral("binding"), i18n("Hardback"));
   } else if(binding == QStringLiteral("平装")) {
     entry->setField(QStringLiteral("binding"), i18n("Paperback"));
   }
 
   entry->setField(QStringLiteral("pub_year"), mapValue(resultMap_, "pubdate").left(4));
   entry->setField(QStringLiteral("isbn"), mapValue(resultMap_, "isbn10"));
   entry->setField(QStringLiteral("pages"), mapValue(resultMap_, "pages"));
   entry->setField(QStringLiteral("cover"), mapValue(resultMap_, "image"));
   entry->setField(QStringLiteral("keyword"), mapValue(resultMap_, "tags", "title"));
 
   if(optionalFields().contains(QStringLiteral("origtitle")) &&
      !mapValue(resultMap_, "origin_title").isEmpty()) {
     entry->setField(QStringLiteral("origtitle"), mapValue(resultMap_, "origin_title"));
   }
   if(optionalFields().contains(QStringLiteral("douban"))) {
     entry->setField(QStringLiteral("douban"), mapValue(resultMap_, "alt"));
   }
   entry->setField(QStringLiteral("plot"), mapValue(resultMap_, "summary"));
 }
 
 void DoubanFetcher::populateVideoEntry(Data::EntryPtr entry, const QVariantMap& resultMap_) {
   entry->setField(QStringLiteral("title"), mapValue(resultMap_, "title"));
   entry->setField(QStringLiteral("genre"), mapValue(resultMap_, "genres"));
   entry->setField(QStringLiteral("director"), mapValue(resultMap_, "directors", "name"));
   entry->setField(QStringLiteral("writer"), mapValue(resultMap_, "writers", "name"));
   entry->setField(QStringLiteral("year"), mapValue(resultMap_, "year"));
   entry->setField(QStringLiteral("cover"), mapValue(resultMap_, "images", "medium"));
   entry->setField(QStringLiteral("plot"), mapValue(resultMap_, "summary"));
 
   QStringList actors;
   foreach(const QVariant& v, resultMap_.value(QLatin1String("casts")).toList()) {
     actors << v.toMap().value(QStringLiteral("name")).toString();
   }
   entry->setField(QStringLiteral("cast"), actors.join(FieldFormat::rowDelimiterString()));
 
   if(optionalFields().contains(QStringLiteral("origtitle")) &&
      !mapValue(resultMap_, "original_title").isEmpty()) {
     entry->setField(QStringLiteral("origtitle"), mapValue(resultMap_, "original_title"));
   }
   if(optionalFields().contains(QStringLiteral("douban"))) {
     entry->setField(QStringLiteral("douban"), mapValue(resultMap_, "alt"));
   }
 }
 
 void DoubanFetcher::populateMusicEntry(Data::EntryPtr entry, const QVariantMap& resultMap_) {
   entry->setField(QStringLiteral("title"), mapValue(resultMap_, "title"));
   entry->setField(QStringLiteral("cover"), mapValue(resultMap_, "image"));
   entry->setField(QStringLiteral("artist"), mapValue(resultMap_, "attrs", "singer"));
   entry->setField(QStringLiteral("label"), mapValue(resultMap_, "attrs", "publisher"));
   entry->setField(QStringLiteral("year"), mapValue(resultMap_, "attrs", "pubdate").left(4));
 
   if(mapValue(resultMap_, "attrs", "media") == QLatin1String("Audio CD") ||
      mapValue(resultMap_, "attrs", "media") == QLatin1String("CD")) {
     entry->setField(QStringLiteral("medium"), i18n("Compact Disc"));
   }
 
   QStringList values, tracks;
   foreach(const QVariant& v, resultMap_.value(QLatin1String("attrs"))
                                .toMap().value(QLatin1String("tracks")).toList()) {
     // some cases have all the tracks in one item, separated by "\n" and using 01. track numbers
     if(v.toString().contains(QLatin1Char('\n'))) {
       values << v.toString().split(QStringLiteral("\n"));
     } else {
       values << v.toString();
     }
   }
   QRegExp trackNumRx(QLatin1String("^\\d+[.\\s]{2}"));
   QRegExp trackDurRx(QLatin1String("\\d+:\\d{2}"));
   foreach(QString value, values) { // can't be const
     // might starts with track number
     QStringList l = value.remove(trackNumRx).split(QStringLiteral(" - "));
     if(l.size() == 1) {
       // might be split by tab characters and have track length at end
       l = value.remove(trackNumRx).split(QRegExp(QLatin1String("[\t\n]+")));
       if(trackDurRx.exactMatch(l.last())) {
         tracks << l.first() + FieldFormat::columnDelimiterString() +
                   entry->field(QStringLiteral("artist")) + FieldFormat::columnDelimiterString() +
                   l.last();
       } else {
         tracks << l.first();
       }
     } else if(l.size() > 1) {
       const QString last = l.takeLast();
       tracks << l.join(QLatin1String(" - ")) + FieldFormat::columnDelimiterString() + last;
     }
   }
   entry->setField(QStringLiteral("track"), tracks.join(FieldFormat::rowDelimiterString()));
 
   if(optionalFields().contains(QStringLiteral("origtitle")) &&
      !mapValue(resultMap_, "original_title").isEmpty()) {
     entry->setField(QStringLiteral("origtitle"), mapValue(resultMap_, "original_title"));
   }
   if(optionalFields().contains(QStringLiteral("douban"))) {
     entry->setField(QStringLiteral("douban"), mapValue(resultMap_, "alt"));
   }
 }
 
 Tellico::Fetch::FetchRequest DoubanFetcher::updateRequest(Data::EntryPtr entry_) {
   QString isbn = entry_->field(QStringLiteral("isbn"));
   if(!isbn.isEmpty()) {
     return FetchRequest(ISBN, isbn);
   }
 
   QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Title, title);
   }
   return FetchRequest();
 }
 
 Tellico::Fetch::ConfigWidget* DoubanFetcher::configWidget(QWidget* parent_) const {
   return new DoubanFetcher::ConfigWidget(parent_, this);
 }
 
 QString DoubanFetcher::defaultName() {
   return QStringLiteral("Douban.com");
 }
 
 QString DoubanFetcher::defaultIcon() {
   return favIcon("http://www.douban.com");
 }
 
 Tellico::StringHash DoubanFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("origtitle")] = i18n("Original Title");
   hash[QStringLiteral("douban")] = i18n("Douban Link");
   return hash;
 }
 
 DoubanFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const DoubanFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 
   // now add additional fields widget
   addFieldsWidget(DoubanFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 void DoubanFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   Q_UNUSED(config_);
 }
 
 QString DoubanFetcher::ConfigWidget::preferredName() const {
   return DoubanFetcher::defaultName();
 }
diff --git a/src/fetch/entrezfetcher.cpp b/src/fetch/entrezfetcher.cpp
index e3e66ab2..aa4704e1 100644
--- a/src/fetch/entrezfetcher.cpp
+++ b/src/fetch/entrezfetcher.cpp
@@ -1,488 +1,488 @@
 /***************************************************************************
     Copyright (C) 2005-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "entrezfetcher.h"
 #include "../utils/guiproxy.h"
 #include "../collection.h"
 #include "../entry.h"
 #include "../fieldformat.h"
 #include "../core/filehandler.h"
 #include "../translators/xslthandler.h"
 #include "../translators/tellicoimporter.h"
 #include "../utils/datafileregistry.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KConfigGroup>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QDomDocument>
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QVBoxLayout>
 #include <QUrlQuery>
 
 namespace {
   static const int ENTREZ_MAX_RETURNS_TOTAL = 25;
   static const char* ENTREZ_BASE_URL = "http://eutils.ncbi.nlm.nih.gov/entrez/eutils/";
   static const char* ENTREZ_SEARCH_CGI = "esearch.fcgi";
   static const char* ENTREZ_SUMMARY_CGI = "esummary.fcgi";
   static const char* ENTREZ_FETCH_CGI = "efetch.fcgi";
   static const char* ENTREZ_LINK_CGI = "elink.fcgi";
   static const char* ENTREZ_DEFAULT_DATABASE = "pubmed";
 }
 
 using namespace Tellico;
 using namespace Tellico::Fetch;
 using Tellico::Fetch::EntrezFetcher;
 
 EntrezFetcher::EntrezFetcher(QObject* parent_) : Fetcher(parent_), m_xsltHandler(nullptr),
     m_start(1), m_total(-1), m_step(Begin), m_started(false) {
 }
 
 EntrezFetcher::~EntrezFetcher() {
 }
 
 QString EntrezFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool EntrezFetcher::canSearch(FetchKey k) const {
   return k == Title || k == Person || k == Keyword || k == Raw || k == PubmedID || k == DOI;
 }
 
 bool EntrezFetcher::canFetch(int type) const {
   return type == Data::Collection::Bibtex;
 }
 
 void EntrezFetcher::readConfigHook(const KConfigGroup& config_) {
   QString s = config_.readEntry("Database", ENTREZ_DEFAULT_DATABASE); // default to pubmed
   if(!s.isEmpty()) {
     m_dbname = s;
   }
 }
 
 void EntrezFetcher::search() {
   m_started = true;
   m_start = 1;
   m_total = -1;
 
   if(m_dbname.isEmpty()) {
     m_dbname = QLatin1String(ENTREZ_DEFAULT_DATABASE);
   }
 
   QUrl u(QString::fromLatin1(ENTREZ_BASE_URL));
   u.setPath(u.path() + QLatin1String(ENTREZ_SEARCH_CGI));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("tool"),       QStringLiteral("Tellico"));
   q.addQueryItem(QStringLiteral("retmode"),    QStringLiteral("xml"));
   q.addQueryItem(QStringLiteral("usehistory"), QStringLiteral("y"));
   q.addQueryItem(QStringLiteral("retmax"),     QStringLiteral("1")); // we're just getting the count
   q.addQueryItem(QStringLiteral("db"),         m_dbname);
   q.addQueryItem(QStringLiteral("term"),       request().value);
   switch(request().key) {
     case Title:
       q.addQueryItem(QStringLiteral("field"), QStringLiteral("titl"));
       break;
 
     case Person:
       q.addQueryItem(QStringLiteral("field"), QStringLiteral("auth"));
       break;
 
     case Keyword:
       // for Tellico Keyword searches basically mean search for any field matching
 //      q.addQueryItem(QLatin1String("field"), QLatin1String("word"));
       break;
 
     case PubmedID:
       q.addQueryItem(QStringLiteral("field"), QStringLiteral("pmid"));
       break;
 
     case DOI:
     case Raw:
       // for DOI, enough to match any field to DOI value
       //q.setQuery(u.query() + QLatin1Char('&') + request().value);
       break;
 
     default:
       myWarning() << "key not supported:" << request().key;
       stop();
       return;
   }
   u.setQuery(q);
 
   m_step = Search;
 //  myLog() << "search url: " << u.url();
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)),
-          SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result,
+          this, &EntrezFetcher::slotComplete);
 }
 
 void EntrezFetcher::continueSearch() {
   m_started = true;
   doSummary();
 }
 
 void EntrezFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   m_step = Begin;
   emit signalDone(this);
 }
 
 void EntrezFetcher::slotComplete(KJob*) {
   Q_ASSERT(m_job);
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from entrezfetcher.cpp: " << __LINE__;
   QFile f(QLatin1String("/tmp/test.xml"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   switch(m_step) {
     case Search:
       searchResults(data);
       break;
     case Summary:
       summaryResults(data);
       break;
     case Begin:
     case Fetch:
     default:
       myLog() << "wrong step =" << m_step;
       stop();
       break;
   }
 }
 
 void EntrezFetcher::searchResults(const QByteArray& data_) {
   QDomDocument dom;
   if(!dom.setContent(data_, false)) {
     myWarning() << "server did not return valid XML.";
     stop();
     return;
   }
   // find Count, QueryKey, and WebEnv elements
   int count = 0;
   for(QDomNode n = dom.documentElement().firstChild(); !n.isNull(); n = n.nextSibling()) {
     QDomElement e = n.toElement();
     if(e.isNull()) {
       continue;
     }
     if(e.tagName() == QLatin1String("Count")) {
       m_total = e.text().toInt();
       ++count;
     } else if(e.tagName() == QLatin1String("QueryKey")) {
       m_queryKey = e.text();
       ++count;
     } else if(e.tagName() == QLatin1String("WebEnv")) {
       m_webEnv = e.text();
       ++count;
     }
     if(count >= 3) {
       break; // found them all
     }
   }
 
   doSummary();
 }
 
 void EntrezFetcher::doSummary() {
   QUrl u(QString::fromLatin1(ENTREZ_BASE_URL));
   u.setPath(u.path() + QLatin1String(ENTREZ_SUMMARY_CGI));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("tool"),       QStringLiteral("Tellico"));
   q.addQueryItem(QStringLiteral("retmode"),    QStringLiteral("xml"));
   if(m_start > 1) {
     q.addQueryItem(QStringLiteral("retstart"),   QString::number(m_start));
   }
   q.addQueryItem(QStringLiteral("retmax"),     QString::number(qMin(m_total-m_start-1, ENTREZ_MAX_RETURNS_TOTAL)));
   q.addQueryItem(QStringLiteral("usehistory"), QStringLiteral("y"));
   q.addQueryItem(QStringLiteral("db"),         m_dbname);
   q.addQueryItem(QStringLiteral("query_key"),  m_queryKey);
   q.addQueryItem(QStringLiteral("WebEnv"),     m_webEnv);
   u.setQuery(q);
 
   m_step = Summary;
 //  myLog() << "summary url:" << u.url();
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)),
-          SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result,
+          this, &EntrezFetcher::slotComplete);
 }
 
 void EntrezFetcher::summaryResults(const QByteArray& data_) {
   QDomDocument dom;
   if(!dom.setContent(data_, false)) {
     myWarning() << "server did not return valid XML.";
     stop();
     return;
   }
   // top child is eSummaryResult
   // all children are DocSum
   for(QDomNode n = dom.documentElement().firstChild(); !n.isNull(); n = n.nextSibling()) {
     QDomElement e = n.toElement();
     if(e.isNull() || e.tagName() != QLatin1String("DocSum")) {
       continue;
     }
     QDomNodeList nodes = e.elementsByTagName(QStringLiteral("Id"));
     if(nodes.count() == 0) {
       myDebug() << "no Id elements";
       continue;
     }
     int id = nodes.item(0).toElement().text().toInt();
     QString title, pubdate, authors;
     nodes = e.elementsByTagName(QStringLiteral("Item"));
     for(int j = 0; j < nodes.count(); ++j) {
       if(nodes.item(j).toElement().attribute(QStringLiteral("Name")) == QLatin1String("Title")) {
         title = nodes.item(j).toElement().text();
       } else if(nodes.item(j).toElement().attribute(QStringLiteral("Name")) == QLatin1String("PubDate")) {
         pubdate = nodes.item(j).toElement().text();
       } else if(nodes.item(j).toElement().attribute(QStringLiteral("Name")) == QLatin1String("AuthorList")) {
         QStringList list;
         for(QDomNode aNode = nodes.item(j).firstChild(); !aNode.isNull(); aNode = aNode.nextSibling()) {
           // lazy, assume all children Items are authors
           if(aNode.nodeName() == QLatin1String("Item")) {
             list << aNode.toElement().text();
           }
         }
         authors = list.join(FieldFormat::delimiterString());
       }
       if(!title.isEmpty() && !pubdate.isEmpty() && !authors.isEmpty()) {
         break; // done now
       }
     }
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), title, pubdate + QLatin1Char('/') + authors);
     m_matches.insert(r->uid, id);
     emit signalResultFound(r);
   }
   m_start = m_matches.count() + 1;
   m_hasMoreResults = m_start <= m_total;
   stop(); // done searching
 }
 
 Tellico::Data::EntryPtr EntrezFetcher::fetchEntryHook(uint uid_) {
   // if we already grabbed this one, then just pull it out of the dict
   Data::EntryPtr entry = m_entries[uid_];
   if(entry) {
     return entry;
   }
 
   if(!m_matches.contains(uid_)) {
     return Data::EntryPtr();
   }
 
   if(!m_xsltHandler) {
     initXSLTHandler();
     if(!m_xsltHandler) { // probably an error somewhere in the stylesheet loading
       stop();
       return Data::EntryPtr();
     }
   }
 
   int id = m_matches[uid_];
 
   QUrl u(QString::fromLatin1(ENTREZ_BASE_URL));
   u.setPath(u.path() + QLatin1String(ENTREZ_FETCH_CGI));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("tool"),       QStringLiteral("Tellico"));
   q.addQueryItem(QStringLiteral("retmode"),    QStringLiteral("xml"));
   q.addQueryItem(QStringLiteral("rettype"),    QStringLiteral("abstract"));
   q.addQueryItem(QStringLiteral("db"),         m_dbname);
   q.addQueryItem(QStringLiteral("id"),         QString::number(id));
   u.setQuery(q);
 
   // now it's synchronous
   QString xmlOutput = FileHandler::readXMLFile(u, true /*quiet*/);
   if(xmlOutput.isEmpty()) {
     myWarning() << "unable to download " << u;
     return Data::EntryPtr();
   }
 #if 0
   myWarning() << "turn me off in entrezfetcher.cpp!";
   QFile f1(QLatin1String("/tmp/test-entry.xml"));
   if(f1.open(QIODevice::WriteOnly)) {
     QTextStream t(&f1);
     t.setCodec("UTF-8");
     t << xmlOutput;
   }
   f1.close();
 #endif
   QString str = m_xsltHandler->applyStylesheet(xmlOutput);
   Import::TellicoImporter imp(str);
   Data::CollPtr coll = imp.collection();
   if(!coll) {
     myWarning() << "invalid collection";
     return Data::EntryPtr();
   }
   if(coll->entryCount() == 0) {
     myDebug() << "no entries in collection";
     return Data::EntryPtr();
   } else if(coll->entryCount() > 1) {
     myDebug() << "collection has multiple entries, taking first one";
   }
 
   Data::EntryPtr e = coll->entries().front();
 
   // try to get a link, but only if necessary
   if(optionalFields().contains(QStringLiteral("url"))) {
     QUrl link(QString::fromLatin1(ENTREZ_BASE_URL));
     link.setPath(link.path() + QLatin1String(ENTREZ_LINK_CGI));
     QUrlQuery q;
     q.addQueryItem(QStringLiteral("tool"),   QStringLiteral("Tellico"));
     q.addQueryItem(QStringLiteral("cmd"),    QStringLiteral("llinks"));
     q.addQueryItem(QStringLiteral("db"),     m_dbname);
     q.addQueryItem(QStringLiteral("dbfrom"), m_dbname);
     q.addQueryItem(QStringLiteral("id"),     QString::number(id));
     link.setQuery(q);
 
     QDomDocument linkDom = FileHandler::readXMLDocument(link, false /* namespace */, true /* quiet */);
     // need eLinkResult/LinkSet/IdUrlList/IdUrlSet/ObjUrl/Url
     QDomNode linkNode = linkDom.namedItem(QStringLiteral("eLinkResult"))
                                .namedItem(QStringLiteral("LinkSet"))
                                .namedItem(QStringLiteral("IdUrlList"))
                                .namedItem(QStringLiteral("IdUrlSet"))
                                .namedItem(QStringLiteral("ObjUrl"))
                                .namedItem(QStringLiteral("Url"));
     if(!linkNode.isNull()) {
       QString u = linkNode.toElement().text();
 //      myDebug() << u;
       if(!u.isEmpty()) {
         if(!coll->hasField(QStringLiteral("url"))) {
           Data::FieldPtr field(new Data::Field(QStringLiteral("url"), i18n("URL"), Data::Field::URL));
           field->setCategory(i18n("Miscellaneous"));
           coll->addField(field);
         }
         e->setField(QStringLiteral("url"), u);
       }
     }
   }
 
   m_entries.insert(uid_, e);
   return e;
 }
 
 void EntrezFetcher::initXSLTHandler() {
   QString xsltfile = DataFileRegistry::self()->locate(QStringLiteral("pubmed2tellico.xsl"));
   if(xsltfile.isEmpty()) {
     myWarning() << "can not locate pubmed2tellico.xsl.";
     return;
   }
 
   QUrl u = QUrl::fromLocalFile(xsltfile);
 
   if(!m_xsltHandler) {
     m_xsltHandler = new XSLTHandler(u);
   }
   if(!m_xsltHandler->isValid()) {
     myWarning() << "error in pubmed2tellico.xsl.";
     delete m_xsltHandler;
     m_xsltHandler = nullptr;
     return;
   }
 }
 
 Tellico::Fetch::FetchRequest EntrezFetcher::updateRequest(Data::EntryPtr entry_) {
 //  myDebug();
   QString s = entry_->field(QStringLiteral("pmid"));
   if(!s.isEmpty()) {
     return FetchRequest(PubmedID, s);
   }
 
   s = entry_->field(QStringLiteral("doi"));
   if(!s.isEmpty()) {
     return FetchRequest(DOI, s);
   }
 
   s = entry_->field(QStringLiteral("title"));
   if(!s.isEmpty()) {
     return FetchRequest(Title, s);
   }
   return FetchRequest();
 }
 
 QString EntrezFetcher::defaultName() {
   return i18n("Entrez Database");
 }
 
 QString EntrezFetcher::defaultIcon() {
   return favIcon("http://www.ncbi.nlm.nih.gov");
 }
 
 //static
 Tellico::StringHash EntrezFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("institution")] = i18n("Institution");
   hash[QStringLiteral("abstract")]    = i18n("Abstract");
   hash[QStringLiteral("url")]         = i18n("URL");
   return hash;
 }
 
 Tellico::Fetch::ConfigWidget* EntrezFetcher::configWidget(QWidget* parent_) const {
   return new EntrezFetcher::ConfigWidget(parent_, this);
 }
 
 EntrezFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const EntrezFetcher* fetcher_/*=0*/)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 
   // now add additional fields widget
   addFieldsWidget(EntrezFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 QString EntrezFetcher::ConfigWidget::preferredName() const {
   return EntrezFetcher::defaultName();
 }
diff --git a/src/fetch/execexternalfetcher.cpp b/src/fetch/execexternalfetcher.cpp
index 541f4bf1..a2de8ae5 100644
--- a/src/fetch/execexternalfetcher.cpp
+++ b/src/fetch/execexternalfetcher.cpp
@@ -1,550 +1,551 @@
 /***************************************************************************
     Copyright (C) 2005-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "execexternalfetcher.h"
 #include "fetchmanager.h"
 #include "../collection.h"
 #include "../entry.h"
 #include "../fieldformat.h"
 #include "../derivedvalue.h"
 #include "../tellico_debug.h"
 #include "../gui/combobox.h"
 #include "../gui/lineedit.h"
 #include "../gui/collectiontypecombo.h"
 #include "../utils/cursorsaver.h"
 #include "../newstuff/manager.h"
 #include "../translators/translators.h"
 #include "../translators/tellicoimporter.h"
 #include "../translators/bibteximporter.h"
 #include "../translators/xsltimporter.h"
 #include "../translators/risimporter.h"
 #include "../utils/datafileregistry.h"
 
 #include <KLocalizedString>
 #include <KProcess>
 #include <KUrlRequester>
 #include <KAcceleratorManager>
 #include <KShell>
 #include <KConfigGroup>
 
 #include <QLabel>
 #include <QRegExp>
 #include <QGroupBox>
 #include <QGridLayout>
 
 using namespace Tellico;
 using Tellico::Fetch::ExecExternalFetcher;
 
 QStringList ExecExternalFetcher::parseArguments(const QString& str_) {
   // matching escaped quotes is too hard... :(
 //  QRegExp quotes(QLatin1String("[^\\\\](['\"])(.*[^\\\\])\\1"));
   QRegExp quotes(QLatin1String("(['\"])(.*)\\1"));
   quotes.setMinimal(true);
   QRegExp spaces(QLatin1String("\\s+"));
   spaces.setMinimal(true);
 
   QStringList args;
   int pos = 0;
   for(int nextPos = quotes.indexIn(str_); nextPos > -1; pos = nextPos+1, nextPos = quotes.indexIn(str_, pos)) {
     // a non-quotes arguments runs from pos to nextPos
     args += str_.mid(pos, nextPos-pos).split(spaces, QString::SkipEmptyParts);
     // move nextpos marker to end of match
     pos = quotes.pos(2); // skip quotation mark
     nextPos += quotes.matchedLength();
     args += str_.mid(pos, nextPos-pos-1);
   }
   // catch the end stuff
   args += str_.mid(pos).split(spaces, QString::SkipEmptyParts);
 
   return args;
 }
 
 ExecExternalFetcher::ExecExternalFetcher(QObject* parent_) : Fetcher(parent_),
     m_started(false), m_collType(-1), m_formatType(-1), m_canUpdate(false), m_process(nullptr), m_deleteOnRemove(false) {
 }
 
 ExecExternalFetcher::~ExecExternalFetcher() {
   stop();
 }
 
 QString ExecExternalFetcher::source() const {
   return m_name;
 }
 
 bool ExecExternalFetcher::canFetch(int type_) const {
   return m_collType == -1 ? false : m_collType == type_;
 }
 
 void ExecExternalFetcher::readConfigHook(const KConfigGroup& config_) {
   QString s = config_.readPathEntry("ExecPath", QString());
   if(!s.isEmpty()) {
     m_path = s;
   }
   QList<int> argKeys;
   if(config_.hasKey("ArgumentKeys")) {
     argKeys = config_.readEntry("ArgumentKeys", argKeys);
   } else {
     myDebug() << "appending default keyword argument";
     argKeys.append(Keyword);
   }
   QStringList args = config_.readEntry("Arguments", QStringList());
   if(argKeys.count() != args.count()) {
     myWarning() << "unequal number of arguments and keys";
   }
   int n = qMin(argKeys.count(), args.count());
   for(int i = 0; i < n; ++i) {
     m_args.insert(static_cast<FetchKey>(argKeys[i]), args[i]);
   }
   if(config_.hasKey("UpdateArgs")) {
     m_canUpdate = true;
     m_updateArgs = config_.readEntry("UpdateArgs");
   } else {
     m_canUpdate = false;
   }
   m_collType = config_.readEntry("CollectionType", -1);
   m_formatType = config_.readEntry("FormatType", -1);
   m_deleteOnRemove = config_.readEntry("DeleteOnRemove", false);
   m_newStuffName = config_.readEntry("NewStuffName");
 }
 
 void ExecExternalFetcher::search() {
   m_started = true;
 
   if(request().key != ExecUpdate && !m_args.contains(request().key)) {
     myDebug() << "stopping: not an update and no matching argument for search key";
     stop();
     return;
   }
 
   if(request().key == ExecUpdate) {
     // because the rowDelimiterString() is used below
     QStringList args = FieldFormat::splitTable(request().value);
     startSearch(args);
     return;
   }
 
   // should KShell::quoteArg() be used?
   // %1 gets replaced by the search value, but since the arguments are going to be split
   // the search value needs to be enclosed in quotation marks
   // but first check to make sure the user didn't do that already
   // AND the "%1" wasn't used in the settings
   QString value = request().value;
   if(request().key == ISBN) {
     value.remove(QLatin1Char('-')); // remove hyphens from isbn values
     // shouldn't hurt and might keep from confusing stupid search sources
   }
   QRegExp rx1(QLatin1String("['\"].*\\1"));
   if(!rx1.exactMatch(value)) {
     value = QLatin1Char('"') + value + QLatin1Char('"');
   }
   QString args = m_args.value(request().key);
   QRegExp rx2(QLatin1String("['\"]%1\\1"));
   args.replace(rx2, QStringLiteral("%1"));
   startSearch(parseArguments(args.arg(value))); // replace %1 with search value
 }
 
 void ExecExternalFetcher::startSearch(const QStringList& args_) {
   if(m_path.isEmpty()) {
     Q_ASSERT(!m_path.isEmpty());
     stop();
     return;
   }
 
   m_process = new KProcess();
-  connect(m_process, SIGNAL(readyReadStandardOutput()), SLOT(slotData()));
-  connect(m_process, SIGNAL(readyReadStandardError()), SLOT(slotError()));
-  connect(m_process, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(slotProcessExited()));
+  connect(m_process, &QProcess::readyReadStandardOutput, this, &ExecExternalFetcher::slotData);
+  connect(m_process, &QProcess::readyReadStandardError, this, &ExecExternalFetcher::slotError);
+  void (QProcess::* finished)(int, QProcess::ExitStatus) = &QProcess::finished;
+  connect(m_process, finished, this, &ExecExternalFetcher::slotProcessExited);
   m_process->setOutputChannelMode(KProcess::SeparateChannels);
   m_process->setProgram(m_path, args_);
   if(m_process && m_process->execute() < 0) {
     myDebug() << "process failed to start";
     stop();
   }
 }
 
 void ExecExternalFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_process) {
     m_process->kill();
     m_process->deleteLater();
     m_process = nullptr;
   }
   m_data.clear();
   m_started = false;
   m_errors.clear();
   emit signalDone(this);
 }
 
 void ExecExternalFetcher::slotData() {
   m_data.append(m_process->readAllStandardOutput());
 }
 
 void ExecExternalFetcher::slotError() {
   GUI::CursorSaver cs(Qt::ArrowCursor);
   QString msg = QString::fromLocal8Bit(m_process->readAllStandardError());
   msg.prepend(source() + QLatin1String(": "));
   if(msg.endsWith(QChar::fromLatin1('\n'))) {
     msg.truncate(msg.length()-1);
   }
   myDebug() << msg;
   m_errors << msg;
 }
 
 void ExecExternalFetcher::slotProcessExited() {
 //  DEBUG_LINE;
   if(m_process->exitStatus() != QProcess::NormalExit || m_process->exitCode() != 0) {
     myDebug() << source() << ": process did not exit successfully";
     if(!m_errors.isEmpty()) {
       message(m_errors.join(QChar::fromLatin1('\n')), MessageHandler::Error);
     }
     stop();
     return;
   }
   if(!m_errors.isEmpty()) {
     message(m_errors.join(QChar::fromLatin1('\n')), MessageHandler::Warning);
   }
 
   if(m_data.isEmpty()) {
     myDebug() << source() << ": no data";
     stop();
     return;
   }
 
   const QString text = QString::fromUtf8(m_data.constData(), m_data.size());
   Import::Format format = static_cast<Import::Format>(m_formatType > -1 ? m_formatType : Import::TellicoXML);
   Import::Importer* imp = nullptr;
   // only 4 formats re supported here
   switch(format) {
     case Import::TellicoXML:
       imp = new Import::TellicoImporter(text);
       break;
 
     case Import::Bibtex:
       imp = new Import::BibtexImporter(text);
       break;
 
     case Import::MODS:
       imp = new Import::XSLTImporter(text);
       {
         QString xsltFile = DataFileRegistry::self()->locate(QStringLiteral("mods2tellico.xsl"));
         if(!xsltFile.isEmpty()) {
           QUrl u = QUrl::fromLocalFile(xsltFile);
           static_cast<Import::XSLTImporter*>(imp)->setXSLTURL(u);
         } else {
           myWarning() << "unable to find mods2tellico.xml!";
           delete imp;
           imp = nullptr;
         }
       }
       break;
 
     case Import::RIS:
       imp = new Import::RISImporter(text);
       break;
 
     default:
       break;
   }
   if(!imp) {
     stop();
     return;
   }
 
   Data::CollPtr coll = imp->collection();
   if(!coll) {
     if(!imp->statusMessage().isEmpty()) {
       message(imp->statusMessage(), MessageHandler::Status);
     }
     myDebug() << source() << ": no collection pointer";
     delete imp;
     stop();
     return;
   }
 
   delete imp;
   if(coll->entryCount() == 0) {
 //    myDebug() << "no results";
     stop();
     return;
   }
 
   Data::EntryList entries = coll->entries();
   foreach(Data::EntryPtr entry, entries) {
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
   }
   stop(); // be sure to call this
 }
 
 Tellico::Data::EntryPtr ExecExternalFetcher::fetchEntryHook(uint uid_) {
   return m_entries[uid_];
 }
 
 Tellico::Fetch::FetchRequest ExecExternalFetcher::updateRequest(Data::EntryPtr entry_) {
   if(!m_canUpdate) {
     return FetchRequest();
   }
 
   QStringList args = parseArguments(m_updateArgs);
   for(QStringList::Iterator it = args.begin(); it != args.end(); ++it) {
     Data::DerivedValue dv(*it);
     *it = dv.value(entry_, false);
   }
   return FetchRequest(ExecUpdate, args.join(FieldFormat::rowDelimiterString()));
 }
 
 Tellico::Fetch::ConfigWidget* ExecExternalFetcher::configWidget(QWidget* parent_) const {
   return new ExecExternalFetcher::ConfigWidget(parent_, this);
 }
 
 QString ExecExternalFetcher::defaultName() {
   return i18n("External Application");
 }
 
 QString ExecExternalFetcher::defaultIcon() {
   return QStringLiteral("application-x-executable");
 }
 
 ExecExternalFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const ExecExternalFetcher* fetcher_/*=0*/)
     : Fetch::ConfigWidget(parent_), m_deleteOnRemove(false) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
 
   QLabel* label = new QLabel(i18n("Collection &type:"), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_collCombo = new GUI::CollectionTypeCombo(optionsWidget());
-  connect(m_collCombo, SIGNAL(activated(int)), SLOT(slotSetModified()));
+  void (GUI::ComboBox::* activatedInt)(int) = &GUI::ComboBox::activated;
+  connect(m_collCombo, activatedInt, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_collCombo, row, 1);
   QString w = i18n("Set the collection type of the data returned from the external application.");
   label->setWhatsThis(w);
   m_collCombo->setWhatsThis(w);
   label->setBuddy(m_collCombo);
 
   label = new QLabel(i18n("&Result type: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_formatCombo = new GUI::ComboBox(optionsWidget());
   m_formatCombo->addItem(QStringLiteral("Tellico"), Import::TellicoXML);
   m_formatCombo->addItem(QStringLiteral("Bibtex"), Import::Bibtex);
   m_formatCombo->addItem(QStringLiteral("MODS"), Import::MODS);
   m_formatCombo->addItem(QStringLiteral("RIS"), Import::RIS);
-  connect(m_formatCombo, SIGNAL(activated(int)), SLOT(slotSetModified()));
+  connect(m_formatCombo, activatedInt, this, &ExecExternalFetcher::ConfigWidget::slotSetModified);
   l->addWidget(m_formatCombo, row, 1);
   w = i18n("Set the result type of the data returned from the external application.");
   label->setWhatsThis(w);
   m_formatCombo->setWhatsThis(w);
   label->setBuddy(m_formatCombo);
 
   label = new QLabel(i18n("Application &path: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_pathEdit = new KUrlRequester(optionsWidget());
-  connect(m_pathEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_pathEdit, &KUrlRequester::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_pathEdit, row, 1);
   w = i18n("Set the path of the application to run that should output a valid Tellico data file.");
   label->setWhatsThis(w);
   m_pathEdit->setWhatsThis(w);
   label->setBuddy(m_pathEdit);
 
   w = i18n("Select the search keys supported by the data source.");
   // in this string, the %1 is not a placeholder, it's an example
   QString w2 = i18n("Add any arguments that may be needed. <b>%1</b> will be replaced by the search term."); // krazy:exclude=i18ncheckarg
   QGroupBox* gbox = new QGroupBox(i18n("Arguments"), optionsWidget());
   ++row;
   l->addWidget(gbox, row, 0, 1, 2);
   QGridLayout* gridLayout = new QGridLayout(gbox);
   gridLayout->setSpacing(2);
   row = -1;
   const Fetch::KeyMap keyMap = Fetch::Manager::self()->keyMap();
   for(Fetch::KeyMap::ConstIterator it = keyMap.begin(); it != keyMap.end(); ++it) {
     FetchKey key = it.key();
     if(key == Raw) {
       continue;
     }
     QCheckBox* cb = new QCheckBox(it.value(), gbox);
     gridLayout->addWidget(cb, ++row, 0);
     m_cbDict.insert(key, cb);
     GUI::LineEdit* le = new GUI::LineEdit(gbox);
     le->setPlaceholderText(QStringLiteral("%1")); // for example
     le->completionObject()->addItem(QStringLiteral("%1"));
     gridLayout->addWidget(le, row, 1);
     m_leDict.insert(key, le);
     if(fetcher_ && fetcher_->m_args.contains(key)) {
       cb->setChecked(true);
       le->setEnabled(true);
       le->setText(fetcher_->m_args.value(key));
     } else {
       cb->setChecked(false);
       le->setEnabled(false);
     }
-    connect(cb, SIGNAL(toggled(bool)), le, SLOT(setEnabled(bool)));
+    connect(cb, &QAbstractButton::toggled, le, &QWidget::setEnabled);
     cb->setWhatsThis(w);
     le->setWhatsThis(w2);
   }
   m_cbUpdate = new QCheckBox(i18n("Update"), gbox);
   gridLayout->addWidget(m_cbUpdate, ++row, 0);
   m_leUpdate = new GUI::LineEdit(gbox);
   m_leUpdate->setPlaceholderText(QStringLiteral("%{title}")); // for example
   m_leUpdate->completionObject()->addItem(QStringLiteral("%{title}"));
   m_leUpdate->completionObject()->addItem(QStringLiteral("%{isbn}"));
   gridLayout->addWidget(m_leUpdate, row, 1);
   /* TRANSLATORS: Do not translate %{author}. */
   w2 = i18n("<p>Enter the arguments which should be used to search for available updates to an entry.</p><p>"
            "The format is the same as for fields with derived values, where field names "
            "are contained inside braces, such as <i>%{author}</i>. See the documentation for details.</p>");
   m_cbUpdate->setWhatsThis(w);
   m_leUpdate->setWhatsThis(w2);
   if(fetcher_ && fetcher_->m_canUpdate) {
     m_cbUpdate->setChecked(true);
     m_leUpdate->setEnabled(true);
     m_leUpdate->setText(fetcher_->m_updateArgs);
   } else {
     m_cbUpdate->setChecked(false);
     m_leUpdate->setEnabled(false);
   }
-  connect(m_cbUpdate, SIGNAL(toggled(bool)), m_leUpdate, SLOT(setEnabled(bool)));
+  connect(m_cbUpdate, &QAbstractButton::toggled, m_leUpdate, &QWidget::setEnabled);
 
   l->setRowStretch(++row, 1);
 
   if(fetcher_) {
     m_pathEdit->setUrl(QUrl::fromLocalFile(fetcher_->m_path));
     m_newStuffName = fetcher_->m_newStuffName;
   }
   if(fetcher_ && fetcher_->m_collType > -1) {
     m_collCombo->setCurrentType(fetcher_->m_collType);
   } else {
     m_collCombo->setCurrentType(Data::Collection::Book);
   }
   if(fetcher_ && fetcher_->m_formatType > -1) {
     m_formatCombo->setCurrentData(fetcher_->m_formatType);
   } else {
     m_formatCombo->setCurrentData(Import::TellicoXML);
   }
   m_deleteOnRemove = fetcher_ && fetcher_->m_deleteOnRemove;
   KAcceleratorManager::manage(optionsWidget());
 }
 
 ExecExternalFetcher::ConfigWidget::~ConfigWidget() {
 }
 
 void ExecExternalFetcher::ConfigWidget::readConfig(const KConfigGroup& config_) {
   m_pathEdit->setUrl(QUrl::fromLocalFile(config_.readPathEntry("ExecPath", QString())));
   QList<int> argKeys = config_.readEntry("ArgumentKeys", QList<int>());
   QStringList argValues = config_.readEntry("Arguments", QStringList());
   if(argKeys.count() != argValues.count()) {
     myWarning() << "unequal number of arguments and keys";
   }
   int n = qMin(argKeys.count(), argValues.count());
   QMap<FetchKey, QString> args;
   for(int i = 0; i < n; ++i) {
     args[static_cast<FetchKey>(argKeys[i])] = argValues[i];
   }
   for(QList<int>::Iterator it = argKeys.begin(); it != argKeys.end(); ++it) {
     if(*it == Raw) {
       continue;
     }
     FetchKey key = static_cast<FetchKey>(*it);
     QCheckBox* cb = m_cbDict[key];
     QLineEdit* le = m_leDict[key];
     if(cb && le) {
       if(args.contains(key)) {
         cb->setChecked(true);
         le->setEnabled(true);
         le->setText(args[key]);
       } else {
         cb->setChecked(false);
         le->setEnabled(false);
         le->clear();
       }
     }
   }
 
   if(config_.hasKey("UpdateArgs")) {
     m_cbUpdate->setChecked(true);
     m_leUpdate->setEnabled(true);
     m_leUpdate->setText(config_.readEntry("UpdateArgs"));
   } else {
     m_cbUpdate->setChecked(false);
     m_leUpdate->setEnabled(false);
     m_leUpdate->clear();
   }
 
   int collType = config_.readEntry("CollectionType", -1);
   m_collCombo->setCurrentType(collType);
 
   int formatType = config_.readEntry("FormatType", -1);
   m_formatCombo->setCurrentData(static_cast<Import::Format>(formatType));
   m_deleteOnRemove = config_.readEntry("DeleteOnRemove", false);
   m_name = config_.readEntry("Name");
   m_newStuffName = config_.readEntry("NewStuffName");
 }
 
 void ExecExternalFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   QUrl u = m_pathEdit->url();
   if(!u.isEmpty()) {
     config_.writePathEntry("ExecPath", u.path());
   }
   QList<int> keys;
   QStringList args;
   QHash<int, QCheckBox*>::const_iterator it = m_cbDict.constBegin();
   for( ; it != m_cbDict.constEnd(); ++it) {
     if(it.value()->isChecked()) {
       keys << it.key();
       args << m_leDict[it.key()]->text();
     }
   }
   config_.writeEntry("ArgumentKeys", keys);
   config_.writeEntry("Arguments", args);
 
   if(m_cbUpdate->isChecked()) {
     config_.writeEntry("UpdateArgs", m_leUpdate->text());
   } else {
     config_.deleteEntry("UpdateArgs");
   }
 
   config_.writeEntry("CollectionType", m_collCombo->currentType());
   config_.writeEntry("FormatType", m_formatCombo->currentData().toInt());
   config_.writeEntry("DeleteOnRemove", m_deleteOnRemove);
   if(!m_newStuffName.isEmpty()) {
     config_.writeEntry("NewStuffName", m_newStuffName);
   }
-  slotSetModified(false);
 }
 
 void ExecExternalFetcher::ConfigWidget::removed() {
   if(!m_deleteOnRemove) {
     return;
   }
   if(!m_newStuffName.isEmpty()) {
     NewStuff::Manager::self()->removeScript(m_newStuffName);
   }
 }
 
 QString ExecExternalFetcher::ConfigWidget::preferredName() const {
   return m_name.isEmpty() ? ExecExternalFetcher::defaultName() : m_name;
 }
diff --git a/src/fetch/fetcherjob.cpp b/src/fetch/fetcherjob.cpp
index c405ae54..b0165e58 100644
--- a/src/fetch/fetcherjob.cpp
+++ b/src/fetch/fetcherjob.cpp
@@ -1,95 +1,95 @@
 /***************************************************************************
     Copyright (C) 2005-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "fetcherjob.h"
 #include "../entry.h"
 #include "../tellico_debug.h"
 
 #include <QTimer>
 
 using namespace Tellico;
 using namespace Tellico::Fetch;
 using Tellico::Fetch::FetcherJob;
 
 FetcherJob::FetcherJob(QObject* parent_, Fetcher::Ptr fetcher_, const FetchRequest& request_)
     : KJob(parent_), m_fetcher(fetcher_), m_request(request_), m_maximumResults(0) {
-  connect(m_fetcher.data(), SIGNAL(signalResultFound(Tellico::Fetch::FetchResult*)),
-          SLOT(slotResult(Tellico::Fetch::FetchResult*)));
-  connect(m_fetcher.data(), SIGNAL(signalDone(Tellico::Fetch::Fetcher*)),
-          SLOT(slotDone()));
+  connect(m_fetcher.data(), &Fetcher::signalResultFound,
+          this, &FetcherJob::slotResult);
+  connect(m_fetcher.data(), &Fetcher::signalDone,
+          this, &FetcherJob::slotDone);
 }
 
 FetcherJob::~FetcherJob() {
   qDeleteAll(m_results);
   m_results.clear();
 }
 
 Tellico::Data::EntryList FetcherJob::entries() {
   Data::EntryList list;
   foreach(FetchResult* result, m_results) {
     Data::EntryPtr entry = result->fetchEntry();
     if(entry) {
       list << entry;
     }
   }
   return list;
 }
 
 void FetcherJob::setMaximumResults(int count_) {
   Q_ASSERT(count_ >= 0);
   m_maximumResults = count_;
 }
 
 void FetcherJob::start() {
-  QTimer::singleShot(0, this, SLOT(startSearch()));
+  QTimer::singleShot(0, this, &FetcherJob::startSearch);
 }
 
 void FetcherJob::startSearch() {
   m_fetcher->startSearch(m_request);
 }
 
 void FetcherJob::slotResult(Tellico::Fetch::FetchResult* result_) {
   if(!result_) {
     myDebug() << "null result";
     return;
   }
   m_results.append(result_);
   if(m_maximumResults > 0 && m_results.count() >= m_maximumResults) {
     doKill();
   }
 }
 
 void FetcherJob::slotDone() {
   // only continue if more results were specifically asked for
   if(m_fetcher->hasMoreResults() && m_results.count() < m_maximumResults) {
     m_fetcher->continueSearch();
   } else {
     emitResult();
   }
 }
 
 bool FetcherJob::doKill() {
   m_fetcher->stop();
   return true;
 }
diff --git a/src/fetch/fetchmanager.cpp b/src/fetch/fetchmanager.cpp
index 9fc88758..8405796c 100644
--- a/src/fetch/fetchmanager.cpp
+++ b/src/fetch/fetchmanager.cpp
@@ -1,586 +1,586 @@
 /***************************************************************************
     Copyright (C) 2003-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include <config.h>
 
 #include "fetchmanager.h"
 #include "configwidget.h"
 #include "messagehandler.h"
 #include "../entry.h"
 #include "../collection.h"
 #include "../document.h"
 #include "../utils/string_utils.h"
 #include "../utils/tellico_utils.h"
 #include "../tellico_debug.h"
 
 #ifdef HAVE_YAZ
 #include "z3950fetcher.h"
 #endif
 #include "srufetcher.h"
 #include "execexternalfetcher.h"
 
 #include <KLocalizedString>
 #include <KIconLoader>
 #include <KIO/Job>
 #include <KSharedConfig>
 
 #include <QFileInfo>
 #include <QDir>
 #include <QTemporaryFile>
 
 #define LOAD_ICON(name, group, size) \
   KIconLoader::global()->loadIcon(name, static_cast<KIconLoader::Group>(group), size_)
 
 using Tellico::Fetch::Manager;
 Manager* Manager::s_self = nullptr;
 
 Manager::Manager() : QObject(), m_currentFetcherIndex(-1), m_messager(new ManagerMessage()),
                      m_count(0), m_loadDefaults(false) {
   // must create static pointer first
   Q_ASSERT(!s_self);
   s_self = this;
   // no need to load fetchers since the initializer does it for us
 
 //  m_keyMap.insert(FetchFirst, QString());
   m_keyMap.insert(Title,      i18n("Title"));
   m_keyMap.insert(Person,     i18n("Person"));
   m_keyMap.insert(ISBN,       i18n("ISBN"));
   m_keyMap.insert(UPC,        i18n("UPC/EAN"));
   m_keyMap.insert(Keyword,    i18n("Keyword"));
   m_keyMap.insert(DOI,        i18n("DOI"));
   m_keyMap.insert(ArxivID,    i18n("arXiv ID"));
   m_keyMap.insert(PubmedID,   i18n("PubMed ID"));
   m_keyMap.insert(LCCN,       i18n("LCCN"));
   m_keyMap.insert(Raw,        i18n("Raw Query"));
 //  m_keyMap.insert(FetchLast,  QString());
 }
 
 Manager::~Manager() {
   delete m_messager;
 }
 
 void Manager::registerFunction(int type_, const FetcherFunction& func_) {
   functionRegistry.insert(type_, func_);
 }
 
 void Manager::loadFetchers() {
   m_fetchers.clear();
   m_uuidHash.clear();
 
   KSharedConfigPtr config = KSharedConfig::openConfig();
   if(config->hasGroup(QStringLiteral("Data Sources"))) {
     KConfigGroup configGroup(config, QStringLiteral("Data Sources"));
     int nSources = configGroup.readEntry("Sources Count", 0);
     for(int i = 0; i < nSources; ++i) {
       QString group = QStringLiteral("Data Source %1").arg(i);
       Fetcher::Ptr f = createFetcher(config, group);
       if(f) {
         m_fetchers.append(f);
         f->setMessageHandler(m_messager);
         m_uuidHash.insert(f->uuid(), f);
       }
     }
     m_loadDefaults = false;
   } else { // add default sources
     m_fetchers = defaultFetchers();
     m_loadDefaults = true;
   }
 }
 
 const Tellico::Fetch::FetcherVec& Manager::fetchers() const {
   return m_fetchers;
 }
 
 Tellico::Fetch::FetcherVec Manager::fetchers(int type_) {
   FetcherVec vec;
   foreach(Fetcher::Ptr fetcher, m_fetchers) {
     if(fetcher->canFetch(type_)) {
       vec.append(fetcher);
     }
   }
   return vec;
 }
 
 Tellico::Fetch::Fetcher::Ptr Manager::fetcherByUuid(const QString& uuid_) {
   return m_uuidHash.contains(uuid_) ? m_uuidHash[uuid_] : Fetcher::Ptr();
 }
 
 Tellico::Fetch::KeyMap Manager::keyMap(const QString& source_) const {
   // an empty string means return all
   if(source_.isEmpty()) {
     return m_keyMap;
   }
 
   // assume there's only one fetcher match
   Fetcher::Ptr foundFetcher;
   foreach(Fetcher::Ptr fetcher, m_fetchers) {
     if(source_ == fetcher->source()) {
       foundFetcher = fetcher;
       break;
     }
   }
   if(!foundFetcher) {
     myWarning() << "no fetcher found!";
     return KeyMap();
   }
 
   KeyMap map;
   for(KeyMap::ConstIterator it = m_keyMap.constBegin(); it != m_keyMap.constEnd(); ++it) {
     if(foundFetcher->canSearch(it.key())) {
       map.insert(it.key(), it.value());
     }
   }
   return map;
 }
 
 void Manager::startSearch(const QString& source_, Tellico::Fetch::FetchKey key_, const QString& value_) {
   if(value_.isEmpty()) {
     emit signalDone();
     return;
   }
 
   FetchRequest request(Data::Document::self()->collection()->type(), key_, value_);
 
   // assume there's only one fetcher match
   int i = 0;
   m_currentFetcherIndex = -1;
   foreach(Fetcher::Ptr fetcher, m_fetchers) {
     if(source_ == fetcher->source()) {
       ++m_count; // Fetcher::search() might emit done(), so increment before calling search()
-      connect(fetcher.data(), SIGNAL(signalResultFound(Tellico::Fetch::FetchResult*)),
-              SIGNAL(signalResultFound(Tellico::Fetch::FetchResult*)));
-      connect(fetcher.data(), SIGNAL(signalDone(Tellico::Fetch::Fetcher*)),
-              SLOT(slotFetcherDone(Tellico::Fetch::Fetcher*)));
+      connect(fetcher.data(), &Fetcher::signalResultFound,
+              this, &Manager::signalResultFound);
+      connect(fetcher.data(), &Fetcher::signalDone,
+              this, &Manager::slotFetcherDone);
       fetcher->startSearch(request);
       m_currentFetcherIndex = i;
       break;
     }
     ++i;
   }
 }
 
 void Manager::continueSearch() {
   if(m_currentFetcherIndex < 0 || m_currentFetcherIndex >= static_cast<int>(m_fetchers.count())) {
     myDebug() << "can't continue!";
     emit signalDone();
     return;
   }
   Fetcher::Ptr fetcher = m_fetchers[m_currentFetcherIndex];
   if(fetcher && fetcher->hasMoreResults()) {
     ++m_count;
-    connect(fetcher.data(), SIGNAL(signalResultFound(Tellico::Fetch::FetchResult*)),
-            SIGNAL(signalResultFound(Tellico::Fetch::FetchResult*)));
-    connect(fetcher.data(), SIGNAL(signalDone(Tellico::Fetch::Fetcher*)),
-            SLOT(slotFetcherDone(Tellico::Fetch::Fetcher*)));
+    connect(fetcher.data(), &Fetcher::signalResultFound,
+            this, &Manager::signalResultFound);
+    connect(fetcher.data(), &Fetcher::signalDone,
+            this, &Manager::slotFetcherDone);
     fetcher->continueSearch();
   } else {
     emit signalDone();
   }
 }
 
 bool Manager::hasMoreResults() const {
   if(m_currentFetcherIndex < 0 || m_currentFetcherIndex >= static_cast<int>(m_fetchers.count())) {
     return false;
   }
   Fetcher::Ptr fetcher = m_fetchers[m_currentFetcherIndex];
   return fetcher && fetcher->hasMoreResults();
 }
 
 void Manager::stop() {
 //  DEBUG_LINE;
   foreach(Fetcher::Ptr fetcher, m_fetchers) {
     if(fetcher->isSearching()) {
       fetcher->stop();
       fetcher->saveConfig();
     }
   }
 #ifndef NDEBUG
   if(m_count != 0) {
     myDebug() << "count should be 0!";
   }
 #endif
   m_count = 0;
 }
 
 void Manager::slotFetcherDone(Tellico::Fetch::Fetcher* fetcher_) {
 //  myDebug() << (fetcher_ ? fetcher_->source() : QString()) << ":" << m_count;
   fetcher_->disconnect(); // disconnect all signals
   fetcher_->saveConfig();
   --m_count;
   if(m_count <= 0) {
     emit signalDone();
   }
 }
 
 bool Manager::canFetch() const {
   foreach(Fetcher::Ptr fetcher, m_fetchers) {
     if(fetcher->canFetch(Data::Document::self()->collection()->type())) {
       return true;
     }
   }
   return false;
 }
 
 Tellico::Fetch::Fetcher::Ptr Manager::createFetcher(KSharedConfigPtr config_, const QString& group_) {
   if(!config_->hasGroup(group_)) {
     myDebug() << "no config group for " << group_;
     return Fetcher::Ptr();
   }
 
   KConfigGroup config(config_, group_);
 
   int fetchType = config.readEntry("Type", int(Fetch::Unknown));
   if(fetchType == Fetch::Unknown) {
     myDebug() << "unknown type " << fetchType << ", skipping";
     return Fetcher::Ptr();
   }
 
   // special case: the BoardGameGeek fetcher was originally implemented as a Ruby script
   // now, it's available with an XML API, so prefer the new version
   // so check for fetcher version and switch to the XML if version is missing or lower
   if(fetchType == Fetch::ExecExternal &&
      config.readPathEntry("ExecPath", QString()).endsWith(QLatin1String("boardgamegeek.rb"))) {
     KConfigGroup generalConfig(config_, QStringLiteral("General Options"));
     if(generalConfig.readEntry("FetchVersion", 0) < 1) {
       fetchType = Fetch::BoardGameGeek;
       generalConfig.writeEntry("FetchVersion", 1);
     }
   }
   // special case: the Bedetheque fetcher was originally implemented as a Python script
   // now, it's available as a builtin data source, so prefer the new version
   // so check for fetcher version and switch to the newer if version is missing or lower
   if(fetchType == Fetch::ExecExternal &&
      config.readPathEntry("ExecPath", QString()).endsWith(QStringLiteral("bedetheque.py"))) {
     KConfigGroup generalConfig(config_, QStringLiteral("General Options"));
     if(generalConfig.readEntry("FetchVersion", 0) < 2) {
       fetchType = Fetch::Bedetheque;
       generalConfig.writeEntry("FetchVersion", 2);
     }
   }
 
   Fetcher::Ptr f;
   if(functionRegistry.contains(fetchType)) {
     f = functionRegistry.value(fetchType).create(this);
     f->readConfig(config, group_);
   }
   return f;
 }
 
 #define FETCHER_ADD(type) \
   do { \
     if(functionRegistry.contains(type)) { \
       vec.append(functionRegistry.value(type).create(this)); \
     } \
   } while(false)
 
 // static
 Tellico::Fetch::FetcherVec Manager::defaultFetchers() {
   FetcherVec vec;
   vec.append(SRUFetcher::libraryOfCongress(this));
 // books
   FETCHER_ADD(ISBNdb);
   FETCHER_ADD(OpenLibrary);
   FETCHER_ADD(GoogleBook);
 // comic books
   FETCHER_ADD(AnimeNfo);
   FETCHER_ADD(Bedetheque);
   FETCHER_ADD(ComicVine);
 // bibliographic
   FETCHER_ADD(Arxiv);
   FETCHER_ADD(GoogleScholar);
   FETCHER_ADD(BiblioShare);
   FETCHER_ADD(DBLP);
   FETCHER_ADD(HathiTrust);
 // music
   FETCHER_ADD(MusicBrainz);
 // video games
   FETCHER_ADD(TheGamesDB);
   FETCHER_ADD(IGDB);
   FETCHER_ADD(VNDB);
   FETCHER_ADD(VideoGameGeek);
 // board games
   FETCHER_ADD(BoardGameGeek);
 // movies
   FETCHER_ADD(TheMovieDB);
 #ifdef ENABLE_IMDB
   FETCHER_ADD(IMDB);
 #endif
   QStringList langs = QLocale().uiLanguages();
   if(langs.first().contains(QLatin1Char('-'))) {
     // I'm not sure QT always include two-letter locale codes
     langs << langs.first().section(QLatin1Char('-'), 0, 0);
   }
 // only add IBS if user includes italian
   if(langs.contains(QStringLiteral("it"))) {
     FETCHER_ADD(IBS);
   }
   if(langs.contains(QStringLiteral("fr"))) {
     FETCHER_ADD(DVDFr);
     FETCHER_ADD(Allocine);
   }
   if(langs.contains(QStringLiteral("ru"))) {
     FETCHER_ADD(KinoPoisk);
   }
   if(langs.contains(QStringLiteral("ua"))) {
     FETCHER_ADD(KinoTeatr);
   }
   if(langs.contains(QStringLiteral("de"))) {
     FETCHER_ADD(Kino);
   }
   if(langs.contains(QStringLiteral("cn"))) {
     FETCHER_ADD(Douban);
   }
   if(langs.contains(QStringLiteral("dk"))) {
     FETCHER_ADD(DBC);
   }
   return vec;
 }
 
 #undef FETCHER_ADD
 
 Tellico::Fetch::FetcherVec Manager::createUpdateFetchers(int collType_) {
   if(m_loadDefaults) {
     return defaultFetchers();
   }
 
   FetcherVec vec;
   KConfigGroup config(KSharedConfig::openConfig(), "Data Sources");
   int nSources = config.readEntry("Sources Count", 0);
   for(int i = 0; i < nSources; ++i) {
     QString group = QStringLiteral("Data Source %1").arg(i);
     // needs the KConfig*
     Fetcher::Ptr fetcher = createFetcher(KSharedConfig::openConfig(), group);
     if(fetcher && fetcher->canFetch(collType_) && fetcher->canUpdate()) {
       vec.append(fetcher);
     }
   }
   return vec;
 }
 
 Tellico::Fetch::FetcherVec Manager::createUpdateFetchers(int collType_, Tellico::Fetch::FetchKey key_) {
   FetcherVec fetchers;
   // creates new fetchers
   FetcherVec allFetchers = createUpdateFetchers(collType_);
   foreach(Fetcher::Ptr fetcher, allFetchers) {
     if(fetcher->canSearch(key_)) {
       fetchers.append(fetcher);
     }
   }
   return fetchers;
 }
 
 Tellico::Fetch::Fetcher::Ptr Manager::createUpdateFetcher(int collType_, const QString& source_) {
   Fetcher::Ptr newFetcher;
   // creates new fetchers
   FetcherVec fetchers = createUpdateFetchers(collType_);
   foreach(Fetcher::Ptr fetcher, fetchers) {
     if(fetcher->source() == source_) {
       newFetcher = fetcher;
       break;
     }
   }
   return newFetcher;
 }
 
 void Manager::updateStatus(const QString& message_) {
   emit signalStatus(message_);
 }
 
 Tellico::Fetch::NameTypeMap Manager::nameTypeMap() {
   Fetch::NameTypeMap map;
   FunctionRegistry::const_iterator it = functionRegistry.constBegin();
   while(it != functionRegistry.constEnd()) {
     map.insert(functionRegistry.value(it.key()).name(), static_cast<Type>(it.key()));
     ++it;
   }
 
   // now find all the scripts distributed with tellico
   QStringList files = Tellico::locateAllFiles(QStringLiteral("tellico/data-sources/*.spec"));
   foreach(const QString& file, files) {
     KConfig spec(file, KConfig::SimpleConfig);
     KConfigGroup specConfig(&spec, QString());
     QString name = specConfig.readEntry("Name");
     if(name.isEmpty()) {
       myDebug() << "no name for" << file;
       continue;
     }
 
     bool enabled = specConfig.readEntry("Enabled", true);
     if(!enabled || !bundledScriptHasExecPath(file, specConfig)) { // no available exec
       continue;
     }
 
     map.insert(name, ExecExternal);
     m_scriptMap.insert(name, file);
   }
   return map;
 }
 
 // called when creating a new fetcher
 Tellico::Fetch::ConfigWidget* Manager::configWidget(QWidget* parent_, Tellico::Fetch::Type type_, const QString& name_) {
   ConfigWidget* w = nullptr;
   if(functionRegistry.contains(type_)) {
     w = functionRegistry.value(type_).configWidget(parent_);
   } else {
     myWarning() << "no widget defined for type =" << type_;
   }
   if(w && type_ == ExecExternal) {
     if(!name_.isEmpty() && m_scriptMap.contains(name_)) {
       // bundledScriptHasExecPath() actually needs to write the exec path
       // back to the config so the configWidget can read it. But if the spec file
       // is not readable, that doesn't work. So work around it with a copy to a temp file
       QTemporaryFile tmpFile;
       tmpFile.open();
       QUrl from = QUrl::fromLocalFile(m_scriptMap[name_]);
       QUrl to = QUrl::fromLocalFile(tmpFile.fileName());
       // have to overwrite since QTemporaryFile already created it
       KIO::Job* job = KIO::file_copy(from, to, -1, KIO::Overwrite);
       if(!job->exec()) {
         myDebug() << job->errorString();
       }
       KConfig spec(to.path(), KConfig::SimpleConfig);
       KConfigGroup specConfig(&spec, QString());
       // pass actual location of spec file
       if(name_ == specConfig.readEntry("Name") && bundledScriptHasExecPath(m_scriptMap[name_], specConfig)) {
         w->readConfig(specConfig);
       } else {
         myWarning() << "Can't read config file for " << to.path();
       }
     }
   }
 
   return w;
 }
 
 // static
 QString Manager::typeName(Tellico::Fetch::Type type_) {
   if(self()->functionRegistry.contains(type_)) {
     return self()->functionRegistry.value(type_).name();
   }
   myWarning() << "none found for" << type_;
   return QString();
 }
 
 QPixmap Manager::fetcherIcon(Tellico::Fetch::Fetcher::Ptr fetcher_, int group_, int size_) {
   if(fetcher_->type() == Fetch::Z3950) {
 #ifdef HAVE_YAZ
     const Fetch::Z3950Fetcher* f = static_cast<const Fetch::Z3950Fetcher*>(fetcher_.data());
     QUrl u;
     u.setScheme(QStringLiteral("http"));
     u.setHost(f->host());
     QString icon = Fetcher::favIcon(u);
     if(!icon.isEmpty()) {
       return LOAD_ICON(icon, group_, size_);
     }
 #endif
   } else
   if(fetcher_->type() == Fetch::ExecExternal) {
     const Fetch::ExecExternalFetcher* f = static_cast<const Fetch::ExecExternalFetcher*>(fetcher_.data());
     const QString p = f->execPath();
     QUrl u;
     if(p.contains(QStringLiteral("allocine"))) {
       u = QUrl(QStringLiteral("http://www.allocine.fr"));
     } else if(p.contains(QStringLiteral("ministerio_de_cultura"))) {
       u = QUrl(QStringLiteral("http://www.mcu.es"));
     } else if(p.contains(QStringLiteral("dark_horse_comics"))) {
       u = QUrl(QStringLiteral("http://www.darkhorse.com"));
     } else if(p.contains(QStringLiteral("boardgamegeek"))) {
       u = QUrl(QStringLiteral("http://www.boardgamegeek.com"));
     } else if(p.contains(QStringLiteral("supercat"))) {
       u = QUrl(QStringLiteral("https://evergreen-ils.org"));
     } else if(f->source().contains(QStringLiteral("amarok"), Qt::CaseInsensitive)) {
       return LOAD_ICON(QStringLiteral("amarok"), group_, size_);
     }
     if(!u.isEmpty() && u.isValid()) {
       QString icon = Fetcher::favIcon(u);
       if(!icon.isEmpty()) {
         return LOAD_ICON(icon, group_, size_);
       }
     }
   }
   return fetcherIcon(fetcher_->type(), group_, size_);
 }
 
 QPixmap Manager::fetcherIcon(Tellico::Fetch::Type type_, int group_, int size_) {
   QString name;
   if(self()->functionRegistry.contains(type_)) {
     name = self()->functionRegistry.value(type_).icon();
   } else {
     myWarning() << "no pixmap defined for type =" << type_;
   }
 
   if(name.isEmpty()) {
     // use default tellico application icon
     name = QStringLiteral("tellico");
   }
 
   QPixmap pix = KIconLoader::global()->loadIcon(name, static_cast<KIconLoader::Group>(group_),
                                                 size_, KIconLoader::DefaultState,
                                                 QStringList(), nullptr, true);
   if(pix.isNull()) {
     QIcon icon = QIcon::fromTheme(name);
     const int groupSize = KIconLoader::global()->currentSize(static_cast<KIconLoader::Group>(group_));
     size_ = size_ == 0 ? groupSize : size_;
     pix = icon.pixmap(size_, size_);
   }
   if(pix.isNull()) {
     pix = BarIcon(name);
   }
   return pix;
 }
 
 Tellico::StringHash Manager::optionalFields(Type type_) {
   if(self()->functionRegistry.contains(type_)) {
     return self()->functionRegistry.value(type_).optionalFields();
   }
   return StringHash();
 }
 
 bool Manager::bundledScriptHasExecPath(const QString& specFile_, KConfigGroup& config_) {
   // make sure ExecPath is set and executable
   // for the bundled scripts, either the exec name is not set, in which case it is the
   // name of the spec file, minus the .spec, or the exec is set, and is local to the dir
   // if not, look for it
   QFileInfo specInfo(specFile_);
   QString exec = config_.readPathEntry("ExecPath", QString());
   QFileInfo execInfo(exec);
   if(exec.isEmpty() || !execInfo.exists()) {
     exec = specInfo.canonicalPath() + QDir::separator() + specInfo.completeBaseName(); // remove ".spec"
   } else if(execInfo.isRelative()) {
     exec = specInfo.canonicalPath() + QDir::separator() + exec;
   } else if(!execInfo.isExecutable()) {
     myWarning() << "not executable:" << specFile_;
     return false;
   }
   execInfo.setFile(exec);
   if(!execInfo.exists() || !execInfo.isExecutable()) {
     myWarning() << "no exec file for" << specFile_;
     myWarning() << "exec =" << exec;
     return false; // we're not ok
   }
 
   config_.writePathEntry("ExecPath", exec);
   config_.sync(); // might be readonly, but that's ok
   return true;
 }
diff --git a/src/fetch/filmasterfetcher.cpp b/src/fetch/filmasterfetcher.cpp
index aed124ac..14f1df2c 100644
--- a/src/fetch/filmasterfetcher.cpp
+++ b/src/fetch/filmasterfetcher.cpp
@@ -1,329 +1,329 @@
 /***************************************************************************
     Copyright (C) 2011 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "filmasterfetcher.h"
 #include "../collections/videocollection.h"
 #include "../images/imagefactory.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../entry.h"
 #include "../core/filehandler.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QGridLayout>
 #include <QTextCodec>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QUrlQuery>
 
 namespace {
   static const char* FILMASTER_API_URL = "http://api.filmaster.com";
   static const char* FILMASTER_QUERY_URL = "http://api.filmaster.com/1.1/search/";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::FilmasterFetcher;
 
 FilmasterFetcher::FilmasterFetcher(QObject* parent_)
     : Fetcher(parent_), m_started(false) {
 }
 
 FilmasterFetcher::~FilmasterFetcher() {
 }
 
 QString FilmasterFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 QString FilmasterFetcher::attribution() const {
   return i18n("This data is licensed under <a href=""%1"">specific terms</a>.",
               QLatin1String("http://filmaster.com/license/"));
 }
 
 bool FilmasterFetcher::canSearch(FetchKey k) const {
   return k == Title || k == Person || k == Keyword;
 }
 
 bool FilmasterFetcher::canFetch(int type) const {
   return type == Data::Collection::Video;
 }
 
 void FilmasterFetcher::readConfigHook(const KConfigGroup&) {
 }
 
 void FilmasterFetcher::search() {
   m_started = true;
 
   QUrl u(QString::fromLatin1(FILMASTER_QUERY_URL));
 
   switch(request().key) {
     case Title:
       u.setPath(u.path() + QLatin1String("film/"));
       break;
 
     case Person:
       u.setPath(u.path() + QLatin1String("person/"));
       break;
 
     default:
       break;
   }
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("phrase"), request().value);
   u.setQuery(q);
 
 //  myDebug() << "url:" << u;
 
   QPointer<KIO::StoredTransferJob> job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(job, GUI::Proxy::widget());
-  connect(job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(job.data(), &KJob::result, this, &FilmasterFetcher::slotComplete);
 }
 
 void FilmasterFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 Tellico::Data::EntryPtr FilmasterFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entries.value(uid_);
   if(!entry) {
     myWarning() << "no entry in dict";
     return Data::EntryPtr();
   }
 
   const QString image = entry->field(QStringLiteral("cover"));
   if(image.contains(QLatin1Char('/'))) {
     QUrl imageUrl;
     if(image.startsWith(QLatin1String("//"))) {
       imageUrl = QUrl(QLatin1String("http:") + image);
     } else {
       imageUrl = QUrl(QString::fromLatin1(FILMASTER_API_URL));
       imageUrl.setPath(imageUrl.path() + image);
     }
     const QString id = ImageFactory::addImage(imageUrl, true);
     if(id.isEmpty()) {
       myDebug() << "Failed to load" << imageUrl;
       message(i18n("The cover image could not be loaded."), MessageHandler::Warning);
     }
     // empty image ID is ok
     entry->setField(QStringLiteral("cover"), id);
   }
   return entry;
 }
 
 Tellico::Fetch::FetchRequest FilmasterFetcher::updateRequest(Data::EntryPtr entry_) {
   const QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Title, title);
   }
   return FetchRequest();
 }
 
 void FilmasterFetcher::slotComplete(KJob* job_) {
   KIO::StoredTransferJob* job = static_cast<KIO::StoredTransferJob*>(job_);
 //  myDebug();
 
   if(job->error()) {
     job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from filmasterfetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/test.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   QVariantMap resultsMap = doc.object().toVariantMap();
   QVariantList resultList;
   switch(request().key) {
     case Title:
       resultList = resultsMap.value(QStringLiteral("best_results")).toList()
                  + resultsMap.value(QStringLiteral("results")).toList();
       break;
 
     case Person:
       {
         const QVariantList personList = resultsMap.value(QStringLiteral("best_results")).toList();
         QStringList uris;
         foreach(const QVariant& person, personList) {
           const QVariantMap personMap = person.toMap();
           uris << mapValue(personMap, "films_played_uri");
           uris << mapValue(personMap, "films_directed_uri");
         }
         foreach(const QString& uri, uris) {
           QUrl u(QString::fromLatin1(FILMASTER_API_URL));
           u.setPath(uri);
           QString output = FileHandler::readTextFile(u, false /*quiet*/, true /*utf8*/);
           QJsonDocument doc2 = QJsonDocument::fromJson(output.toUtf8());
           resultList += doc2.object().toVariantMap().value(QStringLiteral("objects")).toList();
         }
       }
       break;
 
     case Keyword:
       resultList = resultsMap.value(QStringLiteral("films")).toMap().value(QStringLiteral("best_results")).toList();
       break;
 
     default:
       break;
   }
 
   if(resultList.isEmpty()) {
     myDebug() << "no results";
     stop();
     return;
   }
 
   Data::CollPtr coll(new Data::VideoCollection(true));
   if(!coll->hasField(QStringLiteral("filmaster")) && optionalFields().contains(QStringLiteral("filmaster"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("filmaster"), i18n("Filmaster Link"), Data::Field::URL));
     field->setCategory(i18n("General"));
     coll->addField(field);
   }
 
   foreach(const QVariant& result, resultList) {
   //  myDebug() << "found result:" << result;
     Data::EntryPtr entry(new Data::Entry(coll));
     populateEntry(entry, result.toMap());
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
   }
 
 //  m_start = m_entries.count();
 //  m_hasMoreResults = m_start <= m_total;
   m_hasMoreResults = false; // for now, no continued searches
   stop();
 }
 
 void FilmasterFetcher::populateEntry(Data::EntryPtr entry_, const QVariantMap& result_) {
   entry_->setField(QStringLiteral("title"), mapValue(result_, "title"));
   entry_->setField(QStringLiteral("year"), mapValue(result_, "release_year"));
   entry_->setField(QStringLiteral("genre"), mapValue(result_, "tags"));
   entry_->setField(QStringLiteral("nationality"), mapValue(result_, "production_country_list"));
   entry_->setField(QStringLiteral("cover"), mapValue(result_, "image"));
   entry_->setField(QStringLiteral("plot"), mapValue(result_, "description"));
 
   QStringList directors;
   foreach(const QVariant& director, result_.value(QLatin1String("directors")).toList()) {
     const QVariantMap directorMap = director.toMap();
     directors << mapValue(directorMap, "name") + QLatin1Char(' ') + mapValue(directorMap, "surname");
   }
   if(!directors.isEmpty()) {
     entry_->setField(QStringLiteral("director"), directors.join(FieldFormat::delimiterString()));
   }
 
   const QString castUri = mapValue(result_, "characters_uri");
   if(!castUri.isEmpty()) {
     QUrl u(QString::fromLatin1(FILMASTER_API_URL));
     u.setPath(castUri);
     QString output = FileHandler::readTextFile(u, false /*quiet*/, true /*utf8*/);
     QJsonDocument doc = QJsonDocument::fromJson(output.toUtf8());
     QVariantList castList = doc.object().toVariantMap().value(QStringLiteral("objects")).toList();
     QStringList castLines;
     foreach(const QVariant& castResult, castList) {
       const QVariantMap castMap = castResult.toMap();
       const QVariantMap nameMap = castMap.value(QStringLiteral("person")).toMap();
       castLines << mapValue(nameMap, "name") + QLatin1Char(' ') + mapValue(nameMap, "surname")
                  + FieldFormat::columnDelimiterString()
                  + mapValue(castMap, "character");
     }
     if(!castLines.isEmpty()) {
       entry_->setField(QStringLiteral("cast"), castLines.join(FieldFormat::rowDelimiterString()));
     }
   }
 
   if(optionalFields().contains(QStringLiteral("filmaster"))) {
     entry_->setField(QStringLiteral("filmaster"), QLatin1String("http://filmaster.com/film/") + mapValue(result_, "permalink"));
   }
 }
 
 Tellico::Fetch::ConfigWidget* FilmasterFetcher::configWidget(QWidget* parent_) const {
   return new FilmasterFetcher::ConfigWidget(parent_, this);
 }
 
 QString FilmasterFetcher::defaultName() {
   return QStringLiteral("Filmaster"); // no translation
 }
 
 QString FilmasterFetcher::defaultIcon() {
   return favIcon("http://www.filmaster.com");
 }
 
 Tellico::StringHash FilmasterFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("filmaster")] = i18n("Filmaster Link");
   return hash;
 }
 
 FilmasterFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const FilmasterFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 
   // now add additional fields widget
   addFieldsWidget(FilmasterFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 void FilmasterFetcher::ConfigWidget::saveConfigHook(KConfigGroup&) {
 }
 
 QString FilmasterFetcher::ConfigWidget::preferredName() const {
   return FilmasterFetcher::defaultName();
 }
diff --git a/src/fetch/gcstarpluginfetcher.cpp b/src/fetch/gcstarpluginfetcher.cpp
index ffc4e61f..181c956d 100644
--- a/src/fetch/gcstarpluginfetcher.cpp
+++ b/src/fetch/gcstarpluginfetcher.cpp
@@ -1,482 +1,483 @@
 /***************************************************************************
     Copyright (C) 2005-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "gcstarpluginfetcher.h"
 #include "gcstarthread.h"
 #include "fetchmanager.h"
 #include "../collection.h"
 #include "../entry.h"
 #include "../translators/gcstarimporter.h"
 #include "../gui/combobox.h"
 #include "../gui/collectiontypecombo.h"
 #include "../utils/cursorsaver.h"
 #include "../core/filehandler.h"
 #include "../utils/guiproxy.h"
 #include "../tellico_debug.h"
 
 #include <KConfigGroup>
 #include <KProcess>
 #include <KAcceleratorManager>
 #include <KShell>
 #include <KFilterDev>
 #include <KCompressionDevice>
 #include <KTar>
 #include <KLocalizedString>
 
 #include <QTemporaryDir>
 #include <QDir>
 #include <QLabel>
 #include <QShowEvent>
 #include <QGridLayout>
 #include <QBuffer>
 #include <QStandardPaths>
 
 using namespace Tellico;
 using Tellico::Fetch::GCstarPluginFetcher;
 
 GCstarPluginFetcher::CollectionPlugins GCstarPluginFetcher::collectionPlugins;
 GCstarPluginFetcher::PluginParse GCstarPluginFetcher::pluginParse = NotYet;
 
 //static
 GCstarPluginFetcher::PluginList GCstarPluginFetcher::plugins(int collType_) {
   if(!collectionPlugins.contains(collType_)) {
     GUI::CursorSaver cs;
     QString gcstar = QStandardPaths::findExecutable(QStringLiteral("gcstar"));
 
     if(pluginParse == NotYet) {
       KProcess proc;
       proc.setProgram(gcstar, QStringList() << QStringLiteral("--version"));
       proc.setOutputChannelMode(KProcess::OnlyStdoutChannel);
       // wait 5 seconds at most, just a sanity thing, never want to block completely
       if(proc.execute(5000) > -1) {
         QString output = QString::fromLocal8Bit(proc.readAllStandardOutput());
         if(!output.isEmpty()) {
           // always going to be x.y[.z] ?
           QRegExp versionRx(QLatin1String("(\\d+)\\.(\\d+)(?:\\.(\\d+))?"));
           if(versionRx.indexIn(output) > -1) {
             int x = versionRx.cap(1).toInt();
             int y = versionRx.cap(2).toInt();
             int z = versionRx.cap(3).toInt(); // ok to be empty
             myDebug() << QStringLiteral("found %1.%2.%3").arg(x).arg(y).arg(z);
             // --list-plugins argument was added for 1.3 release
             pluginParse = (x >= 1 && y >=3) ? New : Old;
           }
         }
       }
       // if still zero, then we should use old in future
       if(pluginParse == NotYet) {
         pluginParse = Old;
       }
     }
 
     if(pluginParse == New) {
       readPluginsNew(collType_, gcstar);
     } else {
       readPluginsOld(collType_, gcstar);
     }
   }
 
   return collectionPlugins.contains(collType_) ? collectionPlugins.value(collType_) : GCstarPluginFetcher::PluginList();
 }
 
 void GCstarPluginFetcher::readPluginsNew(int collType_, const QString& gcstar_) {
   PluginList plugins;
 
   const QString gcstarCollection = gcstarType(collType_);
   if(gcstarCollection.isEmpty()) {
     collectionPlugins.insert(collType_, plugins);
     return;
   }
 
   QStringList args;
   args << QStringLiteral("--execute")
        << QStringLiteral("--list-plugins")
        << QStringLiteral("--collection")
        << gcstarCollection;
 
   KProcess proc;
   proc.setProgram(gcstar_, args);
   proc.setOutputChannelMode(KProcess::OnlyStdoutChannel);
   if(proc.execute() < 0) {
     myWarning() << "can't start";
     return;
   }
 
   bool hasName = false;
   PluginInfo info;
   QTextStream stream(&proc);
   for(QString line = stream.readLine(); !stream.atEnd(); line = stream.readLine()) {
     if(line.isEmpty()) {
       if(hasName) {
         plugins << info;
       }
       hasName = false;
       info.clear();
     } else {
       // authors have \t at beginning
       line = line.trimmed();
       if(!hasName) {
         info.insert(QStringLiteral("name"), line);
         hasName = true;
       } else {
         info.insert(QStringLiteral("author"), line);
       }
 //      myDebug() << line;
     }
   }
 
   collectionPlugins.insert(collType_, plugins);
 }
 
 void GCstarPluginFetcher::readPluginsOld(int collType_, const QString& gcstar_) {
   QDir dir(gcstar_, QStringLiteral("GC*.pm"));
   dir.cd(QStringLiteral("../../lib/gcstar/GCPlugins/"));
 
   QRegExp rx(QLatin1String("get(Name|Author|Lang)\\s*\\{\\s*return\\s+['\"](.+)['\"]"));
   rx.setMinimal(true);
 
   PluginList plugins;
 
   const QString dirName = gcstarType(collType_);
   if(dirName.isEmpty()) {
     collectionPlugins.insert(collType_, plugins);
     return;
   }
 
   foreach(const QString& file, dir.entryList()) {
     QUrl u = QUrl::fromLocalFile(dir.filePath(file));
     PluginInfo info;
     QString text = FileHandler::readTextFile(u);
     for(int pos = rx.indexIn(text); pos > -1; pos = rx.indexIn(text, pos+rx.matchedLength())) {
       info.insert(rx.cap(1).toLower(), rx.cap(2));
     }
     // only add if it has a name
     if(info.contains(QStringLiteral("name"))) {
       plugins << info;
     }
   }
   // inserting empty list is ok
   collectionPlugins.insert(collType_, plugins);
 }
 
 QString GCstarPluginFetcher::gcstarType(int collType_) {
   switch(collType_) {
     case Data::Collection::Book:      return QStringLiteral("GCbooks");
     case Data::Collection::Video:     return QStringLiteral("GCfilms");
     case Data::Collection::Album:     return QStringLiteral("GCmusics");
     case Data::Collection::ComicBook: return QStringLiteral("GCcomics");
     case Data::Collection::Wine:      return QStringLiteral("GCwines");
     case Data::Collection::Coin:      return QStringLiteral("GCcoins");
     case Data::Collection::Stamp:     return QStringLiteral("GCstamps");
     case Data::Collection::Game:      return QStringLiteral("GCgames");
     case Data::Collection::BoardGame: return QStringLiteral("GCboardgames");
     default: break;
   }
   return QString();
 }
 
 GCstarPluginFetcher::GCstarPluginFetcher(QObject* parent_) : Fetcher(parent_),
     m_started(false), m_collType(-1), m_thread(nullptr) {
 }
 
 GCstarPluginFetcher::~GCstarPluginFetcher() {
   stop();
 }
 
 QString GCstarPluginFetcher::source() const {
   return m_name;
 }
 
 bool GCstarPluginFetcher::canFetch(int type_) const {
   return m_collType == -1 ? false : m_collType == type_;
 }
 
 void GCstarPluginFetcher::readConfigHook(const KConfigGroup& config_) {
   m_collType = config_.readEntry("CollectionType", -1);
   m_plugin = config_.readEntry("Plugin");
 }
 
 void GCstarPluginFetcher::search() {
   m_started = true;
   if(m_plugin.isEmpty() || m_collType == -1) {
     myWarning() << "no plugin information!";
     myDebug() << m_collType << m_plugin;
     stop();
     return;
   }
 
   m_data.clear();
 
   const QString gcstar = QStandardPaths::findExecutable(QStringLiteral("gcstar"));
   if(gcstar.isEmpty()) {
     myWarning() << "gcstar not found!";
     stop();
     return;
   }
 
   QStringList args;
   args << QStringLiteral("--execute")
        << QStringLiteral("--collection")  << gcstarType(m_collType)
        << QStringLiteral("--export")      << QStringLiteral("TarGz")
        << QStringLiteral("--exportprefs") << QStringLiteral("collection=>/tmp/test.gcs,file=>/tmp/test1.tar.gz")
        << QStringLiteral("--website")     << m_plugin
        << QStringLiteral("--download")    << KShell::quoteArg(request().value);
   myLog() << args;
 
   m_thread = new GCstarThread(this);
   m_thread->setProgram(gcstar, args);
-  connect(m_thread, SIGNAL(standardOutput(QByteArray)), SLOT(slotData(QByteArray)));
-  connect(m_thread, SIGNAL(standardError(QByteArray)), SLOT(slotError(QByteArray)));
-  connect(m_thread, SIGNAL(finished()), SLOT(slotProcessExited()));
+  connect(m_thread, &GCstarThread::standardOutput, this, &GCstarPluginFetcher::slotData);
+  connect(m_thread, &GCstarThread::standardError, this, &GCstarPluginFetcher::slotError);
+  connect(m_thread, &QThread::finished, this, &GCstarPluginFetcher::slotProcessExited);
   m_thread->start();
 }
 
 void GCstarPluginFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_thread) {
     if(m_thread->isRunning()) {
       m_thread->terminate();
       m_thread->wait();
     }
     delete m_thread;
     m_thread = nullptr;
   }
   m_data.clear();
   m_started = false;
   m_errors.clear();
   emit signalDone(this);
 }
 
 void GCstarPluginFetcher::slotData(const QByteArray& data_) {
   m_data.append(data_);
 }
 
 void GCstarPluginFetcher::slotError(const QByteArray& data_) {
   QString msg = QString::fromLocal8Bit(data_);
   msg.prepend(source() + QLatin1String(": "));
   myDebug() << msg;
   m_errors << msg;
 }
 
 void GCstarPluginFetcher::slotProcessExited() {
   // if stop() is called and the thread terminated
   // the finished() signal will still fire
   if(!m_started) {
     return;
   }
 
   if(!m_errors.isEmpty()) {
     message(m_errors.join(QLatin1String("\n")), MessageHandler::Warning);
   }
 
   if(m_data.isEmpty()) {
     myDebug() << source() << ": no data";
     stop();
     return;
   }
 
   QBuffer filterBuffer(&m_data);
   KCompressionDevice::CompressionType compressionType = KFilterDev::compressionTypeForMimeType(QStringLiteral("application/x-gzip"));
   KCompressionDevice filter(&filterBuffer, false, compressionType);
   if(!filter.open(QIODevice::ReadOnly)) {
     myWarning() << "unable to open gzip filter";
     stop();
     return;
   }
 
   QByteArray tarData = filter.readAll();
   QBuffer buffer(&tarData);
 
   KTar tar(&buffer);
   if(!tar.open(QIODevice::ReadOnly)) {
     myWarning() << "unable to open tar file";
     stop();
     return;
   }
 
   const KArchiveDirectory* dir = tar.directory();
   if(!dir) {
     myWarning() << "unable to open tar directory";
     stop();
     return;
   }
 
   QTemporaryDir tempDir;
   dir->copyTo(tempDir.path());
 
   // KDE seems to have a bug (#252821) for gcstar files where the images are not in the images/ directory
   foreach(const QString& filename, dir->entries()) {
     if(dir->entry(filename)->isFile() && filename != QLatin1String("collection.gcs")) {
       const KArchiveFile* f = static_cast<const KArchiveFile*>(dir->entry(filename));
       f->copyTo(tempDir.path() + QLatin1String("/images"));
     }
   }
 
   QUrl gcsUrl = QUrl::fromLocalFile(tempDir.path());
   gcsUrl = gcsUrl.adjusted(QUrl::StripTrailingSlash);
   gcsUrl.setPath(gcsUrl.path() + QLatin1String("/collection.gcs"));
 
   Import::GCstarImporter imp(gcsUrl);
   imp.setHasRelativeImageLinks(true);
 
   Data::CollPtr coll = imp.collection();
   if(!coll) {
     if(!imp.statusMessage().isEmpty()) {
       message(imp.statusMessage(), MessageHandler::Status);
     }
     myWarning() << "no collection pointer";
     stop();
     return;
   }
 
   foreach(Data::EntryPtr entry, coll->entries()) {
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
     if(!m_started) {
       return;
     }
   }
   stop(); // be sure to call this
 }
 
 Tellico::Data::EntryPtr GCstarPluginFetcher::fetchEntryHook(uint uid_) {
   return m_entries[uid_];
 }
 
 Tellico::Fetch::FetchRequest GCstarPluginFetcher::updateRequest(Data::EntryPtr entry_) {
   // ry searching for title and rely on Collection::sameEntry() to figure things out
   QString t = entry_->field(QStringLiteral("title"));
   if(!t.isEmpty()) {
     return FetchRequest(Fetch::Title, t);
   }
   return FetchRequest();
 }
 
 Tellico::Fetch::ConfigWidget* GCstarPluginFetcher::configWidget(QWidget* parent_) const {
   return new GCstarPluginFetcher::ConfigWidget(parent_, this);
 }
 
 QString GCstarPluginFetcher::defaultName() {
   return i18n("GCstar Plugin");
 }
 
 QString GCstarPluginFetcher::defaultIcon() {
   return QStringLiteral("gcstar");
 }
 
 GCstarPluginFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const GCstarPluginFetcher* fetcher_/*=0*/)
     : Fetch::ConfigWidget(parent_), m_needPluginList(true) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
 
   QLabel* label = new QLabel(i18n("Collection &type:"), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_collCombo = new GUI::CollectionTypeCombo(optionsWidget());
-  connect(m_collCombo, SIGNAL(activated(int)), SLOT(slotSetModified()));
-  connect(m_collCombo, SIGNAL(activated(int)), SLOT(slotTypeChanged()));
+  void (GUI::ComboBox::* activatedInt)(int) = &GUI::ComboBox::activated;
+  connect(m_collCombo, activatedInt, this, &ConfigWidget::slotSetModified);
+  connect(m_collCombo, activatedInt, this, &ConfigWidget::slotTypeChanged);
   l->addWidget(m_collCombo, row, 1, 1, 3);
   QString w = i18n("Set the collection type of the data returned from the plugin.");
   label->setWhatsThis(w);
   m_collCombo->setWhatsThis(w);
   label->setBuddy(m_collCombo);
 
   label = new QLabel(i18n("&Plugin: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_pluginCombo = new GUI::ComboBox(optionsWidget());
-  connect(m_pluginCombo, SIGNAL(activated(int)), SLOT(slotSetModified()));
-  connect(m_pluginCombo, SIGNAL(activated(int)), SLOT(slotPluginChanged()));
+  connect(m_pluginCombo, activatedInt, this, &ConfigWidget::slotSetModified);
+  connect(m_pluginCombo, activatedInt, this, &ConfigWidget::slotPluginChanged);
   l->addWidget(m_pluginCombo, row, 1, 1, 3);
   w = i18n("Select the GCstar plugin used for the data source.");
   label->setWhatsThis(w);
   m_pluginCombo->setWhatsThis(w);
   label->setBuddy(m_pluginCombo);
 
   label = new QLabel(i18n("Author: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_authorLabel = new QLabel(optionsWidget());
   l->addWidget(m_authorLabel, row, 1);
 
   if(fetcher_) {
     if(fetcher_->m_collType > -1) {
       m_collCombo->setCurrentType(fetcher_->m_collType);
     } else {
       m_collCombo->setCurrentType(fetcher_->collectionType());
     }
     m_originalPluginName = fetcher_->m_plugin;
   } else {
     // default to Book for now
     m_collCombo->setCurrentType(Data::Collection::Book);
   }
 
   KAcceleratorManager::manage(optionsWidget());
 }
 
 GCstarPluginFetcher::ConfigWidget::~ConfigWidget() {
 }
 
 void GCstarPluginFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   config_.writeEntry("CollectionType", m_collCombo->currentType());
   config_.writeEntry("Plugin", m_pluginCombo->currentText());
 }
 
 QString GCstarPluginFetcher::ConfigWidget::preferredName() const {
   QString plugin = m_pluginCombo->currentText();
   return plugin.isEmpty() ? plugin : QLatin1String("GCstar - ") + plugin;
 }
 
 void GCstarPluginFetcher::ConfigWidget::slotTypeChanged() {
   int collType = m_collCombo->currentType();
   m_pluginCombo->clear();
   QStringList pluginNames;
   GCstarPluginFetcher::PluginList list = GCstarPluginFetcher::plugins(collType);
   foreach(const GCstarPluginFetcher::PluginInfo& info, list) {
     pluginNames << info.value(QStringLiteral("name")).toString();
     m_pluginCombo->addItem(pluginNames.last(), info);
   }
   slotPluginChanged();
   emit signalName(preferredName());
 }
 
 void GCstarPluginFetcher::ConfigWidget::slotPluginChanged() {
   PluginInfo info = m_pluginCombo->currentData().toHash();
   m_authorLabel->setText(info[QStringLiteral("author")].toString());
   emit signalName(preferredName());
 }
 
 void GCstarPluginFetcher::ConfigWidget::showEvent(QShowEvent*) {
   if(m_needPluginList) {
     m_needPluginList = false;
     slotTypeChanged(); // update plugin combo box
     if(!m_originalPluginName.isEmpty()) {
       m_pluginCombo->setEditText(m_originalPluginName);
       slotPluginChanged();
     }
   }
 }
diff --git a/src/fetch/gcstarthread.cpp b/src/fetch/gcstarthread.cpp
index 175a3f7f..608b52b8 100644
--- a/src/fetch/gcstarthread.cpp
+++ b/src/fetch/gcstarthread.cpp
@@ -1,54 +1,54 @@
 /***************************************************************************
     Copyright (C) 2010 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "gcstarthread.h"
 
 #include <KProcess>
 
 using Tellico::Fetch::GCstarThread;
 
 GCstarThread::GCstarThread(QObject* obj) : QThread(obj) {
 }
 
 void GCstarThread::setProgram(const QString& program_, const QStringList& args_) {
   m_program = program_;
   m_args = args_;
 }
 
 void GCstarThread::run() {
   KProcess proc;
-  connect(&proc, SIGNAL(readyReadStandardOutput()), SLOT(slotData()));
-  connect(&proc, SIGNAL(readyReadStandardError()), SLOT(slotError()));
+  connect(&proc, &QProcess::readyReadStandardOutput, this, &GCstarThread::slotData);
+  connect(&proc, &QProcess::readyReadStandardError, this, &GCstarThread::slotError);
   proc.setOutputChannelMode(KProcess::SeparateChannels);
   proc.setProgram(m_program, m_args);
   proc.execute();
 }
 
 void GCstarThread::slotData() {
   emit standardOutput(static_cast<KProcess*>(sender())->readAllStandardOutput());
 }
 
 void GCstarThread::slotError() {
   emit standardError(static_cast<KProcess*>(sender())->readAllStandardError());
 }
diff --git a/src/fetch/giantbombfetcher.cpp b/src/fetch/giantbombfetcher.cpp
index f298c463..9fd379de 100644
--- a/src/fetch/giantbombfetcher.cpp
+++ b/src/fetch/giantbombfetcher.cpp
@@ -1,261 +1,261 @@
 /***************************************************************************
     Copyright (C) 2010 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "giantbombfetcher.h"
 #include "../translators/xslthandler.h"
 #include "../translators/tellicoimporter.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QGridLayout>
 #include <QDomDocument>
 #include <QTextCodec>
 #include <QUrlQuery>
 
 namespace {
   static const int GIANTBOMB_MAX_RETURNS_TOTAL = 20;
   static const char* GIANTBOMB_API_URL = "http://api.giantbomb.com";
   static const char* GIANTBOMB_API_KEY = "291bfe4b2d77a460e67dd8f90c1e7e56c3e4f05a";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::GiantBombFetcher;
 
 GiantBombFetcher::GiantBombFetcher(QObject* parent_)
     : XMLFetcher(parent_)
     , m_total(-1)
     , m_apiKey(QLatin1String(GIANTBOMB_API_KEY)) {
   setLimit(GIANTBOMB_MAX_RETURNS_TOTAL);
   setXSLTFilename(QStringLiteral("giantbomb2tellico.xsl"));
 }
 
 GiantBombFetcher::~GiantBombFetcher() {
 }
 
 QString GiantBombFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool GiantBombFetcher::canFetch(int type) const {
   return type == Data::Collection::Game;
 }
 
 void GiantBombFetcher::readConfigHook(const KConfigGroup& config_) {
   QString k = config_.readEntry("API Key", GIANTBOMB_API_KEY);
   if(!k.isEmpty()) {
     m_apiKey = k;
   }
 }
 
 void GiantBombFetcher::resetSearch() {
   m_total = -1;
 }
 
 QUrl GiantBombFetcher::searchUrl() {
   QUrl u(QString::fromLatin1(GIANTBOMB_API_URL));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("format"), QStringLiteral("xml"));
   q.addQueryItem(QStringLiteral("api_key"), m_apiKey);
 
   switch(request().key) {
     case Keyword:
       u.setPath(QStringLiteral("/search"));
       q.addQueryItem(QStringLiteral("query"), request().value);
       q.addQueryItem(QStringLiteral("resources"), QStringLiteral("game"));
       break;
 
     default:
       myWarning() << "key not recognized: " << request().key;
       return QUrl();
   }
   u.setQuery(q);
 
 //  myDebug() << "url: " << u.url();
   return u;
 }
 
 void GiantBombFetcher::parseData(QByteArray& data_) {
   Q_UNUSED(data_);
 #if 0
   if(m_total == -1) {
     QDomDocument dom;
     if(!dom.setContent(data, false)) {
       myWarning() << "server did not return valid XML.";
       return;
     }
     // total is /resp/fetchresults/@numResults
     QDomNode n = dom.documentElement().namedItem(QLatin1String("resp"))
                                       .namedItem(QLatin1String("fetchresults"));
     QDomElement e = n.toElement();
     if(!e.isNull()) {
       m_total = e.attribute(QLatin1String("numResults")).toInt();
       myDebug() << "total = " << m_total;
     }
   }
   m_start = m_entries.count() + 1;
   // not sure how to specify start in the REST url
   //  m_hasMoreResults = m_start <= m_total;
 #endif
 }
 
 Tellico::Data::EntryPtr GiantBombFetcher::fetchEntryHookData(Data::EntryPtr entry_) {
   Q_ASSERT(entry_);
 
   const QString id = entry_->field(QStringLiteral("giantbomb-id"));
   if(id.isEmpty()) {
     myDebug() << "no giantbomb id found";
     return entry_;
   }
 
   QUrl u(QString::fromLatin1(GIANTBOMB_API_URL));
   u.setPath(QStringLiteral("/game/%1/").arg(id));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("format"), QStringLiteral("xml"));
   q.addQueryItem(QStringLiteral("api_key"), m_apiKey);
   u.setQuery(q);
 //  myDebug() << "url: " << u;
 
   // quiet
   QString output = FileHandler::readXMLFile(u, true);
 
 #if 0
   myWarning() << "Remove output debug from giantbombfetcher.cpp";
   QFile f(QStringLiteral("/tmp/test2.xml"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << output;
   }
   f.close();
 #endif
 
   Import::TellicoImporter imp(xsltHandler()->applyStylesheet(output));
   // be quiet when loading images
   imp.setOptions(imp.options() ^ Import::ImportShowImageErrors);
   Data::CollPtr coll = imp.collection();
 //  getTracks(entry);
   if(!coll) {
     myWarning() << "no collection pointer";
     return entry_;
   }
 
   if(coll->entryCount() > 1) {
     myDebug() << "weird, more than one entry found";
   }
 
   // don't want to include id
   coll->removeField(QStringLiteral("giantbomb-id"));
   return coll->entries().front();
 }
 
 Tellico::Fetch::FetchRequest GiantBombFetcher::updateRequest(Data::EntryPtr entry_) {
   QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Keyword, title);
   }
   return FetchRequest();
 }
 
 Tellico::Fetch::ConfigWidget* GiantBombFetcher::configWidget(QWidget* parent_) const {
   return new GiantBombFetcher::ConfigWidget(parent_, this);
 }
 
 QString GiantBombFetcher::defaultName() {
   return QStringLiteral("Giant Bomb");
 }
 
 QString GiantBombFetcher::defaultIcon() {
   return favIcon("http://www.giantbomb.com");
 }
 
 Tellico::StringHash GiantBombFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("giantbomb")] = i18n("GiantBomb Link");
   hash[QStringLiteral("pegi")] = i18n("PEGI Rating");
   return hash;
 }
 
 GiantBombFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const GiantBombFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
 
   QLabel* al = new QLabel(i18n("Registration is required for accessing the %1 data source. "
                                "If you agree to the terms and conditions, <a href='%2'>sign "
                                "up for an account</a>, and enter your information below.",
                                 preferredName(),
                                 QLatin1String("http://api.giantbomb.com")),
                           optionsWidget());
   al->setOpenExternalLinks(true);
   al->setWordWrap(true);
   ++row;
   l->addWidget(al, row, 0, 1, 2);
   // richtext gets weird with size
   al->setMinimumWidth(al->sizeHint().width());
 
   QLabel* label = new QLabel(i18n("Access key: "), optionsWidget());
   l->addWidget(label, ++row, 0);
 
   m_apiKeyEdit = new QLineEdit(optionsWidget());
-  connect(m_apiKeyEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_apiKeyEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_apiKeyEdit, row, 1);
   QString w = i18n("The default Tellico key may be used, but searching may fail due to reaching access limits.");
   label->setWhatsThis(w);
   m_apiKeyEdit->setWhatsThis(w);
   label->setBuddy(m_apiKeyEdit);
 
   l->setRowStretch(++row, 10);
 
   // now add additional fields widget
   addFieldsWidget(GiantBombFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 
   if(fetcher_) {
     // only show the key if it is not the default Tellico one...
     // that way the user is prompted to apply for their own
     if(fetcher_->m_apiKey != QLatin1String(GIANTBOMB_API_KEY)) {
       m_apiKeyEdit->setText(fetcher_->m_apiKey);
     }
   }
 }
 
 void GiantBombFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   QString apiKey = m_apiKeyEdit->text().trimmed();
   if(!apiKey.isEmpty()) {
     config_.writeEntry("API Key", apiKey);
   }
 }
 
 QString GiantBombFetcher::ConfigWidget::preferredName() const {
   return GiantBombFetcher::defaultName();
 }
diff --git a/src/fetch/googlebookfetcher.cpp b/src/fetch/googlebookfetcher.cpp
index f350c720..12eb563f 100644
--- a/src/fetch/googlebookfetcher.cpp
+++ b/src/fetch/googlebookfetcher.cpp
@@ -1,423 +1,423 @@
 /***************************************************************************
     Copyright (C) 2011 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "googlebookfetcher.h"
 #include "../collections/bookcollection.h"
 #include "../entry.h"
 #include "../images/imagefactory.h"
 #include "../utils/isbnvalidator.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../core/filehandler.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 #include <KConfigGroup>
 
 #include <QLineEdit>
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QGridLayout>
 #include <QTextCodec>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QUrlQuery>
 
 namespace {
   static const int GOOGLEBOOK_MAX_RETURNS = 20;
   static const char* GOOGLEBOOK_API_URL = "https://www.googleapis.com/books/v1/volumes";
   static const char* GOOGLEBOOK_API_KEY = "AIzaSyBdsa_DEGpDQ6PzZyYHHHokRIBY8thOdUQ";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::GoogleBookFetcher;
 
 GoogleBookFetcher::GoogleBookFetcher(QObject* parent_)
     : Fetcher(parent_)
     , m_started(false)
     , m_start(0)
     , m_total(0)
     , m_apiKey(QLatin1String(GOOGLEBOOK_API_KEY)) {
 }
 
 GoogleBookFetcher::~GoogleBookFetcher() {
 }
 
 QString GoogleBookFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool GoogleBookFetcher::canSearch(FetchKey k) const {
   return k == Title || k == Person || k == ISBN || k == Keyword;
 }
 
 bool GoogleBookFetcher::canFetch(int type) const {
   return type == Data::Collection::Book || type == Data::Collection::Bibtex;
 }
 
 void GoogleBookFetcher::readConfigHook(const KConfigGroup& config_) {
   // allow an empty key if the config key does exist
   m_apiKey = config_.readEntry("API Key", GOOGLEBOOK_API_KEY);
 }
 
 void GoogleBookFetcher::search() {
   m_start = 0;
   m_total = -1;
   continueSearch();
 }
 
 void GoogleBookFetcher::continueSearch() {
   m_started = true;
   // we only split ISBN and LCCN values
   QStringList searchTerms;
   if(request().key == ISBN) {
     searchTerms = FieldFormat::splitValue(request().value);
   } else  {
     searchTerms += request().value;
   }
   foreach(const QString& searchTerm, searchTerms) {
     doSearch(searchTerm);
   }
   if(m_jobs.isEmpty()) {
     stop();
   }
 }
 
 void GoogleBookFetcher::doSearch(const QString& term_) {
   QUrl u(QString::fromLatin1(GOOGLEBOOK_API_URL));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("maxResults"), QString::number(GOOGLEBOOK_MAX_RETURNS));
   q.addQueryItem(QStringLiteral("startIndex"), QString::number(m_start));
   q.addQueryItem(QStringLiteral("printType"), QStringLiteral("books"));
   // we don't require a key, cause it might work without it
   if(!m_apiKey.isEmpty()) {
     q.addQueryItem(QStringLiteral("key"), m_apiKey);
   }
 
   switch(request().key) {
     case Title:
       q.addQueryItem(QStringLiteral("q"), QLatin1String("intitle:") + term_);
       break;
 
     case Person:
       q.addQueryItem(QStringLiteral("q"), QLatin1String("inauthor:") + term_);
       break;
 
     case ISBN:
       {
         const QString isbn = ISBNValidator::cleanValue(term_);
         q.addQueryItem(QStringLiteral("q"), QLatin1String("isbn:") + isbn);
       }
       break;
 
     case Keyword:
       q.addQueryItem(QStringLiteral("q"), term_);
       break;
 
     default:
       myWarning() << "key not recognized:" << request().key;
       return;
   }
   u.setQuery(q);
 //  myDebug() << "url:" << u;
 
   QPointer<KIO::StoredTransferJob> job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(job, GUI::Proxy::widget());
-  connect(job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(job.data(), &KJob::result, this, &GoogleBookFetcher::slotComplete);
   m_jobs << job;
 }
 
 void GoogleBookFetcher::endJob(KIO::StoredTransferJob* job_) {
   m_jobs.removeOne(job_);
   if(m_jobs.isEmpty())  {
     stop();
   }
 }
 
 void GoogleBookFetcher::stop() {
   if(!m_started) {
     return;
   }
   foreach(QPointer<KIO::StoredTransferJob> job, m_jobs) {
     if(job) {
       job->kill();
     }
   }
   m_jobs.clear();
   m_started = false;
   emit signalDone(this);
 }
 
 Tellico::Data::EntryPtr GoogleBookFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entries.value(uid_);
   if(!entry) {
     myWarning() << "no entry in dict";
     return Data::EntryPtr();
   }
 
   QString gbs = entry->field(QStringLiteral("gbs-link"));
   if(!gbs.isEmpty()) {
     // quiet
     QByteArray data = FileHandler::readDataFile(QUrl::fromUserInput(gbs), true);
     QJsonDocument doc = QJsonDocument::fromJson(data);
     populateEntry(entry, doc.object().toVariantMap());
   }
 
   const QString image_id = entry->field(QStringLiteral("cover"));
   // if it's still a url, we need to load it
   if(image_id.startsWith(QLatin1String("http"))) {
     const QString id = ImageFactory::addImage(QUrl::fromUserInput(image_id), true);
     if(id.isEmpty()) {
       message(i18n("The cover image could not be loaded."), MessageHandler::Warning);
       entry->setField(QStringLiteral("cover"), QString());
     } else {
       entry->setField(QStringLiteral("cover"), id);
     }
   }
 
   // don't want to include gbs json link
   entry->setField(QStringLiteral("gbs-link"), QString());
 
   return entry;
 }
 
 Tellico::Fetch::FetchRequest GoogleBookFetcher::updateRequest(Data::EntryPtr entry_) {
   const QString isbn = entry_->field(QStringLiteral("isbn"));
   if(!isbn.isEmpty()) {
     return FetchRequest(ISBN, isbn);
   }
   QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Title, title);
   }
   return FetchRequest();
 }
 
 void GoogleBookFetcher::slotComplete(KJob* job_) {
   KIO::StoredTransferJob* job = static_cast<KIO::StoredTransferJob*>(job_);
 //  myDebug();
 
   if(job->error()) {
     job->uiDelegate()->showErrorMessage();
     endJob(job);
     return;
   }
 
   QByteArray data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     endJob(job);
     return;
   }
 
 #if 0
   myWarning() << "Remove debug from googlebookfetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/test.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   Data::CollPtr coll(new Data::BookCollection(true));
   // always add the gbs-link for fetchEntryHook
   Data::FieldPtr field(new Data::Field(QStringLiteral("gbs-link"), QStringLiteral("GBS Link"), Data::Field::URL));
   field->setCategory(i18n("General"));
   coll->addField(field);
 
   if(!coll->hasField(QStringLiteral("googlebook")) && optionalFields().contains(QStringLiteral("googlebook"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("googlebook"), i18n("Google Book Link"), Data::Field::URL));
     field->setCategory(i18n("General"));
     coll->addField(field);
   }
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   QVariantMap result = doc.object().toVariantMap();
   m_total = result.value(QStringLiteral("totalItems")).toInt();
 //  myDebug() << "total:" << m_total;
 
   QVariantList resultList = result.value(QStringLiteral("items")).toList();
   if(resultList.isEmpty()) {
     myDebug() << "no results";
     endJob(job);
     return;
   }
 
   foreach(const QVariant& result, resultList) {
   //  myDebug() << "found result:" << result;
 
     Data::EntryPtr entry(new Data::Entry(coll));
     populateEntry(entry, result.toMap());
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
   }
 
   m_start = m_entries.count();
   m_hasMoreResults = request().key != ISBN && m_start <= m_total;
   endJob(job);
 }
 
 void GoogleBookFetcher::populateEntry(Data::EntryPtr entry, const QVariantMap& resultMap) {
   if(entry->collection()->hasField(QStringLiteral("gbs-link"))) {
     entry->setField(QStringLiteral("gbs-link"), mapValue(resultMap, "selfLink"));
   }
 
   const QVariantMap volumeMap = resultMap.value(QStringLiteral("volumeInfo")).toMap();
   entry->setField(QStringLiteral("title"),     mapValue(volumeMap, "title"));
   entry->setField(QStringLiteral("subtitle"),  mapValue(volumeMap, "subtitle"));
   entry->setField(QStringLiteral("pub_year"),  mapValue(volumeMap, "publishedDate").left(4));
   entry->setField(QStringLiteral("author"),    mapValue(volumeMap, "authors"));
   // workaround for bug, where publisher can be enclosed in quotes
   QString pub = mapValue(volumeMap, "publisher");
   if(pub.startsWith(QLatin1Char('"')) && pub.endsWith(QLatin1Char('"'))) {
     pub.chop(1);
     pub = pub.remove(0, 1);
   }
   entry->setField(QStringLiteral("publisher"), pub);
   entry->setField(QStringLiteral("pages"),     mapValue(volumeMap, "pageCount"));
   entry->setField(QStringLiteral("language"),  mapValue(volumeMap, "language"));
   entry->setField(QStringLiteral("comments"),  mapValue(volumeMap, "description"));
 
   QStringList catList = volumeMap.value(QStringLiteral("categories")).toStringList();
   // google is going to give us a lot of categories
   QSet<QString> cats;
   foreach(const QString& cat, catList) {
     cats += cat.split(QRegExp(QLatin1String("\\s*/\\s*"))).toSet();
   }
   // remove General
   cats.remove(QStringLiteral("General"));
   catList = cats.toList();
   catList.sort();
   entry->setField(QStringLiteral("keyword"), catList.join(FieldFormat::delimiterString()));
 
   QString isbn;
   foreach(const QVariant& idVariant, volumeMap.value(QLatin1String("industryIdentifiers")).toList()) {
     const QVariantMap idMap = idVariant.toMap();
     if(mapValue(idMap, "type") == QLatin1String("ISBN_10")) {
       isbn = mapValue(idMap, "identifier");
       break;
     } else if(mapValue(idMap, "type") == QLatin1String("ISBN_13")) {
       isbn = mapValue(idMap, "identifier");
       // allow isbn10 to override, so don't break here
     }
   }
   if(!isbn.isEmpty()) {
     ISBNValidator val(this);
     val.fixup(isbn);
     entry->setField(QStringLiteral("isbn"), isbn);
   }
 
   const QVariantMap imageMap = volumeMap.value(QStringLiteral("imageLinks")).toMap();
   if(imageMap.contains(QStringLiteral("small"))) {
     entry->setField(QStringLiteral("cover"), mapValue(imageMap, "small"));
   } else if(imageMap.contains(QStringLiteral("thumbnail"))) {
     entry->setField(QStringLiteral("cover"), mapValue(imageMap, "thumbnail"));
   } else if(imageMap.contains(QStringLiteral("smallThumbnail"))) {
     entry->setField(QStringLiteral("cover"), mapValue(imageMap, "smallThumbnail"));
   }
 
   if(optionalFields().contains(QStringLiteral("googlebook"))) {
     entry->setField(QStringLiteral("googlebook"), mapValue(volumeMap, "infoLink"));
   }
 }
 
 Tellico::Fetch::ConfigWidget* GoogleBookFetcher::configWidget(QWidget* parent_) const {
   return new GoogleBookFetcher::ConfigWidget(parent_, this);
 }
 
 QString GoogleBookFetcher::defaultName() {
   return i18n("Google Book Search");
 }
 
 QString GoogleBookFetcher::defaultIcon() {
   return favIcon("http://books.google.com");
 }
 
 Tellico::StringHash GoogleBookFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("googlebook")] = i18n("Google Book Link");
   return hash;
 }
 
 GoogleBookFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const GoogleBookFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
   QLabel* al = new QLabel(i18n("Registration is required for accessing the %1 data source. "
                                "If you agree to the terms and conditions, <a href='%2'>sign "
                                "up for an account</a>, and enter your information below.",
                                 preferredName(),
                                 QLatin1String("https://code.google.com/apis/console")),
                           optionsWidget());
   al->setOpenExternalLinks(true);
   al->setWordWrap(true);
   ++row;
   l->addWidget(al, row, 0, 1, 2);
   // richtext gets weird with size
   al->setMinimumWidth(al->sizeHint().width());
 
   QLabel* label = new QLabel(i18n("Access key: "), optionsWidget());
   l->addWidget(label, ++row, 0);
 
   m_apiKeyEdit = new QLineEdit(optionsWidget());
-  connect(m_apiKeyEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_apiKeyEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_apiKeyEdit, row, 1);
   QString w = i18n("The default Tellico key may be used, but searching may fail due to reaching access limits.");
   label->setWhatsThis(w);
   m_apiKeyEdit->setWhatsThis(w);
   label->setBuddy(m_apiKeyEdit);
 
   l->setRowStretch(++row, 10);
 
   // now add additional fields widget
   addFieldsWidget(GoogleBookFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 
   if(fetcher_ && fetcher_->m_apiKey != QLatin1String(GOOGLEBOOK_API_KEY)) {
     // only show the key if it is not the default Tellico one...
     // that way the user is prompted to apply for their own
     m_apiKeyEdit->setText(fetcher_->m_apiKey);
   }
 }
 
 void GoogleBookFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   QString apiKey = m_apiKeyEdit->text().trimmed();
   if(!apiKey.isEmpty()) {
     config_.writeEntry("API Key", apiKey);
   }
 }
 
 QString GoogleBookFetcher::ConfigWidget::preferredName() const {
   return GoogleBookFetcher::defaultName();
 }
diff --git a/src/fetch/googlescholarfetcher.cpp b/src/fetch/googlescholarfetcher.cpp
index 55593ed3..b2a05ae0 100644
--- a/src/fetch/googlescholarfetcher.cpp
+++ b/src/fetch/googlescholarfetcher.cpp
@@ -1,286 +1,286 @@
 /***************************************************************************
     Copyright (C) 2008-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "googlescholarfetcher.h"
 #include "../core/filehandler.h"
 #include "../translators/bibteximporter.h"
 #include "../collections/bibtexcollection.h"
 #include "../entry.h"
 #include "../utils/guiproxy.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QFile>
 #include <QTextCodec>
 #include <QUrlQuery>
 
 namespace {
   static const int GOOGLE_MAX_RETURNS_TOTAL = 20;
   static const char* SCHOLAR_BASE_URL = "http://scholar.google.com/scholar";
   static const char* SCHOLAR_SET_CONFIG_URL = "http://scholar.google.com/scholar_settings?hl=en&as_sdt=0,5";
   static const char* SCHOLAR_SET_BIBTEX_URL = "http://scholar.google.com/scholar_setprefs?hl=en&num=100&scis=yes&scisf=4&submit=";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::GoogleScholarFetcher;
 
 GoogleScholarFetcher::GoogleScholarFetcher(QObject* parent_)
     : Fetcher(parent_),
       m_limit(GOOGLE_MAX_RETURNS_TOTAL), m_start(0), m_total(0), m_job(nullptr), m_started(false),
       m_cookieIsSet(false) {
   m_bibtexRx = QRegExp(QLatin1String("<a\\s.*href\\s*=\\s*\"([^>]*scholar\\.bib[^>]*)\""));
   m_bibtexRx.setMinimal(true);
 }
 
 GoogleScholarFetcher::~GoogleScholarFetcher() {
 }
 
 QString GoogleScholarFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool GoogleScholarFetcher::canFetch(int type) const {
   return type == Data::Collection::Bibtex;
 }
 
 void GoogleScholarFetcher::readConfigHook(const KConfigGroup& config_) {
   Q_UNUSED(config_);
 }
 
 void GoogleScholarFetcher::search() {
   if(!m_cookieIsSet) {
     setBibtexCookie();
   }
   m_started = true;
   m_start = 0;
   m_total = -1;
   doSearch();
 }
 
 void GoogleScholarFetcher::continueSearch() {
   m_started = true;
   doSearch();
 }
 
 void GoogleScholarFetcher::doSearch() {
 //  myDebug() << "value = " << value_;
 
   QUrl u(QString::fromLatin1(SCHOLAR_BASE_URL));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("start"), QString::number(m_start));
 
   QString value = request().value;
   if(!value.startsWith(QLatin1Char('"'))) {
     value = QLatin1Char('"') + value;
   }
   if(!value.endsWith(QLatin1Char('"'))) {
     value += QLatin1Char('"');
   }
   switch(request().key) {
     case Title:
       q.addQueryItem(QStringLiteral("q"), QStringLiteral("allintitle:%1").arg(request().value));
       break;
 
     case Keyword:
       q.addQueryItem(QStringLiteral("q"), request().value);
       break;
 
     case Person:
       q.addQueryItem(QStringLiteral("q"), QStringLiteral("author:%1").arg(request().value));
       break;
 
     default:
       myWarning() << "key not recognized: " << request().key;
       stop();
       return;
   }
   u.setQuery(q);
 //  myDebug() << "url: " << u.url();
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)),
-          SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result,
+          this, &GoogleScholarFetcher::slotComplete);
 }
 
 void GoogleScholarFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 void GoogleScholarFetcher::slotComplete(KJob*) {
 //  myDebug();
 
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
   const QString text = QString::fromUtf8(data.constData(), data.size());
 
 #if 0
   myWarning() << "Remove debug from googlescholarfetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/test.html"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << text;
   }
   f.close();
 #endif
 
   QString bibtex;
   int count = 0;
   for(int pos = m_bibtexRx.indexIn(text); count < m_limit && pos > -1; pos = m_bibtexRx.indexIn(text, pos+m_bibtexRx.matchedLength()), ++count) {
     // for some reason, KIO and google don't return bibtex when '&' is escaped
     QString url = m_bibtexRx.cap(1).replace(QLatin1String("&amp;"), QLatin1String("&"));
     QUrl bibtexUrl = QUrl(QString::fromLatin1(SCHOLAR_BASE_URL)).resolved(QUrl(url));
 //    myDebug() << bibtexUrl;
     bibtex += FileHandler::readTextFile(bibtexUrl, true);
   }
 
   Import::BibtexImporter imp(bibtex);
   // quiet warnings...
   imp.setCurrentCollection(Data::CollPtr(new Data::BibtexCollection(true)));
   Data::CollPtr coll = imp.collection();
   if(!coll) {
     myDebug() << "no collection pointer";
     stop();
     return;
   }
 
   count = 0;
   Data::EntryList entries = coll->entries();
   foreach(Data::EntryPtr entry, entries) {
     if(count >= m_limit) {
       break;
     }
     if(!m_started) {
       // might get aborted
       break;
     }
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, Data::EntryPtr(entry));
     emit signalResultFound(r);
     ++count;
   }
   m_start = m_entries.count();
 //  m_hasMoreResults = m_start <= m_total;
   m_hasMoreResults = false; // for now, no continued searches
 
   stop(); // required
 }
 
 Tellico::Data::EntryPtr GoogleScholarFetcher::fetchEntryHook(uint uid_) {
   return m_entries[uid_];
 }
 
 Tellico::Fetch::FetchRequest GoogleScholarFetcher::updateRequest(Data::EntryPtr entry_) {
   QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Title, title);
   }
   return FetchRequest();
 }
 
 Tellico::Fetch::ConfigWidget* GoogleScholarFetcher::configWidget(QWidget* parent_) const {
   return new GoogleScholarFetcher::ConfigWidget(parent_, this);
 }
 
 QString GoogleScholarFetcher::defaultName() {
   // no i18n
   return QStringLiteral("Google Scholar");
 }
 
 QString GoogleScholarFetcher::defaultIcon() {
   return favIcon("http://scholar.google.com");
 }
 
 void GoogleScholarFetcher::setBibtexCookie() {
   // it appears that the series of url reads are necessary to get the correct cookie set
   // have to set preferences to have bibtex output
   const QString text = FileHandler::readTextFile(QUrl(QString::fromLatin1(SCHOLAR_SET_CONFIG_URL)), true);
   // find hidden input variables
   QRegExp inputRx(QLatin1String("<input\\s+[^>]*\\s*type\\s*=\\s*\"hidden\"\\s+[^>]+>"));
   inputRx.setMinimal(true);
   QRegExp pairRx(QLatin1String("([^=\\s<]+)\\s*=\\s*\"?([^=\\s\">]+)\"?"));
   QHash<QString, QString> nameValues;
   for(int pos = inputRx.indexIn(text); pos > -1; pos = inputRx.indexIn(text, pos+inputRx.matchedLength())) {
     const QString input = inputRx.cap(0);
     QString name, value;
     for(int pos2 = pairRx.indexIn(input); pos2 > -1; pos2 = pairRx.indexIn(input, pos2+pairRx.matchedLength())) {
       if(pairRx.cap(1).toLower() == QLatin1String("name")) {
         name = pairRx.cap(2);
       } else if(pairRx.cap(1).toLower() == QLatin1String("value")) {
         value = pairRx.cap(2);
       }
     }
     if(!name.isEmpty() && !value.isEmpty()) {
       nameValues.insert(name, value);
     }
   }
   QString newUrl = QLatin1String(SCHOLAR_SET_BIBTEX_URL);
   for(QHash<QString, QString>::const_iterator i = nameValues.constBegin(); i != nameValues.constEnd(); ++i) {
     newUrl += QLatin1Char('&') + i.key() + QLatin1Char('=') + i.value();
   }
   FileHandler::readTextFile(QUrl(newUrl), true);
   m_cookieIsSet = true;
 }
 
 GoogleScholarFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const GoogleScholarFetcher* /*=0*/)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 }
 
 QString GoogleScholarFetcher::ConfigWidget::preferredName() const {
   return GoogleScholarFetcher::defaultName();
 }
diff --git a/src/fetch/hathitrustfetcher.cpp b/src/fetch/hathitrustfetcher.cpp
index 38367e6f..4b180e3c 100644
--- a/src/fetch/hathitrustfetcher.cpp
+++ b/src/fetch/hathitrustfetcher.cpp
@@ -1,325 +1,325 @@
 /***************************************************************************
     Copyright (C) 2012 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "hathitrustfetcher.h"
 #include "../translators/xslthandler.h"
 #include "../translators/tellicoimporter.h"
 #include "../utils/isbnvalidator.h"
 #include "../utils/lccnvalidator.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../utils/datafileregistry.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KJobWidgets>
 
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QGridLayout>
 #include <QTextCodec>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QDomDocument>
 
 namespace {
   static const char* HATHITRUST_QUERY_URL = "http://catalog.hathitrust.org/api/volumes/full/json/";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::HathiTrustFetcher;
 
 HathiTrustFetcher::HathiTrustFetcher(QObject* parent_)
     : Fetcher(parent_), m_started(false), m_MARC21XMLHandler(nullptr), m_MODSHandler(nullptr) {
 }
 
 HathiTrustFetcher::~HathiTrustFetcher() {
   delete m_MARC21XMLHandler;
   m_MARC21XMLHandler = nullptr;
   delete m_MODSHandler;
   m_MODSHandler = nullptr;
 }
 
 QString HathiTrustFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool HathiTrustFetcher::canSearch(FetchKey k) const {
   return k == ISBN || k == LCCN;
 }
 
 bool HathiTrustFetcher::canFetch(int type) const {
   return type == Data::Collection::Book || type == Data::Collection::Bibtex;
 }
 
 void HathiTrustFetcher::readConfigHook(const KConfigGroup&) {
 }
 
 void HathiTrustFetcher::search() {
   m_started = true;
   doSearch();
 }
 
 void HathiTrustFetcher::doSearch() {
   QUrl u(QString::fromLatin1(HATHITRUST_QUERY_URL));
 
   QStringList searchValues;
   // we split ISBN and LCCN values, which are the only ones we accept anyway
   const QStringList searchTerms = FieldFormat::splitValue(request().value);
   foreach(const QString& searchTerm, searchTerms) {
     if(request().key == ISBN) {
       searchValues += QStringLiteral("isbn:%1").arg(ISBNValidator::cleanValue(searchTerm));
     } else {
       searchValues += QStringLiteral("lccn:%1").arg(LCCNValidator::formalize(searchTerm));
     }
   }
   u.setPath(u.path() + searchValues.join(QLatin1String("|")));
 
 //  myDebug() << u;
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result, this, &HathiTrustFetcher::slotComplete);
 }
 
 void HathiTrustFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
   }
   m_started = false;
   emit signalDone(this);
 }
 
 bool HathiTrustFetcher::initMARC21Handler() {
   if(m_MARC21XMLHandler) {
     return true;
   }
 
   QString xsltfile = DataFileRegistry::self()->locate(QStringLiteral("MARC21slim2MODS3.xsl"));
   if(xsltfile.isEmpty()) {
     myWarning() << "can not locate MARC21slim2MODS3.xsl.";
     return false;
   }
 
   QUrl u = QUrl::fromLocalFile(xsltfile);
 
   m_MARC21XMLHandler = new XSLTHandler(u);
   if(!m_MARC21XMLHandler->isValid()) {
     myWarning() << "error in MARC21slim2MODS3.xsl.";
     delete m_MARC21XMLHandler;
     m_MARC21XMLHandler = nullptr;
     return false;
   }
   return true;
 }
 
 bool HathiTrustFetcher::initMODSHandler() {
   if(m_MODSHandler) {
     return true;
   }
 
   QString xsltfile = DataFileRegistry::self()->locate(QStringLiteral("mods2tellico.xsl"));
   if(xsltfile.isEmpty()) {
     myWarning() << "can not locate mods2tellico.xsl.";
     return false;
   }
 
   QUrl u = QUrl::fromLocalFile(xsltfile);
 
   m_MODSHandler = new XSLTHandler(u);
   if(!m_MODSHandler->isValid()) {
     myWarning() << "error in mods2tellico.xsl.";
     delete m_MODSHandler;
     m_MODSHandler = nullptr;
     // no use in keeping the MARC handlers now
     delete m_MARC21XMLHandler;
     m_MARC21XMLHandler = nullptr;
     return false;
   }
   return true;
 }
 
 Tellico::Data::EntryPtr HathiTrustFetcher::fetchEntryHook(uint uid_) {
   return m_entries.value(uid_);
 }
 
 Tellico::Fetch::FetchRequest HathiTrustFetcher::updateRequest(Data::EntryPtr entry_) {
   const QString isbn = entry_->field(QStringLiteral("isbn"));
   if(!isbn.isEmpty()) {
     return FetchRequest(ISBN, isbn);
   }
   const QString lccn = entry_->field(QStringLiteral("lccn"));
   if(!lccn.isEmpty()) {
     return FetchRequest(LCCN, lccn);
   }
   return FetchRequest();
 }
 
 void HathiTrustFetcher::slotComplete(KJob* job_) {
   KIO::StoredTransferJob* job = static_cast<KIO::StoredTransferJob*>(job_);
 
   if(!initMARC21Handler() || !initMODSHandler()) {
     // debug messages are taken care of in the specific methods
     stop();
     return;
   }
 
   if(job->error()) {
     job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from hathitrustfetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/test.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   QVariantMap resultMap = doc.object().toVariantMap();
   if(resultMap.isEmpty()) {
     myDebug() << "no results";
     stop();
     return;
   }
 
   QVariantMap::const_iterator i = resultMap.constBegin();
   for( ; i != resultMap.constEnd(); ++i) {
     const QVariantMap recordMap = i.value().toMap().value(QStringLiteral("records")).toMap();
     if(recordMap.isEmpty()) {
       myDebug() << "empty result map";
       continue;
     }
     // we know there's a record, so no need to check for existence of first iterator in map
     QVariantMap::const_iterator ri = recordMap.constBegin();
     if(ri == recordMap.constEnd()) {
       myWarning() << "no iterator in record";
       continue;
     }
     QString marcxml = ri.value().toMap().value(QStringLiteral("marc-xml")).toString();
     // HathiTrust doesn't always include the XML NS in the JSON results. Assume it's always
     // MARC XML and check that
     QDomDocument dom;
     if(dom.setContent(marcxml, true /* namespace processing */) && dom.documentElement().namespaceURI().isEmpty()) {
       const QString rootName = dom.documentElement().tagName();
       myDebug() << "no namespace, attempting to set on" << rootName << "element";
       QRegExp rootRx(QLatin1Char('<') + rootName + QLatin1Char('>'));
       QString newRoot = QLatin1Char('<') + rootName + QLatin1String(" xmlns=\"http://www.loc.gov/MARC21/slim\">");
       marcxml.replace(rootRx, newRoot);
     }
     const QString modsxml = m_MARC21XMLHandler->applyStylesheet(marcxml);
 
     Import::TellicoImporter imp(m_MODSHandler->applyStylesheet(modsxml));
     imp.setOptions(imp.options() ^ Import::ImportProgress); // no progress needed
     Data::CollPtr coll = imp.collection();
     if(!coll) {
       myWarning() << "no coll pointer";
       continue;
     }
 
     // since the Dewey and LoC field titles have a context in their i18n call here
     // but not in the mods2tellico.xsl stylesheet where the field is actually created
     // update the field titles here
     QHashIterator<QString, QString> i(allOptionalFields());
     while(i.hasNext()) {
       i.next();
       Data::FieldPtr field = coll->fieldByName(i.key());
       if(field) {
         field->setTitle(i.value());
         coll->modifyField(field);
       }
     }
 
     foreach(Data::EntryPtr entry, coll->entries()) {
       FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
       m_entries.insert(r->uid, entry);
       emit signalResultFound(r);
     }
   }
 
   m_hasMoreResults = false; // for now, no continued searches
   stop();
 }
 
 Tellico::Fetch::ConfigWidget* HathiTrustFetcher::configWidget(QWidget* parent_) const {
   return new HathiTrustFetcher::ConfigWidget(parent_, this);
 }
 
 QString HathiTrustFetcher::defaultName() {
   return QStringLiteral("HathiTrust"); // no translation
 }
 
 QString HathiTrustFetcher::defaultIcon() {
   return favIcon("http://www.hathitrust.org");
 }
 
 Tellico::StringHash HathiTrustFetcher::allOptionalFields() {
   // same ones as z3950fetcher
   StringHash hash;
   hash[QStringLiteral("address")]  = i18n("Address");
   hash[QStringLiteral("abstract")] = i18n("Abstract");
   hash[QStringLiteral("illustrator")] = i18n("Illustrator");
   hash[QStringLiteral("dewey")] = i18nc("Dewey Decimal classification system", "Dewey Decimal");
   hash[QStringLiteral("lcc")] = i18nc("Library of Congress classification system", "LoC Classification");
   return hash;
 }
 
 HathiTrustFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const HathiTrustFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 
   // now add additional fields widget
   addFieldsWidget(HathiTrustFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 void HathiTrustFetcher::ConfigWidget::saveConfigHook(KConfigGroup&) {
 }
 
 QString HathiTrustFetcher::ConfigWidget::preferredName() const {
   return HathiTrustFetcher::defaultName();
 }
diff --git a/src/fetch/ibsfetcher.cpp b/src/fetch/ibsfetcher.cpp
index 37b7c254..332b3f76 100644
--- a/src/fetch/ibsfetcher.cpp
+++ b/src/fetch/ibsfetcher.cpp
@@ -1,366 +1,366 @@
 /***************************************************************************
     Copyright (C) 2006-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "ibsfetcher.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../collections/bookcollection.h"
 #include "../entry.h"
 #include "../fieldformat.h"
 #include "../core/filehandler.h"
 #include "../images/imagefactory.h"
 #include "../utils/isbnvalidator.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KJobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QRegExp>
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QVBoxLayout>
 #include <QUrlQuery>
 #include <QJsonDocument>
 #include <QJsonObject>
 
 namespace {
   static const char* IBS_BASE_URL = "https://www.ibs.it/search/";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::IBSFetcher;
 
 IBSFetcher::IBSFetcher(QObject* parent_)
     : Fetcher(parent_), m_total(0), m_started(false) {
 }
 
 IBSFetcher::~IBSFetcher() {
 }
 
 QString IBSFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool IBSFetcher::canFetch(int type) const {
   return type == Data::Collection::Book || type == Data::Collection::Bibtex;
 }
 
 // No UPC or Raw for now.
 bool IBSFetcher::canSearch(FetchKey k) const {
   return k == Title || k == Person || k == ISBN;
 }
 
 void IBSFetcher::readConfigHook(const KConfigGroup& config_) {
   Q_UNUSED(config_);
 }
 
 void IBSFetcher::search() {
   m_started = true;
   m_matches.clear();
 
   QUrl u(QString::fromLatin1(IBS_BASE_URL));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("ts"), QStringLiteral("as"));
 
   switch(request().key) {
     case Title:
       {
         // can't have ampersands
         QString s = request().value;
         s.remove(QLatin1Char('&'));
         q.addQueryItem(QStringLiteral("query"), s);
       }
       break;
 
     case ISBN:
       {
         QString s = request().value;
         // limit to first isbn
         s = s.section(QLatin1Char(';'), 0, 0);
         // isbn13 search doesn't work?
         s = ISBNValidator::isbn10(s);
         // dashes don't work
         s.remove(QLatin1Char('-'));
         q.addQueryItem(QStringLiteral("query"), s);
       }
       break;
 
     case Keyword:
       q.addQueryItem(QStringLiteral("query"), request().value);
       break;
 
     default:
       myWarning() << "key not recognized: " << request().key;
       stop();
       return;
   }
   u.setQuery(q);
 //  myDebug() << "url: " << u.url();
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result, this, &IBSFetcher::slotComplete);
 }
 
 void IBSFetcher::stop() {
   if(!m_started) {
     return;
   }
 
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 void IBSFetcher::slotComplete(KJob*) {
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
 
   QString s = Tellico::decodeHTML(data);
   // really specific regexp
   QRegExp itemRx(QLatin1String("class=\"item \">(.*)class=\"price"));
   itemRx.setMinimal(true);
   QRegExp titleRx(QLatin1String("<div class=\"title\">\\s*<a href=\"(.*)\">(.*)</div>"));
   titleRx.setMinimal(true);
   QRegExp yearRx(QLatin1String("<label>Anno</label>(.*)</"));
   yearRx.setMinimal(true);
   QRegExp tagRx(QLatin1String("<.*>"));
   tagRx.setMinimal(true);
 
   QString url, title, year;
   for(int pos = itemRx.indexIn(s); m_started && pos > -1; pos = itemRx.indexIn(s, pos+itemRx.matchedLength())) {
     QString s = itemRx.cap(1);
     if(s.contains(titleRx)) {
       url = titleRx.cap(1);
       title = titleRx.cap(2).remove(tagRx).simplified();
     }
     if(s.contains(yearRx)) {
       year = yearRx.cap(1).remove(tagRx).simplified();
     }
     if(!url.isEmpty() && !title.isEmpty()) {
       // the url probable contains &amp; so be careful
       QUrl u = m_job->url();
       u = u.resolved(QUrl(url.replace(QLatin1String("&amp;"), QLatin1String("&"))));
       FetchResult* r = new FetchResult(Fetcher::Ptr(this), title, year);
       m_matches.insert(r->uid, u);
       emit signalResultFound(r);
     }
   }
 
   // since the fetch is done, don't worry about holding the job pointer
   m_job = nullptr;
   stop();
 }
 
 Tellico::Data::EntryPtr IBSFetcher::fetchEntryHook(uint uid_) {
   // if we already grabbed this one, then just pull it out of the dict
   Data::EntryPtr entry = m_entries[uid_];
   if(entry) {
     return entry;
   }
 
   QUrl url = m_matches[uid_];
   if(url.isEmpty()) {
     myWarning() << "no url in map";
     return Data::EntryPtr();
   }
 
   QString results = Tellico::decodeHTML(FileHandler::readDataFile(url, true));
   if(results.isEmpty()) {
     myDebug() << "no text results";
     return Data::EntryPtr();
   }
 
 //  myDebug() << url.url();
 #if 0
   myWarning() << "Remove debug from ibsfetcher.cpp";
   QFile f(QLatin1String("/tmp/test.html"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << results;
   }
   f.close();
 #endif
 
   entry = parseEntry(results);
   if(!entry) {
     myDebug() << "error in processing entry";
     return Data::EntryPtr();
   }
   m_entries.insert(uid_, entry); // keep for later
   return entry;
 }
 
 Tellico::Data::EntryPtr IBSFetcher::parseEntry(const QString& str_) {
   QRegExp jsonRx(QLatin1String("<script type=\"application/ld\\+json\">(.*)</script"));
   jsonRx.setMinimal(true);
 
   if(!str_.contains(jsonRx)) {
     myDebug() << "No JSON block";
     return Data::EntryPtr();
   }
 
 #if 0
   myWarning() << "Remove json debug from ibsfetcher.cpp";
   QFile f(QLatin1String("/tmp/test.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << jsonRx.cap(1);
   }
   f.close();
 #endif
   QJsonDocument doc = QJsonDocument::fromJson(jsonRx.cap(1).toUtf8());
   QVariantMap objectMap = doc.object().toVariantMap();
   QVariantMap resultMap = objectMap.value(QStringLiteral("mainEntity")).toMap();
   if(resultMap.isEmpty()) {
     myDebug() << "no JSON object";
     return Data::EntryPtr();
   }
 
   Data::CollPtr coll(new Data::BookCollection(true));
   Data::EntryPtr entry(new Data::Entry(coll));
 
   // as genre, take the last breadcrumb
   QString genre = mapValue(objectMap, "breadcrumb");
   genre = genre.section(QStringLiteral(">"), -1);
   entry->setField(QStringLiteral("genre"), genre);
 
   // the title in the embedded loses it's identifier? "La..."
   entry->setField(QStringLiteral("title"), mapValue(resultMap, "name"));
   entry->setField(QStringLiteral("author"), mapValue(resultMap, "author"));
 
   const QString bookFormat = mapValue(resultMap, "bookFormat");
   if(bookFormat == QLatin1String("http://schema.org/Paperback")) {
     entry->setField(QStringLiteral("binding"), i18n("Paperback"));
   } else if(bookFormat == QLatin1String("http://schema.org/Hardcover")) {
     entry->setField(QStringLiteral("binding"), i18n("Hardback"));
   } else if(bookFormat == QLatin1String("http://schema.org/EBook")) {
     entry->setField(QStringLiteral("binding"), i18n("E-Book"));
   }
 
   entry->setField(QStringLiteral("pub_year"), mapValue(resultMap, "datePublished"));
   entry->setField(QStringLiteral("cover"), mapValue(resultMap, "image"));
   entry->setField(QStringLiteral("isbn"), mapValue(resultMap, "isbn"));
 
   // inLanguage is upper-case language code
   const QString lang = mapValue(resultMap, "inLanguage");
   entry->setField(QStringLiteral("language"), QLocale(lang.toLower()).nativeLanguageName());
 
   entry->setField(QStringLiteral("plot"), mapValue(resultMap, "description"));
   entry->setField(QStringLiteral("pages"), mapValue(resultMap, "numberOfPages"));
   entry->setField(QStringLiteral("publisher"), mapValue(resultMap, "publisher"));
 
   // multiple authors do not show up in the embedded JSON
   QRegExp titleDivRx(QLatin1String("<div id=\"title\">(.*)</div>"));
   titleDivRx.setMinimal(true);
   if(str_.contains(titleDivRx)) {
     const QString titleDiv = titleDivRx.cap(1);
     QRegExp authorRx(QLatin1String("<a href=\"/libri/autori/[^>]+>(.*)</a>"));
     authorRx.setMinimal(true);
     QStringList authors;
     for(int pos = authorRx.indexIn(titleDiv); pos > -1; pos = authorRx.indexIn(titleDiv, pos+authorRx.matchedLength())) {
       authors << authorRx.cap(1).simplified();
     }
     if(!authors.isEmpty()) {
       entry->setField(QStringLiteral("author"), authors.join(FieldFormat::delimiterString()));
     }
     // the title in the embedded loses its identifier? "La..."
     QRegExp labelRx(QLatin1String("<label>(.*)</label>"));
     if(titleDiv.contains(labelRx)) {
       entry->setField(QStringLiteral("title"), labelRx.cap(1).simplified());
     }
   }
 
   QRegExp tagRx(QLatin1String("<.*>"));
   tagRx.setMinimal(true);
 
   // editor is not in embedded json
   QRegExp editorRx(QLatin1String("<strong>Curatore:</strong>(.*)</div"));
   editorRx.setMinimal(true);
   if(str_.contains(editorRx)) {
     entry->setField(QStringLiteral("editor"), editorRx.cap(1).remove(tagRx).simplified());
   }
 
   // editor is not in embedded json
   QRegExp translatorRx(QLatin1String("<strong>Traduttore:</strong>(.*)</div"));
   translatorRx.setMinimal(true);
   if(str_.contains(translatorRx)) {
     entry->setField(QStringLiteral("translator"), translatorRx.cap(1).remove(tagRx).simplified());
   }
 
   return entry;
 }
 
 Tellico::Fetch::FetchRequest IBSFetcher::updateRequest(Data::EntryPtr entry_) {
   QString isbn = entry_->field(QStringLiteral("isbn"));
   if(!isbn.isEmpty()) {
     return FetchRequest(Fetch::ISBN, isbn);
   }
   QString t = entry_->field(QStringLiteral("title"));
   if(!t.isEmpty()) {
     return FetchRequest(Fetch::Title, t);
   }
   return FetchRequest();
 }
 
 Tellico::Fetch::ConfigWidget* IBSFetcher::configWidget(QWidget* parent_) const {
   return new IBSFetcher::ConfigWidget(parent_);
 }
 
 QString IBSFetcher::defaultName() {
   return i18n("Internet Bookshop (ibs.it)");
 }
 
 QString IBSFetcher::defaultIcon() {
   return favIcon("http://www.ibs.it");
 }
 
 IBSFetcher::ConfigWidget::ConfigWidget(QWidget* parent_)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 }
 
 QString IBSFetcher::ConfigWidget::preferredName() const {
   return IBSFetcher::defaultName();
 }
diff --git a/src/fetch/igdbfetcher.cpp b/src/fetch/igdbfetcher.cpp
index c7a20503..ab18214f 100644
--- a/src/fetch/igdbfetcher.cpp
+++ b/src/fetch/igdbfetcher.cpp
@@ -1,626 +1,626 @@
 /***************************************************************************
     Copyright (C) 2017 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "igdbfetcher.h"
 #include "../collections/gamecollection.h"
 #include "../images/imagefactory.h"
 #include "../core/filehandler.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KJob>
 #include <KJobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 #include <KIO/StoredTransferJob>
 
 #include <QUrl>
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QGridLayout>
 #include <QTextCodec>
 #include <QJsonDocument>
 #include <QJsonArray>
 
 namespace {
   static const int IGDB_MAX_RETURNS_TOTAL = 20;
   static const char* IGDB_API_URL = "https://api-v3.igdb.com";
   static const char* IGDB_MAGIC_TOKEN = "dabb2142d9bca4936809251194acd4b25635dfe74d7f1d2d8ced8ab241700a3320111d7995f741769ca94b7de88b487812738fb9043247707a4e281e48786051";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::IGDBFetcher;
 
 IGDBFetcher::IGDBFetcher(QObject* parent_)
     : Fetcher(parent_), m_started(false) {
   if(m_genreHash.isEmpty()) {
     populateHashes();
   }
 }
 
 IGDBFetcher::~IGDBFetcher() {
 }
 
 QString IGDBFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 QString IGDBFetcher::attribution() const {
   return i18n("This information was freely provided by <a href=\"https://igdb.com\">IGDB.com</a>.");
 }
 
 bool IGDBFetcher::canSearch(FetchKey k) const {
   return k == Keyword;
 }
 
 bool IGDBFetcher::canFetch(int type) const {
   return type == Data::Collection::Game;
 }
 
 void IGDBFetcher::readConfigHook(const KConfigGroup& config_) {
   QString k = config_.readEntry("APIv3 Key");
   if(!k.isEmpty()) {
     m_apiKey = k;
   }
 }
 
 void IGDBFetcher::search() {
   continueSearch();
 }
 
 void IGDBFetcher::continueSearch() {
   m_started = true;
 
   if(m_apiKey.isEmpty()) {
     m_apiKey = Tellico::reverseObfuscate(IGDB_MAGIC_TOKEN);
   }
 
   QUrl u(QString::fromLatin1(IGDB_API_URL));
   u.setPath(u.path() + QStringLiteral("/games/"));
 
   QStringList clauseList;
   switch(request().key) {
     case Keyword:
       clauseList += QString(QStringLiteral("search \"%1\";")).arg(request().value);
       break;
 
     default:
       myWarning() << "key not recognized:" << request().key;
       stop();
       return;
   }
   clauseList += QStringLiteral("fields *,cover.url,age_ratings.*,involved_companies.*;");
   // exclude some of the bigger unused fields
   clauseList += QStringLiteral("exclude keywords,screenshots,tags;");
   clauseList += QString(QStringLiteral("limit %1;")).arg(QString::number(IGDB_MAX_RETURNS_TOTAL));
 //  myDebug() << u << clauseList.join(QStringLiteral(" "));
 
   m_job = igdbJob(u, m_apiKey, clauseList.join(QStringLiteral(" ")));
-  connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result, this, &IGDBFetcher::slotComplete);
 }
 
 void IGDBFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 Tellico::Data::EntryPtr IGDBFetcher::fetchEntryHook(uint uid_) {
   if(!m_entries.contains(uid_)) {
     myDebug() << "no entry ptr";
     return Data::EntryPtr();
   }
 
   Data::EntryPtr entry = m_entries.value(uid_);
 
   QStringList publishers;
   // grab the publisher data
   if(entry->field(QStringLiteral("publisher")).isEmpty()) {
     foreach(const QString& pid, FieldFormat::splitValue(entry->field(QStringLiteral("pub-id")))) {
       const QString publisher = companyName(pid);
       if(!publisher.isEmpty()) {
         publishers << publisher;
       }
     }
   }
   entry->setField(QStringLiteral("publisher"), publishers.join(FieldFormat::delimiterString()));
 
   QStringList developers;
   // grab the developer data
   if(entry->field(QStringLiteral("developer")).isEmpty()) {
     foreach(const QString& did, FieldFormat::splitValue(entry->field(QStringLiteral("dev-id")))) {
       const QString developer = companyName(did);
       if(!developer.isEmpty()) {
         developers << developer;
       }
     }
   }
   entry->setField(QStringLiteral("developer"), developers.join(FieldFormat::delimiterString()));
 
   // image might still be a URL
   const QString image_id = entry->field(QStringLiteral("cover"));
   if(image_id.contains(QLatin1Char('/'))) {
     const QString id = ImageFactory::addImage(QUrl::fromUserInput(image_id), true /* quiet */);
     if(id.isEmpty()) {
       message(i18n("The cover image could not be loaded."), MessageHandler::Warning);
     }
     // empty image ID is ok
     entry->setField(QStringLiteral("cover"), id);
   }
 
   // clear the placeholder fields
   entry->setField(QStringLiteral("pub-id"), QString());
   entry->setField(QStringLiteral("dev-id"), QString());
   return entry;
 }
 
 Tellico::Fetch::FetchRequest IGDBFetcher::updateRequest(Data::EntryPtr entry_) {
   QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Keyword, title);
   }
   return FetchRequest();
 }
 
 void IGDBFetcher::slotComplete(KJob* job_) {
   KIO::StoredTransferJob* job = static_cast<KIO::StoredTransferJob*>(job_);
 
   if(job->error()) {
     job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   const QByteArray data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from igdbfetcher.cpp";
   QFile file(QStringLiteral("/tmp/test.json"));
   if(file.open(QIODevice::WriteOnly)) {
     QTextStream t(&file);
     t.setCodec("UTF-8");
     t << data;
   }
   file.close();
 #endif
 
   Data::CollPtr coll(new Data::GameCollection(true));
   if(optionalFields().contains(QStringLiteral("pegi"))) {
     QStringList pegi = QStringLiteral("PEGI 3, PEGI 7, PEGI 12, PEGI 16, PEGI 18")
                                     .split(QRegExp(QStringLiteral("\\s*,\\s*")), QString::SkipEmptyParts);
     Data::FieldPtr field(new Data::Field(QStringLiteral("pegi"), i18n("PEGI Rating"), pegi));
     field->setFlags(Data::Field::AllowGrouped);
     field->setCategory(i18n("General"));
     coll->addField(field);
   }
   if(optionalFields().contains(QStringLiteral("igdb"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("igdb"), i18n("IGDB Link"), Data::Field::URL));
     field->setCategory(i18n("General"));
     coll->addField(field);
   }
   // placeholder for publisher id, to be removed later
   Data::FieldPtr f(new Data::Field(QStringLiteral("pub-id"), QString(), Data::Field::Number));
   f->setFlags(Data::Field::AllowMultiple);
   coll->addField(f);
   // placeholder for developer id, to be removed later
   f = new Data::Field(QStringLiteral("dev-id"), QString(), Data::Field::Number);
   f->setFlags(Data::Field::AllowMultiple);
   coll->addField(f);
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   foreach(const QVariant& result, doc.array().toVariantList()) {
     QVariantMap resultMap = result.toMap();
     Data::EntryPtr entry(new Data::Entry(coll));
     populateEntry(entry, resultMap);
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
   }
 
   stop();
 }
 
 void IGDBFetcher::populateEntry(Data::EntryPtr entry_, const QVariantMap& resultMap_) {
   entry_->setField(QStringLiteral("title"), mapValue(resultMap_, "name"));
   entry_->setField(QStringLiteral("description"), mapValue(resultMap_, "summary"));
 
   QString cover = mapValue(resultMap_, "cover", "url");
   if(cover.startsWith(QLatin1Char('/'))) {
     cover.prepend(QStringLiteral("https:"));
   }
   entry_->setField(QStringLiteral("cover"), cover);
 
   QVariantList genreIDs = resultMap_.value(QStringLiteral("genres")).toList();
   QStringList genres;
   foreach(const QVariant& id, genreIDs) {
     QString g = m_genreHash.value(id.toInt());
     if(!g.isEmpty()) {
       genres << g;
     }
   }
   entry_->setField(QStringLiteral("genre"), genres.join(FieldFormat::delimiterString()));
 
   qlonglong release_t = mapValue(resultMap_, "first_release_date").toLongLong();
   if(release_t > 0) {
     // could use QDateTime::fromSecsSinceEpoch but that was introduced in Qt 5.8
     // while I still support Qt 5.6, in theory...
     QDateTime dt = QDateTime::fromMSecsSinceEpoch(release_t * 1000);
     entry_->setField(QStringLiteral("year"), QString::number(dt.date().year()));
   }
 
   QVariantList platforms = resultMap_.value(QStringLiteral("platforms")).toList();
   if(!platforms.isEmpty()) {
     // just take the first one for now
     // TODO:: suport multiple
     QString platform = m_platformHash.value(platforms.first().toInt());
     platform = Data::GameCollection::normalizePlatform(platform);
     // make the assumption that if the platform name isn't already in the allowed list, it should be added
     Data::FieldPtr f = entry_->collection()->fieldByName(QStringLiteral("platform"));
     if(f && !f->allowed().contains(platform)) {
       f->setAllowed(QStringList(f->allowed()) << platform);
     }
     entry_->setField(QStringLiteral("platform"), platform);
   }
 
   const QVariantList ageRatingList = resultMap_.value(QStringLiteral("age_ratings")).toList();
   foreach(const QVariant& ageRating, ageRatingList) {
     const QVariantMap ratingMap = ageRating.toMap();
     // per Age Rating Enums, ESRB==1, PEGI==2
     const int category = ratingMap.value(QStringLiteral("category")).toInt();
     const int rating = ratingMap.value(QStringLiteral("rating")).toInt();
     if(category == 1) {
       entry_->setField(QStringLiteral("certification"), m_esrbHash.value(rating));
     } else if(category == 2 && optionalFields().contains(QStringLiteral("pegi"))) {
       entry_->setField(QStringLiteral("pegi"), m_pegiHash.value(rating));
     }
   }
 
   QStringList pubs, devs;
   const QVariantList companyList = resultMap_.value(QStringLiteral("involved_companies")).toList();
   foreach(const QVariant& company, companyList) {
     const QVariantMap companyMap = company.toMap();
     if(companyMap.value(QStringLiteral("publisher")).toBool()) {
       pubs += companyMap.value(QStringLiteral("company")).toString();
     } else if(companyMap.value(QStringLiteral("developer")).toBool()) {
       devs += companyMap.value(QStringLiteral("company")).toString();
     }
   }
   entry_->setField(QStringLiteral("pub-id"), pubs.join(FieldFormat::delimiterString()));
   entry_->setField(QStringLiteral("dev-id"), devs.join(FieldFormat::delimiterString()));
 
   if(optionalFields().contains(QStringLiteral("igdb"))) {
     entry_->setField(QStringLiteral("igdb"), mapValue(resultMap_, "url"));
   }
 }
 
 QString IGDBFetcher::companyName(const QString& companyId_) const {
   if(m_companyHash.contains(companyId_)) {
     return m_companyHash.value(companyId_);
   }
 
   QUrl u(QString::fromLatin1(IGDB_API_URL));
   u.setPath(u.path() + QStringLiteral("/companies/"));
 
   QStringList clauseList;
   clauseList += QStringLiteral("fields name;");
   clauseList += QString(QStringLiteral("where id = %1;")).arg(companyId_);
 //  myDebug() << u << clauseList.join(QStringLiteral(" "));
 
   QPointer<KIO::StoredTransferJob> job = igdbJob(u, m_apiKey, clauseList.join(QStringLiteral(" ")));
   if(!job->exec()) {
     myDebug() << job->errorString() << u;
     return QString();
   }
   const QByteArray data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data for" << u;
     return QString();
   }
 #if 0
   myWarning() << "Remove company debug from igdbfetcher.cpp";
   QFile file(QStringLiteral("/tmp/igdb-company.json"));
   if(file.open(QIODevice::WriteOnly)) {
     QTextStream t(&file);
     t.setCodec("UTF-8");
     t << data;
   }
   file.close();
 #endif
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   QVariantList companyList = doc.array().toVariantList();
   if(companyList.isEmpty()) {
     return QString();
   }
   const QString company = mapValue(companyList.at(0).toMap(), "name");
   m_companyHash.insert(companyId_, company);
   return company;
 }
 
 Tellico::Fetch::ConfigWidget* IGDBFetcher::configWidget(QWidget* parent_) const {
   return new IGDBFetcher::ConfigWidget(parent_, this);
 }
 
 // Use member hash for certain field names for now.
 // Don't expect IGDB values to change. This avoids exponentially multiplying the number of API calls
 void IGDBFetcher::populateHashes() {
   m_genreHash.insert(2,  QStringLiteral("Point-and-click"));
   m_genreHash.insert(4,  QStringLiteral("Fighting"));
   m_genreHash.insert(5,  QStringLiteral("Shooter"));
   m_genreHash.insert(7,  QStringLiteral("Music"));
   m_genreHash.insert(8,  QStringLiteral("Platform"));
   m_genreHash.insert(9,  QStringLiteral("Puzzle"));
   m_genreHash.insert(10, QStringLiteral("Racing"));
   m_genreHash.insert(11, QStringLiteral("Real Time Strategy (RTS)"));
   m_genreHash.insert(12, QStringLiteral("Role-playing (RPG)"));
   m_genreHash.insert(13, QStringLiteral("Simulator"));
   m_genreHash.insert(14, QStringLiteral("Sport"));
   m_genreHash.insert(15, QStringLiteral("Strategy"));
   m_genreHash.insert(16, QStringLiteral("Turn-based strategy (TBS)"));
   m_genreHash.insert(24, QStringLiteral("Tactical"));
   m_genreHash.insert(25, QStringLiteral("Hack and slash/Beat 'em up"));
   m_genreHash.insert(26, QStringLiteral("Quiz/Trivia"));
   m_genreHash.insert(30, QStringLiteral("Pinball"));
   m_genreHash.insert(31, QStringLiteral("Adventure"));
   m_genreHash.insert(32, QStringLiteral("Indie"));
   m_genreHash.insert(33, QStringLiteral("Arcade"));
 
   m_platformHash.insert(3, QStringLiteral("Linux"));
   m_platformHash.insert(4, QStringLiteral("Nintendo 64"));
   m_platformHash.insert(5, QStringLiteral("Wii"));
   m_platformHash.insert(6, QStringLiteral("PC (Microsoft Windows)"));
   m_platformHash.insert(7, QStringLiteral("PlayStation"));
   m_platformHash.insert(8, QStringLiteral("PlayStation 2"));
   m_platformHash.insert(9, QStringLiteral("PlayStation 3"));
   m_platformHash.insert(11, QStringLiteral("Xbox"));
   m_platformHash.insert(12, QStringLiteral("Xbox 360"));
   m_platformHash.insert(13, QStringLiteral("PC DOS"));
   m_platformHash.insert(14, QStringLiteral("Mac"));
   m_platformHash.insert(15, QStringLiteral("Commodore C64/128"));
   m_platformHash.insert(16, QStringLiteral("Amiga"));
   m_platformHash.insert(18, QStringLiteral("Nintendo Entertainment System (NES)"));
   m_platformHash.insert(19, QStringLiteral("Super Nintendo Entertainment System (SNES)"));
   m_platformHash.insert(20, QStringLiteral("Nintendo DS"));
   m_platformHash.insert(21, QStringLiteral("Nintendo GameCube"));
   m_platformHash.insert(22, QStringLiteral("Game Boy Color"));
   m_platformHash.insert(23, QStringLiteral("Dreamcast"));
   m_platformHash.insert(24, QStringLiteral("Game Boy Advance"));
   m_platformHash.insert(25, QStringLiteral("Amstrad CPC"));
   m_platformHash.insert(26, QStringLiteral("ZX Spectrum"));
   m_platformHash.insert(27, QStringLiteral("MSX"));
   m_platformHash.insert(29, QStringLiteral("Sega Mega Drive/Genesis"));
   m_platformHash.insert(30, QStringLiteral("Sega 32X"));
   m_platformHash.insert(32, QStringLiteral("Sega Saturn"));
   m_platformHash.insert(33, QStringLiteral("Game Boy"));
   m_platformHash.insert(34, QStringLiteral("Android"));
   m_platformHash.insert(35, QStringLiteral("Sega Game Gear"));
   m_platformHash.insert(36, QStringLiteral("Xbox Live Arcade"));
   m_platformHash.insert(37, QStringLiteral("Nintendo 3DS"));
   m_platformHash.insert(38, QStringLiteral("PlayStation Portable"));
   m_platformHash.insert(39, QStringLiteral("iOS"));
   m_platformHash.insert(41, QStringLiteral("Wii U"));
   m_platformHash.insert(42, QStringLiteral("N-Gage"));
   m_platformHash.insert(44, QStringLiteral("Tapwave Zodiac"));
   m_platformHash.insert(45, QStringLiteral("PlayStation Network"));
   m_platformHash.insert(46, QStringLiteral("PlayStation Vita"));
   m_platformHash.insert(47, QStringLiteral("Virtual Console (Nintendo)"));
   m_platformHash.insert(48, QStringLiteral("PlayStation 4"));
   m_platformHash.insert(49, QStringLiteral("Xbox One"));
   m_platformHash.insert(50, QStringLiteral("3DO Interactive Multiplayer"));
   m_platformHash.insert(51, QStringLiteral("Family Computer Disk System"));
   m_platformHash.insert(52, QStringLiteral("Arcade"));
   m_platformHash.insert(53, QStringLiteral("MSX2"));
   m_platformHash.insert(55, QStringLiteral("Mobile"));
   m_platformHash.insert(56, QStringLiteral("WiiWare"));
   m_platformHash.insert(57, QStringLiteral("WonderSwan"));
   m_platformHash.insert(58, QStringLiteral("Super Famicom"));
   m_platformHash.insert(59, QStringLiteral("Atari 2600"));
   m_platformHash.insert(60, QStringLiteral("Atari 7800"));
   m_platformHash.insert(61, QStringLiteral("Atari Lynx"));
   m_platformHash.insert(62, QStringLiteral("Atari Jaguar"));
   m_platformHash.insert(63, QStringLiteral("Atari ST/STE"));
   m_platformHash.insert(64, QStringLiteral("Sega Master System"));
   m_platformHash.insert(65, QStringLiteral("Atari 8-bit"));
   m_platformHash.insert(66, QStringLiteral("Atari 5200"));
   m_platformHash.insert(67, QStringLiteral("Intellivision"));
   m_platformHash.insert(68, QStringLiteral("ColecoVision"));
   m_platformHash.insert(69, QStringLiteral("BBC Microcomputer System"));
   m_platformHash.insert(70, QStringLiteral("Vectrex"));
   m_platformHash.insert(71, QStringLiteral("Commodore VIC-20"));
   m_platformHash.insert(72, QStringLiteral("Ouya"));
   m_platformHash.insert(73, QStringLiteral("BlackBerry OS"));
   m_platformHash.insert(74, QStringLiteral("Windows Phone"));
   m_platformHash.insert(75, QStringLiteral("Apple II"));
   m_platformHash.insert(77, QStringLiteral("Sharp X1"));
   m_platformHash.insert(78, QStringLiteral("Sega CD"));
   m_platformHash.insert(79, QStringLiteral("Neo Geo MVS"));
   m_platformHash.insert(80, QStringLiteral("Neo Geo AES"));
   m_platformHash.insert(82, QStringLiteral("Web browser"));
   m_platformHash.insert(84, QStringLiteral("SG-1000"));
   m_platformHash.insert(85, QStringLiteral("Donner Model 30"));
   m_platformHash.insert(86, QStringLiteral("TurboGrafx-16/PC Engine"));
   m_platformHash.insert(87, QStringLiteral("Virtual Boy"));
   m_platformHash.insert(88, QStringLiteral("Odyssey"));
   m_platformHash.insert(89, QStringLiteral("Microvision"));
   m_platformHash.insert(90, QStringLiteral("Commodore PET"));
   m_platformHash.insert(91, QStringLiteral("Bally Astrocade"));
   m_platformHash.insert(92, QStringLiteral("SteamOS"));
   m_platformHash.insert(93, QStringLiteral("Commodore 16"));
   m_platformHash.insert(94, QStringLiteral("Commodore Plus/4"));
   m_platformHash.insert(95, QStringLiteral("PDP-1"));
   m_platformHash.insert(96, QStringLiteral("PDP-10"));
   m_platformHash.insert(97, QStringLiteral("PDP-8"));
   m_platformHash.insert(98, QStringLiteral("DEC GT40"));
   m_platformHash.insert(99, QStringLiteral("Family Computer"));
   m_platformHash.insert(100, QStringLiteral("Analogue electronics"));
   m_platformHash.insert(101, QStringLiteral("Ferranti Nimrod Computer"));
   m_platformHash.insert(102, QStringLiteral("EDSAC"));
   m_platformHash.insert(103, QStringLiteral("PDP-7"));
   m_platformHash.insert(104, QStringLiteral("HP 2100"));
   m_platformHash.insert(105, QStringLiteral("HP 3000"));
   m_platformHash.insert(106, QStringLiteral("SDS Sigma 7"));
   m_platformHash.insert(107, QStringLiteral("Call-A-Computer time-shared mainframe computer system"));
   m_platformHash.insert(108, QStringLiteral("PDP-11"));
   m_platformHash.insert(109, QStringLiteral("CDC Cyber 70"));
   m_platformHash.insert(110, QStringLiteral("PLATO"));
   m_platformHash.insert(111, QStringLiteral("Imlac PDS-1"));
   m_platformHash.insert(112, QStringLiteral("Microcomputer"));
   m_platformHash.insert(113, QStringLiteral("OnLive Game System"));
   m_platformHash.insert(114, QStringLiteral("Amiga CD32"));
   m_platformHash.insert(115, QStringLiteral("Apple IIGS"));
   m_platformHash.insert(116, QStringLiteral("Acorn Archimedes"));
   m_platformHash.insert(117, QStringLiteral("Philips CD-i"));
   m_platformHash.insert(118, QStringLiteral("FM Towns"));
   m_platformHash.insert(119, QStringLiteral("Neo Geo Pocket"));
   m_platformHash.insert(120, QStringLiteral("Neo Geo Pocket Color"));
   m_platformHash.insert(121, QStringLiteral("Sharp X68000"));
   m_platformHash.insert(122, QStringLiteral("Nuon"));
   m_platformHash.insert(123, QStringLiteral("WonderSwan Color"));
   m_platformHash.insert(124, QStringLiteral("SwanCrystal"));
   m_platformHash.insert(125, QStringLiteral("PC-8801"));
   m_platformHash.insert(126, QStringLiteral("TRS-80"));
   m_platformHash.insert(127, QStringLiteral("Fairchild Channel F"));
   m_platformHash.insert(128, QStringLiteral("PC Engine SuperGrafx"));
   m_platformHash.insert(129, QStringLiteral("Texas Instruments TI-99"));
   m_platformHash.insert(130, QStringLiteral("Nintendo Switch"));
   m_platformHash.insert(131, QStringLiteral("Nintendo PlayStation"));
   m_platformHash.insert(132, QStringLiteral("Amazon Fire TV"));
   m_platformHash.insert(133, QStringLiteral("Philips Videopac G7000"));
   m_platformHash.insert(134, QStringLiteral("Acorn Electron"));
   m_platformHash.insert(135, QStringLiteral("Hyper Neo Geo 64"));
   m_platformHash.insert(136, QStringLiteral("Neo Geo CD"));
 
   // cheat by grabbing i18n values from default collection
   Data::CollPtr c(new Data::GameCollection(true));
   QStringList esrb = c->fieldByName(QStringLiteral("certification"))->allowed();
   Q_ASSERT(esrb.size() == 8);
   while(esrb.size() < 8) {
     esrb << QString();
   }
   m_esrbHash.insert(1, esrb.at(7));
   m_esrbHash.insert(2, esrb.at(6));
   m_esrbHash.insert(3, esrb.at(5));
   m_esrbHash.insert(4, esrb.at(4));
   m_esrbHash.insert(5, esrb.at(3));
   m_esrbHash.insert(6, esrb.at(2));
   m_esrbHash.insert(7, esrb.at(1));
 
   m_pegiHash.insert(1, QStringLiteral("PEGI 3"));
   m_pegiHash.insert(2, QStringLiteral("PEGI 7"));
   m_pegiHash.insert(3, QStringLiteral("PEGI 12"));
   m_pegiHash.insert(4, QStringLiteral("PEGI 16"));
   m_pegiHash.insert(5, QStringLiteral("PEGI 18"));
 }
 
 QString IGDBFetcher::defaultName() {
   return i18n("Internet Game Database (IGDB.com)");
 }
 
 QString IGDBFetcher::defaultIcon() {
   return favIcon("http://www.igdb.com");
 }
 
 Tellico::StringHash IGDBFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("pegi")] = i18n("PEGI Rating");
   hash[QStringLiteral("igdb")] = i18n("IGDB Link");
   return hash;
 }
 
 QPointer<KIO::StoredTransferJob> IGDBFetcher::igdbJob(const QUrl& url_, const QString& apiKey_, const QString& query_) {
   QPointer<KIO::StoredTransferJob> job = KIO::storedHttpPost(query_.toUtf8(), url_, KIO::HideProgressInfo);
   job->addMetaData(QStringLiteral("customHTTPHeader"), QStringLiteral("user-key: ") + apiKey_);
   job->addMetaData(QStringLiteral("accept"), QStringLiteral("application/json"));
   KJobWidgets::setWindow(job, GUI::Proxy::widget());
   return job;
 }
 
 IGDBFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const IGDBFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
 
   QLabel* al = new QLabel(i18n("Registration is required for accessing the %1 data source. "
                                "If you agree to the terms and conditions, <a href='%2'>sign "
                                "up for an account</a>, and enter your information below.",
                                 IGDBFetcher::defaultName(),
                                 QStringLiteral("https://api.igdb.com/signup")),
                           optionsWidget());
   al->setOpenExternalLinks(true);
   al->setWordWrap(true);
   ++row;
   l->addWidget(al, row, 0, 1, 2);
   // richtext gets weird with size
   al->setMinimumWidth(al->sizeHint().width());
 
   QLabel* label = new QLabel(i18n("Access key: "), optionsWidget());
   l->addWidget(label, ++row, 0);
 
   m_apiKeyEdit = new QLineEdit(optionsWidget());
-  connect(m_apiKeyEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_apiKeyEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_apiKeyEdit, row, 1);
   label->setBuddy(m_apiKeyEdit);
 
   l->setRowStretch(++row, 10);
 
   // now add additional fields widget
   addFieldsWidget(IGDBFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 
   // don't show the default API key
   if(fetcher_ && fetcher_->m_apiKey != Tellico::reverseObfuscate(IGDB_MAGIC_TOKEN)) {
     m_apiKeyEdit->setText(fetcher_->m_apiKey);
   }
 }
 
 void IGDBFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   const QString apiKey = m_apiKeyEdit->text().trimmed();
   if(!apiKey.isEmpty()) {
     config_.writeEntry("APIv3 Key", apiKey);
   }
 }
 
 QString IGDBFetcher::ConfigWidget::preferredName() const {
   return IGDBFetcher::defaultName();
 }
diff --git a/src/fetch/imdbfetcher.cpp b/src/fetch/imdbfetcher.cpp
index 1ce53264..ba31dfae 100644
--- a/src/fetch/imdbfetcher.cpp
+++ b/src/fetch/imdbfetcher.cpp
@@ -1,1557 +1,1558 @@
 /***************************************************************************
     Copyright (C) 2004-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "imdbfetcher.h"
 #include "../utils/guiproxy.h"
 #include "../collections/videocollection.h"
 #include "../entry.h"
 #include "../field.h"
 #include "../fieldformat.h"
 #include "../core/filehandler.h"
 #include "../images/imagefactory.h"
 #include "../utils/string_utils.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KIO/Job>
 #include <KJobUiDelegate>
 #include <KAcceleratorManager>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QSpinBox>
 #include <QRegExp>
 #include <QFile>
 #include <QMap>
 #include <QLabel>
 #include <QCheckBox>
 #include <QGroupBox>
 #include <QGridLayout>
 #include <QUrlQuery>
 
 namespace {
   static const uint IMDB_MAX_RESULTS = 20;
 }
 
 using namespace Tellico;
 using Tellico::Fetch::IMDBFetcher;
 
 QRegExp* IMDBFetcher::s_tagRx = nullptr;
 QRegExp* IMDBFetcher::s_anchorRx = nullptr;
 QRegExp* IMDBFetcher::s_anchorTitleRx = nullptr;
 QRegExp* IMDBFetcher::s_anchorNameRx = nullptr;
 QRegExp* IMDBFetcher::s_titleRx = nullptr;
 
 // static
 void IMDBFetcher::initRegExps() {
   s_tagRx = new QRegExp(QStringLiteral("<.*>"));
   s_tagRx->setMinimal(true);
 
   s_anchorRx = new QRegExp(QStringLiteral("<a\\s+[^>]*href\\s*=\\s*\"([^\"]+)\"[^<]*>([^<]+)</a>"), Qt::CaseInsensitive);
   s_anchorRx->setMinimal(true);
 
   s_anchorTitleRx = new QRegExp(QStringLiteral("<a\\s+[^>]*href\\s*=\\s*\"([^\"]*/title/[^\"]*)\"[^<]*>([^<]*)</a>"), Qt::CaseInsensitive);
   s_anchorTitleRx->setMinimal(true);
 
   s_anchorNameRx = new QRegExp(QStringLiteral("<a\\s+[^>]*href\\s*=\\s*\"([^\"]*/name/[^\"]*)\"[^<]*>(.+)</a>"), Qt::CaseInsensitive);
   s_anchorNameRx->setMinimal(true);
 
   s_titleRx = new QRegExp(QStringLiteral("<title>(.*)</title>"), Qt::CaseInsensitive);
   s_titleRx->setMinimal(true);
 }
 
 // static
 const IMDBFetcher::LangData& IMDBFetcher::langData(int lang_) {
   Q_ASSERT(lang_ >= 0);
   Q_ASSERT(lang_ <  6);
   static LangData dataVector[6] = {
     {
       i18n("Internet Movie Database"),
       QStringLiteral("www.imdb.com"),
       QStringLiteral("findSectionHeader"),
       QStringLiteral("Exact Matches"),
       QStringLiteral("Partial Matches"),
       QStringLiteral("Approx Matches"),
       QStringLiteral("findSectionHeader"),
       QStringLiteral("Other Results"),
       QStringLiteral("aka"),
       QStringLiteral("Directed by"),
       QStringLiteral("Written by"),
       QStringLiteral("Produced by"),
       QStringLiteral("runtime.*(\\d+)\\s+min"),
       QStringLiteral("aspect ratio"),
       QStringLiteral("also known as"),
       QStringLiteral("Production Co"),
       QStringLiteral("cast"),
       QStringLiteral("cast overview"),
       QStringLiteral("credited cast"),
       QStringLiteral("episodes"),
       QStringLiteral("Genre"),
       QStringLiteral("Sound"),
       QStringLiteral("Color"),
       QStringLiteral("Language"),
       QStringLiteral("Certification"),
       QStringLiteral("Country"),
       QStringLiteral("plot\\s+(outline|summary)(?!/)")
     }, {
       i18n("Internet Movie Database (French)"),
       QStringLiteral("www.imdb.fr"),
       QStringLiteral("findSectionHeader"),
       QStringLiteral("Résultats Exacts"),
       QStringLiteral("Résultats Partiels"),
       QStringLiteral("Résultats Approximatif"),
       QStringLiteral("findSectionHeader"),
       QStringLiteral("Résultats Autres"),
       QStringLiteral("autre titre"),
       QStringLiteral("Réalisateur"),
       QStringLiteral("Scénarist"),
       QString(),
       QStringLiteral("Durée.*(\\d+)\\s+min"),
       QStringLiteral("Format"),
       QStringLiteral("Alias"),
       QStringLiteral("Sociétés de Production"),
       QStringLiteral("Ensemble"),
       QStringLiteral("cast overview"), // couldn't get phrase
       QStringLiteral("credited cast"), // couldn't get phrase
       QStringLiteral("episodes"),
       QStringLiteral("Genre"),
       QStringLiteral("Son"),
       QStringLiteral("Couleur"),
       QStringLiteral("Langue"),
       QStringLiteral("Classification"),
       QStringLiteral("Pays"),
       QStringLiteral("Intrigue\\s*")
     }, {
       i18n("Internet Movie Database (Spanish)"),
       QStringLiteral("www.imdb.es"),
       QStringLiteral("findSectionHeader"),
       QStringLiteral("Resultados Exactos"),
       QStringLiteral("Resultados Parciales"),
       QStringLiteral("Resultados Aproximados"),
       QStringLiteral("findSectionHeader"),
       QStringLiteral("Resultados Otros"),
       QStringLiteral("otro título"),
       QStringLiteral("Director"),
       QStringLiteral("Escritores"),
       QString(),
       QStringLiteral("Duración.*(\\d+)\\s+min"),
       QStringLiteral("Relación de Aspecto"),
       QStringLiteral("Conocido como"),
       QStringLiteral("Compañías Productores"),
       QStringLiteral("Reparto"),
       QStringLiteral("cast overview"), // couldn't get phrase
       QStringLiteral("credited cast"), // couldn't get phrase
       QStringLiteral("episodes"),
       QStringLiteral("Género"),
       QStringLiteral("Sonido"),
       QStringLiteral("Color"),
       QStringLiteral("Idioma"),
       QStringLiteral("Clasificación"),
       QStringLiteral("País"),
       QStringLiteral("Trama\\s*")
     }, {
       i18n("Internet Movie Database (German)"),
       QStringLiteral("www.imdb.de"),
       QStringLiteral("findSectionHeader"),
       QStringLiteral("genaue Übereinstimmung"),
       QStringLiteral("teilweise Übereinstimmung"),
       QStringLiteral("näherungsweise Übereinstimmung"),
       QStringLiteral("findSectionHeader"),
       QStringLiteral("andere Übereinstimmung"),
       QStringLiteral("andere titel"),
       QStringLiteral("Regisseur"),
       QStringLiteral("Drehbuchautoren"),
       QString(),
       QStringLiteral("Länge.*(\\d+)\\s+min"),
       QStringLiteral("Seitenverhältnis"),
       QStringLiteral("Auch bekannt als"),
       QStringLiteral("Produktionsfirmen"),
       QStringLiteral("Besetzung"),
       QStringLiteral("cast overview"), // couldn't get phrase
       QStringLiteral("credited cast"), // couldn't get phrase
       QStringLiteral("episodes"),
       QStringLiteral("Genre"),
       QStringLiteral("Tonverfahren"),
       QStringLiteral("Farbe"),
       QStringLiteral("Sprache"),
       QStringLiteral("Altersfreigabe"),
       QStringLiteral("Land"),
       QStringLiteral("Handlung\\s*")
     }, {
       i18n("Internet Movie Database (Italian)"),
       QStringLiteral("www.imdb.it"),
       QStringLiteral("findSectionHeader"),
       QStringLiteral("risultati esatti"),
       QStringLiteral("risultati parziali"),
       QStringLiteral("risultati approssimati"),
       QStringLiteral("findSectionHeader"),
       QStringLiteral("Resultados Otros"),
       QStringLiteral("otro título"),
       QStringLiteral("Regista"),
       QStringLiteral("Sceneggiatori"),
       QString(),
       QStringLiteral("Durata.*(\\d+)\\s+min"),
       QStringLiteral("Aspect Ratio"),
       QStringLiteral("Alias"),
       QStringLiteral("Società di produzione"),
       QStringLiteral("Cast"),
       QStringLiteral("cast overview"), // couldn't get phrase
       QStringLiteral("credited cast"), // couldn't get phrase
       QStringLiteral("episodes"),
       QStringLiteral("Genere"),
       QStringLiteral("Sonoro"),
       QStringLiteral("Colore"),
       QStringLiteral("Lingua"),
       QStringLiteral("Divieti"),
       QStringLiteral("Nazionalità"),
       QStringLiteral("Trama\\s*")
     }, {
       i18n("Internet Movie Database (Portuguese)"),
       QStringLiteral("www.imdb.pt"),
       QStringLiteral("findSectionHeader"),
       QStringLiteral("Exato"),
       QStringLiteral("Combinação Parcial"),
       QStringLiteral("Combinação Aproximada"),
       QStringLiteral("findSectionHeader"),
       QStringLiteral("Combinação Otros"),
       QStringLiteral("otro título"),
       QStringLiteral("Diretor"),
       QStringLiteral("Escritores"),
       QString(),
       QStringLiteral("Duração.*(\\d+)\\s+min"),
       QStringLiteral("Resolução"),
       QStringLiteral("Também Conhecido Como"),
       QStringLiteral("Companhias de Produção"),
       QStringLiteral("Elenco"),
       QStringLiteral("cast overview"), // couldn't get phrase
       QStringLiteral("credited cast"), // couldn't get phrase
       QStringLiteral("episodes"),
       QStringLiteral("Gênero"),
       QStringLiteral("Mixagem de Som"),
       QStringLiteral("Cor"),
       QStringLiteral("Lingua"),
       QStringLiteral("Certificação"),
       QStringLiteral("País"),
       QStringLiteral("Argumento\\s*")
     }
   };
 
   return dataVector[qBound(0, lang_, static_cast<int>(sizeof(dataVector)/sizeof(LangData)))];
 }
 
 IMDBFetcher::IMDBFetcher(QObject* parent_) : Fetcher(parent_),
     m_job(nullptr), m_started(false), m_fetchImages(true),
     m_numCast(10), m_redirected(false), m_limit(IMDB_MAX_RESULTS), m_lang(EN),
     m_currentTitleBlock(Unknown), m_countOffset(0) {
   if(!s_tagRx) {
     initRegExps();
   }
   m_host = langData(m_lang).siteHost;
 }
 
 IMDBFetcher::~IMDBFetcher() {
 }
 
 QString IMDBFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool IMDBFetcher::canFetch(int type) const {
   return type == Data::Collection::Video;
 }
 
 // imdb can search title only
 bool IMDBFetcher::canSearch(FetchKey k) const {
   return k == Title;
 }
 
 void IMDBFetcher::readConfigHook(const KConfigGroup& config_) {
   /*
   const int lang = config_.readEntry("Lang", int(EN));
   m_lang = static_cast<Lang>(lang);
   */
   if(m_name.isEmpty()) {
     m_name = langData(m_lang).siteTitle;
   }
   QString h = config_.readEntry("Host");
   if(h.isEmpty()) {
     m_host = langData(m_lang).siteHost;
   } else {
     m_host = h;
   }
   m_numCast = config_.readEntry("Max Cast", 10);
   m_fetchImages = config_.readEntry("Fetch Images", true);
 }
 
 // multiple values not supported
 void IMDBFetcher::search() {
   m_started = true;
   m_redirected = false;
 
   m_matches.clear();
   m_popularTitles.clear();
   m_exactTitles.clear();
   m_partialTitles.clear();
   m_currentTitleBlock = Unknown;
   m_countOffset = 0;
 
   m_url = QUrl();
   m_url.setScheme(QStringLiteral("https"));
   m_url.setHost(m_host);
   m_url.setPath(QStringLiteral("/find"));
 
   // as far as I can tell, the url encoding should always be iso-8859-1?
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("q"), request().value);
 
   switch(request().key) {
     case Title:
       q.addQueryItem(QStringLiteral("s"), QStringLiteral("tt"));
       m_url.setQuery(q);
       break;
 
     case Raw:
       m_url = QUrl(request().value);
       break;
 
     default:
       myWarning() << "not supported:" << request().key;
       stop();
       return;
   }
 //  myDebug() << m_url;
 
   m_job = KIO::storedGet(m_url, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)),
-          SLOT(slotComplete(KJob*)));
-  connect(m_job, SIGNAL(redirection(KIO::Job*, QUrl)),
-          SLOT(slotRedirection(KIO::Job*, QUrl)));
+  connect(m_job.data(), &KJob::result,
+          this, &IMDBFetcher::slotComplete);
+  connect(m_job.data(), &KIO::TransferJob::redirection,
+          this, &IMDBFetcher::slotRedirection);
 }
 
 void IMDBFetcher::continueSearch() {
   m_started = true;
   m_limit += IMDB_MAX_RESULTS;
 
   if(m_currentTitleBlock == Popular) {
     parseTitleBlock(m_popularTitles);
     // if the offset is 0, then we need to be looking at the next block
     m_currentTitleBlock = m_countOffset == 0 ? Exact : Popular;
   }
 
   // current title block might have changed
   if(m_currentTitleBlock == Exact) {
     parseTitleBlock(m_exactTitles);
     m_currentTitleBlock = m_countOffset == 0 ? Partial : Exact;
   }
 
   if(m_currentTitleBlock == Partial) {
     parseTitleBlock(m_partialTitles);
     m_currentTitleBlock = m_countOffset == 0 ? Approx : Partial;
   }
 
   if(m_currentTitleBlock == Approx) {
     parseTitleBlock(m_approxTitles);
     m_currentTitleBlock = m_countOffset == 0 ? Unknown : Approx;
   }
 
   stop();
 }
 
 void IMDBFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
 
   m_started = false;
   m_redirected = false;
 
   emit signalDone(this);
 }
 
 void IMDBFetcher::slotRedirection(KIO::Job*, const QUrl& toURL_) {
   m_url = toURL_;
   if(m_url.path().contains(QRegExp(QStringLiteral("/tt\\d+/$"))))  {
     m_url.setPath(m_url.path() + QStringLiteral("reference"));
   }
   m_redirected = true;
 }
 
 void IMDBFetcher::slotComplete(KJob*) {
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   m_text = Tellico::fromHtmlData(m_job->data(), "UTF-8");
   if(m_text.isEmpty()) {
     myLog() << "No data returned";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from imdbfetcher.cpp for /tmp/testimdbresults.html";
   QFile f(QString::fromLatin1("/tmp/testimdbresults.html"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << m_text;
   }
   f.close();
 #endif
 
   // a single result was found if we got redirected
   switch(request().key) {
     case Title:
       if(m_redirected) {
         parseSingleTitleResult();
       } else {
         parseMultipleTitleResults();
       }
       break;
 
     case Raw:
       parseSingleTitleResult();
       break;
 
     default:
       myWarning() << "skipping results";
       break;
   }
 }
 
 void IMDBFetcher::parseSingleTitleResult() {
   s_titleRx->indexIn(Tellico::decodeHTML(m_text));
   // split title at parenthesis
   const QString cap1 = s_titleRx->cap(1);
   int pPos = cap1.indexOf(QLatin1Char('('));
   // FIXME: maybe remove parentheses here?
   FetchResult* r = new FetchResult(Fetcher::Ptr(this),
                                    pPos == -1 ? cap1 : cap1.left(pPos),
                                    pPos == -1 ? QString() : cap1.mid(pPos));
   // IMDB returns different HTML for single title results and has a query in the url
   // clear the query so we download the "canonical" page for the title
   QUrl url(m_url);
   url.setQuery(QString());
   m_matches.insert(r->uid, url);
   m_allMatches.insert(r->uid, url);
   emit signalResultFound(r);
 
   m_hasMoreResults = false;
   stop();
 }
 
 void IMDBFetcher::parseMultipleTitleResults() {
   QString output = Tellico::decodeHTML(m_text);
 
   const LangData& data = langData(m_lang);
   // IMDb can return three title lists, popular, exact, and partial
   // the popular titles are in the first table
   int pos_popular = output.indexOf(data.title_popular, 0,                    Qt::CaseInsensitive);
   int pos_exact   = output.indexOf(data.match_exact,   qMax(pos_popular, 0), Qt::CaseInsensitive);
   int pos_partial = output.indexOf(data.match_partial, qMax(pos_exact,   0), Qt::CaseInsensitive);
   int pos_approx  = output.indexOf(data.match_approx,  qMax(pos_partial, 0), Qt::CaseInsensitive);
 
   int end_popular = pos_exact; // keep track of where to end
   if(end_popular == -1) {
     end_popular = pos_partial == -1 ? (pos_approx == -1 ? output.length() : pos_approx) : pos_partial;
   }
   int end_exact = pos_partial; // keep track of where to end
   if(end_exact == -1) {
     end_exact = pos_approx == -1 ? output.length() : pos_approx;
   }
   int end_partial = pos_approx; // keep track of where to end
   if(end_partial == -1) {
     end_partial = output.length();
   }
 
   // if found popular matches
   if(pos_popular > -1) {
     m_popularTitles = output.mid(pos_popular, end_popular-pos_popular);
   }
   // if found exact matches
   if(pos_exact > -1) {
     m_exactTitles = output.mid(pos_exact, end_exact-pos_exact);
   }
   if(pos_partial > -1) {
     m_partialTitles = output.mid(pos_partial, end_partial-pos_partial);
   }
   if(pos_approx > -1) {
     m_approxTitles = output.mid(pos_approx);
   }
 
   parseTitleBlock(m_popularTitles);
   // if the offset is 0, then we need to be looking at the next block
   m_currentTitleBlock = m_countOffset == 0 ? Exact : Popular;
 
   if(m_matches.size() < m_limit) {
     parseTitleBlock(m_exactTitles);
     m_currentTitleBlock = m_countOffset == 0 ? Partial : Exact;
   }
 
   if(m_matches.size() < m_limit) {
     parseTitleBlock(m_partialTitles);
     m_currentTitleBlock = m_countOffset == 0 ? Approx : Partial;
   }
 
   if(m_matches.size() < m_limit) {
     parseTitleBlock(m_approxTitles);
     m_currentTitleBlock = m_countOffset == 0 ? Unknown : Approx;
   }
 
   if(m_matches.size() == 0) {
     myLog() << "no matches found.";
   }
 
   stop();
 }
 
 void IMDBFetcher::parseTitleBlock(const QString& str_) {
   if(str_.isEmpty()) {
     m_countOffset = 0;
     return;
   }
 
   QRegExp akaRx(QStringLiteral("%1 (.*)(</li>|</td>|<br)").arg(langData(m_lang).aka), Qt::CaseInsensitive);
   akaRx.setMinimal(true);
 
   m_hasMoreResults = false;
 
   int count = 0;
   int start = s_anchorTitleRx->indexIn(str_);
   while(m_started && start > -1) {
     // split title at parenthesis
     const QString cap1 = s_anchorTitleRx->cap(1); // the anchor url
     const QString cap2 = s_anchorTitleRx->cap(2).trimmed(); // the anchor text
     start += s_anchorTitleRx->matchedLength();
     int pPos = cap2.indexOf(QLatin1Char('(')); // if it has parentheses, use that for description
     QString desc;
     if(pPos > -1) {
       int pPos2 = cap2.indexOf(QLatin1Char(')'), pPos+1);
       if(pPos2 > -1) {
         desc = cap2.mid(pPos+1, pPos2-pPos-1);
       }
     } else {
       // parenthesis might be outside anchor tag
       int end = s_anchorTitleRx->indexIn(str_, start);
       if(end == -1) {
         end = str_.length();
       }
       const QString text = str_.mid(start, end-start);
       pPos = text.indexOf(QLatin1Char('('));
       if(pPos > -1) {
         const int pNewLine = text.indexOf(QStringLiteral("<br"));
         if(pNewLine == -1 || pPos < pNewLine) {
           const int pPos2 = text.indexOf(QLatin1Char(')'), pPos);
           desc = text.mid(pPos+1, pPos2-pPos-1);
         }
         // IMDB occasionally has (I) in results. If so, continue parsing string
         if(desc == QStringLiteral("I") || desc == QStringLiteral("II")) {
           pPos = text.indexOf(QLatin1Char('('), pPos+1);
           if(pPos > -1 && (pNewLine == -1 || pPos < pNewLine)) {
             const int pPos2 = text.indexOf(QLatin1Char(')'), pPos);
             desc = text.mid(pPos+1, pPos2-pPos-1);
           }
         }
         pPos = -1;
       }
     }
     // multiple matches might have 'aka' info
     int end = s_anchorTitleRx->indexIn(str_, start+1);
     if(end == -1) {
       end = str_.length();
     }
     int akaPos = akaRx.indexIn(str_, start+1);
     if(akaPos > -1 && akaPos < end) {
       // limit to 50 chars
       desc += QLatin1Char(' ') + akaRx.cap(1).trimmed().remove(*s_tagRx);
       if(desc.length() > 50) {
         desc = desc.left(50) + QStringLiteral("...");
       }
     }
 
     start = s_anchorTitleRx->indexIn(str_, start);
 
     if(count < m_countOffset) {
       ++count;
       continue;
     }
 
     // if we got this far, then there is a valid result
     if(m_matches.size() >= m_limit) {
       m_hasMoreResults = true;
       break;
     }
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), pPos == -1 ? cap2 : cap2.left(pPos), desc);
     QUrl u = QUrl(m_url).resolved(QUrl(cap1));
     u.setQuery(QString());
     m_matches.insert(r->uid, u);
     m_allMatches.insert(r->uid, u);
     emit signalResultFound(r);
     ++count;
   }
   if(!m_hasMoreResults && m_currentTitleBlock != Partial) {
     m_hasMoreResults = true;
   }
   m_countOffset = m_matches.size() < m_limit ? 0 : count;
 }
 
 Tellico::Data::EntryPtr IMDBFetcher::fetchEntryHook(uint uid_) {
   // if we already grabbed this one, then just pull it out of the dict
   Data::EntryPtr entry = m_entries[uid_];
   if(entry) {
     return entry;
   }
 
   if(!m_matches.contains(uid_) && !m_allMatches.contains(uid_)) {
     myLog() << "no url found";
     return Data::EntryPtr();
   }
   QUrl url = m_matches.contains(uid_) ? m_matches[uid_]
                                       : m_allMatches[uid_];
   if(url.path().contains(QRegExp(QStringLiteral("/tt\\d+/$"))))  {
     url.setPath(url.path() + QStringLiteral("reference"));
   }
 
   QUrl origURL = m_url; // keep to switch back
   QString results;
   // if the url matches the current one, no need to redownload it
   if(url == m_url) {
 //    myDebug() << "matches previous URL, no downloading needed.";
     results = Tellico::decodeHTML(m_text);
   } else {
     // now it's synchronous
     // be quiet about failure
     results = Tellico::fromHtmlData(FileHandler::readDataFile(url, true), "UTF-8");
     m_url = url; // needed for processing
 #if 0
     myWarning() << "Remove debug from imdbfetcher.cpp for /tmp/testimdbresult.html";
     myDebug() << m_url;
     QFile f(QStringLiteral("/tmp/testimdbresult.html"));
     if(f.open(QIODevice::WriteOnly)) {
       QTextStream t(&f);
       t << results;
     }
     f.close();
 #endif
     results = Tellico::decodeHTML(results);
   }
   if(results.isEmpty()) {
     myLog() << "no text results";
     m_url = origURL;
     return Data::EntryPtr();
   }
 
   entry = parseEntry(results);
   m_url = origURL;
   if(!entry) {
     myDebug() << "error in processing entry";
     return Data::EntryPtr();
   }
   m_entries.insert(uid_, entry); // keep for later
   return entry;
 }
 
 Tellico::Data::EntryPtr IMDBFetcher::parseEntry(const QString& str_) {
   Data::CollPtr coll(new Data::VideoCollection(true));
   Data::EntryPtr entry(new Data::Entry(coll));
 
   doTitle(str_, entry);
   doRunningTime(str_, entry);
   doAspectRatio(str_, entry);
   doAlsoKnownAs(str_, entry);
   doPlot(str_, entry, m_url);
   if(m_lang == EN) {
     doLists(str_, entry);
   } else {
     doLists2(str_, entry);
   }
   doStudio(str_, entry);
   doPerson(str_, entry, langData(m_lang).director, QStringLiteral("director"));
   doPerson(str_, entry, langData(m_lang).writer, QStringLiteral("writer"));
   doRating(str_, entry);
   doCast(str_, entry, m_url);
   if(m_fetchImages) {
     // needs base URL
     doCover(str_, entry, m_url);
   }
 
   const QString imdb = QStringLiteral("imdb");
   if(!coll->hasField(imdb) && optionalFields().contains(imdb)) {
     Data::FieldPtr field(new Data::Field(imdb, i18n("IMDb Link"), Data::Field::URL));
     field->setCategory(i18n("General"));
     coll->addField(field);
   }
   if(coll->hasField(imdb) && coll->fieldByName(imdb)->type() == Data::Field::URL) {
     m_url.setQuery(QString());
     // we want to strip the "/reference" from the url
     QString url = m_url.url();
     if(url.endsWith(QStringLiteral("/reference"))) {
       url = m_url.adjusted(QUrl::RemoveFilename).url();
     }
     entry->setField(imdb, url);
   }
   return entry;
 }
 
 void IMDBFetcher::doTitle(const QString& str_, Tellico::Data::EntryPtr entry_) {
   if(s_titleRx->indexIn(str_) > -1) {
     const QString cap1 = s_titleRx->cap(1);
     // titles always have parentheses
     int pPos = cap1.indexOf(QLatin1Char('('));
     QString title = cap1.left(pPos).trimmed();
     // remove first and last quotes is there
     if(title.startsWith(QLatin1Char('"')) && title.endsWith(QLatin1Char('"'))) {
       title = title.mid(1, title.length()-2);
     }
     entry_->setField(QStringLiteral("title"), title);
 
     // now for movies with original non-english titles, the <title> is english
     // but the page header is the original title. Grab the orig title
     QRegExp h3TitleRx(QStringLiteral("<h3[^>]+itemprop=\"name\"\\s*>(.*)<"), Qt::CaseInsensitive);
     h3TitleRx.setMinimal(true);
     if(h3TitleRx.indexIn(str_) > -1) {
       const QString h3Title = h3TitleRx.cap(1).trimmed();
       if(h3Title != title) {
         // mis-matching titles. If the user has requested original title,
         // put it in origtitle field and keep english as title
         // otherwise replace
         if(optionalFields().contains(QStringLiteral("origtitle"))) {
           Data::FieldPtr f(new Data::Field(QStringLiteral("origtitle"), i18n("Original Title")));
           f->setFormatType(FieldFormat::FormatTitle);
           entry_->collection()->addField(f);
           entry_->setField(QStringLiteral("origtitle"), h3Title);
         } else {
           entry_->setField(QStringLiteral("title"), h3Title);
         }
       }
     }
 
     // remove parentheses and extract year
     int pPos2 = pPos+1;
     while(pPos2 < cap1.length() && cap1[pPos2].isDigit()) {
       ++pPos2;
     }
     QString year = cap1.mid(pPos+1, pPos2-pPos-1);
     if(!year.isEmpty()) {
       entry_->setField(QStringLiteral("year"), year);
     }
   }
 }
 
 void IMDBFetcher::doRunningTime(const QString& str_, Tellico::Data::EntryPtr entry_) {
   // running time
   QRegExp runtimeRx(langData(m_lang).runtime, Qt::CaseInsensitive);
   runtimeRx.setMinimal(true);
 
   if(runtimeRx.indexIn(str_) > -1) {
     entry_->setField(QStringLiteral("running-time"), runtimeRx.cap(1));
   }
 }
 
 void IMDBFetcher::doAspectRatio(const QString& str_, Tellico::Data::EntryPtr entry_) {
   QRegExp rx(QStringLiteral("%1.*([\\d\\.\\,]+\\s*:\\s*[\\d\\.\\,]+)").arg(langData(m_lang).aspect_ratio), Qt::CaseInsensitive);
   rx.setMinimal(true);
 
   if(rx.indexIn(str_) > -1) {
     entry_->setField(QStringLiteral("aspect-ratio"), rx.cap(1).trimmed());
   }
 }
 
 void IMDBFetcher::doAlsoKnownAs(const QString& str_, Tellico::Data::EntryPtr entry_) {
   if(!optionalFields().contains(QStringLiteral("alttitle"))) {
     return;
   }
 
   // match until next b tag
 //  QRegExp akaRx(QStringLiteral("also known as(.*)<b(?:\\s.*)?>"));
   QRegExp akaRx(QStringLiteral("%1(.*)(<a|<span)[>\\s/]").arg(langData(m_lang).also_known_as), Qt::CaseInsensitive);
   akaRx.setMinimal(true);
 
   if(akaRx.indexIn(str_) > -1 && !akaRx.cap(1).isEmpty()) {
     Data::FieldPtr f = entry_->collection()->fieldByName(QStringLiteral("alttitle"));
     if(!f) {
       f = new Data::Field(QStringLiteral("alttitle"), i18n("Alternative Titles"), Data::Field::Table);
       f->setFormatType(FieldFormat::FormatTitle);
       entry_->collection()->addField(f);
     }
 
     // split by </li>
     QStringList list = akaRx.cap(1).split(QStringLiteral("</li>"));
     // lang could be included with [fr]
 //    const QRegExp parRx(QStringLiteral("\\(.+\\)"));
     const QRegExp brackRx(QStringLiteral("\\[\\w+\\]"));
     const QRegExp countryRx(QStringLiteral("\\s*\\(.+\\)\\s*$"));
     QStringList values;
     for(QStringList::Iterator it = list.begin(); it != list.end(); ++it) {
       QString s = *it;
       // sometimes, the word "more" gets linked to the releaseinfo page, check that
       if(s.contains(QStringLiteral("releaseinfo"))) {
         continue;
       }
       s.remove(*s_tagRx);
       s.remove(brackRx);
       // remove country
       s.remove(countryRx);
       s.remove(QLatin1Char('"'));
       s = s.trimmed();
       // the first value ends up being or starting with the colon after "Also known as"
       // I'm too lazy to figure out a better regexp
       if(s.startsWith(QLatin1Char(':'))) {
         s = s.mid(1);
         s = s.trimmed();
       }
       if(!s.isEmpty()) {
         values += s;
       }
     }
     if(!values.isEmpty()) {
       entry_->setField(QStringLiteral("alttitle"), values.join(FieldFormat::rowDelimiterString()));
     }
 //  } else {
 //    myLog() << "'Also Known As' not found";
   }
 }
 
 void IMDBFetcher::doPlot(const QString& str_, Tellico::Data::EntryPtr entry_, const QUrl& baseURL_) {
   // plot summaries provided by users are on a separate page
   // should those be preferred?
 
   bool useUserSummary = false;
 
   // match until next <p> tag
   QString plotRxStr = langData(m_lang).plot + QStringLiteral("(.*)</(p|div|li)");
   QRegExp plotRx(plotRxStr, Qt::CaseInsensitive);
   plotRx.setMinimal(true);
   QRegExp plotURLRx(QStringLiteral("<a\\s+.*href\\s*=\\s*\".*/title/.*/plotsummary\""), Qt::CaseInsensitive);
   plotURLRx.setMinimal(true);
   if(plotRx.indexIn(str_) > -1) {
     QString thisPlot = plotRx.cap(2);
     // if ends with "Written by", remove it. It has an em tag
     thisPlot.remove(QRegExp(QStringLiteral("<em class=\"nobr\".*</em>")));
     thisPlot.remove(*s_tagRx); // remove HTML tags
     thisPlot = thisPlot.simplified();
     // if thisPlot ends with (more) or contains
     // a url that ends with plotsummary, then we'll grab it, otherwise not
     if(plotRx.cap(0).endsWith(QStringLiteral("(more)</")) ||
        plotURLRx.indexIn(plotRx.cap(0)) > -1 ||
        thisPlot.isEmpty()) {
       useUserSummary = true;
     } else {
       entry_->setField(QStringLiteral("plot"), thisPlot);
     }
   } else {
     useUserSummary = true;
   }
 
   if(useUserSummary) {
     QRegExp idRx(QStringLiteral("title/(tt\\d+)"));
     idRx.indexIn(baseURL_.path());
     QUrl plotURL = baseURL_;
     plotURL.setPath(QStringLiteral("/title/") + idRx.cap(1) + QStringLiteral("/plotsummary"));
     // be quiet about failure
     QString plotPage = Tellico::fromHtmlData(FileHandler::readDataFile(plotURL, true), "UTF-8");
 
     if(!plotPage.isEmpty()) {
       QRegExp plotRx(QStringLiteral("id=\"plot-summaries-content\">(.*)</p"));
       plotRx.setMinimal(true);
       QRegExp plotRx2(QStringLiteral("<div\\s+id\\s*=\\s*\"swiki.2.1\">(.*)</d"));
       plotRx2.setMinimal(true);
       QString userPlot;
       if(plotRx.indexIn(plotPage) > -1) {
         userPlot = plotRx.cap(1);
       } else if(plotRx2.indexIn(plotPage) > -1) {
         userPlot = plotRx2.cap(1);
       }
       userPlot.remove(*s_tagRx); // remove HTML tags
       // remove last little "written by", if there
       userPlot.remove(QRegExp(QStringLiteral("\\s*written by.*$"), Qt::CaseInsensitive));
       if(!userPlot.isEmpty()) {
         entry_->setField(QStringLiteral("plot"), Tellico::decodeHTML(userPlot.simplified()));
       }
     }
   }
 //  myDebug() << "Plot:" << entry_->field(QStringLiteral("plot"));
 }
 
 void IMDBFetcher::doStudio(const QString& str_, Tellico::Data::EntryPtr entry_) {
   // match until next opening tag
 //  QRegExp productionRx(langData(m_lang).studio, Qt::CaseInsensitive);
   QRegExp productionRx(langData(m_lang).studio);
   productionRx.setMinimal(true);
 
   QRegExp blackcatRx(QStringLiteral("blackcatheader"), Qt::CaseInsensitive);
   blackcatRx.setMinimal(true);
 
   const int pos1 = str_.indexOf(productionRx);
   if(pos1 == -1) {
 //    myLog() << "No studio found";
     return;
   }
 
   int pos2 = str_.indexOf(blackcatRx, pos1);
   if(pos2 == -1) {
     pos2 = str_.length();
   }
   // stop matching when getting to Distributors
   int pos3 = str_.indexOf(QStringLiteral("Distributors"), pos1);
   if(pos3 > -1 && pos3 < pos2) {
     pos2 = pos3;
   }
 
   const QString text = str_.mid(pos1, pos2-pos1);
   const QString company = QStringLiteral("/company/");
   QStringList studios;
   for(int pos = s_anchorRx->indexIn(text); pos > -1; pos = s_anchorRx->indexIn(text, pos+s_anchorRx->matchedLength())) {
     const QString cap1 = s_anchorRx->cap(1);
     if(cap1.contains(company)) {
       studios += s_anchorRx->cap(2).trimmed();
     }
   }
 
   entry_->setField(QStringLiteral("studio"), studios.join(FieldFormat::delimiterString()));
 }
 
 void IMDBFetcher::doPerson(const QString& str_, Tellico::Data::EntryPtr entry_,
                            const QString& imdbHeader_, const QString& fieldName_) {
   QRegExp br2Rx(QStringLiteral("<br[\\s/]*>\\s*<br[\\s/]*>"), Qt::CaseInsensitive);
   br2Rx.setMinimal(true);
   QRegExp divRx(QStringLiteral("<div\\s[^>]*class\\s*=\\s*\"(?:ipl-header__content|info|txt-block)\"[^>]*>(.*)</table"), Qt::CaseInsensitive);
   divRx.setMinimal(true);
 
   const QString name = QStringLiteral("/name/");
   StringSet people;
   for(int pos = str_.indexOf(divRx); pos > -1; pos = str_.indexOf(divRx, pos+divRx.matchedLength())) {
     const QString infoBlock = divRx.cap(1);
     if(infoBlock.contains(imdbHeader_, Qt::CaseInsensitive)) {
       int pos2 = s_anchorRx->indexIn(infoBlock);
       while(pos2 > -1) {
         if(s_anchorRx->cap(1).contains(name)) {
           people.add(s_anchorRx->cap(2).trimmed());
         }
         pos2 = s_anchorRx->indexIn(infoBlock, pos2+s_anchorRx->matchedLength());
       }
       break;
     }
   }
   if(!people.isEmpty()) {
     entry_->setField(fieldName_, people.toList().join(FieldFormat::delimiterString()));
   }
 }
 
 void IMDBFetcher::doCast(const QString& str_, Tellico::Data::EntryPtr entry_, const QUrl& baseURL_) {
   // the extended cast list is on a separate page
   // that's usually a lot of people
   // but since it can be in billing order, the main actors might not
   // be in the short list
   QRegExp idRx(QStringLiteral("title/(tt\\d+)"));
   idRx.indexIn(baseURL_.path());
   QUrl castURL = baseURL_;
   castURL.setPath(QStringLiteral("/title/") + idRx.cap(1) + QStringLiteral("/fullcredits"));
 
   // be quiet about failure and be sure to translate entities
   const QString castPage = Tellico::decodeHTML(FileHandler::readTextFile(castURL, true));
 #if 0
   myWarning() << "Remove debug from imdbfetcher.cpp (/tmp/testimdbcast.html)";
   QFile f(QString::fromLatin1("/tmp/testimdbcast.html"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t << castPage;
   }
   f.close();
 #endif
 
   const LangData& data = langData(m_lang);
 
   int pos = -1;
   // the text to search, depends on which page is being read
   QString castText = castPage;
   if(castText.isEmpty()) {
     // fall back to short list
     castText = str_;
     pos = castText.indexOf(data.cast1, 0, Qt::CaseInsensitive);
     if(pos == -1) {
       pos = castText.indexOf(data.cast2, 0, Qt::CaseInsensitive);
     }
   } else {
     // first look for anchor
     QRegExp castAnchorRx(QStringLiteral("<a\\s+name\\s*=\\s*\"cast\""), Qt::CaseInsensitive);
     pos = castAnchorRx.indexIn(castText);
     if(pos < 0) {
       QRegExp tableClassRx(QStringLiteral("<table\\s+class\\s*=\\s*\"cast_list\""), Qt::CaseInsensitive);
       pos = tableClassRx.indexIn(castText);
       if(pos < 0) {
         // fragile, the word "cast" appears in the title, but need to find
         // the one right above the actual cast table
         // for TV shows, there's a link on the sidebar for "episodes case"
         // so need to not match that one
         const QString castEnd = data.cast + QStringLiteral("</");
         pos = castText.indexOf(castEnd, 0, Qt::CaseInsensitive);
         if(pos > 9) {
           // back up 9 places
           if(castText.midRef(pos-9, 9).startsWith(data.episodes)) {
             // find next cast list
             pos = castText.indexOf(castEnd, pos+6, Qt::CaseInsensitive);
           }
         }
       }
     }
   }
   if(pos == -1) { // no cast list found
     myLog() << "no cast list found";
     return;
   }
   // loop until closing table tag
   int endPos = castText.indexOf(QStringLiteral("</table"), pos, Qt::CaseInsensitive);
   castText = castText.mid(pos, endPos-pos+1);
 
   QStringList actorList, characterList;
   QRegularExpression tdActorRx(QStringLiteral("<td>.*?<a href=\"/name.+?\".*?>(.+?)</a"),
                                QRegularExpression::DotMatchesEverythingOption);
   QRegularExpression tdCharRx(QStringLiteral("<td class=\"character\">(.+?)</td"),
                               QRegularExpression::DotMatchesEverythingOption);
 
   QRegularExpressionMatchIterator i = tdActorRx.globalMatch(castText);
   while(i.hasNext()) {
     QRegularExpressionMatch match = i.next();
     actorList += match.captured(1).simplified();
   }
   i = tdCharRx.globalMatch(castText);
   while(i.hasNext()) {
     QRegularExpressionMatch match = i.next();
     characterList += match.captured(1).remove(*s_tagRx).simplified();
   }
 
   // sanity check
   while(characterList.length() > actorList.length()) {
     myDebug() << "Too many characters";
     characterList.removeLast();
   }
   while(characterList.length() < actorList.length()) {
     characterList += QString();
   }
 
   QStringList cast;
   cast.reserve(actorList.size());
   for(int i = 0; i < actorList.size(); ++i) {
     cast += actorList.at(i)
           + FieldFormat::columnDelimiterString()
           + characterList.at(i);
     if(cast.count() >= m_numCast) {
       break;
     }
   }
 
   if(cast.isEmpty()) {
     QRegExp tdRx(QStringLiteral("<td[^>]*>(.*)</td>"), Qt::CaseInsensitive);
     tdRx.setMinimal(true);
 
     QRegExp tdActorRx(QStringLiteral("<td\\s+[^>]*itemprop=\"actor\"[^>]*>(.*)</td>"), Qt::CaseInsensitive);
     tdActorRx.setMinimal(true);
 
     QRegExp tdCharRx(QStringLiteral("<td\\s+[^>]*class=\"character\"[^>]*>(.*)</td>"), Qt::CaseInsensitive);
     tdCharRx.setMinimal(true);
 
     pos = tdActorRx.indexIn(castText);
     while(pos > -1 && cast.count() < m_numCast) {
       QString actorText = tdActorRx.cap(1).remove(*s_tagRx).simplified();
       const int pos2 = tdCharRx.indexIn(castText, pos+1);
       if(pos2 > -1) {
         cast += actorText
               + FieldFormat::columnDelimiterString()
               + tdCharRx.cap(1).remove(*s_tagRx).simplified();
       }
       pos = tdActorRx.indexIn(castText, qMax(pos+1, pos2));
     }
   }
 
   if(!cast.isEmpty()) {
     entry_->setField(QStringLiteral("cast"), cast.join(FieldFormat::rowDelimiterString()));
   }
 
   // also do other items from fullcredits page, like producer
   QStringList producers;
   pos = castPage.indexOf(data.producer, 0, Qt::CaseInsensitive);
   if(pos > -1) {
     int endPos = castText.indexOf(QStringLiteral("</table"), pos, Qt::CaseInsensitive);
     if(endPos == -1) {
       endPos = castText.length();
     }
     const QString prodText = castPage.mid(pos, endPos-pos+1);
     QRegExp tdCharRx(QStringLiteral("<td\\s+[^>]*class=\"credit\"[^>]*>(.*)</td>"));
     tdCharRx.setMinimal(true);
 
     pos = s_anchorNameRx->indexIn(prodText);
     while(pos > -1) {
       const int pos2 = tdCharRx.indexIn(prodText, pos+1);
       const QString credit = tdCharRx.cap(1).trimmed();
       if(pos2 > -1 && (credit.startsWith(QStringLiteral("producer")) ||
                        credit.startsWith(QStringLiteral("co-producer")) ||
                        credit.startsWith(QStringLiteral("associate producer")))) {
         producers += s_anchorNameRx->cap(2).trimmed();
       }
       pos = s_anchorNameRx->indexIn(prodText, pos+1);
     }
   }
 
   if(!producers.isEmpty()) {
     entry_->setField(QStringLiteral("producer"), producers.join(FieldFormat::delimiterString()));
   }
 #if 0
   myWarning() << "Remove debug from imdbfetcher.cpp";
   QFile f2(QString::fromLatin1("/tmp/testimdbcast2.html"));
   if(f2.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << producers.join(FieldFormat::delimiterString());
   }
   f2.close();
 #endif
 }
 
 void IMDBFetcher::doRating(const QString& str_, Tellico::Data::EntryPtr entry_) {
   if(!optionalFields().contains(QStringLiteral("imdb-rating"))) {
     return;
   }
 
   QRegExp divRx(QStringLiteral("<div class=\"ipl-rating-star[\\s\"]+>(.*)</div"), Qt::CaseInsensitive);
   divRx.setMinimal(true);
 
   if(divRx.indexIn(str_) > -1) {
     if(!entry_->collection()->hasField(QStringLiteral("imdb-rating"))) {
       Data::FieldPtr f(new Data::Field(QStringLiteral("imdb-rating"), i18n("IMDb Rating"), Data::Field::Rating));
       f->setCategory(i18n("General"));
       f->setProperty(QStringLiteral("maximum"), QStringLiteral("10"));
       entry_->collection()->addField(f);
     }
 
     QString text = divRx.cap(0);
     text.remove(*s_tagRx);
 
     QRegExp ratingRx(QStringLiteral("\\s(\\d+.?\\d*)\\s"));
     if(ratingRx.indexIn(text) > -1) {
       bool ok;
       float value = ratingRx.cap(1).toFloat(&ok);
       if(!ok) {
         value = QLocale().toFloat(ratingRx.cap(1), &ok);
       }
       if(ok) {
         entry_->setField(QStringLiteral("imdb-rating"), QString::number(value));
       }
     }
   }
 }
 
 void IMDBFetcher::doCover(const QString& str_, Tellico::Data::EntryPtr entry_, const QUrl& baseURL_) {
   QRegExp imgRx(QStringLiteral("<img\\s+[^>]*src\\s*=\\s*\"([^\"]*)\"[^>]*>"), Qt::CaseInsensitive);
   imgRx.setMinimal(true);
 
   QRegExp posterRx(QStringLiteral("<a\\s+[^>]*name\\s*=\\s*\"poster\"[^>]*>(.*)</a>"), Qt::CaseInsensitive);
   posterRx.setMinimal(true);
 
   const QString cover = QStringLiteral("cover");
 
   int pos = posterRx.indexIn(str_);
   while(pos > -1) {
     if(posterRx.cap(1).contains(imgRx)) {
       QUrl u = QUrl(baseURL_).resolved(QUrl(imgRx.cap(1)));
       QString id = ImageFactory::addImage(u, true);
       if(!id.isEmpty()) {
         entry_->setField(cover, id);
         return;
       }
     }
     pos = posterRx.indexIn(str_, pos+posterRx.matchedLength());
   }
 
   // <link rel='image_src'
   QRegExp linkRx(QStringLiteral("<link (.*)>"), Qt::CaseInsensitive);
   linkRx.setMinimal(true);
 
   const QString src = QStringLiteral("image_src");
   pos = linkRx.indexIn(str_);
   while(pos > -1) {
     const QString tag = linkRx.cap(1);
     if(tag.contains(src, Qt::CaseInsensitive)) {
       QRegExp hrefRx(QStringLiteral("href=['\"](.*)['\"]"), Qt::CaseInsensitive);
       hrefRx.setMinimal(true);
       if(hrefRx.indexIn(tag) > -1) {
         QUrl u = QUrl(baseURL_).resolved(QUrl(hrefRx.cap(1)));
         // imdb uses amazon media image, where the img src "encodes" requests for image sizing and cropping
         // strip everything after the "@." and add UY64 to limit the max image dimension to 640
         int n = u.url().indexOf(QStringLiteral("@."));
         if(n > -1) {
           const QString newLink = u.url().left(n) + QStringLiteral("@.UY640.jpg");
           const QString id = ImageFactory::addImage(QUrl(newLink), true);
           if(!id.isEmpty()) {
             entry_->setField(cover, id);
             return;
           }
         }
         const QString id = ImageFactory::addImage(u, true);
         if(!id.isEmpty()) {
           entry_->setField(cover, id);
           return;
         }
       }
     }
     pos = linkRx.indexIn(str_, pos+linkRx.matchedLength());
   }
 
   // <img alt="poster"
   posterRx.setPattern(QStringLiteral("<img\\s+[^>]*alt\\s*=\\s*\"poster\"[^>]+src\\s*=\\s*\"([^\"]+)\""));
   pos = posterRx.indexIn(str_);
   if(pos > -1) {
     QUrl u = QUrl(baseURL_).resolved(QUrl(posterRx.cap(1)));
     QString id = ImageFactory::addImage(u, true);
     if(!id.isEmpty()) {
       entry_->setField(cover, id);
       return;
     }
   }
 
   // didn't find the cover, IMDb also used to put "cover" inside the url
   // cover is the img with the "cover" alt text
   pos = imgRx.indexIn(str_);
   while(pos > -1) {
     const QString url = imgRx.cap(0).toLower();
     if(url.contains(cover)) {
       QUrl u = QUrl(baseURL_).resolved(QUrl(imgRx.cap(1)));
       QString id = ImageFactory::addImage(u, true);
       if(!id.isEmpty()) {
         entry_->setField(cover, id);
         return;
       }
     }
     pos = imgRx.indexIn(str_, pos+imgRx.matchedLength());
   }
 }
 
 void IMDBFetcher::doLists2(const QString& str_, Tellico::Data::EntryPtr entry_) {
   QRegExp divInfoRx(QStringLiteral("<div class=\"info\">(.*)</div"), Qt::CaseInsensitive);
   divInfoRx.setMinimal(true);
 
   const LangData& data = langData(m_lang);
 
   QStringList genres, countries, langs, certs, tracks;
   for(int pos = divInfoRx.indexIn(str_); pos > -1; pos = divInfoRx.indexIn(str_, pos+divInfoRx.matchedLength())) {
     const QString text = divInfoRx.cap(1).remove(*s_tagRx);
     const QString tag = text.section(QLatin1Char(':'), 0, 0).simplified();
     QString value = text.section(QLatin1Char(':'), 1, -1).simplified();
     if(tag == data.genre) {
       foreach(const QString& token, value.split(QLatin1Char('|'))) {
         genres << token.trimmed();
       }
     } else if(tag == data.language) {
       foreach(const QString& token, value.split(QRegExp(QLatin1String("[,|]")))) {
         langs << token.trimmed();
       }
     } else if(tag == data.sound) {
       foreach(const QString& token, value.split(QLatin1Char('|'))) {
         tracks << token.trimmed();
       }
     } else if(tag == data.country) {
       countries << value;
     } else if(tag == data.certification) {
       foreach(const QString& token, value.split(QLatin1Char('|'))) {
         certs << token.trimmed();
       }
     } else if(tag == data.color) {
       // cut off any parentheses
       value = value.section(QLatin1Char('('), 0, 0).trimmed();
       // change "black and white" to "black & white"
       value.replace(QStringLiteral("and"), QStringLiteral("&"));
       if(value == data.color) {
         entry_->setField(QStringLiteral("color"), i18n("Color"));
       } else {
         entry_->setField(QStringLiteral("color"), value);
       }
     }
   }
 
   entry_->setField(QStringLiteral("genre"), genres.join(FieldFormat::delimiterString()));
   entry_->setField(QStringLiteral("nationality"), countries.join(FieldFormat::delimiterString()));
   entry_->setField(QStringLiteral("language"), langs.join(FieldFormat::delimiterString()));
   entry_->setField(QStringLiteral("audio-track"), tracks.join(FieldFormat::delimiterString()));
   if(!certs.isEmpty()) {
     // first try to set default certification
     const QStringList& certsAllowed = entry_->collection()->fieldByName(QStringLiteral("certification"))->allowed();
     foreach(const QString& cert, certs) {
       QString country = cert.section(QLatin1Char(':'), 0, 0);
       QString lcert = cert.section(QLatin1Char(':'), 1, 1);
       if(lcert == QStringLiteral("Unrated")) {
         lcert = QLatin1Char('U');
       }
       lcert += QStringLiteral(" (") + country + QLatin1Char(')');
       if(certsAllowed.contains(lcert)) {
         entry_->setField(QStringLiteral("certification"), lcert);
         break;
       }
     }
 
     // now add new field for all certifications
     const QString allc = QStringLiteral("allcertification");
     if(optionalFields().contains(allc)) {
       Data::FieldPtr f = entry_->collection()->fieldByName(allc);
       if(!f) {
         f = new Data::Field(allc, i18n("Certifications"), Data::Field::Table);
         f->setFlags(Data::Field::AllowGrouped);
         entry_->collection()->addField(f);
       }
       entry_->setField(QStringLiteral("allcertification"), certs.join(FieldFormat::rowDelimiterString()));
     }
   }
 }
 
 // look at every anchor tag in the string
 void IMDBFetcher::doLists(const QString& str_, Tellico::Data::EntryPtr entry_) {
   const QString genre = QStringLiteral("/Genres/");
   const QString genre2 = QStringLiteral("/genre/");
   const QString country = QStringLiteral("/country/");
   const QString lang = QStringLiteral("/language/");
   const QString colorInfo = QStringLiteral("colors=");
   const QString cert = QStringLiteral("certificates=");
   const QString soundMix = QStringLiteral("sound_mixes=");
   const QString year = QStringLiteral("/Years/");
 
   // if we reach faqs or user comments, we can stop
   const QString faqs = QStringLiteral("/faq");
   const QString users = QStringLiteral("/user/");
   // IMdb also has links with the word "sections" in them, remove that
   // for genres and nationalities
 
   int startPos = str_.indexOf(QStringLiteral("<div id=\"pagecontent\">"));
   if(startPos == -1) {
     startPos = 0;
   }
 
   QStringList genres, countries, langs, certs, tracks;
   for(int pos = s_anchorRx->indexIn(str_, startPos); pos > -1; pos = s_anchorRx->indexIn(str_, pos+s_anchorRx->matchedLength())) {
     const QString cap1 = s_anchorRx->cap(1);
     if(cap1.contains(genre) || cap1.contains(genre2)) {
       const QString g = s_anchorRx->cap(2);
       if(!g.contains(QStringLiteral(" section"), Qt::CaseInsensitive) &&
          !g.contains(QStringLiteral(" genre"), Qt::CaseInsensitive)) {
         // ignore "Most Popular by Genre"
         genres += g.trimmed();
       }
     } else if(cap1.contains(country)) {
       if(!s_anchorRx->cap(2).contains(QStringLiteral(" section"), Qt::CaseInsensitive)) {
         countries += s_anchorRx->cap(2).trimmed();
       }
     } else if(cap1.contains(lang) && !cap1.contains(QStringLiteral("contribute"))) {
       langs += s_anchorRx->cap(2).trimmed();
     } else if(cap1.contains(colorInfo)) {
       QString value = s_anchorRx->cap(2);
       // cut off any parentheses
       value = value.section(QLatin1Char('('), 0, 0).trimmed();
       // change "black and white" to "black & white"
       value.replace(QStringLiteral("and"), QStringLiteral("&"));
       entry_->setField(QStringLiteral("color"), value.trimmed());
     } else if(cap1.contains(cert)) {
       certs += s_anchorRx->cap(2).trimmed();
     } else if(cap1.contains(soundMix)) {
       tracks += s_anchorRx->cap(2).trimmed();
       // if year field wasn't set before, do it now
     } else if(entry_->field(QStringLiteral("year")).isEmpty() && cap1.contains(year)) {
       entry_->setField(QStringLiteral("year"), s_anchorRx->cap(2).trimmed());
     } else if((cap1.contains(faqs) || cap1.contains(users)) && !genres.isEmpty()) {
       break;
     }
   }
 
   // since we have multiple genre search strings
   genres.removeDuplicates();
 
   entry_->setField(QStringLiteral("genre"), genres.join(FieldFormat::delimiterString()));
   entry_->setField(QStringLiteral("nationality"), countries.join(FieldFormat::delimiterString()));
   entry_->setField(QStringLiteral("language"), langs.join(FieldFormat::delimiterString()));
   entry_->setField(QStringLiteral("audio-track"), tracks.join(FieldFormat::delimiterString()));
   if(!certs.isEmpty()) {
     // first try to set default certification
     const QStringList& certsAllowed = entry_->collection()->fieldByName(QStringLiteral("certification"))->allowed();
     foreach(const QString& cert, certs) {
       QString country = cert.section(QLatin1Char(':'), 0, 0);
       if(country == QStringLiteral("United States")) {
         country = QStringLiteral("USA");
       }
       QString lcert = cert.section(QLatin1Char(':'), 1, 1);
       if(lcert == QStringLiteral("Unrated")) {
         lcert = QLatin1Char('U');
       }
       lcert += QStringLiteral(" (") + country + QLatin1Char(')');
       if(certsAllowed.contains(lcert)) {
         entry_->setField(QStringLiteral("certification"), lcert);
         break;
       }
     }
 
     // now add new field for all certifications
     const QString allc = QStringLiteral("allcertification");
     if(optionalFields().contains(allc)) {
       Data::FieldPtr f = entry_->collection()->fieldByName(allc);
       if(!f) {
         f = new Data::Field(allc, i18n("Certifications"), Data::Field::Table);
         f->setFlags(Data::Field::AllowGrouped);
         entry_->collection()->addField(f);
       }
       entry_->setField(QStringLiteral("allcertification"), certs.join(FieldFormat::rowDelimiterString()));
     }
   }
 }
 
 Tellico::Fetch::FetchRequest IMDBFetcher::updateRequest(Data::EntryPtr entry_) {
   const QString t = entry_->field(QStringLiteral("title"));
   QUrl link = QUrl::fromUserInput(entry_->field(QStringLiteral("imdb")));
 
   if(!link.isEmpty() && link.isValid()) {
     if(link.host() != m_host) {
 //      myLog() << "switching hosts to " << m_host;
       link.setHost(m_host);
     }
     return FetchRequest(Fetch::Raw, link.url());
   }
 
   // optimistically try searching for title and rely on Collection::sameEntry() to figure things out
   if(!t.isEmpty()) {
     return FetchRequest(Fetch::Title, t);
   }
   return FetchRequest();
 }
 
 QString IMDBFetcher::defaultName() {
   return i18n("Internet Movie Database");
 }
 
 QString IMDBFetcher::defaultIcon() {
   return favIcon("https://www.imdb.com");
 }
 
 //static
 Tellico::StringHash IMDBFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("imdb")]             = i18n("IMDb Link");
   hash[QStringLiteral("imdb-rating")]      = i18n("IMDb Rating");
   hash[QStringLiteral("alttitle")]         = i18n("Alternative Titles");
   hash[QStringLiteral("allcertification")] = i18n("Certifications");
   hash[QStringLiteral("origtitle")]        = i18n("Original Title");
   return hash;
 }
 
 Tellico::Fetch::ConfigWidget* IMDBFetcher::configWidget(QWidget* parent_) const {
   return new IMDBFetcher::ConfigWidget(parent_, this);
 }
 
 IMDBFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const IMDBFetcher* fetcher_/*=0*/)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
   /*
   IMDB.fr and others now redirects to imdb.com
   QLabel* label = new QLabel(i18n("Country: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_langCombo = new GUI::ComboBox(optionsWidget());
   m_langCombo->addItem(i18n("United States"), EN);
   m_langCombo->addItem(i18n("France"), FR);
   m_langCombo->addItem(i18n("Spain"), ES);
   m_langCombo->addItem(i18n("Germany"), DE);
   m_langCombo->addItem(i18n("Italy"), IT);
   m_langCombo->addItem(i18n("Portugal"), PT);
   connect(m_langCombo, SIGNAL(activated(int)), SLOT(slotSetModified()));
   connect(m_langCombo, SIGNAL(activated(int)), SLOT(slotSiteChanged()));
   l->addWidget(m_langCombo, row, 1);
   QString w = i18n("The Internet Movie Database provides data from several different localized sites. "
                    "Choose the one you wish to use for this data source.");
   label->setWhatsThis(w);
   m_langCombo->setWhatsThis(w);
   label->setBuddy(m_langCombo);
   */
 
   QLabel* label = new QLabel(i18n("&Maximum cast: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_numCast = new QSpinBox(optionsWidget());
   m_numCast->setMaximum(99);
   m_numCast->setMinimum(0);
   m_numCast->setValue(10);
-  connect(m_numCast, SIGNAL(valueChanged(QString)), SLOT(slotSetModified()));
+  void (QSpinBox::* valueChanged)(const QString&) = &QSpinBox::valueChanged;
+  connect(m_numCast, valueChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_numCast, row, 1);
   QString w = i18n("The list of cast members may include many people. Set the maximum number returned from the search.");
   label->setWhatsThis(w);
   m_numCast->setWhatsThis(w);
   label->setBuddy(m_numCast);
 
   m_fetchImageCheck = new QCheckBox(i18n("Download cover &image"), optionsWidget());
-  connect(m_fetchImageCheck, SIGNAL(clicked()), SLOT(slotSetModified()));
+  connect(m_fetchImageCheck, &QAbstractButton::clicked, this, &ConfigWidget::slotSetModified);
   ++row;
   l->addWidget(m_fetchImageCheck, row, 0, 1, 2);
   w = i18n("The cover image may be downloaded as well. However, too many large images in the "
            "collection may degrade performance.");
   m_fetchImageCheck->setWhatsThis(w);
 
   l->setRowStretch(++row, 10);
 
   // now add additional fields widget
   addFieldsWidget(IMDBFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
   KAcceleratorManager::manage(optionsWidget());
 
   if(fetcher_) {
     // m_langCombo->setCurrentData(fetcher_->m_lang);
     m_numCast->setValue(fetcher_->m_numCast);
     m_fetchImageCheck->setChecked(fetcher_->m_fetchImages);
   } else { //defaults
     // m_langCombo->setCurrentData(EN);
     m_numCast->setValue(10);
     m_fetchImageCheck->setChecked(true);
   }
 }
 
 void IMDBFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   // int n = m_langCombo->currentData().toInt();
   // config_.writeEntry("Lang", n);
   config_.writeEntry("Host", QString()); // clear old host entry
   config_.writeEntry("Max Cast", m_numCast->value());
   config_.writeEntry("Fetch Images", m_fetchImageCheck->isChecked());
 }
 
 QString IMDBFetcher::ConfigWidget::preferredName() const {
   // return IMDBFetcher::langData(m_langCombo->currentData().toInt()).siteTitle;
   return IMDBFetcher::langData(EN).siteTitle;
 }
 
 void IMDBFetcher::ConfigWidget::slotSiteChanged() {
   emit signalName(preferredName());
 }
diff --git a/src/fetch/isbndbfetcher.cpp b/src/fetch/isbndbfetcher.cpp
index 5a505388..4e346488 100644
--- a/src/fetch/isbndbfetcher.cpp
+++ b/src/fetch/isbndbfetcher.cpp
@@ -1,378 +1,378 @@
 /***************************************************************************
     Copyright (C) 2006-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "isbndbfetcher.h"
 #include "../collections/bookcollection.h"
 #include "../images/imagefactory.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KConfigGroup>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QLineEdit>
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QVBoxLayout>
 #include <QTextCodec>
 #include <QJsonDocument>
 #include <QJsonObject>
 
 namespace {
   static const int ISBNDB_MAX_RETURNS_TOTAL = 25;
   static const char* ISBNDB_BASE_URL = "https://api.isbndb.com";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::ISBNdbFetcher;
 
 ISBNdbFetcher::ISBNdbFetcher(QObject* parent_)
     : Fetcher(parent_),
       m_limit(ISBNDB_MAX_RETURNS_TOTAL), m_total(-1), m_numResults(0),
       m_job(nullptr), m_started(false) {
 }
 
 ISBNdbFetcher::~ISBNdbFetcher() {
 }
 
 QString ISBNdbFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool ISBNdbFetcher::canFetch(int type) const {
   return type == Data::Collection::Book || type == Data::Collection::Bibtex;
 }
 
 void ISBNdbFetcher::readConfigHook(const KConfigGroup& config_) {
   QString k = config_.readEntry("API Key");
   if(!k.isEmpty()) {
     m_apiKey = k;
   }
 }
 
 void ISBNdbFetcher::search() {
   m_started = true;
   m_total = -1;
   m_numResults = 0;
 
   doSearch();
 }
 
 void ISBNdbFetcher::continueSearch() {
   m_started = true;
 
   if(m_apiKey.isEmpty()) {
     myDebug() << "empty API key";
     message(i18n("An access key is required to use this data source.")
             + QLatin1Char(' ') +
             i18n("Those values must be entered in the data source settings."), MessageHandler::Error);
     stop();
     return;
   }
 
   doSearch();
 }
 
 void ISBNdbFetcher::doSearch() {
 //  myDebug() << "value = " << value_;
 
   QUrl u(QString::fromLatin1(ISBNDB_BASE_URL));
   switch(request().key) {
     case Title:
       u.setPath(QStringLiteral("/books/") + request().value);
       break;
 
     case Person:
       u.setPath(QStringLiteral("/author/") + request().value);
       break;
 
     case ISBN:
       u.setPath(QStringLiteral("/book/"));
       {
         // can only grab first value
         QString v = request().value.section(QLatin1Char(';'), 0);
         v.remove(QLatin1Char('-'));
         u.setPath(u.path() + v);
       }
       break;
 
     default:
       myWarning() << "key not recognized: " << request().key;
       stop();
       return;
   }
 //  myDebug() << "url: " << u.url();
 
   m_job = isbndbJob(u, m_apiKey);
-  connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result, this, &ISBNdbFetcher::slotComplete);
 }
 
 void ISBNdbFetcher::stop() {
   if(!m_started) {
     return;
   }
 //  myDebug();
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
 
   m_started = false;
   emit signalDone(this);
 }
 
 void ISBNdbFetcher::slotComplete(KJob* job_) {
   KIO::StoredTransferJob* job = static_cast<KIO::StoredTransferJob*>(job_);
 
   if(job->error()) {
     job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   const QByteArray data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from isbndbfetcher.cpp";
   QFile file(QString::fromLatin1("/tmp/test.json"));
   if(file.open(QIODevice::WriteOnly)) {
     QTextStream t(&file);
     t.setCodec("UTF-8");
     t << data;
   }
   file.close();
 #endif
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   QVariantMap result = doc.object().toVariantMap();
   QVariantList resultList;
   if(result.contains(QStringLiteral("book"))) {
     resultList += result.value(QStringLiteral("book"));
     m_total = 1;
   } else if(result.contains(QStringLiteral("books"))) {
     m_total = result.value(QStringLiteral("total")).toInt();
     resultList = result.value(QStringLiteral("books")).toList();
   } else {
     const QString msg = result.value(QStringLiteral("message")).toString();
     myDebug() << "no results:" << msg;
     stop();
     return;
   }
 //  myDebug() << "Total:" << m_total;
 
   Data::CollPtr coll(new Data::BookCollection(true));
 
   int count = 0;
   foreach(const QVariant& result, resultList) {
 //    myDebug() << "found result:" << result;
 
     Data::EntryPtr entry(new Data::Entry(coll));
     populateEntry(entry, result.toMap());
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
     ++count;
     ++m_numResults;
     if(count >= m_limit) {
       break;
     }
   }
 
   stop(); // required
 }
 
 Tellico::Data::EntryPtr ISBNdbFetcher::fetchEntryHook(uint uid_) {
   if(!m_entries.contains(uid_)) {
     myDebug() << "no entry ptr";
     return Data::EntryPtr();
   }
 
   Data::EntryPtr entry = m_entries.value(uid_);
 
   // image might still be a URL
   const QString image_id = entry->field(QStringLiteral("cover"));
   if(image_id.contains(QLatin1Char('/'))) {
     const QString id = ImageFactory::addImage(QUrl::fromUserInput(image_id), true /* quiet */);
     if(id.isEmpty()) {
       message(i18n("The cover image could not be loaded."), MessageHandler::Warning);
     }
     // empty image ID is ok
     entry->setField(QStringLiteral("cover"), id);
   }
 
   return entry;
 }
 
 Tellico::Fetch::FetchRequest ISBNdbFetcher::updateRequest(Data::EntryPtr entry_) {
   QString isbn = entry_->field(QStringLiteral("isbn"));
   if(!isbn.isEmpty()) {
     return FetchRequest(Fetch::ISBN, isbn);
   }
 
   // optimistically try searching for title and rely on Collection::sameEntry() to figure things out
   QString t = entry_->field(QStringLiteral("title"));
   if(!t.isEmpty()) {
     return FetchRequest(Fetch::Title, t);
   }
   return FetchRequest();
 }
 
 void ISBNdbFetcher::populateEntry(Data::EntryPtr entry_, const QVariantMap& resultMap_) {
   entry_->setField(QStringLiteral("title"), mapValue(resultMap_, "title"));
   entry_->setField(QStringLiteral("isbn"), mapValue(resultMap_, "isbn"));
   // "date_published" can be "2008-12-13" or "July 2012"
   QString pubYear = mapValue(resultMap_, "date_published").remove(QRegExp(QStringLiteral("[^\\d]"))).left(4);
   entry_->setField(QStringLiteral("pub_year"), pubYear);
   QStringList authors;
   foreach(const QVariant& author, resultMap_.value(QLatin1String("authors")).toList()) {
     authors += author.toString();
   }
   entry_->setField(QStringLiteral("author"), authors.join(FieldFormat::delimiterString()));
   entry_->setField(QStringLiteral("publisher"), mapValue(resultMap_, "publisher"));
   entry_->setField(QStringLiteral("edition"), mapValue(resultMap_, "edition"));
   QString binding = mapValue(resultMap_, "binding");
   if(binding.isEmpty()) {
     binding = mapValue(resultMap_, "format");
   }
   if(binding.startsWith(QStringLiteral("Hardcover"))) {
     binding = QStringLiteral("Hardback");
   } else if(binding.startsWith(QStringLiteral("Paperback"))) {
     binding = QStringLiteral("Paperback");
   }
   if(!binding.isEmpty()) {
     entry_->setField(QStringLiteral("binding"), i18n(binding.toUtf8().constData()));
   }
   QStringList subjects;
   foreach(const QVariant& subject, resultMap_.value(QLatin1String("subjects")).toList()) {
     subjects += subject.toString();
   }
   entry_->setField(QStringLiteral("genre"), subjects.join(FieldFormat::delimiterString()));
   entry_->setField(QStringLiteral("cover"), mapValue(resultMap_, "image"));
   entry_->setField(QStringLiteral("pages"), mapValue(resultMap_, "pages"));
   entry_->setField(QStringLiteral("language"), mapValue(resultMap_, "language"));
   entry_->setField(QStringLiteral("plot"), mapValue(resultMap_, "overview"));
   if(mapValue(resultMap_, "overview").isEmpty()) {
     entry_->setField(QStringLiteral("plot"), mapValue(resultMap_, "synopsis"));
   }
 
   const QString dewey = mapValue(resultMap_, "dewey_decimal");
   if(!dewey.isEmpty() && optionalFields().contains(QStringLiteral("dewey"))) {
     if(!entry_->collection()->hasField(QStringLiteral("dewey"))) {
       Data::FieldPtr field(new Data::Field(QStringLiteral("dewey"), i18n("Dewey Decimal"), Data::Field::Line));
       field->setCategory(i18n("Publishing"));
       entry_->collection()->addField(field);
     }
     entry_->setField(QStringLiteral("dewey"), dewey);
   }
 }
 
 Tellico::Fetch::ConfigWidget* ISBNdbFetcher::configWidget(QWidget* parent_) const {
   return new ISBNdbFetcher::ConfigWidget(parent_, this);
 }
 
 QString ISBNdbFetcher::defaultName() {
   return i18n("ISBNdb.com");
 }
 
 QString ISBNdbFetcher::defaultIcon() {
   return favIcon("http://isbndb.com");
 }
 
 Tellico::StringHash ISBNdbFetcher::allOptionalFields() {
   // same ones as z3950fetcher
   StringHash hash;
   hash[QStringLiteral("dewey")] = i18nc("Dewey Decimal classification system", "Dewey Decimal");
   return hash;
 }
 
 QPointer<KIO::StoredTransferJob> ISBNdbFetcher::isbndbJob(const QUrl& url_, const QString& apiKey_) {
   QPointer<KIO::StoredTransferJob> job = KIO::storedGet(url_, KIO::NoReload, KIO::HideProgressInfo);
   job->addMetaData(QStringLiteral("customHTTPHeader"), QStringLiteral("X-API-Key: ") + apiKey_);
   job->addMetaData(QStringLiteral("accept"), QStringLiteral("application/json"));
   KJobWidgets::setWindow(job, GUI::Proxy::widget());
   return job;
 }
 
 ISBNdbFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const ISBNdbFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
   QLabel* al = new QLabel(i18n("Registration is required for accessing the %1 data source. "
                                "If you agree to the terms and conditions, <a href='%2'>sign "
                                "up for an account</a>, and enter your information below.",
                                 preferredName(),
                                 QStringLiteral("https://isbndb.com/isbn-database")),
                           optionsWidget());
   al->setOpenExternalLinks(true);
   al->setWordWrap(true);
   ++row;
   l->addWidget(al, row, 0, 1, 2);
   // richtext gets weird with size
   al->setMinimumWidth(al->sizeHint().width());
 
   QLabel* label = new QLabel(i18n("Access key: "), optionsWidget());
   l->addWidget(label, ++row, 0);
 
   m_apiKeyEdit = new QLineEdit(optionsWidget());
-  connect(m_apiKeyEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_apiKeyEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_apiKeyEdit, row, 1);
   label->setBuddy(m_apiKeyEdit);
 
   l->setRowStretch(++row, 10);
 
   if(fetcher_) {
     m_apiKeyEdit->setText(fetcher_->m_apiKey);
   }
 
   // now add additional fields widget
   addFieldsWidget(ISBNdbFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 void ISBNdbFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   QString apiKey = m_apiKeyEdit->text().trimmed();
   if(!apiKey.isEmpty()) {
     config_.writeEntry("API Key", apiKey);
   }
 }
 
 QString ISBNdbFetcher::ConfigWidget::preferredName() const {
   return ISBNdbFetcher::defaultName();
 }
diff --git a/src/fetch/kinofetcher.cpp b/src/fetch/kinofetcher.cpp
index 783111db..d3c81025 100644
--- a/src/fetch/kinofetcher.cpp
+++ b/src/fetch/kinofetcher.cpp
@@ -1,381 +1,381 @@
 /***************************************************************************
     Copyright (C) 2017 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "kinofetcher.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../collections/bookcollection.h"
 #include "../collections/videocollection.h"
 #include "../entry.h"
 #include "../fieldformat.h"
 #include "../core/filehandler.h"
 #include "../images/imagefactory.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfig>
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QRegularExpression>
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QVBoxLayout>
 #include <QUrlQuery>
 #include <QJsonDocument>
 #include <QJsonObject>
 
 namespace {
   static const char* KINO_BASE_URL = "https://www.kino.de/se/";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::KinoFetcher;
 
 KinoFetcher::KinoFetcher(QObject* parent_)
     : Fetcher(parent_), m_started(false) {
 }
 
 KinoFetcher::~KinoFetcher() {
 }
 
 QString KinoFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool KinoFetcher::canFetch(int type) const {
   return type == Data::Collection::Video;
 }
 
 void KinoFetcher::readConfigHook(const KConfigGroup& config_) {
   Q_UNUSED(config_);
 }
 
 void KinoFetcher::search() {
   m_started = true;
   m_matches.clear();
 
   QUrl u(QString::fromLatin1(KINO_BASE_URL));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("sp_search_filter"), QStringLiteral("movie"));
 
   switch(request().key) {
     case Title:
       q.addQueryItem(QStringLiteral("searchterm"), request().value);
       break;
 
     default:
       myWarning() << "key not recognized: " << request().key;
       stop();
       return;
   }
   u.setQuery(q);
 //  myDebug() << "url:" << u;
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)),
-          SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result,
+          this, &KinoFetcher::slotComplete);
 }
 
 void KinoFetcher::stop() {
   if(!m_started) {
     return;
   }
 
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 void KinoFetcher::slotComplete(KJob*) {
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   const QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
 
   // since the fetch is done, don't worry about holding the job pointer
   m_job = nullptr;
 
   QString s = Tellico::decodeHTML(data);
 #if 0
   myWarning() << "Remove debug from kinofetcher.cpp";
   QFile f(QStringLiteral("/tmp/test.html"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << s;
   }
   f.close();
 #endif
 
   QRegularExpression linkRx(QStringLiteral("<span class=\"card-label\">Film.+?<a .+?card-link.+?href=\"(.+?)\".*?>(.+?)</"));
   QRegularExpression dateSpanRx(QStringLiteral("<span .+?movie-startdate.+?>(.+?)</span"));
   QRegularExpression dateRx(QStringLiteral("\\d{2}\\.\\d{2}\\.(\\d{4})"));
   QRegularExpression yearEndRx(QStringLiteral("(\\d{4})/?$"));
 
   QRegularExpressionMatchIterator i = linkRx.globalMatch(s);
   while(i.hasNext()) {
     QRegularExpressionMatch match = i.next();
     QString u = match.captured(1);
     if(u.isEmpty()) {
       continue;
     }
     if(u.startsWith(QLatin1String("//"))) {
       u.prepend(QLatin1String("https:"));
     }
     Data::CollPtr coll(new Data::VideoCollection(true));
     Data::EntryPtr entry(new Data::Entry(coll));
     coll->addEntries(entry);
 
     entry->setField(QStringLiteral("title"), match.captured(2));
 
     QString y;
     QRegularExpressionMatch dateMatch = dateSpanRx.match(s, match.capturedEnd());
     if(dateMatch.hasMatch()) {
       y = dateRx.match(dateMatch.captured(1)).captured(1);
     } else {
       // see if year is embedded in url
       y = yearEndRx.match(u).captured(1);
     }
     entry->setField(QStringLiteral("year"), y);
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     QUrl url = QUrl(QString::fromLatin1(KINO_BASE_URL)).resolved(QUrl(u));
     m_matches.insert(r->uid, url);
     m_entries.insert(r->uid, entry);
     // don't emit signal until after putting url in matches hash
     emit signalResultFound(r);
   }
 
   stop();
 }
 
 Tellico::Data::EntryPtr KinoFetcher::fetchEntryHook(uint uid_) {
   if(!m_entries.contains(uid_)) {
     myWarning() << "no entry in hash";
     return Data::EntryPtr();
   }
 
   Data::EntryPtr entry = m_entries[uid_];
   // if the url is not in the hash, the entry has already been fully populated
   if(!m_matches.contains(uid_)) {
     return entry;
   }
 
   QString results = Tellico::decodeHTML(FileHandler::readTextFile(m_matches[uid_], true, true));
   if(results.isEmpty()) {
     myDebug() << "no text results from" << m_matches[uid_];
     return entry;
   }
 
 #if 0
   myWarning() << "Remove debug from kinofetcher.cpp";
   QFile f(QStringLiteral("/tmp/test2.html"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << results;
   }
   f.close();
 #endif
 
   parseEntry(entry, results);
   // remove url to signal the entry is fully populated
   m_matches.remove(uid_);
   return entry;
 }
 
 void KinoFetcher::parseEntry(Data::EntryPtr entry, const QString& str_) {
   QRegularExpression jsonRx(QStringLiteral("<script type=\"application/ld\\+json\">(.*?)</script"),
                             QRegularExpression::DotMatchesEverythingOption);
   QRegularExpressionMatchIterator i = jsonRx.globalMatch(str_);
   while(i.hasNext()) {
     QJsonDocument doc = QJsonDocument::fromJson(i.next().captured(1).toUtf8());
     QVariantMap objectMap = doc.object().toVariantMap();
     if(mapValue(objectMap, "@type") != QStringLiteral("Movie")) {
       continue;
     }
     entry->setField(QStringLiteral("director"), mapValue(objectMap, "director", "name"));
 
     QStringList actors;
     foreach(QVariant v, objectMap.value(QLatin1String("actor")).toList()) {
       const QString actor = mapValue(v.toMap(), "name");
       if(!actor.isEmpty()) actors += actor;
     }
     if(!actors.isEmpty()) {
       entry->setField(QStringLiteral("cast"), actors.join(FieldFormat::rowDelimiterString()));
     }
     // cover could be a relative link
     QString coverLink = mapValue(objectMap, "image");
     if(coverLink.startsWith(QLatin1String("//"))) {
       coverLink.prepend(QLatin1String("https:"));
     }
     entry->setField(QStringLiteral("cover"), coverLink);
   }
 
   QRegularExpression tagRx(QStringLiteral("<.+?>"));
 
   QRegularExpression nationalityRx(QStringLiteral("<dt>Produktionsland</dt><dd>(.*?)</dd>"));
   QRegularExpressionMatch nationalityMatch = nationalityRx.match(str_);
   if(nationalityMatch.hasMatch()) {
     const QString n = nationalityMatch.captured(1).remove(tagRx);
     entry->setField(QStringLiteral("nationality"), n);
   }
 
   QRegularExpression lengthRx(QStringLiteral("<dt.*?>Dauer</dt><dd.*?>(.*?)</dd>"));
   QRegularExpressionMatch lengthMatch = lengthRx.match(str_);
   if(lengthMatch.hasMatch()) {
     const QString l = lengthMatch.captured(1).remove(tagRx).remove(QStringLiteral(" Min"));
     entry->setField(QStringLiteral("running-time"), l);
   }
 
   QRegularExpression genreRx(QStringLiteral("<dt.*?>Genre</dt><dd.*?>(.*?)</dd>"));
   QRegularExpressionMatch genreMatch = genreRx.match(str_);
   if(genreMatch.hasMatch()) {
     QRegularExpression anchorRx(QStringLiteral("<a.*?>(.*?)</a>"));
     QRegularExpressionMatchIterator i = anchorRx.globalMatch(genreMatch.captured(1));
     QStringList genres;
     while(i.hasNext()) {
       genres += i.next().captured(1).trimmed();
     }
     entry->setField(QStringLiteral("genre"), genres.join(FieldFormat::delimiterString()));
   }
 
   QRegularExpression certRx(QStringLiteral("<dt>FSK</dt><dd>(.*?)</dd>"));
   QRegularExpressionMatch certMatch = certRx.match(str_);
   if(certMatch.hasMatch()) {
     // need to translate? Let's just add FSK ratings to the allowed values
     QStringList allowed = entry->collection()->hasField(QStringLiteral("certification")) ?
                           entry->collection()->fieldByName(QStringLiteral("certification"))->allowed() :
                           QStringList();
     if(!allowed.contains(QStringLiteral("FSK 0 (DE)"))) {
       allowed << QStringLiteral("FSK 0 (DE)")
               << QStringLiteral("FSK 6 (DE)")
               << QStringLiteral("FSK 12 (DE)")
               << QStringLiteral("FSK 16 (DE)")
               << QStringLiteral("FSK 18 (DE)");
       entry->collection()->fieldByName(QStringLiteral("certification"))->setAllowed(allowed);
     }
     QString c = certMatch.captured(1).remove(tagRx);
     if(c == QStringLiteral("ab 0")) {
       c = QStringLiteral("FSK 0 (DE)");
     } else if(c == QLatin1String("ab 6")) {
       c = QStringLiteral("FSK 6 (DE)");
     } else if(c == QLatin1String("ab 12")) {
       c = QStringLiteral("FSK 12 (DE)");
     } else if(c == QLatin1String("ab 16")) {
       c = QStringLiteral("FSK 16 (DE)");
     } else if(c == QLatin1String("ab 18")) {
       c = QStringLiteral("FSK 18 (DE)");
     }
     entry->setField(QStringLiteral("certification"), c);
   }
 
   QRegularExpression studioRx(QStringLiteral("<dt>Filmverleih</dt><dd>(.*?)</dd>"));
   QRegularExpressionMatch studioMatch = studioRx.match(str_);
   if(studioMatch.hasMatch()) {
     QString s = studioMatch.captured(1).remove(tagRx).remove(QStringLiteral(" Min"));
     entry->setField(QStringLiteral("studio"), s);
   }
 
   QRegularExpression plotRx(QStringLiteral("<div class=\"post-body-meta\">\\s*</div>(.*?)<(/section|h2)>"),
                                           QRegularExpression::DotMatchesEverythingOption);
   QRegularExpressionMatch plotMatch = plotRx.match(str_);
   if(plotMatch.hasMatch()) {
     QString plot;
     // sometimes the plot starts with double <p>
     QRegularExpression pRx(QStringLiteral("<p>(?!<p>).*?</p>"));
     QRegularExpressionMatchIterator i = pRx.globalMatch(plotMatch.captured(1));
     while(i.hasNext()) {
       plot += i.next().captured(0);
     }
     entry->setField(QStringLiteral("plot"), plot.trimmed());
   }
 
   QString cover = entry->field(QStringLiteral("cover"));
   if(!cover.isEmpty()) {
     const QString id = ImageFactory::addImage(QUrl::fromUserInput(cover), true /* quiet */);
     if(id.isEmpty()) {
       message(i18n("The cover image could not be loaded."), MessageHandler::Warning);
     }
     // empty image ID is ok
     entry->setField(QStringLiteral("cover"), id);
   }
 }
 
 Tellico::Fetch::FetchRequest KinoFetcher::updateRequest(Data::EntryPtr entry_) {
   QString t = entry_->field(QStringLiteral("title"));
   if(!t.isEmpty()) {
     return FetchRequest(Fetch::Title, t);
   }
   return FetchRequest();
 }
 
 Tellico::Fetch::ConfigWidget* KinoFetcher::configWidget(QWidget* parent_) const {
   return new KinoFetcher::ConfigWidget(parent_, this);
 }
 
 QString KinoFetcher::defaultName() {
   return QStringLiteral("Kino.de");
 }
 
 QString KinoFetcher::defaultIcon() {
   return favIcon("https://www.kino.de");
 }
 
 //static
 Tellico::StringHash KinoFetcher::allOptionalFields() {
   StringHash hash;
   // TODO: add link
 //  hash[QStringLiteral("kino")] = i18n("Kino.de Link");
   return hash;
 }
 
 KinoFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const KinoFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 
   // now add additional fields widget
   addFieldsWidget(KinoFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 QString KinoFetcher::ConfigWidget::preferredName() const {
   return KinoFetcher::defaultName();
 }
diff --git a/src/fetch/kinopoiskfetcher.cpp b/src/fetch/kinopoiskfetcher.cpp
index 9a2b9a99..085c67bf 100644
--- a/src/fetch/kinopoiskfetcher.cpp
+++ b/src/fetch/kinopoiskfetcher.cpp
@@ -1,447 +1,447 @@
 /***************************************************************************
     Copyright (C) 2017 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "kinopoiskfetcher.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../collections/videocollection.h"
 #include "../entry.h"
 #include "../fieldformat.h"
 #include "../core/filehandler.h"
 #include "../images/imagefactory.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KJobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QRegExp>
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QVBoxLayout>
 #include <QUrlQuery>
 
 namespace {
   static const char* KINOPOISK_SEARCH_URL = "http://www.kinopoisk.ru/index.php";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::KinoPoiskFetcher;
 
 KinoPoiskFetcher::KinoPoiskFetcher(QObject* parent_)
     : Fetcher(parent_), m_started(false) {
 }
 
 KinoPoiskFetcher::~KinoPoiskFetcher() {
 }
 
 QString KinoPoiskFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool KinoPoiskFetcher::canFetch(int type) const {
   return type == Data::Collection::Video;
 }
 
 bool KinoPoiskFetcher::canSearch(FetchKey k) const {
   return k == Title;
 }
 
 void KinoPoiskFetcher::readConfigHook(const KConfigGroup& config_) {
   Q_UNUSED(config_);
 }
 
 void KinoPoiskFetcher::search() {
   m_started = true;
   m_matches.clear();
 
   QUrl u(QString::fromLatin1(KINOPOISK_SEARCH_URL));
   QUrlQuery q;
 
   switch(request().key) {
     case Title:
       // first means return first result only
       //q.addQueryItem(QStringLiteral("first"), QStringLiteral("yes"));
       q.addQueryItem(QStringLiteral("kp_query"), request().value);
       break;
 
     default:
       myWarning() << "key not recognized: " << request().key;
       stop();
       return;
   }
   u.setQuery(q);
 //  myDebug() << "url: " << u.url();
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result, this, &KinoPoiskFetcher::slotComplete);
 }
 
 void KinoPoiskFetcher::stop() {
   if(!m_started) {
     return;
   }
 
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 void KinoPoiskFetcher::slotComplete(KJob*) {
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
 
   const QString output = Tellico::decodeHTML(data);
 #if 0
   myWarning() << "Remove debug from kinopoiskfetcher.cpp";
   QFile f(QStringLiteral("/tmp/test1.html"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << output;
   }
   f.close();
 #endif
 
   // look for a paragraph, class=",", with an internal /ink to "/level/1/film..."
   QRegExp resultRx(QStringLiteral("<p class=\"name\">\\s*"
                                   "<a href=\"/level/1/film[^\"]+\".* data-url=\"([^\"]*)\".*>(.*)</a>\\s*"
                                   "<span class=\"year\">(.*)</span"));
   resultRx.setMinimal(true);
 
   QString href, title, year;
   for(int pos = resultRx.indexIn(output); m_started && pos > -1;
           pos = resultRx.indexIn(output, pos+resultRx.matchedLength())) {
     href = resultRx.cap(1);
     title = resultRx.cap(2);
     year = resultRx.cap(3);
     if(!href.isEmpty()) {
       QUrl url(QString::fromLatin1(KINOPOISK_SEARCH_URL));
       url = url.resolved(QUrl(href));
 //      myDebug() << url << title << year;
       FetchResult* r = new FetchResult(Fetcher::Ptr(this), title, year);
       m_matches.insert(r->uid, url);
       emit signalResultFound(r);
     }
   }
 
   // since the fetch is done, don't worry about holding the job pointer
   m_job = nullptr;
   stop();
 }
 
 Tellico::Data::EntryPtr KinoPoiskFetcher::fetchEntryHook(uint uid_) {
   // if we already grabbed this one, then just pull it out of the dict
   Data::EntryPtr entry = m_entries[uid_];
   if(entry) {
     return entry;
   }
 
   QUrl url = m_matches[uid_];
   if(url.isEmpty()) {
     myWarning() << "no url in map";
     return Data::EntryPtr();
   }
 
   const QString results = Tellico::decodeHTML(FileHandler::readDataFile(url, true));
   if(results.isEmpty()) {
     myDebug() << "no text results";
     return Data::EntryPtr();
   }
 
 #if 0
   myDebug() << url.url();
   myWarning() << "Remove debug from kinopoiskfetcher.cpp";
   QFile f(QStringLiteral("/tmp/test2.html"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << results;
   }
   f.close();
 #endif
 
   entry = parseEntry(results);
   if(!entry) {
     myDebug() << "error in processing entry";
     return Data::EntryPtr();
   }
 
   if(optionalFields().contains(QStringLiteral("kinopoisk"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("kinopoisk"), i18n("KinoPoisk Link"), Data::Field::URL));
     field->setCategory(i18n("General"));
     entry->collection()->addField(field);
     entry->setField(QStringLiteral("kinopoisk"), url.url());
   }
 
   m_entries.insert(uid_, entry); // keep for later
   return entry;
 }
 
 Tellico::Data::EntryPtr KinoPoiskFetcher::parseEntry(const QString& str_) {
   Data::CollPtr coll(new Data::VideoCollection(true));
   Data::EntryPtr entry(new Data::Entry(coll));
   coll->addEntries(entry);
 
   QRegExp tagRx(QStringLiteral("<.*>"));
   tagRx.setMinimal(true);
 
   QRegExp anchorRx(QStringLiteral("<a\\s+href=\".*\"[^>]*>(.*)</"));
   anchorRx.setMinimal(true);
 
   QRegExp titleRx(QStringLiteral("class=\"moviename-big\"[^>]*>([^(]+).*</"));
   titleRx.setMinimal(true);
   if(str_.contains(titleRx)) {
     QString t = titleRx.cap(1);
     t.remove(tagRx);
     t = t.simplified();
     entry->setField(QStringLiteral("title"), t);
   }
 
   if(optionalFields().contains(QStringLiteral("origtitle"))) {
     Data::FieldPtr f(new Data::Field(QStringLiteral("origtitle"), i18n("Original Title")));
     f->setFormatType(FieldFormat::FormatTitle);
     coll->addField(f);
 
     QRegExp origTitleRx(QStringLiteral("itemprop=\"alternativeHeadline\"[^>]*>([^<]+)</"));
     if(str_.contains(origTitleRx)) {
       entry->setField(QStringLiteral("origtitle"), origTitleRx.cap(1));
     }
   }
 
   QRegExp yearRx(QStringLiteral("<a href=\"/lists/m_act%5Byear[^\"]+\"[^>]*>([^<]+)</a"));
   if(str_.contains(yearRx)) {
     entry->setField(QStringLiteral("year"), yearRx.cap(1));
   }
 
   QRegExp countryRx(QStringLiteral("<a href=\"/lists/m_act%5Bcountry[^\"]+\"[^>]*>([^<]+)</a"));
   countryRx.setMinimal(true);
   QStringList countries;
   for(int pos = countryRx.indexIn(str_); pos > -1;
           pos = countryRx.indexIn(str_, pos+countryRx.matchedLength())) {
     countries += countryRx.cap(1);
   }
   if(!countries.isEmpty()) {
     countries.removeDuplicates();
     entry->setField(QStringLiteral("nationality"), countries.join(Tellico::FieldFormat::delimiterString()));
   }
 
   QRegExp genreRx(QStringLiteral("<a href=\"/lists/m_act%5Bgenre[^\"]+\"[^>]*>([^<]+)</a"));
   genreRx.setMinimal(true);
   QStringList genres;
   for(int pos = genreRx.indexIn(str_); pos > -1;
           pos = genreRx.indexIn(str_, pos+genreRx.matchedLength())) {
     genres += genreRx.cap(1);
   }
   if(!genres.isEmpty()) {
     genres.removeDuplicates();
     entry->setField(QStringLiteral("genre"), genres.join(Tellico::FieldFormat::delimiterString()));
   }
 
   QRegExp directorRx(QStringLiteral("<td itemprop=\"director\">(.*)</td"));
   directorRx.setMinimal(true);
   if(str_.contains(directorRx)) {
     QString s = directorRx.cap(1);
     QStringList directors;
     for(int pos = anchorRx.indexIn(s); pos > -1;
             pos = anchorRx.indexIn(s, pos+anchorRx.matchedLength())) {
       QString value = anchorRx.cap(1);
       if(value != QStringLiteral("...")) {
         directors += value;
       }
     }
     if(!directors.isEmpty()) {
       entry->setField(QStringLiteral("director"), directors.join(Tellico::FieldFormat::delimiterString()));
     }
   }
 
   QRegExp writerRx(QStringLiteral("<td class=\"type\">сценарий</td>(.*)</td"));
   writerRx.setMinimal(true);
   if(str_.contains(writerRx)) {
     QString s = writerRx.cap(1);
     QStringList writers;
     for(int pos = anchorRx.indexIn(s); pos > -1;
             pos = anchorRx.indexIn(s, pos+anchorRx.matchedLength())) {
       QString value = anchorRx.cap(1);
       if(value != QStringLiteral("...")) {
         writers += value;
       }
     }
     if(!writers.isEmpty()) {
       entry->setField(QStringLiteral("writer"), writers.join(Tellico::FieldFormat::delimiterString()));
     }
   }
 
   QRegExp producerRx(QStringLiteral("<td itemprop=\"producer\">(.*)</td"));
   producerRx.setMinimal(true);
   if(str_.contains(producerRx)) {
     QString s = producerRx.cap(1);
     QStringList producers;
     for(int pos = anchorRx.indexIn(s); pos > -1;
             pos = anchorRx.indexIn(s, pos+anchorRx.matchedLength())) {
       QString value = anchorRx.cap(1);
       if(value != QStringLiteral("...")) {
         producers += value;
       }
     }
     if(!producers.isEmpty()) {
       entry->setField(QStringLiteral("producer"), producers.join(Tellico::FieldFormat::delimiterString()));
     }
   }
 
   QRegExp composerRx(QStringLiteral("<td itemprop=\"musicBy\">(.*)</td"));
   composerRx.setMinimal(true);
   if(str_.contains(composerRx)) {
     QString s = composerRx.cap(1);
     QStringList composers;
     for(int pos = anchorRx.indexIn(s); pos > -1;
             pos = anchorRx.indexIn(s, pos+anchorRx.matchedLength())) {
       QString value = anchorRx.cap(1);
       if(value != QStringLiteral("...")) {
         composers += value;
       }
     }
     if(!composers.isEmpty()) {
       entry->setField(QStringLiteral("composer"), composers.join(Tellico::FieldFormat::delimiterString()));
     }
   }
 
   QRegExp castRx(QStringLiteral("<h4>В главных ролях.*</h4>.*<ul>(.*)</ul>"));
   castRx.setMinimal(true);
   if(str_.contains(castRx)) {
     QString s = castRx.cap(1);
     QStringList actors;
     for(int pos = anchorRx.indexIn(s); pos > -1;
             pos = anchorRx.indexIn(s, pos+anchorRx.matchedLength())) {
       QString value = anchorRx.cap(1);
       if(value != QStringLiteral("...")) {
         actors += value;
       }
     }
     if(!actors.isEmpty()) {
       entry->setField(QStringLiteral("cast"), actors.join(Tellico::FieldFormat::rowDelimiterString()));
     }
   }
 
   QRegExp runtimeRx(QStringLiteral("id=\"runtime\">(\\d+)"));
   if(str_.contains(runtimeRx)) {
     entry->setField(QStringLiteral("running-time"), runtimeRx.cap(1));
   }
 
   QRegExp plotRx(QStringLiteral("itemprop=\"description\"[^>]*>(.+)</div"));
   plotRx.setMinimal(true);
   if(str_.contains(plotRx)) {
     entry->setField(QStringLiteral("plot"), Tellico::decodeHTML(plotRx.cap(1)));
   } else {
     plotRx.setPattern(QStringLiteral("<meta name=\"description\" content=\"(.+)\""));
     if(str_.contains(plotRx)) {
       entry->setField(QStringLiteral("plot"), Tellico::decodeHTML(plotRx.cap(1)));
     }
   }
 
   QRegExp mpaaRx(QStringLiteral("itemprop=\"contentRating\"[^>]+content=\"MPAA ([^>]+)\""));
   mpaaRx.setMinimal(true);
   if(str_.contains(mpaaRx)) {
     QString value = mpaaRx.cap(1) + QStringLiteral(" (USA)");
 //    entry->setField(QStringLiteral("certification"), i18n(value.toUtf8()));
     entry->setField(QStringLiteral("certification"), value);
   }
 
   QString cover;
   QRegExp coverRx(QStringLiteral("<a class=\"popupBigImage\"[^>]+>\\s*<img.*src=\"([^\"]+)\""));
   coverRx.setMinimal(true);
   if(str_.contains(coverRx)) {
     cover = coverRx.cap(1);
   } else {
     coverRx.setPattern(QStringLiteral("<meta property=\"vk:image\" content=\"(.+)\""));
     if(str_.contains(coverRx)) {
       cover = coverRx.cap(1);
     }
   }
   if(!cover.isEmpty()) {
     const QString id = ImageFactory::addImage(QUrl::fromUserInput(cover), true /* quiet */);
     if(id.isEmpty()) {
       message(i18n("The cover image could not be loaded."), MessageHandler::Warning);
     }
     // empty image ID is ok
     entry->setField(QStringLiteral("cover"), id);
   }
   return entry;
 }
 
 Tellico::Fetch::FetchRequest KinoPoiskFetcher::updateRequest(Data::EntryPtr entry_) {
   QString t = entry_->field(QStringLiteral("title"));
   if(!t.isEmpty()) {
     return FetchRequest(Fetch::Title, t);
   }
   return FetchRequest();
 }
 
 Tellico::Fetch::ConfigWidget* KinoPoiskFetcher::configWidget(QWidget* parent_) const {
   return new KinoPoiskFetcher::ConfigWidget(parent_);
 }
 
 QString KinoPoiskFetcher::defaultName() {
   return QStringLiteral("КиноПоиск (KinoPoisk.ru)");
 }
 
 QString KinoPoiskFetcher::defaultIcon() {
   return favIcon("http://www.kinopoisk.ru");
 }
 
 Tellico::StringHash KinoPoiskFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("origtitle")] = i18n("Original Title");
   hash[QStringLiteral("kinopoisk")] = i18n("KinoPoisk Link");
   return hash;
 }
 
 KinoPoiskFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const KinoPoiskFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 
   addFieldsWidget(KinoPoiskFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 QString KinoPoiskFetcher::ConfigWidget::preferredName() const {
   return KinoPoiskFetcher::defaultName();
 }
diff --git a/src/fetch/kinoteatrfetcher.cpp b/src/fetch/kinoteatrfetcher.cpp
index e8f44ea4..8806b34d 100644
--- a/src/fetch/kinoteatrfetcher.cpp
+++ b/src/fetch/kinoteatrfetcher.cpp
@@ -1,527 +1,527 @@
 /***************************************************************************
     Copyright (C) 2017 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "kinoteatrfetcher.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../collections/videocollection.h"
 #include "../entry.h"
 #include "../fieldformat.h"
 #include "../core/filehandler.h"
 #include "../images/imagefactory.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KJobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QRegularExpression>
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QVBoxLayout>
 #include <QUrlQuery>
 
 namespace {
   static const char* KINOTEATR_SEARCH_URL = "https://kino-teatr.ua/uk/main/films.phtml";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::KinoTeatrFetcher;
 
 KinoTeatrFetcher::KinoTeatrFetcher(QObject* parent_)
     : Fetcher(parent_), m_started(false) {
 }
 
 KinoTeatrFetcher::~KinoTeatrFetcher() {
 }
 
 QString KinoTeatrFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool KinoTeatrFetcher::canFetch(int type) const {
   return type == Data::Collection::Video;
 }
 
 bool KinoTeatrFetcher::canSearch(FetchKey k) const {
   return k == Title;
 }
 
 void KinoTeatrFetcher::readConfigHook(const KConfigGroup& config_) {
   Q_UNUSED(config_);
 }
 
 void KinoTeatrFetcher::search() {
   m_started = true;
   m_matches.clear();
 
   QUrl u(QString::fromLatin1(KINOTEATR_SEARCH_URL));
   QUrlQuery q;
 
   switch(request().key) {
     case Title:
       // TODO: allow year in search query and parse it out?
       //q.addQueryItem(QStringLiteral("year"), QStringLiteral("yes"));
       q.addQueryItem(QStringLiteral("title"), request().value);
       break;
 
     default:
       myWarning() << "key not recognized: " << request().key;
       stop();
       return;
   }
   u.setQuery(q);
 //  myDebug() << "url: " << u.url();
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result, this, &KinoTeatrFetcher::slotComplete);
 }
 
 void KinoTeatrFetcher::stop() {
   if(!m_started) {
     return;
   }
 
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 void KinoTeatrFetcher::slotComplete(KJob*) {
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
 
   const QString output = Tellico::decodeHTML(data);
 #if 0
   myWarning() << "Remove debug from kinoteatrfetcher.cpp";
   QFile f(QStringLiteral("/tmp/test1.html"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << output;
   }
   f.close();
 #endif
 
   // look for a specific div, with an href and title, sometime uses single-quote, sometimes double-quotes
   QRegularExpression resultRx(QStringLiteral("<div id=[\"']searchItemFilms[\"']>\\s*"
                                              ".+?<div id=[\"']lineHr[\"']>"),
                               QRegularExpression::DotMatchesEverythingOption);
   QRegularExpression titleRx(QStringLiteral("<a href='(.+?)' class='searchItemLink'.*?>(.+?)</a>"));
   // the year is within the searchItemText as a 4-digit number, starting with 1 or 2
   QRegularExpression yearRx(QStringLiteral("<p class='searchItemText'>.*?([12]\\d\\d\\d).*?</p>"),
                             QRegularExpression::DotMatchesEverythingOption);
 
   QString href, title, year;
   QRegularExpressionMatchIterator i = resultRx.globalMatch(output);
   while(i.hasNext() && m_started) {
     const QString resultText = i.next().captured();
     QRegularExpressionMatch match = titleRx.match(resultText);
     if(match.hasMatch()) {
       href = match.captured(1);
       title = match.captured(2);
     }
     // there can be multiple
     match = yearRx.match(resultText);
     if(match.hasMatch()) {
       year = match.captured(1);
     }
     if(!href.isEmpty()) {
       QUrl url(QString::fromLatin1(KINOTEATR_SEARCH_URL));
       url = url.resolved(QUrl(href));
 //      myDebug() << url << title << year;
       FetchResult* r = new FetchResult(Fetcher::Ptr(this), title, year);
       m_matches.insert(r->uid, url);
       emit signalResultFound(r);
     }
   }
 
   // since the fetch is done, don't worry about holding the job pointer
   m_job = nullptr;
   stop();
 }
 
 Tellico::Data::EntryPtr KinoTeatrFetcher::fetchEntryHook(uint uid_) {
   // if we already grabbed this one, then just pull it out of the dict
   Data::EntryPtr entry = m_entries[uid_];
   if(entry) {
     return entry;
   }
 
   QUrl url = m_matches[uid_];
   if(url.isEmpty()) {
     myWarning() << "no url in map";
     return Data::EntryPtr();
   }
 
   const QString results = Tellico::decodeHTML(FileHandler::readDataFile(url, true));
   if(results.isEmpty()) {
     myDebug() << "no text results";
     return Data::EntryPtr();
   }
 
 #if 0
   myDebug() << url.url();
   myWarning() << "Remove debug from kinoteatrfetcher.cpp";
   QFile f(QStringLiteral("/tmp/test-kinoteatr.html"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << results;
   }
   f.close();
 #endif
 
   entry = parseEntry(results);
   if(!entry) {
     myDebug() << "error in processing entry";
     return Data::EntryPtr();
   }
 
   QString newPath(url.path());
   newPath.replace(QLatin1String("/film/"), QLatin1String("/film-persons/"));
   QUrl personUrl(url);
   personUrl.setPath(newPath);
 
   const QString personsText = Tellico::decodeHTML(FileHandler::readDataFile(personUrl, true));
   if(!personsText.isEmpty()) {
     parsePeople(entry, personsText);
 #if 0
     myWarning() << "Remove persons debug from kinoteatrfetcher.cpp";
     myDebug() << personUrl.url();
     QFile f2(QStringLiteral("/tmp/test-kinoteatr-persons.html"));
     if(f2.open(QIODevice::WriteOnly)) {
       QTextStream t(&f2);
       t.setCodec("UTF-8");
       t << personsText;
     }
     f2.close();
 #endif
   }
 
   if(optionalFields().contains(QStringLiteral("kinoteatr"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("kinoteatr"), i18n("Kino-Teatr Link"), Data::Field::URL));
     field->setCategory(i18n("General"));
     entry->collection()->addField(field);
     entry->setField(QStringLiteral("kinoteatr"), url.url());
   }
 
   m_entries.insert(uid_, entry); // keep for later
   return entry;
 }
 
 Tellico::Data::EntryPtr KinoTeatrFetcher::parseEntry(const QString& str_) {
   Data::CollPtr coll(new Data::VideoCollection(true));
   Data::EntryPtr entry(new Data::Entry(coll));
   coll->addEntries(entry);
 
   int pos = 0;
 
   QRegularExpression anchorRx(QStringLiteral("<a.+?href=[\"'].+?[\"'].*?>(.*?)</"));
 
   QRegularExpression titleRx(QStringLiteral("<strong class=[\"']red[\"'] itemprop=[\"']name[\"']>(.+?)</strong>"));
   QRegularExpressionMatch match = titleRx.match(str_, pos);
   if(match.hasMatch()) {
     entry->setField(QStringLiteral("title"), match.captured(1).simplified());
     pos = match.capturedEnd();
   }
 
   if(optionalFields().contains(QStringLiteral("origtitle"))) {
     Data::FieldPtr f(new Data::Field(QStringLiteral("origtitle"), i18n("Original Title")));
     f->setFormatType(FieldFormat::FormatTitle);
     coll->addField(f);
 
     QRegularExpression origTitleRx(QStringLiteral("itemprop=\"alternativeHeadline\".*?>(.+?)</"));
     match = origTitleRx.match(str_, pos);
     if(match.hasMatch()) {
       entry->setField(QStringLiteral("origtitle"), match.captured(1).simplified());
     }
   }
 
   QRegularExpression yearRx(QStringLiteral("Рік:.*?([12]\\d\\d\\d).*?</a"));
   match = yearRx.match(str_, pos);
   if(match.hasMatch()) {
     entry->setField(QStringLiteral("year"), match.captured(1));
     pos = match.capturedEnd();
   }
 
   QRegularExpression countryRx(QStringLiteral("Країна:(.*?)<br"),
                                QRegularExpression::DotMatchesEverythingOption);
   match = countryRx.match(str_, pos);
   if(match.hasMatch()) {
     const QString innerText = match.captured(1);
     QStringList countries;
     QRegularExpressionMatchIterator i = anchorRx.globalMatch(innerText);
     while(i.hasNext()) {
       match = i.next();
       const QString s = match.captured(1).simplified();
       if(!s.isEmpty()) {
         countries += s;
       }
     }
     if(!countries.isEmpty()) {
       countries.removeDuplicates();
       entry->setField(QStringLiteral("nationality"), countries.join(Tellico::FieldFormat::delimiterString()));
     }
   }
 
   QRegularExpression genreRx(QStringLiteral("itemprop=\"genre\">(.*?)<br"),
                              QRegularExpression::DotMatchesEverythingOption);
   match = genreRx.match(str_, pos);
   if(match.hasMatch()) {
     const QString innerText = match.captured(1);
     QStringList genres;
     QRegularExpressionMatchIterator i = anchorRx.globalMatch(innerText);
     while(i.hasNext()) {
       match = i.next();
       const QString s = match.captured(1).simplified();
       if(!s.isEmpty()) {
         genres += s;
       }
     }
     if(!genres.isEmpty()) {
       genres.removeDuplicates();
       entry->setField(QStringLiteral("genre"), genres.join(Tellico::FieldFormat::delimiterString()));
     }
   }
 
   QRegularExpression directorRx(QStringLiteral("itemprop=\"director\".*?>(.*?)<br"),
                                 QRegularExpression::DotMatchesEverythingOption);
   match = directorRx.match(str_, pos);
   if(match.hasMatch()) {
     const QString innerText = match.captured(1);
     QStringList directors;
     QRegularExpressionMatchIterator i = anchorRx.globalMatch(innerText);
     while(i.hasNext()) {
       match = i.next();
       const QString s = match.captured(1).simplified();
       if(!s.isEmpty()) {
         directors += s;
       }
     }
     if(!directors.isEmpty()) {
       entry->setField(QStringLiteral("director"), directors.join(Tellico::FieldFormat::delimiterString()));
     }
   }
 
   QRegularExpression runtimeRx(QStringLiteral("Тривалість:.*?(\\d+).*?хв<br>"),
                                QRegularExpression::DotMatchesEverythingOption);
   match = runtimeRx.match(str_, pos);
   if(match.hasMatch()) {
     entry->setField(QStringLiteral("running-time"), match.captured(1));
   }
 
   QRegularExpression plotRx(QStringLiteral("itemprop=[\"']description[\"'].*?>(.+?)</div"),
                             QRegularExpression::DotMatchesEverythingOption);
   match = plotRx.match(str_, pos);
   if(match.hasMatch()) {
     entry->setField(QStringLiteral("plot"), Tellico::decodeHTML(match.captured(1).simplified()));
   } else {
     plotRx.setPattern(QStringLiteral("<meta name=\"og:description\" content=\"(.+?)\""));
     match = plotRx.match(str_);
     if(match.hasMatch()) {
       entry->setField(QStringLiteral("plot"), Tellico::decodeHTML(match.captured(1)));
     }
   }
 
   QString cover;
   QRegularExpression coverRx(QStringLiteral("<img\\s.*?src=[\"'](.+?)[\"'].+?itemprop=[\"']image[\"']"));
   match = coverRx.match(str_);
   if(match.hasMatch()) {
     cover = match.captured(1);
   } else {
     coverRx.setPattern(QStringLiteral("<meta property=\"og:image\" content=\"(.+?)\""));
     match = coverRx.match(str_);
     if(match.hasMatch()) {
       cover = match.captured(1);
     }
   }
   if(!cover.isEmpty()) {
 //    myDebug() << "cover:" << cover;
     const QString id = ImageFactory::addImage(QUrl::fromUserInput(cover), true /* quiet */);
     if(id.isEmpty()) {
       message(i18n("The cover image could not be loaded."), MessageHandler::Warning);
     }
     // empty image ID is ok
     entry->setField(QStringLiteral("cover"), id);
   }
 
   return entry;
 }
 
 void KinoTeatrFetcher::parsePeople(Data::EntryPtr entry_, const QString& str_) {
   if(!entry_) {
     myDebug() << "no entry";
     return;
   }
 
   QRegularExpression nameDivRx(QStringLiteral("<div class='liderName'>(.+?)</div"),
                                QRegularExpression::DotMatchesEverythingOption);
   QRegularExpression anchorRx(QStringLiteral("<a.+?>(.+?)</a"));
   QRegularExpression roleRx(QStringLiteral("<span id='role'>(.+?)</span"));
 
   QRegularExpression castRx(QStringLiteral("Актори(.+?)<div id"), // next div that has an id is for next text block
                             QRegularExpression::DotMatchesEverythingOption);
   QRegularExpressionMatch match = castRx.match(str_);
   if(match.hasMatch()) {
     const QString innerText = match.captured(1);
     QStringList actors, roles;
     QRegularExpressionMatchIterator i = nameDivRx.globalMatch(innerText);
     while(i.hasNext()) {
       match = i.next();
       QRegularExpressionMatch anchorMatch = anchorRx.match(match.captured(1));
       if(anchorMatch.hasMatch()) {
         actors += anchorMatch.captured(1).simplified();
         QRegularExpressionMatch spanMatch = roleRx.match(match.captured(1));
         roles += spanMatch.hasMatch() ? spanMatch.captured(1).simplified() : QString();
       }
     }
     // interleave actors and roles
     QStringList cast;
     for(int i = 0; i< actors.length(); ++i) {
       QString row = actors.at(i);
       if(!roles.at(i).isEmpty()) {
         row += FieldFormat::columnDelimiterString() + roles.at(i);
       }
       cast += row;
     }
     if(!cast.isEmpty()) {
 //      myDebug() << cast;
       entry_->setField(QStringLiteral("cast"), cast.join(FieldFormat::rowDelimiterString()));
     }
   }
 
   QRegularExpression writerRx(QStringLiteral("Сценаристи(.+?)<div id"), // next div that has an id is for next text block
                               QRegularExpression::DotMatchesEverythingOption);
   match = writerRx.match(str_);
   if(match.hasMatch()) {
     const QString innerText = match.captured(1);
     QStringList writers;
     QRegularExpressionMatchIterator i = nameDivRx.globalMatch(innerText);
     while(i.hasNext()) {
       match = i.next();
       QRegularExpressionMatch anchorMatch = anchorRx.match(match.captured(1));
       if(anchorMatch.hasMatch()) {
         writers += anchorMatch.captured(1).simplified();
       }
     }
     if(!writers.isEmpty()) {
       entry_->setField(QStringLiteral("writer"), writers.join(FieldFormat::delimiterString()));
     }
   }
 
   QRegularExpression producerRx(QStringLiteral("Продюсери(.+?)<div id"), // next div that has an id is for next text block
                                 QRegularExpression::DotMatchesEverythingOption);
   match = producerRx.match(str_);
   if(match.hasMatch()) {
     const QString innerText = match.captured(1);
     QStringList producers;
     QRegularExpressionMatchIterator i = nameDivRx.globalMatch(innerText);
     while(i.hasNext()) {
       match = i.next();
       QRegularExpressionMatch anchorMatch = anchorRx.match(match.captured(1));
       if(anchorMatch.hasMatch()) {
         producers += anchorMatch.captured(1).simplified();
       }
     }
     if(!producers.isEmpty()) {
       entry_->setField(QStringLiteral("producer"), producers.join(FieldFormat::delimiterString()));
     }
   }
 
   QRegularExpression composerRx(QStringLiteral("Композитори(.+?)<div id"), // next div that has an id is for next text block
                                 QRegularExpression::DotMatchesEverythingOption);
   match = composerRx.match(str_);
   if(match.hasMatch()) {
     const QString innerText = match.captured(1);
     QStringList composers;
     QRegularExpressionMatchIterator i = nameDivRx.globalMatch(innerText);
     while(i.hasNext()) {
       match = i.next();
       QRegularExpressionMatch anchorMatch = anchorRx.match(match.captured(1));
       if(anchorMatch.hasMatch()) {
         composers += anchorMatch.captured(1).simplified();
       }
     }
     if(!composers.isEmpty()) {
       entry_->setField(QStringLiteral("composer"), composers.join(FieldFormat::delimiterString()));
     }
   }
 }
 
 Tellico::Fetch::FetchRequest KinoTeatrFetcher::updateRequest(Data::EntryPtr entry_) {
   QString t = entry_->field(QStringLiteral("title"));
   if(!t.isEmpty()) {
     return FetchRequest(Fetch::Title, t);
   }
   return FetchRequest();
 }
 
 Tellico::Fetch::ConfigWidget* KinoTeatrFetcher::configWidget(QWidget* parent_) const {
   return new KinoTeatrFetcher::ConfigWidget(parent_);
 }
 
 QString KinoTeatrFetcher::defaultName() {
   return QStringLiteral("Кіно-Театр (kino-teatr.ua)");
 }
 
 QString KinoTeatrFetcher::defaultIcon() {
   return favIcon("https://kino-teatr.ua");
 }
 
 Tellico::StringHash KinoTeatrFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("origtitle")] = i18n("Original Title");
   hash[QStringLiteral("kinoteatr")] = i18n("Kino-Teatr Link");
   return hash;
 }
 
 KinoTeatrFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const KinoTeatrFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 
   addFieldsWidget(KinoTeatrFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 QString KinoTeatrFetcher::ConfigWidget::preferredName() const {
   return KinoTeatrFetcher::defaultName();
 }
diff --git a/src/fetch/mobygamesfetcher.cpp b/src/fetch/mobygamesfetcher.cpp
index 23679174..7a3e4446 100644
--- a/src/fetch/mobygamesfetcher.cpp
+++ b/src/fetch/mobygamesfetcher.cpp
@@ -1,514 +1,514 @@
 /***************************************************************************
     Copyright (C) 2019 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "mobygamesfetcher.h"
 #include "../collections/gamecollection.h"
 #include "../images/imagefactory.h"
 #include "../core/filehandler.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KJob>
 #include <KJobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 #include <KIO/StoredTransferJob>
 
 #include <QUrl>
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QGridLayout>
 #include <QTextCodec>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QUrlQuery>
 #include <QThread>
 
 namespace {
   static const int MOBYGAMES_MAX_RETURNS_TOTAL = 10;
   static const char* MOBYGAMES_API_URL = "https://api.mobygames.com/v1";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::MobyGamesFetcher;
 
 MobyGamesFetcher::MobyGamesFetcher(QObject* parent_)
     : Fetcher(parent_), m_started(false) {
   //  setLimit(MOBYGAMES_MAX_RETURNS_TOTAL);
   if(m_esrbHash.isEmpty()) {
     populateHashes();
   }
 }
 
 MobyGamesFetcher::~MobyGamesFetcher() {
 }
 
 QString MobyGamesFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 QString MobyGamesFetcher::attribution() const {
   return i18n("This information was freely provided by <a href=\"https://mobygames.com\">MobyGames</a>.");
 }
 
 bool MobyGamesFetcher::canSearch(FetchKey k) const {
   return k == Title;
 }
 
 bool MobyGamesFetcher::canFetch(int type) const {
   return type == Data::Collection::Game;
 }
 
 void MobyGamesFetcher::readConfigHook(const KConfigGroup& config_) {
   QString k = config_.readEntry("API Key");
   if(!k.isEmpty()) {
     m_apiKey = k;
   }
 }
 
 void MobyGamesFetcher::search() {
   continueSearch();
 }
 
 void MobyGamesFetcher::continueSearch() {
   m_started = true;
 
   if(m_apiKey.isEmpty()) {
     myDebug() << "empty API key";
     message(i18n("An access key is required to use this data source.")
             + QLatin1Char(' ') +
             i18n("Those values must be entered in the data source settings."), MessageHandler::Error);
     stop();
     return;
   }
 
   QUrl u(QString::fromLatin1(MOBYGAMES_API_URL));
   u.setPath(u.path() + QStringLiteral("/games"));
 
   QUrlQuery q;
   switch(request().key) {
     case Title:
       q.addQueryItem(QStringLiteral("title"), request().value);
       break;
 
     default:
       myWarning() << "key not recognized:" << request().key;
       stop();
       return;
   }
   q.addQueryItem(QStringLiteral("api_key"), m_apiKey);
   q.addQueryItem(QStringLiteral("limit"), QString::number(MOBYGAMES_MAX_RETURNS_TOTAL));
   q.addQueryItem(QStringLiteral("format"), QStringLiteral("normal"));
   u.setQuery(q);
 //  u = QUrl::fromLocalFile(QStringLiteral("/home/robby/games.json"));
 //  myDebug() << u;
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result, this, &MobyGamesFetcher::slotComplete);
 }
 
 void MobyGamesFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 Tellico::Data::EntryPtr MobyGamesFetcher::fetchEntryHook(uint uid_) {
   if(!m_entries.contains(uid_)) {
     myDebug() << "no entry ptr";
     return Data::EntryPtr();
   }
 
   Data::EntryPtr entry = m_entries.value(uid_);
 
   QUrl u(QString::fromLatin1(MOBYGAMES_API_URL));
   u.setPath(u.path() + QStringLiteral("/games/%1/platforms/%2")
                        .arg(entry->field(QStringLiteral("moby-id")),
                             entry->field(QStringLiteral("platform-id"))));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("api_key"), m_apiKey);
   u.setQuery(q);
 //  myDebug() << u;
 
   // need to wait a bit after previous query, Moby error message say 1 sec
   QThread::msleep(1000);
   QPointer<KIO::StoredTransferJob> job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(job, GUI::Proxy::widget());
   if(!job->exec()) {
     myDebug() << job->errorString() << u;
     return entry;
   }
   QByteArray data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data for" << u;
     return entry;
   }
 #if 0
   myWarning() << "Remove platforms debug from mobygamesfetcher.cpp";
   QFile file(QStringLiteral("/tmp/moby-platforms.json"));
   if(file.open(QIODevice::WriteOnly)) {
     QTextStream t(&file);
     t.setCodec("UTF-8");
     t << data;
   }
   file.close();
 #endif
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   QVariantMap map = doc.object().toVariantMap();
   foreach(const QVariant& rating, map.value(QStringLiteral("ratings")).toList()) {
     const QVariantMap ratingMap = rating.toMap();
     const QString ratingSystem = ratingMap.value(QStringLiteral("rating_system_name")).toString();
     if(ratingSystem == QStringLiteral("PEGI Rating")) {
       QString rating = ratingMap.value(QStringLiteral("rating_name")).toString();
       if(!rating.startsWith(QStringLiteral("PEGI"))) {
         rating.prepend(QStringLiteral("PEGI "));
       }
       entry->setField(QStringLiteral("pegi"), rating);
     } else if(ratingSystem == QStringLiteral("ESRB Rating")) {
       const int esrb = ratingMap.value(QStringLiteral("rating_id")).toInt();
       if(m_esrbHash.contains(esrb)) {
         entry->setField(QStringLiteral("certification"), m_esrbHash.value(esrb));
       }
     }
   }
   // just use the first release
   const QVariantList releaseList = map.value(QStringLiteral("releases")).toList();
   if(!releaseList.isEmpty()) {
     const QVariantMap releaseMap = releaseList.at(0).toMap();
     QStringList pubs, devs;
     foreach(const QVariant& company, releaseMap.value(QStringLiteral("companies")).toList()) {
       const QVariantMap companyMap = company.toMap();
       if(companyMap.value(QStringLiteral("role")) == QStringLiteral("Developed by")) {
         devs += companyMap.value(QStringLiteral("company_name")).toString();
       } else if(companyMap.value(QStringLiteral("role")) == QStringLiteral("Published by")) {
         pubs += companyMap.value(QStringLiteral("company_name")).toString();
       }
     }
 //    myDebug() << pubs << devs;
     entry->setField(QStringLiteral("publisher"), pubs.join(FieldFormat::delimiterString()));
     entry->setField(QStringLiteral("developer"), devs.join(FieldFormat::delimiterString()));
   }
 
   // check for empty cover
   const QString image_id = entry->field(QStringLiteral("cover"));
   if(!image_id.isEmpty()) {
     return entry;
   }
 
   u = QUrl(QString::fromLatin1(MOBYGAMES_API_URL));
   u.setPath(u.path() + QStringLiteral("/games/%1/platforms/%2/covers")
                        .arg(entry->field(QStringLiteral("moby-id")),
                             entry->field(QStringLiteral("platform-id"))));
   u.setQuery(q);
 //  myDebug() << u;
 
   // need to wait a bit after previous query
   QThread::msleep(1000);
   job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(job, GUI::Proxy::widget());
   if(!job->exec()) {
     myDebug() << job->errorString() << u;
     return entry;
   }
   data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data for" << u;
     return entry;
   }
 #if 0
   myWarning() << "Remove covers debug from mobygamesfetcher.cpp";
   QFile file2(QStringLiteral("/tmp/moby-covers.json"));
   if(file2.open(QIODevice::WriteOnly)) {
     QTextStream t(&file2);
     t.setCodec("UTF-8");
     t << data;
   }
   file2.close();
 #endif
 
   QString coverUrl;
   doc = QJsonDocument::fromJson(data);
   map = doc.object().toVariantMap();
   QVariantList coverGroupList = map.value(QStringLiteral("cover_groups")).toList();
   foreach(const QVariant& coverGroup, coverGroupList) {
     // just take the first cover
     QVariantList coverList = coverGroup.toMap().value(QStringLiteral("covers")).toList();
     // take the cover that is a scan of "Media" unless there is none
     bool foundCover = false;
     foreach(const QVariant& coverVariant, coverList) {
       const QVariantMap coverMap = coverVariant.toMap();
       if(coverMap.value(QStringLiteral("scan_of")) == QStringLiteral("Media") ||
          coverMap.value(QStringLiteral("scan_of")) == QStringLiteral("Front Cover")) {
         coverUrl = coverMap.value(QStringLiteral("thumbnail_image")).toString();
         foundCover = true;
         break;
       }
     }
     if(foundCover) {
       // no need to continue iteration through cover groups
       break;
     }
   }
 
   if(!coverUrl.isEmpty()) {
 //    myDebug() << coverUrl;
     const QString id = ImageFactory::addImage(QUrl::fromUserInput(coverUrl), true /* quiet */);
     if(id.isEmpty()) {
       message(i18n("The cover image could not be loaded."), MessageHandler::Warning);
     }
     // empty image ID is ok
     entry->setField(QStringLiteral("cover"), id);
   }
 
   // clear the placeholder fields
   entry->setField(QStringLiteral("moby-id"), QString());
   entry->setField(QStringLiteral("platform-id"), QString());
   return entry;
 }
 
 Tellico::Fetch::FetchRequest MobyGamesFetcher::updateRequest(Data::EntryPtr entry_) {
   QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Title, title);
   }
   return FetchRequest();
 }
 
 void MobyGamesFetcher::slotComplete(KJob* job_) {
   KIO::StoredTransferJob* job = static_cast<KIO::StoredTransferJob*>(job_);
 
   if(job->error()) {
     job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   const QByteArray data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from mobygamesfetcher.cpp";
   QFile file(QStringLiteral("/tmp/test.json"));
   if(file.open(QIODevice::WriteOnly)) {
     QTextStream t(&file);
     t.setCodec("UTF-8");
     t << data;
   }
   file.close();
 #endif
 
   Data::CollPtr coll(new Data::GameCollection(true));
   if(optionalFields().contains(QStringLiteral("pegi"))) {
     QStringList pegi = QStringLiteral("PEGI 3, PEGI 7, PEGI 12, PEGI 16, PEGI 18")
                                     .split(QRegExp(QStringLiteral("\\s*,\\s*")), QString::SkipEmptyParts);
     Data::FieldPtr field(new Data::Field(QStringLiteral("pegi"), i18n("PEGI Rating"), pegi));
     field->setFlags(Data::Field::AllowGrouped);
     field->setCategory(i18n("General"));
     coll->addField(field);
   }
   if(optionalFields().contains(QStringLiteral("mobygames"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("mobygames"), i18n("MobyGames Link"), Data::Field::URL));
     field->setCategory(i18n("General"));
     coll->addField(field);
   }
   // placeholder for mobygames id, to be removed later
   Data::FieldPtr f1(new Data::Field(QStringLiteral("moby-id"), QString(), Data::Field::Number));
   coll->addField(f1);
   Data::FieldPtr f2(new Data::Field(QStringLiteral("platform-id"), QString(), Data::Field::Number));
   coll->addField(f2);
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   QVariantMap map = doc.object().toVariantMap();
   foreach(const QVariant& result, map.value(QStringLiteral("games")).toList()) {
     QVariantMap resultMap = result.toMap();
     Data::EntryList entries = createEntries(coll, resultMap);
     foreach(const Data::EntryPtr& entry, entries) {
       FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
       m_entries.insert(r->uid, entry);
       emit signalResultFound(r);
     }
   }
 
   stop();
 }
 
 Tellico::Data::EntryList MobyGamesFetcher::createEntries(Data::CollPtr coll_, const QVariantMap& resultMap_) {
   Data::EntryPtr entry(new Data::Entry(coll_));
   entry->setField(QStringLiteral("title"), mapValue(resultMap_, "title"));
   entry->setField(QStringLiteral("description"), mapValue(resultMap_, "description"));
   entry->setField(QStringLiteral("moby-id"), mapValue(resultMap_, "game_id"));
 
   QStringList genres;
   foreach(const QVariant& genreMap, resultMap_.value(QStringLiteral("genres")).toList()) {
     QString g = genreMap.toMap().value(QStringLiteral("genre_name")).toString();
     if(!g.isEmpty()) {
       genres << g;
     }
   }
   entry->setField(QStringLiteral("genre"), genres.join(FieldFormat::delimiterString()));
 
   if(optionalFields().contains(QStringLiteral("mobygames"))) {
     entry->setField(QStringLiteral("mobygames"), mapValue(resultMap_, "moby_url"));
   }
 
   Data::EntryList entries;
   // return a new entry for every platform
   foreach(const QVariant& platformMapV, resultMap_.value(QStringLiteral("platforms")).toList()) {
     Data::EntryPtr newEntry(new Data::Entry(*entry));
 
     const QVariantMap platformMap = platformMapV.toMap();
     const QString platform = platformMap.value(QStringLiteral("platform_name")).toString();
     if(platform == QStringLiteral("Wii")) {
       newEntry->setField(QStringLiteral("platform"), i18n("Nintendo Wii"));
     } else if(platform == QStringLiteral("Wii U")) {
       // TODO:: add WII U to defaults?
       newEntry->setField(QStringLiteral("platform"), i18n("Nintendo Wii"));
     } else if(platform == QStringLiteral("Nintendo GameCube")) {
       newEntry->setField(QStringLiteral("platform"), i18n("GameCube"));
     } else {
       // also make the assumption that if the platform name isn't already in the allowed list, it should be added
       Data::FieldPtr f = coll_->fieldByName(QStringLiteral("platform"));
       if(f && !f->allowed().contains(platform)) {
         f->setAllowed(QStringList(f->allowed()) << platform);
       }
       newEntry->setField(QStringLiteral("platform"), platform);
     }
 
     newEntry->setField(QStringLiteral("platform-id"),
                        platformMap.value(QStringLiteral("platform_id")).toString());
     newEntry->setField(QStringLiteral("year"),
                        platformMap.value(QStringLiteral("first_release_date")).toString().left(4));
     entries << newEntry;
   }
   return entries;
 }
 
 void MobyGamesFetcher::populateHashes() {
   // cheat by grabbing i18n values from default collection
   Data::CollPtr c(new Data::GameCollection(true));
   QStringList esrb = c->fieldByName(QStringLiteral("certification"))->allowed();
   Q_ASSERT(esrb.size() == 8);
   while(esrb.size() < 8) {
     esrb << QString();
   }
   // 89 == EC
   // 90 == Everyone
   // etc.
   // 95 == Pending
   // https://www.mobygames.com/attribute/sheet/attributeId,89
   m_esrbHash.insert(89, esrb.at(6));
   m_esrbHash.insert(90, esrb.at(5));
   m_esrbHash.insert(91, esrb.at(4));
   m_esrbHash.insert(92, esrb.at(3));
   m_esrbHash.insert(93, esrb.at(2));
   m_esrbHash.insert(94, esrb.at(1));
   m_esrbHash.insert(95, esrb.at(7));
 }
 
 Tellico::Fetch::ConfigWidget* MobyGamesFetcher::configWidget(QWidget* parent_) const {
   return new MobyGamesFetcher::ConfigWidget(parent_, this);
 }
 
 QString MobyGamesFetcher::defaultName() {
   return QStringLiteral("MobyGames");
 }
 
 QString MobyGamesFetcher::defaultIcon() {
   return favIcon("http://www.mobygames.com");
 }
 
 Tellico::StringHash MobyGamesFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("pegi")] = i18n("PEGI Rating");
   hash[QStringLiteral("mobygames")] = i18n("MobyGames Link");
   return hash;
 }
 
 MobyGamesFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const MobyGamesFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
 
   QLabel* al = new QLabel(i18n("Registration is required for accessing the %1 data source. "
                                "If you agree to the terms and conditions, <a href='%2'>sign "
                                "up for an account</a>, and enter your information below.",
                                 MobyGamesFetcher::defaultName(),
                                 QStringLiteral("https://www.mobygames.com/info/api")),
                           optionsWidget());
   al->setOpenExternalLinks(true);
   al->setWordWrap(true);
   ++row;
   l->addWidget(al, row, 0, 1, 2);
   // richtext gets weird with size
   al->setMinimumWidth(al->sizeHint().width());
 
   QLabel* label = new QLabel(i18n("Access key: "), optionsWidget());
   l->addWidget(label, ++row, 0);
 
   m_apiKeyEdit = new QLineEdit(optionsWidget());
-  connect(m_apiKeyEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_apiKeyEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_apiKeyEdit, row, 1);
   label->setBuddy(m_apiKeyEdit);
 
   l->setRowStretch(++row, 10);
 
   // now add additional fields widget
   addFieldsWidget(MobyGamesFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 
   if(fetcher_) {
     m_apiKeyEdit->setText(fetcher_->m_apiKey);
   }
 }
 
 void MobyGamesFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   const QString apiKey = m_apiKeyEdit->text().trimmed();
   if(!apiKey.isEmpty()) {
     config_.writeEntry("API Key", apiKey);
   }
 }
 
 QString MobyGamesFetcher::ConfigWidget::preferredName() const {
   return MobyGamesFetcher::defaultName();
 }
diff --git a/src/fetch/moviemeterfetcher.cpp b/src/fetch/moviemeterfetcher.cpp
index 25e5ead9..28c482ae 100644
--- a/src/fetch/moviemeterfetcher.cpp
+++ b/src/fetch/moviemeterfetcher.cpp
@@ -1,313 +1,313 @@
 /***************************************************************************
     Copyright (C) 2011 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "moviemeterfetcher.h"
 #include "../collections/videocollection.h"
 #include "../images/imagefactory.h"
 #include "../core/filehandler.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KJobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QGridLayout>
 #include <QTextCodec>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QJsonArray>
 #include <QUrlQuery>
 
 namespace {
   static const char* MOVIEMETER_API_KEY = "t80a06uf736d0yd00jpynpdsgea255yk";
   static const char* MOVIEMETER_API_URL = "http://www.moviemeter.nl/api/film/";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::MovieMeterFetcher;
 
 MovieMeterFetcher::MovieMeterFetcher(QObject* parent_)
     : Fetcher(parent_)
     , m_started(false) {
 }
 
 MovieMeterFetcher::~MovieMeterFetcher() {
 }
 
 QString MovieMeterFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 QString MovieMeterFetcher::attribution() const {
   return QStringLiteral("<a href=\"http://www.moviemeter.nl\">MovieMeter</a>");
 }
 
 bool MovieMeterFetcher::canSearch(FetchKey k) const {
   return k == Keyword;
 }
 
 bool MovieMeterFetcher::canFetch(int type) const {
   return type == Data::Collection::Video;
 }
 
 void MovieMeterFetcher::readConfigHook(const KConfigGroup&) {
 }
 
 void MovieMeterFetcher::search() {
   m_started = true;
 
   QUrl u(QString::fromLatin1(MOVIEMETER_API_URL));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("api_key"), QLatin1String(MOVIEMETER_API_KEY));
 
   switch(request().key) {
     case Keyword:
       q.addQueryItem(QStringLiteral("q"), request().value);
       //u.addQueryItem(QLatin1String("type"), QLatin1String("all"));
       break;
 
     case Raw:
       q.setQuery(request().value);
       break;
 
     default:
       myWarning() << "key not recognized:" << request().key;
       stop();
       return;
   }
   u.setQuery(q);
 //  myDebug() << "url: " << u.url();
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result, this, &MovieMeterFetcher::slotComplete);
 }
 
 void MovieMeterFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 Tellico::Data::EntryPtr MovieMeterFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entries.value(uid_);
   if(!entry) {
     myWarning() << "no entry in dict";
     return Data::EntryPtr();
   }
 
   QString id = entry->field(QStringLiteral("moviemeter-id"));
   if(!id.isEmpty()) {
     QUrl u(QString::fromLatin1(MOVIEMETER_API_URL));
     u.setPath(u.path() + id);
     QUrlQuery q;
     q.addQueryItem(QStringLiteral("api_key"), QLatin1String(MOVIEMETER_API_KEY));
     u.setQuery(q);
     // quiet
     QByteArray data = FileHandler::readDataFile(u, true);
 
 #if 0
     myWarning() << "Remove debug2 from moviemeterfetcher.cpp";
     QFile f(QString::fromLatin1("/tmp/test2.json"));
     if(f.open(QIODevice::WriteOnly)) {
       QTextStream t(&f);
       t.setCodec("UTF-8");
       t << data;
     }
     f.close();
 #endif
 
     QJsonDocument doc = QJsonDocument::fromJson(data);
     populateEntry(entry, doc.object().toVariantMap(), true);
   }
 
   // image might still be URL
   const QString image_id = entry->field(QStringLiteral("cover"));
   if(image_id.contains(QLatin1Char('/'))) {
     const QString id = ImageFactory::addImage(QUrl::fromUserInput(image_id), true /* quiet */);
     if(id.isEmpty()) {
       message(i18n("The cover image could not be loaded."), MessageHandler::Warning);
     }
     // empty image ID is ok
     entry->setField(QStringLiteral("cover"), id);
   }
 
   // don't want to include ID field
   entry->setField(QStringLiteral("moviemeter-id"), QString());
 
   return entry;
 }
 
 Tellico::Fetch::FetchRequest MovieMeterFetcher::updateRequest(Data::EntryPtr entry_) {
   const QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Keyword, title);
   }
   return FetchRequest();
 }
 
 void MovieMeterFetcher::slotComplete(KJob* job_) {
   KIO::StoredTransferJob* job = static_cast<KIO::StoredTransferJob*>(job_);
 //  myDebug();
 
   if(job->error()) {
     job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from moviemeterfetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/test.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   Data::CollPtr coll(new Data::VideoCollection(true));
   // always add ID for fetchEntryHook
   Data::FieldPtr field(new Data::Field(QStringLiteral("moviemeter-id"), QStringLiteral("MovieMeter ID"), Data::Field::Line));
   field->setCategory(i18n("General"));
   coll->addField(field);
 
   if(optionalFields().contains(QStringLiteral("moviemeter"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("moviemeter"), i18n("MovieMeter Link"), Data::Field::URL));
     field->setCategory(i18n("General"));
     coll->addField(field);
   }
   if(optionalFields().contains(QStringLiteral("alttitle"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("alttitle"), i18n("Alternative Titles"), Data::Field::Table));
     field->setFormatType(FieldFormat::FormatTitle);
     coll->addField(field);
   }
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   QJsonArray array = doc.array();
   for(int i = 0; i < array.count(); i++) {
   //  myDebug() << "found result:" << result;
 
     Data::EntryPtr entry(new Data::Entry(coll));
     populateEntry(entry, array.at(i).toObject().toVariantMap(), false);
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
   }
 
   stop();
 }
 
 void MovieMeterFetcher::populateEntry(Data::EntryPtr entry_, const QVariantMap& resultMap_, bool fullData_) {
   entry_->setField(QStringLiteral("moviemeter-id"), mapValue(resultMap_, "id"));
   entry_->setField(QStringLiteral("title"), mapValue(resultMap_, "title"));
   entry_->setField(QStringLiteral("year"),  mapValue(resultMap_, "year"));
 
   // if we only need cursory data, then we're done
   if(!fullData_) {
     return;
   }
 
   entry_->setField(QStringLiteral("genre"),  mapValue(resultMap_, "genres"));
   entry_->setField(QStringLiteral("plot"),  mapValue(resultMap_, "plot"));
   entry_->setField(QStringLiteral("running-time"),  mapValue(resultMap_, "duration"));
   entry_->setField(QStringLiteral("director"),  mapValue(resultMap_, "directors"));
   entry_->setField(QStringLiteral("nationality"),  mapValue(resultMap_, "countries"));
 
   QStringList castList;
   foreach(const QVariant& actor, resultMap_.value(QLatin1String("actors")).toList()) {
     castList << mapValue(actor.toMap(), "name");
   }
   entry_->setField(QStringLiteral("cast"), castList.join(FieldFormat::rowDelimiterString()));
 
   if(entry_->collection()->hasField(QStringLiteral("moviemeter"))) {
     entry_->setField(QStringLiteral("moviemeter"), mapValue(resultMap_, "url"));
   }
 
   if(entry_->collection()->hasField(QStringLiteral("alttitle"))) {
     entry_->setField(QStringLiteral("alttitle"), mapValue(resultMap_, "alternative_title"));
   }
 
   entry_->setField(QStringLiteral("cover"), mapValue(resultMap_.value(QStringLiteral("posters")).toMap(), "small"));
 }
 
 Tellico::Fetch::ConfigWidget* MovieMeterFetcher::configWidget(QWidget* parent_) const {
   return new MovieMeterFetcher::ConfigWidget(parent_, this);
 }
 
 QString MovieMeterFetcher::defaultName() {
   return QStringLiteral("MovieMeter"); // no translation
 }
 
 QString MovieMeterFetcher::defaultIcon() {
   return favIcon("https://www.moviemeter.nl");
 }
 
 Tellico::StringHash MovieMeterFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("moviemeter")] = i18n("MovieMeter Link");
   hash[QStringLiteral("alttitle")]   = i18n("Alternative Titles");
   return hash;
 }
 
 MovieMeterFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const MovieMeterFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 
   // now add additional fields widget
   addFieldsWidget(MovieMeterFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 void MovieMeterFetcher::ConfigWidget::saveConfigHook(KConfigGroup&) {
 }
 
 QString MovieMeterFetcher::ConfigWidget::preferredName() const {
   return MovieMeterFetcher::defaultName();
 }
diff --git a/src/fetch/mrlookupfetcher.cpp b/src/fetch/mrlookupfetcher.cpp
index 172810c2..9e10202e 100644
--- a/src/fetch/mrlookupfetcher.cpp
+++ b/src/fetch/mrlookupfetcher.cpp
@@ -1,229 +1,229 @@
 /***************************************************************************
     Copyright (C) 2014 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "mrlookupfetcher.h"
 #include "../translators/bibteximporter.h"
 #include "../collections/bibtexcollection.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KConfigGroup>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QFile>
 #include <QTextCodec>
 #include <QUrlQuery>
 
 namespace {
   static const char* MRLOOKUP_URL = "http://www.ams.org/mrlookup";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::MRLookupFetcher;
 
 MRLookupFetcher::MRLookupFetcher(QObject* parent_)
     : Fetcher(parent_)
     , m_started(false) {
 }
 
 MRLookupFetcher::~MRLookupFetcher() {
 }
 
 QString MRLookupFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool MRLookupFetcher::canSearch(FetchKey k) const {
   return k == Title || k == Person;
 }
 
 bool MRLookupFetcher::canFetch(int type) const {
   return type == Data::Collection::Bibtex;
 }
 
 void MRLookupFetcher::readConfigHook(const KConfigGroup& config_) {
   Q_UNUSED(config_);
 }
 
 void MRLookupFetcher::search() {
   m_started = true;
 
   QUrl u(QString::fromLatin1(MRLOOKUP_URL));
   QUrlQuery q;
   switch(request().key) {
     case Title:
       q.addQueryItem(QStringLiteral("ti"), request().value);
       break;
 
     case Person:
       q.addQueryItem(QStringLiteral("au"), request().value);
       break;
 
     default:
       myWarning() << "key not recognized:" << request().key;
       stop();
       return;
   }
   q.addQueryItem(QStringLiteral("format"), QStringLiteral("bibtex"));
   u.setQuery(q);
 
 //  myDebug() << u;
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result, this, &MRLookupFetcher::slotComplete);
 }
 
 void MRLookupFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 Tellico::Data::EntryPtr MRLookupFetcher::fetchEntryHook(uint uid_) {
   return m_entries[uid_];
 }
 
 Tellico::Fetch::FetchRequest MRLookupFetcher::updateRequest(Data::EntryPtr entry_) {
   QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Title, title);
   }
   return FetchRequest();
 }
 
 void MRLookupFetcher::slotComplete(KJob* job_) {
   KIO::StoredTransferJob* job = static_cast<KIO::StoredTransferJob*>(job_);
 
   if(job->error()) {
     job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
   const QString text = QString::fromUtf8(data.constData(), data.size());
   // grab everything within the <pre></pre> block
   QRegExp preRx(QLatin1String("<pre>(.*)</pre>"));
   preRx.setMinimal(true);
 
   QString bibtexString;
   for(int pos = preRx.indexIn(text); pos > -1; pos = preRx.indexIn(text, pos-1)) {
     bibtexString += preRx.cap(1);
     pos += preRx.matchedLength();
  }
   if(bibtexString.isEmpty()) {
     myDebug() << "no bibtex response";
     stop();
     return;
   }
 #if 0
   myWarning() << "Remove debug from mrlookup.cpp";
   QFile f(QString::fromLatin1("/tmp/test.bibtex"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << bibtexString;
   }
   f.close();
 #endif
 
   Import::BibtexImporter imp(bibtexString);
   // quiet warnings...
   imp.setCurrentCollection(Data::CollPtr(new Data::BibtexCollection(true)));
   Data::CollPtr coll = imp.collection();
   if(!coll) {
     myDebug() << "no collection pointer";
     stop();
     return;
   }
 
   // switch the FJournal field with the Journal field
   foreach(Data::EntryPtr entry, coll->entries()) {
     entry->setField(QStringLiteral("journal"), entry->field(QStringLiteral("fjournal")));
   }
   coll->removeField(QStringLiteral("fjournal"));
   // unnecessary fields
   coll->removeField(QStringLiteral("mrclass"));
   coll->removeField(QStringLiteral("mrnumber"));
   coll->removeField(QStringLiteral("mrreviewer"));
 
   foreach(Data::EntryPtr entry, coll->entries()) {
     if(!m_started) {
       // might get aborted
       break;
     }
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, Data::EntryPtr(entry));
     emit signalResultFound(r);
   }
 //  m_hasMoreResults = m_start <= m_total;
   m_hasMoreResults = false; // for now, no continued searches
 
   stop(); // required
 }
 
 Tellico::Fetch::ConfigWidget* MRLookupFetcher::configWidget(QWidget* parent_) const {
   return new MRLookupFetcher::ConfigWidget(parent_, this);
 }
 
 QString MRLookupFetcher::defaultName() {
   return QStringLiteral("Mathematical Reviews");
 }
 
 QString MRLookupFetcher::defaultIcon() {
   return favIcon("http://www.ams.org");
 }
 
 MRLookupFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const MRLookupFetcher* /*=0*/)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 }
 
 QString MRLookupFetcher::ConfigWidget::preferredName() const {
   return MRLookupFetcher::defaultName();
 }
diff --git a/src/fetch/multifetcher.cpp b/src/fetch/multifetcher.cpp
index 77c1b9cc..7693cb40 100644
--- a/src/fetch/multifetcher.cpp
+++ b/src/fetch/multifetcher.cpp
@@ -1,314 +1,316 @@
 /***************************************************************************
     Copyright (C) 2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "multifetcher.h"
 #include "fetchmanager.h"
 #include "../entrycomparison.h"
 #include "../document.h"
 #include "../gui/collectiontypecombo.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 
 using namespace Tellico;
 using Tellico::Fetch::MultiFetcher;
 
 MultiFetcher::MultiFetcher(QObject* parent_)
     : Fetcher(parent_), m_collType(0), m_started(false) {
 }
 
 MultiFetcher::~MultiFetcher() {
 }
 
 QString MultiFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool MultiFetcher::canFetch(int type) const {
   return type == m_collType;
 }
 
 bool MultiFetcher::canSearch(FetchKey k) const {
   return k == Title ||
          (k == ISBN && m_collType == Data::Collection::Book);
 }
 
 void MultiFetcher::readConfigHook(const KConfigGroup& config_) {
   m_collType = config_.readEntry("CollectionType", -1);
   m_uuids = config_.readEntry("Sources", QStringList());
 }
 
 void MultiFetcher::readSources() const {
   if(!m_fetchers.isEmpty()) {
     return;
   }
   foreach(const QString& uuid, m_uuids) {
     Fetcher::Ptr fetcher = Manager::self()->fetcherByUuid(uuid);
     if(fetcher) {
       m_fetchers.append(fetcher);
-      connect(fetcher.data(), SIGNAL(signalResultFound(Tellico::Fetch::FetchResult*)),
-              SLOT(slotResult(Tellico::Fetch::FetchResult*)));
-      connect(fetcher.data(), SIGNAL(signalDone(Tellico::Fetch::Fetcher*)),
-              SLOT(slotDone()));
+      connect(fetcher.data(), &Fetcher::signalResultFound,
+              this, &MultiFetcher::slotResult);
+      connect(fetcher.data(), &Fetcher::signalDone,
+              this, &MultiFetcher::slotDone);
     }
   }
 }
 
 void MultiFetcher::search() {
   m_started = true;
   readSources();
   foreach(Fetcher::Ptr fetcher, m_fetchers) {
     fetcher->startSearch(request());
   }
 }
 
 void MultiFetcher::continueSearch() {
   m_started = true;
   readSources();
   foreach(Fetcher::Ptr fetcher, m_fetchers) {
     fetcher->continueSearch();
   }
 }
 
 void MultiFetcher::stop() {
   if(!m_started) {
     return;
   }
   m_started = false;
   foreach(Fetcher::Ptr fetcher, m_fetchers) {
     fetcher->stop();
   }
   // no need to emit done, since slotDone() will get called
 }
 
 void MultiFetcher::slotResult(Tellico::Fetch::FetchResult* result) {
   Data::EntryPtr newEntry = result->fetchEntry();
   // first check if we've already received this entry result from another fetcher
   bool alreadyFound = false;
   foreach(Data::EntryPtr entry, m_entries) {
     if(entry->collection()->sameEntry(entry, newEntry) > EntryComparison::ENTRY_GOOD_MATCH) {
       // same entry, so instead of adding a new result, just merge it
       Data::Document::mergeEntry(entry, newEntry);
       alreadyFound = true;
       break;
     }
   }
 
   if(!alreadyFound) {
     m_entries.append(newEntry);
   }
 }
 
 void MultiFetcher::slotDone() {
   //keep it simple, if a little slow
   // iterate over all fetchers, if they are still running, do not emit done
   foreach(Fetcher::Ptr fetcher, m_fetchers) {
     if(fetcher->isSearching())  {
       return;
     }
   }
   // done so emit all results
   foreach(Data::EntryPtr entry, m_entries) {
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entryHash.insert(r->uid, entry);
     emit signalResultFound(r);
   }
   emit signalDone(this);
 }
 
 Tellico::Data::EntryPtr MultiFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entryHash[uid_];
   if(!entry) {
     myWarning() << "no entry in hash";
     return Data::EntryPtr();
   }
   return entry;
 }
 
 Tellico::Fetch::FetchRequest MultiFetcher::updateRequest(Data::EntryPtr entry_) {
 //  myDebug();
   QString isbn = entry_->field(QStringLiteral("isbn"));
   if(!isbn.isEmpty()) {
     return FetchRequest(ISBN, isbn);
   }
   QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Title, title);
   }
   return FetchRequest();
 }
 
 Tellico::Fetch::ConfigWidget* MultiFetcher::configWidget(QWidget* parent_) const {
   return new MultiFetcher::ConfigWidget(parent_, this);
 }
 
 QString MultiFetcher::defaultName() {
   return i18n("Multiple Sources");
 }
 
 QString MultiFetcher::defaultIcon() {
   return QStringLiteral("folder-favorites");
 }
 
 Tellico::StringHash MultiFetcher::allOptionalFields() {
   StringHash hash;
   return hash;
 }
 
 MultiFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const MultiFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
 
   QWidget* hbox = new QWidget(optionsWidget());
   QHBoxLayout* hboxHBoxLayout = new QHBoxLayout(hbox);
   hboxHBoxLayout->setMargin(0);
   l->addWidget(hbox);
 
   QLabel* label = new QLabel(i18n("Collection &type:"), hbox);
   hboxHBoxLayout->addWidget(label);
   m_collCombo = new GUI::CollectionTypeCombo(hbox);
-  connect(m_collCombo, SIGNAL(activated(int)), SLOT(slotSetModified()));
-  connect(m_collCombo, SIGNAL(activated(int)), SLOT(slotTypeChanged()));
+  void (GUI::CollectionTypeCombo::* activatedInt)(int) = &GUI::CollectionTypeCombo::activated;
+  connect(m_collCombo, activatedInt, this, &ConfigWidget::slotSetModified);
+  connect(m_collCombo, activatedInt, this, &ConfigWidget::slotTypeChanged);
   label->setBuddy(m_collCombo);
   hboxHBoxLayout->addWidget(m_collCombo);
 
   m_listWidget = new FetcherListWidget(optionsWidget());
   l->addWidget(m_listWidget);
 
   if(fetcher_) {
     if(fetcher_->m_collType > -1) {
       m_collCombo->setCurrentType(fetcher_->m_collType);
     } else {
       m_collCombo->setCurrentType(fetcher_->collectionType());
     }
   } else {
     // default to Book for now
     m_collCombo->setCurrentType(Data::Collection::Book);
   }
   slotTypeChanged();
   // set the source after the type was changed so the fetcher list is already populated
   if(fetcher_) {
     fetcher_->readSources();
     m_listWidget->setSources(fetcher_->m_fetchers);
   }
 }
 
 void MultiFetcher::ConfigWidget::slotTypeChanged() {
   const int collType = m_collCombo->currentType();
   m_listWidget->setFetchers(Fetch::Manager::self()->fetchers(collType));
 }
 
 void MultiFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   config_.writeEntry("CollectionType", m_collCombo->currentType());
   config_.writeEntry("Sources", m_listWidget->uuids());
 }
 
 QString MultiFetcher::ConfigWidget::preferredName() const {
   return MultiFetcher::defaultName();
 }
 
 MultiFetcher::FetcherItemWidget::FetcherItemWidget(QWidget* parent_)
     : QFrame(parent_) {
   QHBoxLayout* layout = new QHBoxLayout(this);
   layout->setSpacing(0);
   layout->setMargin(0);
   setLayout(layout);
 
   QLabel* label = new QLabel(QStringLiteral("Data source:"), this);
   layout->addWidget(label);
   m_fetcherCombo = new GUI::ComboBox(this);
   layout->addWidget(m_fetcherCombo);
-  connect(m_fetcherCombo, SIGNAL(activated(int)), SIGNAL(signalModified()));
+  void (GUI::ComboBox::* activatedInt)(int) = &GUI::ComboBox::activated;
+  connect(m_fetcherCombo, activatedInt, this, &FetcherItemWidget::signalModified);
   label->setBuddy(m_fetcherCombo);
 }
 
 void MultiFetcher::FetcherItemWidget::setFetchers(const QList<Fetcher::Ptr>& fetchers_) {
   m_fetcherCombo->clear();
   m_fetcherCombo->addItem(QString(), QVariant());
   foreach(Fetcher::Ptr fetcher, fetchers_) {
     // can't contain another multiple fetcher
     if(fetcher->type() == Multiple) {
       continue;
     }
     m_fetcherCombo->addItem(Manager::self()->fetcherIcon(fetcher), fetcher->source(), fetcher->uuid());
   }
 }
 
 void MultiFetcher::FetcherItemWidget::setSource(Fetcher::Ptr fetcher_) {
   m_fetcherCombo->setCurrentData(fetcher_->uuid());
 }
 
 QString MultiFetcher::FetcherItemWidget::fetcherUuid() const {
   return m_fetcherCombo->currentData().toString();
 }
 
 MultiFetcher::FetcherListWidget::FetcherListWidget(QWidget* parent_)
     : KWidgetLister(1, 8, parent_) {
-  connect(this, SIGNAL(clearWidgets()), SIGNAL(signalModified()));
+  connect(this, &KWidgetLister::clearWidgets, this, &FetcherListWidget::signalModified);
   // start with at least 1
   setNumberOfShownWidgetsTo(1);
 }
 
 void MultiFetcher::FetcherListWidget::setFetchers(const QList<Fetcher::Ptr>& fetchers_) {
   m_fetchers = fetchers_;
   foreach(QWidget* widget, mWidgetList) {
     FetcherItemWidget* item = static_cast<FetcherItemWidget*>(widget);
     item->setFetchers(fetchers_);
   }
 }
 
 void MultiFetcher::FetcherListWidget::setSources(const QList<Fetcher::Ptr>& fetchers_) {
   setNumberOfShownWidgetsTo(fetchers_.count());
   Q_ASSERT(fetchers_.count() == mWidgetList.count());
   int i = 0;
   foreach(QWidget* widget, mWidgetList) {
     FetcherItemWidget* item = static_cast<FetcherItemWidget*>(widget);
     item->setSource(fetchers_.at(i));
     ++i;
   }
 }
 
 QStringList MultiFetcher::FetcherListWidget::uuids() const {
   QStringList uuids;
   foreach(QWidget* widget, mWidgetList) {
     FetcherItemWidget* item = static_cast<FetcherItemWidget*>(widget);
     QString uuid = item->fetcherUuid();
     if(!uuid.isEmpty()) {
       uuids << uuid;
     }
   }
   return uuids;
 }
 
 QWidget* MultiFetcher::FetcherListWidget::createWidget(QWidget* parent_) {
   FetcherItemWidget* w = new FetcherItemWidget(parent_);
   w->setFetchers(m_fetchers);
-  connect(w, SIGNAL(signalModified()), SIGNAL(signalModified()));
+  connect(w, &FetcherItemWidget::signalModified, this, &FetcherListWidget::signalModified);
   return w;
 }
diff --git a/src/fetch/musicbrainzfetcher.cpp b/src/fetch/musicbrainzfetcher.cpp
index cbc19c7c..7beeb478 100644
--- a/src/fetch/musicbrainzfetcher.cpp
+++ b/src/fetch/musicbrainzfetcher.cpp
@@ -1,366 +1,366 @@
 /***************************************************************************
     Copyright (C) 2009-2018 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include <config.h> // for TELLICO_VERSION
 
 #include "musicbrainzfetcher.h"
 #include "../translators/xslthandler.h"
 #include "../translators/tellicoimporter.h"
 #include "../images/imagefactory.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../collection.h"
 #include "../entry.h"
 #include "../utils/datafileregistry.h"
 #include "../utils/xmlhandler.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KJobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 #include <KConfigGroup>
 
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QGridLayout>
 #include <QDomDocument>
 #include <QTextCodec>
 #include <QUrlQuery>
 #include <QThread>
 
 namespace {
   static const int MUSICBRAINZ_MAX_RETURNS_TOTAL = 10;
   static const char* MUSICBRAINZ_API_URL = "https://musicbrainz.org/ws/2/";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::MusicBrainzFetcher;
 
 MusicBrainzFetcher::MusicBrainzFetcher(QObject* parent_)
     : Fetcher(parent_), m_xsltHandler(nullptr),
       m_limit(MUSICBRAINZ_MAX_RETURNS_TOTAL), m_total(-1), m_offset(0),
       m_job(nullptr), m_started(false) {
 }
 
 MusicBrainzFetcher::~MusicBrainzFetcher() {
   delete m_xsltHandler;
   m_xsltHandler = nullptr;
 }
 
 QString MusicBrainzFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool MusicBrainzFetcher::canFetch(int type) const {
   return type == Data::Collection::Album;
 }
 
 void MusicBrainzFetcher::readConfigHook(const KConfigGroup&) {
 }
 
 void MusicBrainzFetcher::search() {
   m_started = true;
   m_total = -1;
   m_offset = 0;
   doSearch();
 }
 
 void MusicBrainzFetcher::continueSearch() {
   m_started = true;
   doSearch();
 }
 
 void MusicBrainzFetcher::doSearch() {
   QUrl u(QString::fromLatin1(MUSICBRAINZ_API_URL));
   // all searches are for musical releases since Tellico only tracks albums
   u.setPath(u.path() + QStringLiteral("release"));
 
   QString queryString;
   switch(request().key) {
     case Title:
       queryString = QStringLiteral("release:\"%1\"").arg(request().value);
       break;
 
     case Person:
       queryString = QStringLiteral("artist:\"%1\"").arg(request().value);
       break;
 
     case Keyword:
       queryString = QStringLiteral("artist:\"") + request().value + QStringLiteral("\" OR ") +
                     QStringLiteral("release:\"") + request().value + QStringLiteral("\" OR ")  +
                     QStringLiteral("label:\"") + request().value + QStringLiteral("\"");
       break;
 
     case Raw:
       queryString = request().value;
       break;
 
     default:
       myWarning() << "key not recognized: " << request().key;
       stop();
       return;
   }
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("query"), queryString);
   q.addQueryItem(QStringLiteral("limit"), QString::number(m_limit));
   q.addQueryItem(QStringLiteral("offset"), QString::number(m_offset));
   q.addQueryItem(QStringLiteral("fmt"), QStringLiteral("xml"));
   u.setQuery(q);
 //  myDebug() << "url: " << u.url();
 
   m_requestTimer.start();
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   // see https://musicbrainz.org/doc/XML_Web_Service/Rate_Limiting#Provide_meaningful_User-Agent_strings
   m_job->addMetaData(QStringLiteral("UserAgent"), QStringLiteral("Tellico/%1 ( http://tellico-project.org )")
                                                                 .arg(QStringLiteral(TELLICO_VERSION)));
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)),
-          SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result,
+          this, &MusicBrainzFetcher::slotComplete);
 }
 
 void MusicBrainzFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 void MusicBrainzFetcher::slotComplete(KJob* ) {
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from musicbrainzfetcher.cpp";
   QFile f(QStringLiteral("/tmp/test.xml"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   if(m_total == -1) {
     QDomDocument dom;
     if(!dom.setContent(data, false)) {
       myWarning() << "server did not return valid XML:" << data;
       stop();
       return;
     }
     // total is /metadata/release-list/@count
     QDomNode n = dom.documentElement().namedItem(QStringLiteral("release-list"));
     QDomElement e = n.toElement();
     if(!e.isNull()) {
       m_total = e.attribute(QStringLiteral("count")).toInt();
 //      myDebug() << "total = " << m_total;
     }
   }
 
   if(!m_xsltHandler) {
     initXSLTHandler();
     if(!m_xsltHandler) { // probably an error somewhere in the stylesheet loading
       stop();
       return;
     }
   }
 
   // assume always utf-8
   QString str = m_xsltHandler->applyStylesheet(QString::fromUtf8(data.constData(), data.size()));
   Import::TellicoImporter imp(str);
   // be quiet when loading images
   imp.setOptions(imp.options() ^ Import::ImportShowImageErrors);
   Data::CollPtr coll = imp.collection();
   if(!coll) {
     myDebug() << "no collection pointer";
     stop();
     return;
   }
 
   int count = 0;
   Data::EntryList entries = coll->entries();
   foreach(Data::EntryPtr entry, entries) {
     if(count >= m_limit) {
       break;
     }
     if(!m_started) {
       // might get aborted
       break;
     }
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, Data::EntryPtr(entry));
     emit signalResultFound(r);
     ++count;
   }
 
   m_offset += count;
   m_hasMoreResults = m_offset <= m_total;
 
   stop(); // required
 }
 
 Tellico::Data::EntryPtr MusicBrainzFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entries[uid_];
   if(!entry) {
     myWarning() << "no entry in dict";
     return Data::EntryPtr();
   }
 
   QString mbid = entry->field(QStringLiteral("mbid"));
   if(mbid.isEmpty()) {
     return entry;
   }
 
   QUrl u(QString::fromLatin1(MUSICBRAINZ_API_URL));
   u.setPath(u.path() + QStringLiteral("release/") + mbid);
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("fmt"), QStringLiteral("xml"));
   q.addQueryItem(QStringLiteral("inc"), QStringLiteral("artists+recordings+release-groups+labels+url-rels"));
   u.setQuery(q);
 //  myDebug() << u;
 
   // limit to one request per second
   while(m_requestTimer.elapsed() < 1000) {
     QThread::msleep(300);
   }
   m_requestTimer.start();
 
   KIO::StoredTransferJob* dataJob = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   dataJob->addMetaData(QStringLiteral("UserAgent"), QStringLiteral("Tellico/%1 ( http://tellico-project.org )")
                                                                 .arg(QStringLiteral(TELLICO_VERSION)));
   if(!dataJob->exec()) {
     myDebug() << "Failed to load" << u;
     return entry;
   }
   const QString output = XMLHandler::readXMLData(dataJob->data());
 #if 0
   myWarning() << "Remove output debug from musicbrainzfetcher.cpp";
   QFile f(QStringLiteral("/tmp/test2.xml"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << output;
   }
   f.close();
 #endif
 
   Import::TellicoImporter imp(m_xsltHandler->applyStylesheet(output));
   // be quiet when loading images
   imp.setOptions(imp.options() ^ Import::ImportShowImageErrors);
   Data::CollPtr coll = imp.collection();
 //  getTracks(entry);
   if(!coll || coll->entries().isEmpty()) {
     myWarning() << "no collection pointer or no entries";
     return entry;
   }
 
   if(coll->entryCount() > 1) {
     myDebug() << "weird, more than one entry found";
   }
 
   // don't want to include id
   coll->removeField(QStringLiteral("mbid"));
 
   entry = coll->entries().front();
   m_entries.insert(uid_, entry); // replaces old value
   return entry;
 }
 
 void MusicBrainzFetcher::initXSLTHandler() {
   QString xsltfile = DataFileRegistry::self()->locate(QStringLiteral("musicbrainz2tellico.xsl"));
   if(xsltfile.isEmpty()) {
     myWarning() << "can not locate musicbrainz2tellico.xsl.";
     return;
   }
 
   QUrl u = QUrl::fromLocalFile(xsltfile);
 
   delete m_xsltHandler;
   m_xsltHandler = new XSLTHandler(u);
   if(!m_xsltHandler->isValid()) {
     myWarning() << "error in musicbrainz2tellico.xsl.";
     delete m_xsltHandler;
     m_xsltHandler = nullptr;
     return;
   }
 }
 
 Tellico::Fetch::FetchRequest MusicBrainzFetcher::updateRequest(Data::EntryPtr entry_) {
   const QString title = entry_->field(QStringLiteral("title"));
   const QString artist = entry_->field(QStringLiteral("artist"));
   if(artist.isEmpty() && !title.isEmpty()) {
     return FetchRequest(Title, title);
   } else if(title.isEmpty() && !artist.isEmpty()) {
     return FetchRequest(Person, artist);
   } else if(!title.isEmpty() && !artist.isEmpty()) {
     return FetchRequest(Raw, QStringLiteral("release:\"%1\" AND artist:\"%2\"").arg(title, artist));
   }
   return FetchRequest();
 }
 
 Tellico::Fetch::ConfigWidget* MusicBrainzFetcher::configWidget(QWidget* parent_) const {
   return new MusicBrainzFetcher::ConfigWidget(parent_, this);
 }
 
 QString MusicBrainzFetcher::defaultName() {
   return QStringLiteral("MusicBrainz"); // no translation
 }
 
 QString MusicBrainzFetcher::defaultIcon() {
   return favIcon("https://musicbrainz.org");
 }
 
 MusicBrainzFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const MusicBrainzFetcher*)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 }
 
 void MusicBrainzFetcher::ConfigWidget::saveConfigHook(KConfigGroup&) {
 }
 
 QString MusicBrainzFetcher::ConfigWidget::preferredName() const {
   return MusicBrainzFetcher::defaultName();
 }
diff --git a/src/fetch/omdbfetcher.cpp b/src/fetch/omdbfetcher.cpp
index 4205fbfe..e76b8745 100644
--- a/src/fetch/omdbfetcher.cpp
+++ b/src/fetch/omdbfetcher.cpp
@@ -1,415 +1,415 @@
 /***************************************************************************
     Copyright (C) 2017 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "omdbfetcher.h"
 #include "../collections/videocollection.h"
 #include "../images/imagefactory.h"
 #include "../utils/guiproxy.h"
 #include "../core/filehandler.h"
 #include "../utils/string_utils.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KJob>
 #include <KJobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 #include <KIO/StoredTransferJob>
 
 #include <QUrl>
 #include <QLabel>
 #include <QLineEdit>
 #include <QFile>
 #include <QTextStream>
 #include <QGridLayout>
 #include <QTextCodec>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QUrlQuery>
 
 namespace {
   static const int OMDB_MAX_RETURNS_TOTAL = 20;
   static const char* OMDB_API_URL = "https://www.omdbapi.com";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::OMDBFetcher;
 
 OMDBFetcher::OMDBFetcher(QObject* parent_)
     : Fetcher(parent_)
     , m_started(false) {
   //  setLimit(OMDB_MAX_RETURNS_TOTAL);
 }
 
 OMDBFetcher::~OMDBFetcher() {
 }
 
 QString OMDBFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool OMDBFetcher::canSearch(FetchKey k) const {
   return k == Title;
 }
 
 bool OMDBFetcher::canFetch(int type) const {
   return type == Data::Collection::Video;
 }
 
 void OMDBFetcher::readConfigHook(const KConfigGroup& config_) {
   QString k = config_.readEntry("API Key", QString());
   if(!k.isEmpty()) {
     m_apiKey = k;
   }
 }
 
 void OMDBFetcher::saveConfigHook(KConfigGroup&) {
 }
 
 void OMDBFetcher::search() {
   continueSearch();
 }
 
 void OMDBFetcher::continueSearch() {
   m_started = true;
 
   if(m_apiKey.isEmpty()) {
     myDebug() << "No API key";
     message(i18n("An access key is required to use this data source.")
             + QLatin1Char(' ') +
             i18n("Those values must be entered in the data source settings."), MessageHandler::Error);
     stop();
     return;
   }
 
   QUrl u(QString::fromLatin1(OMDB_API_URL));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("apikey"), m_apiKey);
   switch(request().key) {
     case Title:
       q.addQueryItem(QStringLiteral("type"), QStringLiteral("movie"));
       q.addQueryItem(QStringLiteral("r"), QStringLiteral("json"));
       q.addQueryItem(QStringLiteral("s"), request().value);
       break;
 
     default:
       myWarning() << "key not recognized:" << request().key;
       stop();
       return;
   }
   u.setQuery(q);
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result, this, &OMDBFetcher::slotComplete);
 }
 
 void OMDBFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 Tellico::Data::EntryPtr OMDBFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entries.value(uid_);
   if(!entry) {
     myWarning() << "no entry in dict";
     return Data::EntryPtr();
   }
 
   QString id = entry->field(QStringLiteral("imdb-id"));
   if(!id.isEmpty()) {
     // quiet
     QUrl u(QString::fromLatin1(OMDB_API_URL));
     QUrlQuery q;
     q.addQueryItem(QStringLiteral("type"), QStringLiteral("movie"));
     q.addQueryItem(QStringLiteral("r"), QStringLiteral("json"));
     q.addQueryItem(QStringLiteral("i"), id);
     q.addQueryItem(QStringLiteral("apikey"), m_apiKey);
     u.setQuery(q);
     QByteArray data = FileHandler::readDataFile(u, true);
 #if 0
     myWarning() << "Remove debug2 from omdbfetcher.cpp";
     QFile f(QString::fromLatin1("/tmp/test2.json"));
     if(f.open(QIODevice::WriteOnly)) {
       QTextStream t(&f);
       t.setCodec("UTF-8");
       t << data;
     }
     f.close();
 #endif
     QJsonDocument doc = QJsonDocument::fromJson(data);
     populateEntry(entry, doc.object().toVariantMap(), true);
   }
 
   // image might still be a URL
   const QString image_id = entry->field(QStringLiteral("cover"));
   if(image_id.contains(QLatin1Char('/'))) {
     const QString id = ImageFactory::addImage(QUrl::fromUserInput(image_id), true /* quiet */);
     if(id.isEmpty()) {
       message(i18n("The cover image could not be loaded."), MessageHandler::Warning);
     }
     // empty image ID is ok
     entry->setField(QStringLiteral("cover"), id);
   }
 
   // don't want to include IMDb ID field
   entry->setField(QStringLiteral("imdb-id"), QString());
 
   return entry;
 }
 
 Tellico::Fetch::FetchRequest OMDBFetcher::updateRequest(Data::EntryPtr entry_) {
   QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Title, title);
   }
   return FetchRequest();
 }
 
 void OMDBFetcher::slotComplete(KJob* job_) {
   KIO::StoredTransferJob* job = static_cast<KIO::StoredTransferJob*>(job_);
 
   if(job->error()) {
     job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from omdbfetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/test.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   Data::CollPtr coll(new Data::VideoCollection(true));
   // always add the imdb-id for fetchEntryHook
   Data::FieldPtr field(new Data::Field(QStringLiteral("imdb-id"), QStringLiteral("IMDb ID"), Data::Field::Line));
   field->setCategory(i18n("General"));
   coll->addField(field);
 
 #if 0
   if(optionalFields().contains(QStringLiteral("imdb"))) {
     Data::FieldPtr field(new Data::Field(QLatin1String("imdb"), i18n("IMDb Link"), Data::Field::URL));
     field->setCategory(i18n("General"));
     coll->addField(field);
   }
   if(optionalFields().contains(QStringLiteral("alttitle"))) {
     Data::FieldPtr field(new Data::Field(QLatin1String("alttitle"), i18n("Alternative Titles"), Data::Field::Table));
     field->setFormatType(FieldFormat::FormatTitle);
     coll->addField(field);
   }
   if(optionalFields().contains(QStringLiteral("origtitle"))) {
     Data::FieldPtr f(new Data::Field(QLatin1String("origtitle"), i18n("Original Title")));
     f->setFormatType(FieldFormat::FormatTitle);
     coll->addField(f);
   }
 #endif
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   QVariantMap result = doc.object().toVariantMap();
 
   const bool response = result.value(QStringLiteral("Response")).toBool();
   if(!response) {
     myDebug() << "Error:" << result.value(QStringLiteral("Error")).toString();
     message(result.value(QStringLiteral("Error")).toString(), MessageHandler::Error);
     stop();
     return;
   }
 
   QVariantList resultList = result.value(QStringLiteral("Search")).toList();
   if(resultList.isEmpty()) {
     myDebug() << "no results";
     stop();
     return;
   }
 
   int count = 0;
   foreach(const QVariant& result, resultList) {
 //    myDebug() << "found result:" << result;
 
     Data::EntryPtr entry(new Data::Entry(coll));
     populateEntry(entry, result.toMap(), false);
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
     ++count;
     if(count >= OMDB_MAX_RETURNS_TOTAL) {
       break;
     }
   }
 
   stop();
 }
 
 void OMDBFetcher::populateEntry(Data::EntryPtr entry_, const QVariantMap& resultMap_, bool fullData_) {
   entry_->setField(QStringLiteral("imdb-id"), mapValue(resultMap_, "imdbID"));
   entry_->setField(QStringLiteral("title"), mapValue(resultMap_, "Title"));
   entry_->setField(QStringLiteral("year"),  mapValue(resultMap_, "Year"));
 
   if(!fullData_) {
     return;
   }
 
   const QString cert = mapValue(resultMap_, "Rated");
   Data::FieldPtr certField = entry_->collection()->fieldByName(QStringLiteral("certification"));
   if(certField) {
     foreach(const QString& value, certField->allowed()) {
       if(value.startsWith(cert)) {
         entry_->setField(QStringLiteral("certification"), value);
         break;
       }
     }
   }
   entry_->setField(QStringLiteral("running-time"), mapValue(resultMap_, "Runtime")
                                                   .remove(QRegExp(QLatin1String("[^\\d]"))));
 
   const QStringList genres = mapValue(resultMap_, "Genre").split(QStringLiteral(", "));
   entry_->setField(QStringLiteral("genre"), genres.join(FieldFormat::delimiterString()));
 
   const QStringList directors = mapValue(resultMap_, "Director").split(QStringLiteral(", "));
   entry_->setField(QStringLiteral("director"), directors.join(FieldFormat::delimiterString()));
 
   QStringList writers = mapValue(resultMap_, "Writer").split(QStringLiteral(", "));
   // some wrtiers have parentheticals, remove those
   entry_->setField(QStringLiteral("writer"), writers
                                            .replaceInStrings(QRegExp(QLatin1String("\\s*\\(.+\\)\\s*")), QString())
                                            .join(FieldFormat::delimiterString()));
 
   const QStringList producers = mapValue(resultMap_, "Producer").split(QStringLiteral(", "));
   entry_->setField(QStringLiteral("producer"), producers.join(FieldFormat::delimiterString()));
 
   const QStringList actors = mapValue(resultMap_, "Actors").split(QStringLiteral(", "));
   entry_->setField(QStringLiteral("cast"), actors.join(FieldFormat::rowDelimiterString()));
 
   const QStringList countries = mapValue(resultMap_, "Country").split(QStringLiteral(", "));
   entry_->setField(QStringLiteral("nationality"), countries.join(FieldFormat::delimiterString()));
 
   const QStringList langs = mapValue(resultMap_, "Language").split(QStringLiteral(", "));
   entry_->setField(QStringLiteral("language"), langs.join(FieldFormat::delimiterString()));
 
   entry_->setField(QStringLiteral("cover"), mapValue(resultMap_, "Poster"));
   entry_->setField(QStringLiteral("plot"), mapValue(resultMap_, "Plot"));
 
   if(optionalFields().contains(QStringLiteral("imdb"))) {
     if(!entry_->collection()->hasField(QStringLiteral("imdb"))) {
       Data::FieldPtr field(new Data::Field(QStringLiteral("imdb"), i18n("IMDb Link"), Data::Field::URL));
       field->setCategory(i18n("General"));
       entry_->collection()->addField(field);
     }
     entry_->setField(QStringLiteral("imdb"), QLatin1String("http://www.imdb.com/title/")
                                           + entry_->field(QStringLiteral("imdb-id"))
                                           + QLatin1Char('/'));
   }
 
 }
 
 Tellico::Fetch::ConfigWidget* OMDBFetcher::configWidget(QWidget* parent_) const {
   return new OMDBFetcher::ConfigWidget(parent_, this);
 }
 
 QString OMDBFetcher::defaultName() {
   return QStringLiteral("The Open Movie Database");
 }
 
 QString OMDBFetcher::defaultIcon() {
   return favIcon("http://www.omdbapi.com");
 }
 
 Tellico::StringHash OMDBFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("imdb")] = i18n("IMDb Link");
   return hash;
 }
 
 OMDBFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const OMDBFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
   QLabel* al = new QLabel(i18n("Registration is required for accessing the %1 data source. "
                                "If you agree to the terms and conditions, <a href='%2'>sign "
                                "up for an account</a>, and enter your information below.",
                                 preferredName(),
                                 QLatin1String("http://www.omdbapi.com")),
                           optionsWidget());
   al->setOpenExternalLinks(true);
   al->setWordWrap(true);
   ++row;
   l->addWidget(al, row, 0, 1, 2);
   // richtext gets weird with size
   al->setMinimumWidth(al->sizeHint().width());
 
   QLabel* label = new QLabel(i18n("Access key: "), optionsWidget());
   l->addWidget(label, ++row, 0);
 
   m_apiKeyEdit = new QLineEdit(optionsWidget());
-  connect(m_apiKeyEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_apiKeyEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_apiKeyEdit, row, 1);
   label->setBuddy(m_apiKeyEdit);
 
   l->setRowStretch(++row, 10);
 
   if(fetcher_) {
     m_apiKeyEdit->setText(fetcher_->m_apiKey);
   }
 
   // now add additional fields widget
   addFieldsWidget(OMDBFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 void OMDBFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   const QString apiKey = m_apiKeyEdit->text().trimmed();
   if(!apiKey.isEmpty()) {
     config_.writeEntry("API Key", apiKey);
   }
 }
 
 QString OMDBFetcher::ConfigWidget::preferredName() const {
   return OMDBFetcher::defaultName();
 }
diff --git a/src/fetch/openlibraryfetcher.cpp b/src/fetch/openlibraryfetcher.cpp
index 95be6cc3..1234e246 100644
--- a/src/fetch/openlibraryfetcher.cpp
+++ b/src/fetch/openlibraryfetcher.cpp
@@ -1,409 +1,409 @@
 /***************************************************************************
     Copyright (C) 2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "openlibraryfetcher.h"
 #include "../collections/bookcollection.h"
 #include "../images/imagefactory.h"
 #include "../utils/isbnvalidator.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../entry.h"
 #include "../core/filehandler.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KJobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QGridLayout>
 #include <QTextCodec>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QJsonArray>
 #include <QUrlQuery>
 
 namespace {
   static const char* OPENLIBRARY_QUERY_URL = "http://openlibrary.org/query.json";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::OpenLibraryFetcher;
 
 OpenLibraryFetcher::OpenLibraryFetcher(QObject* parent_)
     : Fetcher(parent_), m_started(false) {
 }
 
 OpenLibraryFetcher::~OpenLibraryFetcher() {
 }
 
 QString OpenLibraryFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool OpenLibraryFetcher::canSearch(FetchKey k) const {
   return k == Title || k == Person || k == ISBN || k == LCCN || k == Keyword;
 }
 
 bool OpenLibraryFetcher::canFetch(int type) const {
   return type == Data::Collection::Book || type == Data::Collection::Bibtex;
 }
 
 void OpenLibraryFetcher::readConfigHook(const KConfigGroup&) {
 }
 
 void OpenLibraryFetcher::search() {
   m_started = true;
   // we only split ISBN and LCCN values
   QStringList searchTerms;
   if(request().key == ISBN || request().key == LCCN) {
     searchTerms = FieldFormat::splitValue(request().value);
   } else  {
     searchTerms += request().value;
   }
   foreach(const QString& searchTerm, searchTerms) {
     doSearch(searchTerm);
   }
   if(m_jobs.isEmpty()) {
     stop();
   }
 }
 
 void OpenLibraryFetcher::doSearch(const QString& term_) {
   QUrl u(QString::fromLatin1(OPENLIBRARY_QUERY_URL));
   QUrlQuery q;
   // books are type/edition
   q.addQueryItem(QStringLiteral("type"), QStringLiteral("/type/edition"));
   q.addQueryItem(QStringLiteral("*"), QString());
 
   switch(request().key) {
     case Title:
       q.addQueryItem(QStringLiteral("title"), term_);
       break;
 
     case Person:
       {
         const QString author = getAuthorKeys(term_);
         if(author.isEmpty()) {
           myWarning() << "no authors found";
           return;
         }
         q.addQueryItem(QStringLiteral("authors"), author);
       }
       break;
 
     case ISBN:
       {
         const QString isbn = ISBNValidator::cleanValue(term_);
         if(isbn.size() > 10) {
           q.addQueryItem(QStringLiteral("isbn_13"), isbn);
         } else {
           q.addQueryItem(QStringLiteral("isbn_10"), isbn);
         }
       }
       break;
 
     case LCCN:
       q.addQueryItem(QStringLiteral("lccn"), term_);
       break;
 
     case Keyword:
       myWarning() << "not supported";
       return;
 
     default:
       myWarning() << "key not recognized:" << request().key;
       return;
   }
   u.setQuery(q);
 //  myDebug() << "url:" << u;
 
   QPointer<KIO::StoredTransferJob> job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(job, GUI::Proxy::widget());
-  connect(job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(job.data(), &KJob::result, this, &OpenLibraryFetcher::slotComplete);
   m_jobs << job;
 }
 
 void OpenLibraryFetcher::endJob(KIO::StoredTransferJob* job_) {
   m_jobs.removeAll(job_);
   if(m_jobs.isEmpty())  {
     stop();
   }
 }
 
 void OpenLibraryFetcher::stop() {
   if(!m_started) {
     return;
   }
   foreach(QPointer<KIO::StoredTransferJob> job, m_jobs) {
     if(job) {
       job->kill();
     }
   }
   m_jobs.clear();
   m_started = false;
   emit signalDone(this);
 }
 
 Tellico::Data::EntryPtr OpenLibraryFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entries.value(uid_);
   if(!entry) {
     myWarning() << "no entry in dict";
     return Data::EntryPtr();
   }
 
   // if the entry is not set, go ahead and try to fetch it
   if(entry->field(QStringLiteral("cover")).isEmpty()) {
     const QString isbn = ISBNValidator::cleanValue(entry->field(QStringLiteral("isbn")));
     if(!isbn.isEmpty()) {
       QUrl imageUrl(QStringLiteral("http://covers.openlibrary.org/b/isbn/%1-M.jpg?default=false").arg(isbn));
       const QString id = ImageFactory::addImage(imageUrl, true);
       if(!id.isEmpty()) {
         entry->setField(QStringLiteral("cover"), id);
       }
     }
   }
 
   return entry;
 }
 
 Tellico::Fetch::FetchRequest OpenLibraryFetcher::updateRequest(Data::EntryPtr entry_) {
   const QString isbn = entry_->field(QStringLiteral("isbn"));
   if(!isbn.isEmpty()) {
     return FetchRequest(ISBN, isbn);
   }
   const QString lccn = entry_->field(QStringLiteral("lccn"));
   if(!lccn.isEmpty()) {
     return FetchRequest(LCCN, lccn);
   }
   const QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Title, title);
   }
   return FetchRequest();
 }
 
 void OpenLibraryFetcher::slotComplete(KJob* job_) {
   KIO::StoredTransferJob* job = static_cast<KIO::StoredTransferJob*>(job_);
 //  myDebug();
 
   if(job->error()) {
     job->uiDelegate()->showErrorMessage();
     endJob(job);
     return;
   }
 
   QByteArray data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     endJob(job);
     return;
   }
 
 #if 0
   myWarning() << "Remove debug from openlibraryfetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/test.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   QJsonArray array = doc.array();
   if(array.isEmpty()) {
 //    myDebug() << "no results";
     endJob(job);
     return;
   }
 
   Data::CollPtr coll(new Data::BookCollection(true));
   if(!coll->hasField(QStringLiteral("openlibrary")) && optionalFields().contains(QStringLiteral("openlibrary"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("openlibrary"), i18n("OpenLibrary Link"), Data::Field::URL));
     field->setCategory(i18n("General"));
     coll->addField(field);
   }
 
   for(int i = 0; i < array.count(); i++) {
     // be sure to check that the fetcher has not been stopped
     // crashes can occur if not
     if(!m_started) {
       break;
     }
 //    myDebug() << "found result:" << result;
     QVariantMap resultMap = array.at(i).toObject().toVariantMap();
 
 //  myDebug() << resultMap.value(QLatin1String("isbn_10")).toList().at(0);
 
     Data::EntryPtr entry(new Data::Entry(coll));
 
     entry->setField(QStringLiteral("title"), mapValue(resultMap, "title"));
     entry->setField(QStringLiteral("subtitle"), mapValue(resultMap, "subtitle"));
     entry->setField(QStringLiteral("pub_year"), mapValue(resultMap, "publish_date"));
     QString isbn = mapValue(resultMap, "isbn_10");
     if(isbn.isEmpty()) {
       isbn = mapValue(resultMap, "isbn_13");
     }
     if(!isbn.isEmpty()) {
       ISBNValidator val(this);
       val.fixup(isbn);
       entry->setField(QStringLiteral("isbn"), isbn);
     }
     entry->setField(QStringLiteral("lccn"), mapValue(resultMap, "lccn"));
     entry->setField(QStringLiteral("genre"), mapValue(resultMap, "genres"));
     entry->setField(QStringLiteral("keyword"), mapValue(resultMap, "subjects"));
     entry->setField(QStringLiteral("edition"), mapValue(resultMap, "edition_name"));
     QString binding = mapValue(resultMap, "physical_format");
     if(binding.toLower() == QLatin1String("hardcover")) {
       binding = QStringLiteral("Hardback");
     } else if(binding.contains(QStringLiteral("paperback"), Qt::CaseInsensitive)) {
       binding = QStringLiteral("Paperback");
     }
     if(!binding.isEmpty()) {
       entry->setField(QStringLiteral("binding"), i18n(binding.toUtf8().constData()));
     }
     entry->setField(QStringLiteral("publisher"), mapValue(resultMap, "publishers"));
     entry->setField(QStringLiteral("series"), mapValue(resultMap, "series"));
     entry->setField(QStringLiteral("pages"), mapValue(resultMap, "number_of_pages"));
     entry->setField(QStringLiteral("comments"), mapValue(resultMap, "notes"));
 
     if(optionalFields().contains(QStringLiteral("openlibrary"))) {
       entry->setField(QStringLiteral("openlibrary"), QLatin1String("http://openlibrary.org") + mapValue(resultMap, "key"));
     }
 
     QStringList authors;
     foreach(const QVariant& authorMap, resultMap.value(QLatin1String("authors")).toList()) {
       const QString key = mapValue(authorMap.toMap(), "key");
       if(!key.isEmpty()) {
         QUrl authorUrl(QString::fromLatin1(OPENLIBRARY_QUERY_URL));
         QUrlQuery q;
         q.addQueryItem(QStringLiteral("type"), QStringLiteral("/type/author"));
         q.addQueryItem(QStringLiteral("key"), key);
         q.addQueryItem(QStringLiteral("name"), QString());
         authorUrl.setQuery(q);
 
         QString output = FileHandler::readTextFile(authorUrl, true /*quiet*/);
         QJsonDocument doc = QJsonDocument::fromJson(output.toUtf8());
         QJsonArray array = doc.array();
         QVariantMap authorResult = array.isEmpty() ? QVariantMap() : array.at(0).toObject().toVariantMap();
         const QString name = mapValue(authorResult, "name");
         if(!name.isEmpty()) {
           authors << name;
         }
       }
     }
     if(!authors.isEmpty()) {
       entry->setField(QStringLiteral("author"), authors.join(FieldFormat::delimiterString()));
     }
 
     QStringList langs;
     foreach(const QVariant& langMap, resultMap.value(QLatin1String("languages")).toList()) {
       const QString key = mapValue(langMap.toMap(), "key");
       if(!key.isEmpty()) {
         QUrl langUrl(QString::fromLatin1(OPENLIBRARY_QUERY_URL));
         QUrlQuery q;
         q.addQueryItem(QStringLiteral("type"), QStringLiteral("/type/language"));
         q.addQueryItem(QStringLiteral("key"), key);
         q.addQueryItem(QStringLiteral("name"), QString());
         langUrl.setQuery(q);
 
         QString output = FileHandler::readTextFile(langUrl, true /*quiet*/, true /*utf8*/);
         QJsonDocument doc = QJsonDocument::fromJson(output.toUtf8());
         QJsonArray array = doc.array();
         QVariantMap langResult = array.isEmpty() ? QVariantMap() : array.at(0).toObject().toVariantMap();
         const QString name = mapValue(langResult, "name");
         if(!name.isEmpty()) {
           langs << i18n(name.toUtf8().constData());
         }
       }
     }
     if(!langs.isEmpty()) {
       entry->setField(QStringLiteral("language"), langs.join(FieldFormat::delimiterString()));
     }
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
   }
 
 //  m_start = m_entries.count();
 //  m_hasMoreResults = m_start <= m_total;
   m_hasMoreResults = false; // for now, no continued searches
   endJob(job);
 }
 
 QString OpenLibraryFetcher::getAuthorKeys(const QString& term_) {
   QUrl u(QString::fromLatin1(OPENLIBRARY_QUERY_URL));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("type"), QStringLiteral("/type/author"));
   q.addQueryItem(QStringLiteral("name"), term_);
   u.setQuery(q);
 
   QString output = FileHandler::readTextFile(u, true /*quiet*/, true /*utf8*/);
   QJsonDocument doc = QJsonDocument::fromJson(output.toUtf8());
   QJsonArray array = doc.array();
 //  myDebug() << "found" << array.count() << "authors";
   // right now, only use the first
   return array.isEmpty() ? QString() : mapValue(array.at(0).toObject().toVariantMap(), "key");
 }
 
 Tellico::Fetch::ConfigWidget* OpenLibraryFetcher::configWidget(QWidget* parent_) const {
   return new OpenLibraryFetcher::ConfigWidget(parent_, this);
 }
 
 QString OpenLibraryFetcher::defaultName() {
   return QStringLiteral("Open Library"); // no translation
 }
 
 QString OpenLibraryFetcher::defaultIcon() {
   return favIcon("http://openlibrary.org");
 }
 
 Tellico::StringHash OpenLibraryFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("openlibrary")] = i18n("OpenLibrary Link");
   return hash;
 }
 
 OpenLibraryFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const OpenLibraryFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 
   // now add additional fields widget
   addFieldsWidget(OpenLibraryFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 void OpenLibraryFetcher::ConfigWidget::saveConfigHook(KConfigGroup&) {
 }
 
 QString OpenLibraryFetcher::ConfigWidget::preferredName() const {
   return OpenLibraryFetcher::defaultName();
 }
diff --git a/src/fetch/srufetcher.cpp b/src/fetch/srufetcher.cpp
index 325ebcbd..ac92dfb0 100644
--- a/src/fetch/srufetcher.cpp
+++ b/src/fetch/srufetcher.cpp
@@ -1,641 +1,643 @@
 /***************************************************************************
     Copyright (C) 2003-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "srufetcher.h"
 #include "../fieldformat.h"
 #include "../collection.h"
 #include "../translators/tellico_xml.h"
 #include "../translators/xslthandler.h"
 #include "../translators/tellicoimporter.h"
 #include "../utils/guiproxy.h"
 #include "../gui/lineedit.h"
 #include "../gui/combobox.h"
 #include "../gui/stringmapwidget.h"
 #include "../utils/string_utils.h"
 #include "../utils/lccnvalidator.h"
 #include "../utils/isbnvalidator.h"
 #include "../utils/datafileregistry.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KIO/Job>
 #include <KJobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 #include <KConfigGroup>
 #include <KComboBox>
 #include <KAcceleratorManager>
 
 #include <QSpinBox>
 #include <QLabel>
 #include <QGridLayout>
 #include <QFile>
 #include <QUrlQuery>
 #include <QDomDocument>
 
 namespace {
   // 7090 was the old default port, but that was just because LoC used it
   // let's use default HTTP port of 80 now
   static const int SRU_DEFAULT_PORT = 80;
   static const int SRU_MAX_RECORDS = 25;
 }
 
 using namespace Tellico;
 using Tellico::Fetch::SRUFetcher;
 
 SRUFetcher::SRUFetcher(QObject* parent_)
     : Fetcher(parent_), m_port(SRU_DEFAULT_PORT), m_job(nullptr), m_MARCXMLHandler(nullptr), m_MODSHandler(nullptr), m_SRWHandler(nullptr), m_started(false) {
 }
 
 SRUFetcher::SRUFetcher(const QString& name_, const QString& host_, uint port_, const QString& path_,
                        const QString& format_, QObject* parent_) : Fetcher(parent_),
       m_host(host_), m_port(port_), m_path(path_), m_format(format_),
       m_job(nullptr), m_MARCXMLHandler(nullptr), m_MODSHandler(nullptr), m_SRWHandler(nullptr), m_started(false) {
   m_name = name_; // m_name is protected in super class
   if(!m_path.startsWith(QLatin1Char('/'))) {
     m_path.prepend(QLatin1Char('/'));
   }
 }
 
 SRUFetcher::~SRUFetcher() {
   delete m_MARCXMLHandler;
   m_MARCXMLHandler = nullptr;
   delete m_MODSHandler;
   m_MODSHandler = nullptr;
   delete m_SRWHandler;
   m_SRWHandler = nullptr;
 }
 
 QString SRUFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool SRUFetcher::canFetch(int type) const {
   return type == Data::Collection::Book || type == Data::Collection::Bibtex;
 }
 
 void SRUFetcher::readConfigHook(const KConfigGroup& config_) {
   m_host = config_.readEntry("Host");
   int p = config_.readEntry("Port", SRU_DEFAULT_PORT);
   if(p > 0) {
     m_port = p;
   }
   m_path = config_.readEntry("Path");
   // used to be called Database
   if(m_path.isEmpty()) {
     m_path = config_.readEntry("Database");
   }
   if(!m_path.startsWith(QLatin1Char('/'))) {
     m_path.prepend(QLatin1Char('/'));
   }
   m_format = config_.readEntry("Format", "mods");
   const QStringList queryFields = config_.readEntry("QueryFields", QStringList());
   const QStringList queryValues = config_.readEntry("QueryValues", QStringList());
   Q_ASSERT(queryFields.count() == queryValues.count());
   for(int i = 0; i < qMin(queryFields.count(), queryValues.count()); ++i) {
     m_queryMap.insert(queryFields.at(i), queryValues.at(i));
   }
 }
 
 void SRUFetcher::search() {
   if(m_host.isEmpty() || m_path.isEmpty() || m_format.isEmpty()) {
     myDebug() << "settings are not set!";
     stop();
     return;
   }
 
   m_started = true;
 
   QUrl u;
   u.setScheme(QStringLiteral("http"));
   u.setHost(m_host);
   u.setPort(m_port);
   u = QUrl::fromUserInput(u.url() + m_path);
 
   QUrlQuery query;
   for(StringMap::ConstIterator it = m_queryMap.constBegin(); it != m_queryMap.constEnd(); ++it) {
     query.addQueryItem(it.key(), it.value());
   }
   // allow user to override these so check for existing item first
   if(!query.hasQueryItem(QStringLiteral("operation"))) {
     query.addQueryItem(QStringLiteral("operation"), QStringLiteral("searchRetrieve"));
   }
   if(!query.hasQueryItem(QStringLiteral("version"))) {
     query.addQueryItem(QStringLiteral("version"), QStringLiteral("1.1"));
   }
   if(!query.hasQueryItem(QStringLiteral("maximumRecords"))) {
     query.addQueryItem(QStringLiteral("maximumRecords"), QString::number(SRU_MAX_RECORDS));
   }
   if(!m_format.isEmpty() && m_format != QLatin1String("none")
      && !query.hasQueryItem(QStringLiteral("recordSchema"))) {
     query.addQueryItem(QStringLiteral("recordSchema"), m_format);
   }
 
   const int type = collectionType();
   QString str = QLatin1Char('"') + request().value + QLatin1Char('"');
   switch(request().key) {
     case Title:
       query.addQueryItem(QStringLiteral("query"), QLatin1String("dc.title=") + str);
       break;
 
     case Person:
       {
         QString s;
         if(type == Data::Collection::Book || type == Data::Collection::Bibtex) {
           s = QLatin1String("author=") + str + QLatin1String(" or dc.author=") + str;
         } else {
           s = QLatin1String("dc.creator=") + str + QLatin1String(" or dc.editor=") + str;
         }
         query.addQueryItem(QStringLiteral("query"), s);
       }
       break;
 
     case ISBN:
       {
         QString s = request().value;
         s.remove(QLatin1Char('-'));
         QStringList isbnList = FieldFormat::splitValue(s);
         // also search for isbn10 values
         for(QStringList::Iterator it = isbnList.begin(); it != isbnList.end(); ++it) {
           if((*it).startsWith(QLatin1String("978"))) {
             QString isbn10 = ISBNValidator::isbn10(*it);
             isbn10.remove(QLatin1Char('-'));
             it = isbnList.insert(it, isbn10);
             ++it;
           }
         }
         QString q;
         for(int i = 0; i < isbnList.count(); ++i) {
           // make an assumption that DC output uses the dc profile and everything else uses Bath for ISBN
           // no idea if this holds true universally, but matches LOC, COPAC, and KB
           if(m_format == QLatin1String("dc")) {
             q += QLatin1String("dc.identifier=") + isbnList.at(i);
           } else {
             q += QLatin1String("bath.isbn=") + isbnList.at(i);
           }
           if(i < isbnList.count()-1) {
             q += QLatin1String(" or ");
           }
         }
         query.addQueryItem(QStringLiteral("query"), q);
       }
       break;
 
     case LCCN:
       {
         QString s = request().value;
         QStringList lccnList = FieldFormat::splitValue(s);
         QString q;
         for(int i = 0; i < lccnList.count(); ++i) {
           q += QLatin1String("bath.lccn=") + lccnList.at(i);
           q += QLatin1String(" or bath.lccn=") + LCCNValidator::formalize(lccnList.at(i));
           if(i < lccnList.count()-1) {
             q += QLatin1String(" or ");
           }
         }
         query.addQueryItem(QStringLiteral("query"), q);
       }
       break;
 
     case Keyword:
       query.addQueryItem(QStringLiteral("query"), str);
       break;
 
     case Raw:
       {
         QString key = request().value.section(QLatin1Char('='), 0, 0).trimmed();
         QString str = request().value.section(QLatin1Char('='), 1).trimmed();
         query.addQueryItem(key, str);
       }
       break;
 
     default:
       myWarning() << "key not recognized: " << request().key;
       stop();
       break;
   }
   u.setQuery(query);
 //  myDebug() << u.url();
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)),
-          SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result,
+          this, &SRUFetcher::slotComplete);
 }
 
 void SRUFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
 
   m_started = false;
   emit signalDone(this);
 }
 
 void SRUFetcher::slotComplete(KJob*) {
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   QByteArray data = m_job->data();
   if(data.isEmpty()) {
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from srufetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/test.xml"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   Data::CollPtr coll;
   QString msg;
 
   const QString result = QString::fromUtf8(data.constData(), data.size());
 
   // first check for SRU errors
   QDomDocument dom;
   if(!dom.setContent(result, true /*namespace*/)) {
     myWarning() << "server did not return valid XML.";
     stop();
     return;
   }
 
   const QString& diag = XML::nsZingDiag;
   QDomNodeList diagList = dom.elementsByTagNameNS(diag, QStringLiteral("diagnostic"));
   for(int i = 0; i < diagList.count(); ++i) {
     QDomElement elem = diagList.item(i).toElement();
     QDomNodeList nodeList1 = elem.elementsByTagNameNS(diag, QStringLiteral("message"));
     QDomNodeList nodeList2 = elem.elementsByTagNameNS(diag, QStringLiteral("details"));
     for(int j = 0; j < nodeList1.count(); ++j) {
       QString d = nodeList1.item(j).toElement().text();
       if(!d.isEmpty()) {
         QString d2 = nodeList2.item(j).toElement().text();
         if(!d2.isEmpty()) {
           d += QLatin1String(" (") + d2 + QLatin1Char(')');
         }
         myDebug() << "[" << m_host << "/" << m_path << "]" << d;
         if(!msg.isEmpty()) {
           msg += QLatin1Char('\n');
         }
         msg += d;
       }
     }
   }
 
   QString modsResult;
   if(m_format == QLatin1String("mods")) {
     modsResult = result;
 //  } else if(m_format == QLatin1String("marcxml") && initMARCXMLHandler()) {
 // some SRU data sources call it MARC21-xml or something other than marcxml
   } else if(m_format.startsWith(QLatin1String("marc"), Qt::CaseInsensitive) && initMARCXMLHandler()) {
     // brute force marcxchange conversion. This is probably wrong at some level
     QString newResult = result;
     if(m_format.startsWith(QLatin1String("marcxchange"), Qt::CaseInsensitive)) {
       newResult.replace(QRegExp(QLatin1String("xmlns:marc=\"info:lc/xmlns/marcxchange-v[12]\"")),
                         QStringLiteral("xmlns:marc=\"http://www.loc.gov/MARC21/slim\""));
     }
     modsResult = m_MARCXMLHandler->applyStylesheet(newResult);
   }
   if(!modsResult.isEmpty() && initMODSHandler()) {
     Import::TellicoImporter imp(m_MODSHandler->applyStylesheet(modsResult));
     coll = imp.collection();
     if(!msg.isEmpty()) {
       msg += QLatin1Char('\n');
     }
     msg += imp.statusMessage();
   } else if((m_format == QLatin1String("pam") ||
              m_format == QLatin1String("dc") ||
              m_format == QLatin1String("none")) &&
             initSRWHandler()) {
     Import::TellicoImporter imp(m_SRWHandler->applyStylesheet(result));
     coll = imp.collection();
     if(!msg.isEmpty()) {
       msg += QLatin1Char('\n');
     }
     msg += imp.statusMessage();
   } else {
     myDebug() << "unrecognized format:" << m_format;
     stop();
     return;
   }
 
   if(coll && !msg.isEmpty()) {
     message(msg, coll->entryCount() == 0 ? MessageHandler::Warning : MessageHandler::Status);
   }
 
   if(!coll) {
     myDebug() << "no collection pointer";
     if(!msg.isEmpty()) {
       message(msg, MessageHandler::Error);
     }
     stop();
     return;
   }
 
   // since the Dewey and LoC field titles have a context in their i18n call here
   // but not in the stylesheet where the field is actually created
   // update the field titles here
   QHashIterator<QString, QString> i(allOptionalFields());
   while(i.hasNext()) {
     i.next();
     Data::FieldPtr field = coll->fieldByName(i.key());
     if(field) {
       field->setTitle(i.value());
       coll->modifyField(field);
     }
   }
 
   foreach(Data::EntryPtr entry, coll->entries()) {
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
   }
   stop();
 }
 
 Tellico::Data::EntryPtr SRUFetcher::fetchEntryHook(uint uid_) {
   return m_entries[uid_];
 }
 
 Tellico::Fetch::FetchRequest SRUFetcher::updateRequest(Data::EntryPtr entry_) {
 //  myDebug() << source() << ": " << entry_->title();
   QString isbn = entry_->field(QStringLiteral("isbn"));
   if(!isbn.isEmpty()) {
     return FetchRequest(Fetch::ISBN, isbn);
   }
 
   QString lccn = entry_->field(QStringLiteral("lccn"));
   if(!lccn.isEmpty()) {
     return FetchRequest(Fetch::LCCN, lccn);
   }
 
   // optimistically try searching for title and rely on Collection::sameEntry() to figure things out
   QString t = entry_->field(QStringLiteral("title"));
   if(!t.isEmpty()) {
     return FetchRequest(Fetch::Title, t);
   }
   return FetchRequest();
 }
 
 bool SRUFetcher::initMARCXMLHandler() {
   if(m_MARCXMLHandler) {
     return true;
   }
 
   QString xsltfile = DataFileRegistry::self()->locate(QStringLiteral("MARC21slim2MODS3.xsl"));
   if(xsltfile.isEmpty()) {
     myWarning() << "can not locate MARC21slim2MODS3.xsl.";
     return false;
   }
 
   QUrl u = QUrl::fromLocalFile(xsltfile);
 
   m_MARCXMLHandler = new XSLTHandler(u);
   if(!m_MARCXMLHandler->isValid()) {
     myWarning() << "error in MARC21slim2MODS3.xsl.";
     delete m_MARCXMLHandler;
     m_MARCXMLHandler = nullptr;
     return false;
   }
   return true;
 }
 
 bool SRUFetcher::initMODSHandler() {
   if(m_MODSHandler) {
     return true;
   }
 
   QString xsltfile = DataFileRegistry::self()->locate(QStringLiteral("mods2tellico.xsl"));
   if(xsltfile.isEmpty()) {
     myWarning() << "can not locate mods2tellico.xsl.";
     return false;
   }
 
   QUrl u = QUrl::fromLocalFile(xsltfile);
 
   m_MODSHandler = new XSLTHandler(u);
   if(!m_MODSHandler->isValid()) {
     myWarning() << "error in mods2tellico.xsl.";
     delete m_MODSHandler;
     m_MODSHandler = nullptr;
     return false;
   }
   return true;
 }
 
 bool SRUFetcher::initSRWHandler() {
   if(m_SRWHandler) {
     return true;
   }
 
   QString xsltfile = DataFileRegistry::self()->locate(QStringLiteral("srw2tellico.xsl"));
   if(xsltfile.isEmpty()) {
     myWarning() << "can not locate srw2tellico.xsl.";
     return false;
   }
 
   QUrl u = QUrl::fromLocalFile(xsltfile);
 
   m_SRWHandler = new XSLTHandler(u);
   if(!m_SRWHandler->isValid()) {
     myWarning() << "error in srw2tellico.xsl.";
     delete m_SRWHandler;
     m_SRWHandler = nullptr;
     return false;
   }
   return true;
 }
 
 Tellico::Fetch::Fetcher::Ptr SRUFetcher::libraryOfCongress(QObject* parent_) {
   return Fetcher::Ptr(new SRUFetcher(i18n("Library of Congress (US)"), QStringLiteral("z3950.loc.gov"), 7090,
                                      QStringLiteral("voyager"), QStringLiteral("mods"), parent_));
 }
 
 QString SRUFetcher::defaultName() {
   return i18n("SRU Server");
 }
 
 QString SRUFetcher::defaultIcon() {
 //  return QLatin1String("network-workgroup"); // just to be different than z3950
   return QStringLiteral(":/icons/sru");
 }
 
 // static
 Tellico::StringHash SRUFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("address")]  = i18n("Address");
   hash[QStringLiteral("abstract")] = i18n("Abstract");
   hash[QStringLiteral("dewey")]    = i18nc("Dewey Decimal classification system", "Dewey Decimal");
   hash[QStringLiteral("lcc")]      = i18nc("Library of Congress classification system", "LoC Classification");
   return hash;
 }
 
 Tellico::Fetch::ConfigWidget* SRUFetcher::configWidget(QWidget* parent_) const {
   return new ConfigWidget(parent_, this);
 }
 
 SRUFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const SRUFetcher* fetcher_ /*=0*/)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
   QLabel* label = new QLabel(i18n("Hos&t: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_hostEdit = new GUI::LineEdit(optionsWidget());
-  connect(m_hostEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
-  connect(m_hostEdit, SIGNAL(textChanged(QString)), SIGNAL(signalName(QString)));
-  connect(m_hostEdit, SIGNAL(textChanged(QString)), SLOT(slotCheckHost()));
+  connect(m_hostEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
+  connect(m_hostEdit, &QLineEdit::textChanged, this, &ConfigWidget::signalName);
+  connect(m_hostEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotCheckHost);
   l->addWidget(m_hostEdit, row, 1);
   QString w = i18n("Enter the host name of the server.");
   label->setWhatsThis(w);
   m_hostEdit->setWhatsThis(w);
   label->setBuddy(m_hostEdit);
 
   label = new QLabel(i18n("&Port: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_portSpinBox = new QSpinBox(optionsWidget());
   m_portSpinBox->setMaximum(999999);
   m_portSpinBox->setMinimum(0);
   m_portSpinBox->setValue(SRU_DEFAULT_PORT);
-  connect(m_portSpinBox, SIGNAL(valueChanged(int)), SLOT(slotSetModified()));
+  void (QSpinBox::* valueChanged)(int) = &QSpinBox::valueChanged;
+  connect(m_portSpinBox, valueChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_portSpinBox, row, 1);
   w = i18n("Enter the port number of the server. The default is %1.", SRU_DEFAULT_PORT);
   label->setWhatsThis(w);
   m_portSpinBox->setWhatsThis(w);
   label->setBuddy(m_portSpinBox);
 
   label = new QLabel(i18n("Path: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_pathEdit = new GUI::LineEdit(optionsWidget());
-  connect(m_pathEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_pathEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_pathEdit, row, 1);
   w = i18n("Enter the path to the database used by the server.");
   label->setWhatsThis(w);
   m_pathEdit->setWhatsThis(w);
   label->setBuddy(m_pathEdit);
 
   label = new QLabel(i18n("Format: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_formatCombo = new GUI::ComboBox(optionsWidget());
   m_formatCombo->addItem(QStringLiteral("MODS"), QLatin1String("mods"));
   m_formatCombo->addItem(QStringLiteral("MARCXML"), QLatin1String("marcxml"));
   m_formatCombo->addItem(QStringLiteral("PAM"), QLatin1String("pam"));
   m_formatCombo->addItem(QStringLiteral("Dublin Core"), QLatin1String("dc"));
   m_formatCombo->setEditable(true);
-  connect(m_formatCombo, SIGNAL(activated(int)), SLOT(slotSetModified()));
-  connect(m_formatCombo, SIGNAL(editTextChanged(QString)), SLOT(slotSetModified()));
+  void (GUI::ComboBox::* activatedInt)(int) = &GUI::ComboBox::activated;
+  connect(m_formatCombo, activatedInt, this, &ConfigWidget::slotSetModified);
+  connect(m_formatCombo, &QComboBox::editTextChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_formatCombo, row, 1);
   w = i18n("Enter the result format used by the server.");
   label->setWhatsThis(w);
   m_formatCombo->setWhatsThis(w);
   label->setBuddy(m_formatCombo);
 
   l->setRowStretch(++row, 1);
 
   m_queryTree = new GUI::StringMapWidget(StringMap(), optionsWidget());
   l->addWidget(m_queryTree, row, 0, 1, 2);
   m_queryTree->setLabels(i18n("Field"), i18n("Value"));
 
   // now add additional fields widget
   addFieldsWidget(SRUFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 
   if(fetcher_) {
     m_hostEdit->setText(fetcher_->m_host);
     m_portSpinBox->setValue(fetcher_->m_port);
     m_pathEdit->setText(fetcher_->m_path);
     if(m_formatCombo->findData(fetcher_->m_format) == -1) {
       m_formatCombo->addItem(fetcher_->m_format, fetcher_->m_format);
     }
     m_formatCombo->setCurrentData(fetcher_->m_format);
     m_queryTree->setStringMap(fetcher_->m_queryMap);
   }
   KAcceleratorManager::manage(optionsWidget());
 }
 
 void SRUFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   QString s = m_hostEdit->text().trimmed();
   if(!s.isEmpty()) {
     config_.writeEntry("Host", s);
   }
   int port = m_portSpinBox->value();
   if(port > 0) {
     config_.writeEntry("Port", port);
   }
   s = m_pathEdit->text().trimmed();
   if(!s.isEmpty()) {
     config_.writeEntry("Path", s);
   }
   s = m_formatCombo->currentData().toString().trimmed();
   if(s.isEmpty()) {
     // user-entered format will not have data set for the item. Just use the text itself
     s = m_formatCombo->currentText().trimmed();
   }
   if(!s.isEmpty()) {
     config_.writeEntry("Format", s);
   }
   StringMap queryMap = m_queryTree->stringMap();
   if(!queryMap.isEmpty()) {
     config_.writeEntry("QueryFields", queryMap.keys());
     config_.writeEntry("QueryValues", queryMap.values());
   }
 }
 
 QString SRUFetcher::ConfigWidget::preferredName() const {
   QString s = m_hostEdit->text();
   return s.isEmpty() ? SRUFetcher::defaultName() : s;
 }
 
 void SRUFetcher::ConfigWidget::slotCheckHost() {
   QString s = m_hostEdit->text();
   // someone might be pasting a full URL, check that
   if(s.indexOf(QLatin1Char(':')) > -1 || s.indexOf(QLatin1Char('/')) > -1) {
     QUrl u(s);
     if(u.isValid()) {
       m_hostEdit->setText(u.host());
       if(u.port() > 0) {
         m_portSpinBox->setValue(u.port());
       }
       if(!u.path().isEmpty()) {
         m_pathEdit->setText(u.path().trimmed());
       }
     }
   }
 }
diff --git a/src/fetch/thegamesdbfetcher.cpp b/src/fetch/thegamesdbfetcher.cpp
index ccb92bca..2af20638 100644
--- a/src/fetch/thegamesdbfetcher.cpp
+++ b/src/fetch/thegamesdbfetcher.cpp
@@ -1,584 +1,585 @@
 /***************************************************************************
     Copyright (C) 2012-2019 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "thegamesdbfetcher.h"
 #include "../collections/gamecollection.h"
 #include "../images/imagefactory.h"
 #include "../gui/combobox.h"
 #include "../core/filehandler.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../utils/tellico_utils.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KJob>
 #include <KJobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 #include <KIO/StoredTransferJob>
 
 #include <QLabel>
 #include <QLineEdit>
 #include <QFile>
 #include <QTextStream>
 #include <QGridLayout>
 #include <QTextCodec>
 #include <QJsonDocument>
 #include <QJsonArray>
 #include <QJsonObject>
 #include <QUrlQuery>
 
 namespace {
   static const int THEGAMESDB_MAX_RETURNS_TOTAL = 20;
   static const char* THEGAMESDB_API_URL = "https://api.thegamesdb.net";
   static const char* THEGAMESDB_API_VERSION = "1.1"; // krazy:exclude=doublequote_chars
   static const char* THEGAMESDB_MAGIC_TOKEN = "f7c4fd9c5d6d4a2fcefe3157192f87e260038abe86b0f3977716596edaebdbb82315586e98fc88b0fb9ff4c01576e4d47b4e556d487a4325221abbddfac36f59d7e114753b5fa6c77a1e73423d5f72460f3b526bcbae4f2be0d86a5854600436784e3a5c5d6bc1a3e2d395f798fb35073051f2c232014023e9dda99edfea5767";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::TheGamesDBFetcher;
 
 TheGamesDBFetcher::TheGamesDBFetcher(QObject* parent_)
     : Fetcher(parent_)
     , m_started(false)
     , m_imageSize(SmallImage) {
   m_apiKey = Tellico::reverseObfuscate(THEGAMESDB_MAGIC_TOKEN);
   loadCachedData();
 }
 
 TheGamesDBFetcher::~TheGamesDBFetcher() {
 }
 
 QString TheGamesDBFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool TheGamesDBFetcher::canSearch(FetchKey k) const {
   return k == Title;
 }
 
 bool TheGamesDBFetcher::canFetch(int type) const {
   return type == Data::Collection::Game;
 }
 
 void TheGamesDBFetcher::readConfigHook(const KConfigGroup& config_) {
   const QString k = config_.readEntry("API Key");
   if(!k.isEmpty()) {
     m_apiKey = k;
   }
   const int imageSize = config_.readEntry("Image Size", -1);
   if(imageSize > -1) {
     m_imageSize = static_cast<ImageSize>(imageSize);
   }
 }
 
 void TheGamesDBFetcher::search() {
   m_started = true;
 
   if(m_apiKey.isEmpty()) {
     myDebug() << "empty API key";
     message(i18n("An access key is required to use this data source.")
             + QLatin1Char(' ') +
             i18n("Those values must be entered in the data source settings."), MessageHandler::Error);
     stop();
     return;
   }
 
   QUrl u(QString::fromLatin1(THEGAMESDB_API_URL));
   u.setPath(QLatin1String("/v") + QLatin1String(THEGAMESDB_API_VERSION));
 
   switch(request().key) {
     case Title:
       u = u.adjusted(QUrl::StripTrailingSlash);
       u.setPath(u.path() + QLatin1String("/Games/ByGameName"));
       {
         QUrlQuery q;
         q.addQueryItem(QStringLiteral("apikey"), m_apiKey);
         if(optionalFields().contains(QStringLiteral("num-player"))) {
           q.addQueryItem(QStringLiteral("fields"), QStringLiteral("players,rating,publishers,genres,overview,platform"));
         } else {
           q.addQueryItem(QStringLiteral("fields"), QStringLiteral("rating,publishers,genres,overview,platform"));
         }
         q.addQueryItem(QStringLiteral("include"), QStringLiteral("platform,boxart"));
         q.addQueryItem(QStringLiteral("name"), request().value);
         u.setQuery(q);
       }
       break;
 
     default:
       myWarning() << "key not recognized:" << request().key;
       stop();
       return;
   }
 //  u = QUrl::fromLocalFile(QStringLiteral("/tmp/test-tgdb.json"));
 //  myDebug() << u;
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result, this, &TheGamesDBFetcher::slotComplete);
 }
 
 void TheGamesDBFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 Tellico::Data::EntryPtr TheGamesDBFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entries.value(uid_);
   if(!entry) {
     myWarning() << "no entry in dict";
     return Data::EntryPtr();
   }
 
   // image might still be a URL
   const QString image_id = entry->field(QStringLiteral("cover"));
   if(image_id.contains(QLatin1Char('/'))) {
     const QString id = ImageFactory::addImage(QUrl::fromUserInput(image_id), true /* quiet */);
     if(id.isEmpty()) {
       message(i18n("The cover image could not be loaded."), MessageHandler::Warning);
     }
     // empty image ID is ok
     entry->setField(QStringLiteral("cover"), id);
   }
 
   // don't want to include TGDb ID field
   entry->setField(QStringLiteral("tgdb-id"), QString());
 
   return entry;
 }
 
 Tellico::Fetch::FetchRequest TheGamesDBFetcher::updateRequest(Data::EntryPtr entry_) {
   QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Title, title);
   }
   return FetchRequest();
 }
 
 void TheGamesDBFetcher::slotComplete(KJob* job_) {
   KIO::StoredTransferJob* job = static_cast<KIO::StoredTransferJob*>(job_);
 
   if(job->error()) {
     job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   const QByteArray data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from thegamesdbfetcher.cpp";
   QFile f(QStringLiteral("/tmp/test-tgdb.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   Data::CollPtr coll(new Data::GameCollection(true));
   // always add the tgdb-id for fetchEntryHook
   Data::FieldPtr field(new Data::Field(QStringLiteral("tgdb-id"), QStringLiteral("TGDb ID"), Data::Field::Line));
   field->setCategory(i18n("General"));
   coll->addField(field);
 
   if(optionalFields().contains(QStringLiteral("num-player"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("num-player"), i18n("Number of Players"), Data::Field::Number));
     field->setCategory(i18n("General"));
     field->setFlags(Data::Field::AllowMultiple | Data::Field::AllowGrouped);
     coll->addField(field);
   }
 
   QVariantMap topLevelMap = QJsonDocument::fromJson(data).object().toVariantMap();
   if(!topLevelMap.contains(QStringLiteral("data"))) {
     myDebug() << "No data in result!";
   }
   readPlatformList(topLevelMap.value(QStringLiteral("include")).toMap()
                               .value(QStringLiteral("platform")).toMap()
                               .value(QStringLiteral("data")).toMap());
   readCoverList(topLevelMap.value(QStringLiteral("include")).toMap()
                            .value(QStringLiteral("boxart")).toMap());
 
   QVariantList resultList = topLevelMap.value(QStringLiteral("data")).toMap()
                                        .value(QStringLiteral("games")).toList();
   if(resultList.isEmpty()) {
     myDebug() << "no results";
     stop();
     return;
   }
 
   int count = 0;
   foreach(const QVariant& result, resultList) {
     Data::EntryPtr entry(new Data::Entry(coll));
     populateEntry(entry, result.toMap());
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
     ++count;
     if(count >= THEGAMESDB_MAX_RETURNS_TOTAL) {
       break;
     }
   }
 
   stop();
 }
 
 void TheGamesDBFetcher::populateEntry(Data::EntryPtr entry_, const QVariantMap& resultMap_) {
   entry_->setField(QStringLiteral("tgdb-id"), mapValue(resultMap_, "id"));
   entry_->setField(QStringLiteral("title"), mapValue(resultMap_, "game_title"));
   entry_->setField(QStringLiteral("year"),  mapValue(resultMap_, "release_date").left(4));
   entry_->setField(QStringLiteral("description"), mapValue(resultMap_, "overview"));
 
   const QString platformId = mapValue(resultMap_, "platform");
   if(m_platforms.contains(platformId)) {
     const QString platform = m_platforms[platformId];
     // make the assumption that if the platform name isn't already in the allowed list, it should be added
     Data::FieldPtr f = entry_->collection()->fieldByName(QStringLiteral("platform"));
     if(f && !f->allowed().contains(platform)) {
       f->setAllowed(QStringList(f->allowed()) << platform);
     }
     entry_->setField(QStringLiteral("platform"), platform);
   }
 
   const QString esrb = mapValue(resultMap_, "rating")
                        .section(QLatin1Char('-'), 1, 1)
                        .trimmed(); // value is like "T - Teen"
   if(!esrb.isEmpty()) {
     entry_->setField(QStringLiteral("certification"), i18n(esrb.toUtf8().constData()));
   }
   const QString coverUrl = m_covers.value(mapValue(resultMap_, "id"));
   if(m_imageSize != NoImage) {
     entry_->setField(QStringLiteral("cover"), coverUrl);
   }
 
   QStringList genres, pubs, devs;
 
   bool alreadyAttemptedLoad = false;
   QVariantList genreIdList = resultMap_.value(QStringLiteral("genres")).toList();
   foreach(const QVariant& v, genreIdList) {
     const int id = v.toInt();
     if(!m_genres.contains(id) && !alreadyAttemptedLoad) {
       readDataList(Genre);
       alreadyAttemptedLoad = true;
     }
     if(m_genres.contains(id)) {
       genres << m_genres[id];
     }
   }
 
   alreadyAttemptedLoad = false;
   QVariantList pubList = resultMap_.value(QStringLiteral("publishers")).toList();
   foreach(const QVariant& v, pubList) {
     const int id = v.toInt();
     if(!m_publishers.contains(id) && !alreadyAttemptedLoad) {
       readDataList(Publisher);
       alreadyAttemptedLoad = true;
     }
     if(m_publishers.contains(id)) {
       pubs << m_publishers[id];
     }
   }
 
   alreadyAttemptedLoad = false;
   QVariantList devList = resultMap_.value(QStringLiteral("developers")).toList();
   foreach(const QVariant& v, devList) {
     const int id = v.toInt();
     if(!m_developers.contains(id) && !alreadyAttemptedLoad) {
       readDataList(Developer);
       alreadyAttemptedLoad = true;
     }
     if(m_developers.contains(id)) {
       devs << m_developers[id];
     }
   }
 
   entry_->setField(QStringLiteral("genre"), genres.join(FieldFormat::delimiterString()));
   entry_->setField(QStringLiteral("publisher"), pubs.join(FieldFormat::delimiterString()));
   entry_->setField(QStringLiteral("developer"), devs.join(FieldFormat::delimiterString()));
 
 if(entry_->collection()->hasField(QStringLiteral("num-player"))) {
     entry_->setField(QStringLiteral("num-player"), mapValue(resultMap_, "players"));
   }
 }
 
 void TheGamesDBFetcher::readPlatformList(const QVariantMap& platformMap_) {
   QMapIterator<QString, QVariant> i(platformMap_);
   while(i.hasNext()) {
     i.next();
     QVariantMap map = i.value().toMap();
     QString name = map.value(QStringLiteral("name")).toString();
     m_platforms.insert(i.key(), Data::GameCollection::normalizePlatform(name));
   }
 }
 
 void TheGamesDBFetcher::readCoverList(const QVariantMap& coverDataMap_) {
   // first, get the base url
   QString imageBase;
   switch(m_imageSize) {
     case SmallImage:
       // this is the default size, using the thumb. Not the small size
       imageBase = QStringLiteral("thumb");
       break;
     case MediumImage:
       imageBase = QStringLiteral("medium");
       break;
     case LargeImage:
       imageBase = QStringLiteral("large");
       break;
     case NoImage:
       m_covers.clear();
       return; // no need to read anything
       break;
   }
 
   QString baseUrl =  coverDataMap_.value(QStringLiteral("base_url")).toMap()
                                   .value(imageBase).toString();
 
   QVariantMap coverMap = coverDataMap_.value(QStringLiteral("data")).toMap();
   QMapIterator<QString, QVariant> i(coverMap);
   while(i.hasNext()) {
     i.next();
     foreach(QVariant v, i.value().toList()) {
       QVariantMap map = v.toMap();
       if(map.value(QStringLiteral("type")) == QLatin1String("boxart") &&
          map.value(QStringLiteral("side")) == QLatin1String("front")) {
         m_covers.insert(i.key(), baseUrl + mapValue(map, "filename"));
         break;
       }
     }
   }
 }
 
 void TheGamesDBFetcher::loadCachedData() {
   // The lists of genres, publishers, and developers are separate, with TGDB requesting that
   // the data be cached heavily and only updated when necessary
   // read the three cached JSON data file for genres, publishers, and developers
 
   QFile genreFile(dataFileName(Genre));
   if(genreFile.open(QIODevice::ReadOnly)) {
     updateData(Genre, genreFile.readAll());
   }
 
   QFile publisherFile(dataFileName(Publisher));
   if(publisherFile.open(QIODevice::ReadOnly)) {
     updateData(Publisher, publisherFile.readAll());
   }
 
   QFile developerFile(dataFileName(Developer));
   if(developerFile.open(QIODevice::ReadOnly)) {
     updateData(Developer, developerFile.readAll());
   }
 }
 
 void TheGamesDBFetcher::updateData(TgdbDataType dataType_, const QByteArray& jsonData_) {
   const QString dataString = QStringLiteral("data");
   QString dataName;
   switch(dataType_) {
     case Genre:
       dataName = QStringLiteral("genres");
       break;
     case Publisher:
       dataName = QStringLiteral("publishers");
       break;
     case Developer:
       dataName = QStringLiteral("developers");
       break;
   }
 
   QHash<int, QString> dataHash;
   const QVariantMap topMap = QJsonDocument::fromJson(jsonData_).object().toVariantMap();
   const QVariantMap resultMap = topMap.value(dataString).toMap()
                                         .value(dataName).toMap();
   for(QMapIterator<QString, QVariant> i(resultMap); i.hasNext(); ) {
     i.next();
     const QVariantMap m = i.value().toMap();
     dataHash.insert(m.value(QStringLiteral("id")).toInt(), mapValue(m, "name"));
   }
 
   // transfer read data into the correct local variable
   switch(dataType_) {
     case Genre:
       m_genres = dataHash;
       break;
     case Publisher:
       m_publishers = dataHash;
       break;
     case Developer:
       m_developers = dataHash;
       break;
   }
 }
 
 void TheGamesDBFetcher::readDataList(TgdbDataType dataType_) {
   QUrl u(QString::fromLatin1(THEGAMESDB_API_URL));
   switch(dataType_) {
     case Genre:
       u.setPath(u.path() + QLatin1String("/Genres"));
       break;
     case Publisher:
       u.setPath(u.path() + QLatin1String("/Publishers"));
       break;
     case Developer:
       u.setPath(u.path() + QLatin1String("/Developers"));
       break;
   }
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("apikey"), m_apiKey);
   u.setQuery(q);
 
 //  u = QUrl::fromLocalFile(dataFileName(dataType_)); // for testing
 //  myDebug() << "Reading" << u;
   const QByteArray data = FileHandler::readDataFile(u, true);
   QFile file(dataFileName(dataType_));
   if(!file.open(QIODevice::WriteOnly) || file.write(data) == -1) {
     myDebug() << "unable to write to" << dataFileName(dataType_);
     return;
   }
   file.close();
   updateData(dataType_, data);
 }
 
 
 Tellico::Fetch::ConfigWidget* TheGamesDBFetcher::configWidget(QWidget* parent_) const {
   return new TheGamesDBFetcher::ConfigWidget(parent_, this);
 }
 
 QString TheGamesDBFetcher::defaultName() {
   return QStringLiteral("TheGamesDB");
 }
 
 QString TheGamesDBFetcher::defaultIcon() {
   return favIcon("https://thegamesdb.net");
 }
 
 Tellico::StringHash TheGamesDBFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("num-player")] = i18n("Number of Players");
   return hash;
 }
 
 QString TheGamesDBFetcher::dataFileName(TgdbDataType dataType_) {
   const QString dataDir = Tellico::saveLocation(QStringLiteral("thegamesdb-data/"));
   QString fileName;
   switch(dataType_) {
     case Genre:
       fileName = dataDir + QLatin1String("genres.json");
       break;
     case Publisher:
       fileName = dataDir + QLatin1String("publishers.json");
       break;
     case Developer:
       fileName = dataDir + QLatin1String("developers.json");
       break;
   }
   return fileName;
 }
 
 TheGamesDBFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const TheGamesDBFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
   QLabel* al = new QLabel(i18n("Registration is required for accessing the %1 data source. "
                                "If you agree to the terms and conditions, <a href='%2'>sign "
                                "up for an account</a>, and enter your information below.",
                                 preferredName(),
                                 QLatin1String("https://forums.thegamesdb.net/viewforum.php?f=10")),
                           optionsWidget());
   al->setOpenExternalLinks(true);
   al->setWordWrap(true);
   ++row;
   l->addWidget(al, row, 0, 1, 2);
   // richtext gets weird with size
   al->setMinimumWidth(al->sizeHint().width());
 
   QLabel* label = new QLabel(i18n("Access key: "), optionsWidget());
   l->addWidget(label, ++row, 0);
 
   m_apiKeyEdit = new QLineEdit(optionsWidget());
-  connect(m_apiKeyEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_apiKeyEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_apiKeyEdit, row, 1);
   label->setBuddy(m_apiKeyEdit);
 
   label = new QLabel(i18n("&Image size: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_imageCombo = new GUI::ComboBox(optionsWidget());
   m_imageCombo->addItem(i18n("Small Image"), SmallImage);
   m_imageCombo->addItem(i18n("Medium Image"), MediumImage);
   m_imageCombo->addItem(i18n("Large Image"), LargeImage);
   m_imageCombo->addItem(i18n("No Image"), NoImage);
-  connect(m_imageCombo, SIGNAL(activated(int)), SLOT(slotSetModified()));
+  void (GUI::ComboBox::* activatedInt)(int) = &GUI::ComboBox::activated;
+  connect(m_imageCombo, activatedInt, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_imageCombo, row, 1);
   QString w = i18n("The cover image may be downloaded as well. However, too many large images in the "
                    "collection may degrade performance.");
   label->setWhatsThis(w);
   m_imageCombo->setWhatsThis(w);
   label->setBuddy(m_imageCombo);
 
   l->setRowStretch(++row, 10);
 
   if(fetcher_) {
     m_apiKeyEdit->setText(fetcher_->m_apiKey);
     m_imageCombo->setCurrentData(fetcher_->m_imageSize);
   } else { // defaults
     m_apiKeyEdit->setText(Tellico::reverseObfuscate(THEGAMESDB_MAGIC_TOKEN));
     m_imageCombo->setCurrentData(SmallImage);
   }
 
   // now add additional fields widget
   addFieldsWidget(TheGamesDBFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 void TheGamesDBFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   const QString apiKey = m_apiKeyEdit->text().trimmed();
   if(!apiKey.isEmpty() && apiKey != Tellico::reverseObfuscate(THEGAMESDB_MAGIC_TOKEN)) {
     config_.writeEntry("API Key", apiKey);
   }
   const int n = m_imageCombo->currentData().toInt();
   config_.writeEntry("Image Size", n);
 }
 
 QString TheGamesDBFetcher::ConfigWidget::preferredName() const {
   return TheGamesDBFetcher::defaultName();
 }
diff --git a/src/fetch/themoviedbfetcher.cpp b/src/fetch/themoviedbfetcher.cpp
index 1f5ae89b..1df247a0 100644
--- a/src/fetch/themoviedbfetcher.cpp
+++ b/src/fetch/themoviedbfetcher.cpp
@@ -1,525 +1,526 @@
 /***************************************************************************
     Copyright (C) 2009-2014 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "themoviedbfetcher.h"
 #include "../collections/videocollection.h"
 #include "../images/imagefactory.h"
 #include "../gui/combobox.h"
 #include "../core/filehandler.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KJob>
 #include <KJobUiDelegate>
 #include <KJobWidgets/KJobWidgets>
 #include <KIO/StoredTransferJob>
 
 #include <QLabel>
 #include <QLineEdit>
 #include <QFile>
 #include <QTextStream>
 #include <QGridLayout>
 #include <QTextCodec>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QUrlQuery>
 
 namespace {
   static const int THEMOVIEDB_MAX_RETURNS_TOTAL = 20;
   static const char* THEMOVIEDB_API_URL = "https://api.themoviedb.org";
   static const char* THEMOVIEDB_API_VERSION = "3"; // krazy:exclude=doublequote_chars
   static const char* THEMOVIEDB_API_KEY = "919890b4128d33c729dc368209ece555";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::TheMovieDBFetcher;
 
 TheMovieDBFetcher::TheMovieDBFetcher(QObject* parent_)
     : Fetcher(parent_)
     , m_started(false)
     , m_locale(QStringLiteral("en"))
     , m_apiKey(QLatin1String(THEMOVIEDB_API_KEY)) {
   //  setLimit(THEMOVIEDB_MAX_RETURNS_TOTAL);
 }
 
 TheMovieDBFetcher::~TheMovieDBFetcher() {
 }
 
 QString TheMovieDBFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 // https://www.themoviedb.org/about/api-terms
 QString TheMovieDBFetcher::attribution() const {
   return QStringLiteral("This product uses the TMDb API but is not endorsed or certified by TMDb.");
 }
 
 bool TheMovieDBFetcher::canSearch(FetchKey k) const {
   return k == Title;
 }
 
 bool TheMovieDBFetcher::canFetch(int type) const {
   return type == Data::Collection::Video;
 }
 
 void TheMovieDBFetcher::readConfigHook(const KConfigGroup& config_) {
   QString k = config_.readEntry("API Key", THEMOVIEDB_API_KEY);
   if(!k.isEmpty()) {
     m_apiKey = k;
   }
   k = config_.readEntry("Locale", "en");
   if(!k.isEmpty()) {
     m_locale = k.toLower();
   }
   k = config_.readEntry("ImageBase");
   if(!k.isEmpty()) {
     m_imageBase = k;
   }
   m_serverConfigDate = config_.readEntry("ServerConfigDate", QDate());
 }
 
 void TheMovieDBFetcher::saveConfigHook(KConfigGroup& config_) {
   if(!m_serverConfigDate.isNull()) {
     config_.writeEntry("ServerConfigDate", m_serverConfigDate);
   }
   config_.writeEntry("ImageBase", m_imageBase);
   config_.sync();
 }
 
 void TheMovieDBFetcher::search() {
   if(m_imageBase.isEmpty() || m_serverConfigDate.daysTo(QDate::currentDate()) > 7) {
     readConfiguration();
   }
   continueSearch();
 }
 
 void TheMovieDBFetcher::continueSearch() {
   m_started = true;
 
   if(m_apiKey.isEmpty()) {
     myDebug() << "empty API key";
     message(i18n("An access key is required to use this data source.")
             + QLatin1Char(' ') +
             i18n("Those values must be entered in the data source settings."), MessageHandler::Error);
     stop();
     return;
   }
 
   QUrl u(QString::fromLatin1(THEMOVIEDB_API_URL));
   u.setPath(QLatin1Char('/') + QLatin1String(THEMOVIEDB_API_VERSION));
 
   switch(request().key) {
     case Title:
       u = u.adjusted(QUrl::StripTrailingSlash);
       u.setPath(u.path() + QLatin1String("/search/movie"));
       {
         QUrlQuery q;
         q.addQueryItem(QStringLiteral("api_key"), m_apiKey);
         q.addQueryItem(QStringLiteral("language"), m_locale);
         q.addQueryItem(QStringLiteral("query"), request().value);
         u.setQuery(q);
       }
       break;
 
     default:
       myWarning() << "key not recognized:" << request().key;
       stop();
       return;
   }
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result, this, &TheMovieDBFetcher::slotComplete);
 }
 
 void TheMovieDBFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 Tellico::Data::EntryPtr TheMovieDBFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entries.value(uid_);
   if(!entry) {
     myWarning() << "no entry in dict";
     return Data::EntryPtr();
   }
 
   QString id = entry->field(QStringLiteral("tmdb-id"));
   if(!id.isEmpty()) {
     // quiet
     QUrl u(QString::fromLatin1(THEMOVIEDB_API_URL));
     u.setPath(QStringLiteral("/%1/movie/%2")
               .arg(QLatin1String(THEMOVIEDB_API_VERSION), id));
     QUrlQuery q;
     q.addQueryItem(QStringLiteral("api_key"), m_apiKey);
     q.addQueryItem(QStringLiteral("language"), m_locale);
     q.addQueryItem(QStringLiteral("append_to_response"),
                    QStringLiteral("alternative_titles,credits"));
     u.setQuery(q);
     QByteArray data = FileHandler::readDataFile(u, true);
 #if 0
     myWarning() << "Remove debug2 from themoviedbfetcher.cpp";
     QFile f(QStringLiteral("/tmp/test2.json"));
     if(f.open(QIODevice::WriteOnly)) {
       QTextStream t(&f);
       t.setCodec("UTF-8");
       t << data;
     }
     f.close();
 #endif
     QJsonDocument doc = QJsonDocument::fromJson(data);
     populateEntry(entry, doc.object().toVariantMap(), true);
   }
 
   // image might still be a URL
   const QString image_id = entry->field(QStringLiteral("cover"));
   if(image_id.contains(QLatin1Char('/'))) {
     const QString id = ImageFactory::addImage(QUrl::fromUserInput(image_id), true /* quiet */);
     if(id.isEmpty()) {
       message(i18n("The cover image could not be loaded."), MessageHandler::Warning);
     }
     // empty image ID is ok
     entry->setField(QStringLiteral("cover"), id);
   }
 
   // don't want to include TMDb ID field
   entry->setField(QStringLiteral("tmdb-id"), QString());
 
   return entry;
 }
 
 Tellico::Fetch::FetchRequest TheMovieDBFetcher::updateRequest(Data::EntryPtr entry_) {
   QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Title, title);
   }
   return FetchRequest();
 }
 
 void TheMovieDBFetcher::slotComplete(KJob* job_) {
   KIO::StoredTransferJob* job = static_cast<KIO::StoredTransferJob*>(job_);
 
   if(job->error()) {
     job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   const QByteArray data = job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from themoviedbfetcher.cpp";
   QFile f(QStringLiteral("/tmp/test.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   Data::CollPtr coll(new Data::VideoCollection(true));
   // always add the tmdb-id for fetchEntryHook
   Data::FieldPtr field(new Data::Field(QStringLiteral("tmdb-id"), QStringLiteral("TMDb ID"), Data::Field::Line));
   field->setCategory(i18n("General"));
   coll->addField(field);
 
   if(optionalFields().contains(QStringLiteral("tmdb"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("tmdb"), i18n("TMDb Link"), Data::Field::URL));
     field->setCategory(i18n("General"));
     coll->addField(field);
   }
   if(optionalFields().contains(QStringLiteral("imdb"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("imdb"), i18n("IMDb Link"), Data::Field::URL));
     field->setCategory(i18n("General"));
     coll->addField(field);
   }
   if(optionalFields().contains(QStringLiteral("alttitle"))) {
     Data::FieldPtr field(new Data::Field(QStringLiteral("alttitle"), i18n("Alternative Titles"), Data::Field::Table));
     field->setFormatType(FieldFormat::FormatTitle);
     coll->addField(field);
   }
   if(optionalFields().contains(QStringLiteral("origtitle"))) {
     Data::FieldPtr f(new Data::Field(QStringLiteral("origtitle"), i18n("Original Title")));
     f->setFormatType(FieldFormat::FormatTitle);
     coll->addField(f);
   }
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   QVariantMap result = doc.object().toVariantMap();
 
   QVariantList resultList = result.value(QStringLiteral("results")).toList();
   if(resultList.isEmpty()) {
     myDebug() << "no results";
     stop();
     return;
   }
 
   int count = 0;
   foreach(const QVariant& result, resultList) {
 //    myDebug() << "found result:" << result;
 
     Data::EntryPtr entry(new Data::Entry(coll));
     populateEntry(entry, result.toMap(), false);
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
     ++count;
     if(count >= THEMOVIEDB_MAX_RETURNS_TOTAL) {
       break;
     }
   }
 
   stop();
 }
 
 void TheMovieDBFetcher::populateEntry(Data::EntryPtr entry_, const QVariantMap& resultMap_, bool fullData_) {
   entry_->setField(QStringLiteral("tmdb-id"), mapValue(resultMap_, "id"));
   entry_->setField(QStringLiteral("title"), mapValue(resultMap_, "title"));
   entry_->setField(QStringLiteral("year"),  mapValue(resultMap_, "release_date").left(4));
 
   QStringList directors, producers, writers, composers;
   QVariantList crewList = resultMap_.value(QStringLiteral("credits")).toMap()
                                     .value(QStringLiteral("crew")).toList();
   foreach(const QVariant& crew, crewList) {
     const QVariantMap crewMap = crew.toMap();
     const QString job = mapValue(crewMap, "job");
     if(job == QLatin1String("Director")) {
       directors += mapValue(crewMap, "name");
     } else if(job == QLatin1String("Producer")) {
       producers += mapValue(crewMap, "name");
     } else if(job == QLatin1String("Screenplay")) {
       writers += mapValue(crewMap, "name");
     } else if(job == QLatin1String("Original Music Composer")) {
       composers += mapValue(crewMap, "name");
     }
   }
   entry_->setField(QStringLiteral("director"), directors.join(FieldFormat::delimiterString()));
   entry_->setField(QStringLiteral("producer"), producers.join(FieldFormat::delimiterString()));
   entry_->setField(QStringLiteral("writer"),     writers.join(FieldFormat::delimiterString()));
   entry_->setField(QStringLiteral("composer"), composers.join(FieldFormat::delimiterString()));
 
   // if we only need cursory data, then we're done
   if(!fullData_) {
     return;
   }
 
   if(entry_->collection()->hasField(QStringLiteral("tmdb"))) {
     entry_->setField(QStringLiteral("tmdb"), QLatin1String("http://www.themoviedb.org/movie/") + mapValue(resultMap_, "id"));
   }
   if(entry_->collection()->hasField(QStringLiteral("imdb"))) {
     entry_->setField(QStringLiteral("imdb"), QLatin1String("http://www.imdb.com/title/") + mapValue(resultMap_, "imdb_id"));
   }
   if(entry_->collection()->hasField(QStringLiteral("origtitle"))) {
     entry_->setField(QStringLiteral("origtitle"), mapValue(resultMap_, "original_title"));
   }
   if(entry_->collection()->hasField(QStringLiteral("alttitle"))) {
     QStringList atitles;
     foreach(const QVariant& atitle, resultMap_.value(QLatin1String("alternative_titles")).toMap()
                                                .value(QLatin1String("titles")).toList()) {
       atitles << mapValue(atitle.toMap(), "title");
     }
     entry_->setField(QStringLiteral("alttitle"), atitles.join(FieldFormat::rowDelimiterString()));
   }
 
   QStringList actors;
   QVariantList castList = resultMap_.value(QStringLiteral("credits")).toMap()
                                     .value(QStringLiteral("cast")).toList();
   foreach(const QVariant& cast, castList) {
     QVariantMap castMap = cast.toMap();
     actors << mapValue(castMap, "name") + FieldFormat::columnDelimiterString() + mapValue(castMap, "character");
   }
   entry_->setField(QStringLiteral("cast"), actors.join(FieldFormat::rowDelimiterString()));
 
   QStringList studios;
   foreach(const QVariant& studio, resultMap_.value(QLatin1String("production_companies")).toList()) {
     studios << mapValue(studio.toMap(), "name");
   }
   entry_->setField(QStringLiteral("studio"), studios.join(FieldFormat::delimiterString()));
 
   QStringList countries;
   foreach(const QVariant& country, resultMap_.value(QLatin1String("production_countries")).toList()) {
     QString name = mapValue(country.toMap(), "name");
     if(name == QLatin1String("United States of America")) {
       name = QStringLiteral("USA");
     }
     countries << name;
   }
   entry_->setField(QStringLiteral("nationality"), countries.join(FieldFormat::delimiterString()));
 
   QStringList genres;
   foreach(const QVariant& genre, resultMap_.value(QLatin1String("genres")).toList()) {
     genres << mapValue(genre.toMap(), "name");
   }
   entry_->setField(QStringLiteral("genre"), genres.join(FieldFormat::delimiterString()));
 
   // hard-coded poster size for now
   QString cover = m_imageBase + QLatin1String("w342") + mapValue(resultMap_, "poster_path");
   entry_->setField(QStringLiteral("cover"), cover);
 
   entry_->setField(QStringLiteral("running-time"), mapValue(resultMap_, "runtime"));
   entry_->setField(QStringLiteral("plot"), mapValue(resultMap_, "overview"));
 }
 
 void TheMovieDBFetcher::readConfiguration() {
   QUrl u(QString::fromLatin1(THEMOVIEDB_API_URL));
   u.setPath(QStringLiteral("/%1/configuration").arg(QLatin1String(THEMOVIEDB_API_VERSION)));
   QUrlQuery q;
   q.addQueryItem(QStringLiteral("api_key"), m_apiKey);
   u.setQuery(q);
 
   QByteArray data = FileHandler::readDataFile(u, true);
 #if 0
   myWarning() << "Remove debug3 from themoviedbfetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/test3.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << data;
   }
   f.close();
 #endif
 
   QJsonDocument doc = QJsonDocument::fromJson(data);
   QVariantMap resultMap = doc.object().toVariantMap();
 
   m_imageBase = mapValue(resultMap.value(QStringLiteral("images")).toMap(), "base_url");
   m_serverConfigDate = QDate::currentDate();
 }
 
 Tellico::Fetch::ConfigWidget* TheMovieDBFetcher::configWidget(QWidget* parent_) const {
   return new TheMovieDBFetcher::ConfigWidget(parent_, this);
 }
 
 QString TheMovieDBFetcher::defaultName() {
   return QStringLiteral("The Movie DB (TMDb)");
 }
 
 QString TheMovieDBFetcher::defaultIcon() {
   return favIcon("https://www.themoviedb.org");
 }
 
 Tellico::StringHash TheMovieDBFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("tmdb")] = i18n("TMDb Link");
   hash[QStringLiteral("imdb")] = i18n("IMDb Link");
   hash[QStringLiteral("alttitle")] = i18n("Alternative Titles");
   hash[QStringLiteral("origtitle")] = i18n("Original Title");
   return hash;
 }
 
 TheMovieDBFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const TheMovieDBFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
 
   QLabel* al = new QLabel(i18n("Registration is required for accessing the %1 data source. "
                                "If you agree to the terms and conditions, <a href='%2'>sign "
                                "up for an account</a>, and enter your information below.",
                                 TheMovieDBFetcher::defaultName(),
                                 QLatin1String("http://api.themoviedb.org")),
                           optionsWidget());
   al->setOpenExternalLinks(true);
   al->setWordWrap(true);
   ++row;
   l->addWidget(al, row, 0, 1, 2);
   // richtext gets weird with size
   al->setMinimumWidth(al->sizeHint().width());
 
   QLabel* label = new QLabel(i18n("Access key: "), optionsWidget());
   l->addWidget(label, ++row, 0);
 
   m_apiKeyEdit = new QLineEdit(optionsWidget());
-  connect(m_apiKeyEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_apiKeyEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_apiKeyEdit, row, 1);
   QString w = i18n("The default Tellico key may be used, but searching may fail due to reaching access limits.");
   label->setWhatsThis(w);
   m_apiKeyEdit->setWhatsThis(w);
   label->setBuddy(m_apiKeyEdit);
 
   label = new QLabel(i18n("Language: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_langCombo = new GUI::ComboBox(optionsWidget());
   m_langCombo->addItem(i18nc("Language", "English"), QLatin1String("en"));
   m_langCombo->addItem(i18nc("Language", "French"), QLatin1String("fr"));
   m_langCombo->addItem(i18nc("Language", "German"), QLatin1String("de"));
   m_langCombo->addItem(i18nc("Language", "Spanish"), QLatin1String("es"));
-  connect(m_langCombo, SIGNAL(activated(int)), SLOT(slotSetModified()));
-  connect(m_langCombo, SIGNAL(activated(int)), SLOT(slotLangChanged()));
+  void (GUI::ComboBox::* activatedInt)(int) = &GUI::ComboBox::activated;
+  connect(m_langCombo, activatedInt, this, &ConfigWidget::slotSetModified);
+  connect(m_langCombo, activatedInt, this, &ConfigWidget::slotLangChanged);
   l->addWidget(m_langCombo, row, 1);
   label->setBuddy(m_langCombo);
 
   l->setRowStretch(++row, 10);
 
   // now add additional fields widget
   addFieldsWidget(TheMovieDBFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 
   if(fetcher_) {
     // only show the key if it is not the default Tellico one...
     // that way the user is prompted to apply for their own
     if(fetcher_->m_apiKey != QLatin1String(THEMOVIEDB_API_KEY)) {
       m_apiKeyEdit->setText(fetcher_->m_apiKey);
     }
     m_langCombo->setCurrentData(fetcher_->m_locale);
   }
 }
 
 void TheMovieDBFetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   const QString apiKey = m_apiKeyEdit->text().trimmed();
   if(!apiKey.isEmpty()) {
     config_.writeEntry("API Key", apiKey);
   }
   const QString lang = m_langCombo->currentData().toString();
   config_.writeEntry("Locale", lang);
 }
 
 QString TheMovieDBFetcher::ConfigWidget::preferredName() const {
   return i18n("TheMovieDB (%1)", m_langCombo->currentText());
 }
 
 void TheMovieDBFetcher::ConfigWidget::slotLangChanged() {
   emit signalName(preferredName());
 }
diff --git a/src/fetch/vndbfetcher.cpp b/src/fetch/vndbfetcher.cpp
index 05b2b1fb..80e7d4a9 100644
--- a/src/fetch/vndbfetcher.cpp
+++ b/src/fetch/vndbfetcher.cpp
@@ -1,447 +1,447 @@
 /***************************************************************************
     Copyright (C) 2013-2019 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include <config.h>
 #include "vndbfetcher.h"
 #include "../collections/gamecollection.h"
 #include "../images/imagefactory.h"
 #include "../utils/guiproxy.h"
 #include "../utils/string_utils.h"
 #include "../entry.h"
 #include "../fieldformat.h"
 #include "../core/filehandler.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 
 #include <QTcpSocket>
 #include <QLabel>
 #include <QFile>
 #include <QTextStream>
 #include <QGridLayout>
 #include <QTextCodec>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QJsonValue>
 #include <QRegularExpression>
 #include <QTimer>
 
 namespace {
   static const char* VNDB_HOSTNAME = "api.vndb.org";
   static const int VNDB_PORT = 19534;
 }
 
 using namespace Tellico;
 using Tellico::Fetch::VNDBFetcher;
 
 VNDBFetcher::VNDBFetcher(QObject* parent_)
     : Fetcher(parent_), m_started(false), m_socket(nullptr), m_isConnected(false), m_state(PreLogin) {
 }
 
 VNDBFetcher::~VNDBFetcher() {
   if(m_socket && m_isConnected) {
     m_socket->disconnectFromHost();
   }
   delete m_socket;
   m_socket = nullptr;
 }
 
 QString VNDBFetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool VNDBFetcher::canSearch(FetchKey k) const {
   return k == Title;
 }
 
 bool VNDBFetcher::canFetch(int type) const {
   return type == Data::Collection::Game;
 }
 
 void VNDBFetcher::readConfigHook(const KConfigGroup&) {
 }
 
 void VNDBFetcher::search() {
   m_started = true;
   m_data.clear();
 
   if(!m_socket) {
     // see https://wiki.qt.io/New_Signal_Slot_Syntax#Overload for why this is necessary
     void (QTcpSocket::* errorSignal)(QAbstractSocket::SocketError) = &QAbstractSocket::error;
     m_socket = new QTcpSocket(this);
     QObject::connect(m_socket, &QTcpSocket::readyRead,    this, &VNDBFetcher::slotRead);
     QObject::connect(m_socket, &QTcpSocket::stateChanged, this, &VNDBFetcher::slotState);
     QObject::connect(m_socket, errorSignal,               this, &VNDBFetcher::slotError);
   }
   if(!m_isConnected) {
     m_socket->connectToHost(QLatin1String(VNDB_HOSTNAME), VNDB_PORT);
   }
 
   //the client ver only wants digits, I think?
   QString clientVersion(QStringLiteral(TELLICO_VERSION));
   clientVersion.remove(QRegularExpression(QStringLiteral("[^0-9.]")));
 
   QByteArray login = "login {"
                              "\"protocol\":1,"
                              "\"client\":\"Tellico\","
                              "\"clientver\": \"";
   login += clientVersion.toUtf8() + "\"}";
   login.append(0x04);
   if(m_socket->waitForConnected()) {
 //    myDebug() << login;
     m_socket->write(login);
     m_socket->waitForReadyRead(5000);
     if(m_state == PreLogin) {
       // login did not work
       stop();
       return;
     }
   }
 
   QByteArray get("get vn basic,details ");
   switch(request().key) {
     case Title:
       get += "(search ~ \"" + request().value.toUtf8() + "\")";
       break;
 
     default:
       myWarning() << "key not recognized:" << request().key;
       return;
   }
 
   m_state = GetVN;
 //  myDebug() << get << m_state;
   get.append(0x04);
   m_socket->write(get);
 }
 
 void VNDBFetcher::stop() {
   if(!m_started) {
     return;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 Tellico::Data::EntryPtr VNDBFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entries.value(uid_);
   if(!entry) {
     myWarning() << "no entry in dict";
     return Data::EntryPtr();
   }
 
   // clear past data
   m_data.clear();
   // don't need anything for the "details" group
   QByteArray get("get release basic,producers ");
   get += "(vn = " + entry->field(QStringLiteral("vn-id")).toLatin1()
        + " and patch = false and type = \"complete\")";
 
   m_state = GetRelease;
 //  myDebug() << get << m_state;
   get.append(0x04);
   m_socket->write(get);
   // 5 sec is long enough?
   m_socket->waitForReadyRead(5000);
 
   if(verifyData()) {
     parseReleaseResults(entry);
   }
 
   // image might still be a URL
   const QString image_id = entry->field(QStringLiteral("cover"));
   if(image_id.contains(QLatin1Char('/'))) {
     const QString id = ImageFactory::addImage(QUrl::fromUserInput(image_id), true /* quiet */);
     if(id.isEmpty()) {
       message(i18n("The cover image could not be loaded."), MessageHandler::Warning);
     }
     // empty image ID is ok
     entry->setField(QStringLiteral("cover"), id);
   }
   // clear the placeholder fields
   entry->setField(QStringLiteral("vn-id"), QString());
 
   if(m_socket && m_socket->isValid()) {
     m_socket->disconnectFromHost();
     m_state = PreLogin;
   }
 
   return entry;
 }
 
 Tellico::Fetch::FetchRequest VNDBFetcher::updateRequest(Data::EntryPtr entry_) {
   const QString title = entry_->field(QStringLiteral("title"));
   if(!title.isEmpty()) {
     return FetchRequest(Title, title);
   }
   return FetchRequest();
 }
 
 bool VNDBFetcher::verifyData() {
   if(m_data.isEmpty()) {
     myDebug() << "no data";
     return false;
   }
 
   // remove the last hex character
   m_data.chop(1);
 
   if(m_data.startsWith("error")) { //krazy:exclude=strings
     QJsonDocument doc = QJsonDocument::fromJson(m_data.mid(5));
     QVariantMap result = doc.object().toVariantMap();
     if(result.contains(QStringLiteral("msg"))) {
       myDebug() << "Data error:" << result.value(QStringLiteral("msg")).toString();
       message(result.value(QStringLiteral("msg")).toString(), MessageHandler::Error);
     }
     return false;
   }
 
 //  myDebug() << m_data;
   if(m_state == PreLogin) {
     if(m_data.startsWith("ok")) { //krazy:exclude=strings
       m_state = PostLogin;
       m_data.clear(); // reset data buffer
       return true;
     }
     // some sort of error
     myDebug() << "Failed to login properly...";
     return false;
   }
 
   if(!m_data.startsWith("results")) { //krazy:exclude=strings
     myDebug() << "Expecting results and didn't get them!";
     return false;
   }
 
   // chop off "results"
   m_data = m_data.mid(7);
   return true;
 }
 
 void VNDBFetcher::parseVNResults() {
   if(!verifyData()) {
     return;
   }
 #if 0
   myWarning() << "Remove debug from vndbfetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/vndbtest.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << m_data;
   }
   f.close();
 #endif
 
   QJsonParseError jsonError;
   QJsonDocument doc = QJsonDocument::fromJson(m_data, &jsonError);
   if(doc.isNull()) {
     myDebug() << "null JSON document:" << jsonError.errorString();
     message(jsonError.errorString(), MessageHandler::Error);
     stop();
     return;
   }
   QVariantMap topResultMap = doc.object().toVariantMap();
   QVariantList resultList = topResultMap.value(QStringLiteral("items")).toList();
   if(resultList.isEmpty()) {
     myDebug() << "no results";
     stop();
     return;
   }
 
   Data::CollPtr coll(new Data::GameCollection(true));
   // placeholder for vn id, to be removed later
   Data::FieldPtr f1(new Data::Field(QStringLiteral("vn-id"), QString(), Data::Field::Number));
   coll->addField(f1);
   // add new fields
   if(optionalFields().contains(QStringLiteral("origtitle"))) {
     Data::FieldPtr f(new Data::Field(QStringLiteral("origtitle"), i18n("Original Title")));
     f->setFormatType(FieldFormat::FormatTitle);
     coll->addField(f);
   }
   if(optionalFields().contains(QStringLiteral("alias"))) {
     Data::FieldPtr f(new Data::Field(QStringLiteral("alias"), i18n("Alias")));
     f->setFlags(Data::Field::AllowMultiple);
     f->setFormatType(FieldFormat::FormatTitle);
     coll->addField(f);
   }
 
   QVariantMap resultMap;
   foreach(const QVariant& result, resultList) {
     // be sure to check that the fetcher has not been stopped
     // crashes can occur if not
     if(!m_started) {
       break;
     }
     resultMap = result.toMap();
 
     Data::EntryPtr entry(new Data::Entry(coll));
     entry->setField(QStringLiteral("title"), mapValue(resultMap, "title"));
     entry->setField(QStringLiteral("vn-id"), mapValue(resultMap, "id"));
     entry->setField(QStringLiteral("year"), mapValue(resultMap, "released").left(4));
     entry->setField(QStringLiteral("genre"), i18n("Visual Novel"));
     entry->setField(QStringLiteral("description"), mapValue(resultMap, "description"));
     entry->setField(QStringLiteral("cover"), mapValue(resultMap, "image"));
     if(optionalFields().contains(QStringLiteral("origtitle"))) {
       entry->setField(QStringLiteral("origtitle"), mapValue(resultMap, "original"));
     }
     if(optionalFields().contains(QStringLiteral("alias"))) {
       const QString aliases = mapValue(resultMap, "aliases");
       entry->setField(QStringLiteral("alias"), aliases.split(QStringLiteral("\n")).join(FieldFormat::delimiterString()));
     }
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
   }
 
 //  m_start = m_entries.count();
 //  m_hasMoreResults = m_start <= m_total;
   m_hasMoreResults = false; // for now, no continued searches
   stop();
 }
 
 void VNDBFetcher::parseReleaseResults(Data::EntryPtr entry_) {
 #if 0
   myWarning() << "Remove debug2 from vndbfetcher.cpp";
   QFile f(QString::fromLatin1("/tmp/vndb-release.json"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("UTF-8");
     t << m_data;
   }
   f.close();
 #endif
 
   QJsonParseError jsonError;
   QJsonDocument doc = QJsonDocument::fromJson(m_data, &jsonError);
   if(doc.isNull()) {
     myDebug() << "null JSON document:" << jsonError.errorString();
     message(jsonError.errorString(), MessageHandler::Error);
     return;
   }
   QVariantMap topResultMap = doc.object().toVariantMap();
   QVariantList resultList = topResultMap.value(QStringLiteral("items")).toList();
   if(resultList.isEmpty()) {
     myDebug() << "no results";
     return;
   }
 
   // only work on the first release item
   const QVariantMap resultMap = resultList.at(0).toMap();
 
   QStringList pubs, devs;
   QVariantList producerList = resultMap.value(QStringLiteral("producers")).toList();
   foreach(const QVariant& producerObject, producerList) {
     const QVariantMap producerMap = producerObject.toMap();
     if(producerMap.value(QStringLiteral("publisher")) == true) {
       pubs += mapValue(producerMap, "name");
     }
     if(producerMap.value(QStringLiteral("developer")) == true) {
       devs += mapValue(producerMap, "name");
     }
   }
   entry_->setField(QStringLiteral("publisher"), pubs.join(FieldFormat::delimiterString()));
   entry_->setField(QStringLiteral("developer"), devs.join(FieldFormat::delimiterString()));
 
   // update release year
   entry_->setField(QStringLiteral("year"), mapValue(resultMap, "released").left(4));
 }
 
 void VNDBFetcher::slotState() {
   if(!m_socket) {
     return;
   }
   if(m_socket->state() == QAbstractSocket::ConnectedState) {
     m_isConnected = true;
   } else if(m_socket->state() == QAbstractSocket::UnconnectedState) {
     m_isConnected = false;
   }
 }
 
 void VNDBFetcher::slotError() {
   if(!m_socket) {
     return;
   }
   myDebug() << "Socket error:" << m_socket->errorString();
 }
 
 void VNDBFetcher::slotRead() {
   m_data += m_socket->readAll();
 
   // check the last character, if it's not the hex character, continue waiting
   if(m_socket->atEnd() && m_data.endsWith(0x04)) {
     switch(m_state) {
       case PreLogin:
         verifyData();
         break;
       case GetVN:
         // necessary for passing unit test
-        QTimer::singleShot(0, this, SLOT(parseVNResults()));
+        QTimer::singleShot(0, this, &VNDBFetcher::parseVNResults);
         break;
       case GetRelease:
         // handled asynch
         break;
       case PostLogin:
       default:
         myDebug() << "Unexpected state in slotRead";
     }
   }
 }
 
 Tellico::Fetch::ConfigWidget* VNDBFetcher::configWidget(QWidget* parent_) const {
   return new VNDBFetcher::ConfigWidget(parent_, this);
 }
 
 QString VNDBFetcher::defaultName() {
   return QStringLiteral("The Visual Novel Database"); // no translation
 }
 
 QString VNDBFetcher::defaultIcon() {
   return favIcon("https://vndb.org");
 }
 
 Tellico::StringHash VNDBFetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("origtitle")] = i18n("Original Title");
   hash[QStringLiteral("alias")] = i18n("Alias");
   return hash;
 }
 
 VNDBFetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const VNDBFetcher* fetcher_)
     : Fetch::ConfigWidget(parent_) {
   QVBoxLayout* l = new QVBoxLayout(optionsWidget());
   l->addWidget(new QLabel(i18n("This source has no options."), optionsWidget()));
   l->addStretch();
 
   // now add additional fields widget
   addFieldsWidget(VNDBFetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 }
 
 void VNDBFetcher::ConfigWidget::saveConfigHook(KConfigGroup&) {
 }
 
 QString VNDBFetcher::ConfigWidget::preferredName() const {
   return VNDBFetcher::defaultName();
 }
diff --git a/src/fetch/xmlfetcher.cpp b/src/fetch/xmlfetcher.cpp
index 9f764d04..8043d672 100644
--- a/src/fetch/xmlfetcher.cpp
+++ b/src/fetch/xmlfetcher.cpp
@@ -1,224 +1,224 @@
 /***************************************************************************
     Copyright (C) 2008-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "xmlfetcher.h"
 #include "../translators/xslthandler.h"
 #include "../translators/tellicoimporter.h"
 #include "../utils/guiproxy.h"
 #include "../utils/xmlhandler.h"
 #include "../utils/string_utils.h"
 #include "../utils/datafileregistry.h"
 #include "../tellico_debug.h"
 
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 
 #include <QFile>
 #include <QTextStream>
 #include <QTextCodec>
 #include <KJobWidgets/KJobWidgets>
 
 using Tellico::Fetch::XMLFetcher;
 
 XMLFetcher::XMLFetcher(QObject* parent_) : Fetcher(parent_)
     , m_xsltHandler(nullptr)
     , m_started(false)
     , m_limit(0) {
 }
 
 XMLFetcher::~XMLFetcher() {
   delete m_xsltHandler;
   m_xsltHandler = nullptr;
 }
 
 void XMLFetcher::search() {
   m_started = true;
   resetSearch();
   doSearch();
 }
 
 void XMLFetcher::continueSearch() {
   m_started = true;
   doSearch();
 }
 
 void XMLFetcher::doSearch() {
   const QUrl u = searchUrl();
   Q_ASSERT(!u.isEmpty());
   if(u.isEmpty()) {
     stop();
     return;
   }
 //  myDebug() << "url: " << u.url();
 
   m_job = KIO::storedGet(u, KIO::NoReload, KIO::HideProgressInfo);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(result(KJob*)), SLOT(slotComplete(KJob*)));
+  connect(m_job.data(), &KJob::result, this, &XMLFetcher::slotComplete);
 }
 
 void XMLFetcher::stop() {
   if(!m_started) {
     return;
   }
   if(m_job) {
     m_job->kill();
     m_job = nullptr;
   }
   m_started = false;
   emit signalDone(this);
 }
 
 void XMLFetcher::slotComplete(KJob* ) {
   Q_ASSERT(m_job);
   if(m_job->error()) {
     m_job->uiDelegate()->showErrorMessage();
     stop();
     return;
   }
 
   if(!m_xsltHandler) {
     initXSLTHandler();
     if(!m_xsltHandler) { // probably an error somewhere in the stylesheet loading
       stop();
       return;
     }
   }
 
   QByteArray data = m_job->data();
   if(data.isEmpty()) {
     myDebug() << "no data";
     stop();
     return;
   }
   // see bug 319662. If fetcher is cancelled, job is killed
   // if the pointer is retained, it gets double-deleted
   m_job = nullptr;
 
 #if 0
   myWarning() << "Remove debug from xmlfetcher.cpp";
   QFile f(QStringLiteral("/tmp/test.xml"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t.setCodec("utf-8");
     t << data;
   }
   f.close();
 #endif
 
   parseData(data);
 
   const QString str = m_xsltHandler->applyStylesheet(XMLHandler::readXMLData(data));
 #if 0
   myWarning() << "Remove debug from xmlfetcher.cpp";
   QFile f2(QStringLiteral("/tmp/test-tellico.xml"));
   if(f2.open(QIODevice::WriteOnly)) {
     QTextStream t(&f2);
     t.setCodec("utf-8");
     t << str;
   }
   f2.close();
 #endif
   Import::TellicoImporter imp(str);
   // be quiet when loading images
   imp.setOptions(imp.options() ^ Import::ImportShowImageErrors);
   Data::CollPtr coll = imp.collection();
   if(!coll) {
     myDebug() << "no collection pointer";
     stop();
     return;
   }
 
   if(m_limit < 1) {
     myDebug() << "Limit < 1, changing to 1";
     m_limit = 1;
   }
 
   int count = 0;
   foreach(Data::EntryPtr entry, coll->entries()) {
     if(count >= m_limit) {
       break;
     }
     if(!m_started) {
       // might get aborted
       break;
     }
 
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
     ++count;
   }
 
   checkMoreResults(m_entries.count());
   stop(); // required
 }
 
 Tellico::Data::EntryPtr XMLFetcher::fetchEntryHook(uint uid_) {
   Data::EntryPtr entry = m_entries[uid_];
   if(!entry) {
     myWarning() << "no entry in dict";
     return Data::EntryPtr();
   }
 
   // the fetcher might end up creating a new entry
   return fetchEntryHookData(entry);
 }
 
 void XMLFetcher::initXSLTHandler() {
   Q_ASSERT(!m_xsltFilename.isEmpty());
   QString xsltfile = DataFileRegistry::self()->locate(m_xsltFilename);
   if(xsltfile.isEmpty()) {
     myWarning() << "can not locate" << m_xsltFilename;
     return;
   }
 
   QUrl u = QUrl::fromLocalFile(xsltfile);
 
   delete m_xsltHandler;
   m_xsltHandler = new XSLTHandler(u);
   if(!m_xsltHandler->isValid()) {
     myWarning() << "error in" << m_xsltFilename;
     delete m_xsltHandler;
     m_xsltHandler = nullptr;
     return;
   }
 }
 
 void XMLFetcher::setXSLTFilename(const QString& filename_) {
   if(!filename_.isEmpty() && filename_ != m_xsltFilename) {
     m_xsltFilename = filename_;
     delete m_xsltHandler;
     m_xsltHandler = nullptr;
   }
 }
 
 void XMLFetcher::setLimit(int limit_) {
   Q_ASSERT(limit_ > 0);
   m_limit = limit_;
 }
 
 Tellico::XSLTHandler* XMLFetcher::xsltHandler() {
   Q_ASSERT(m_xsltHandler);
   return m_xsltHandler;
 }
diff --git a/src/fetch/z3950fetcher.cpp b/src/fetch/z3950fetcher.cpp
index ec859c9f..f49a15c9 100644
--- a/src/fetch/z3950fetcher.cpp
+++ b/src/fetch/z3950fetcher.cpp
@@ -1,845 +1,847 @@
 /***************************************************************************
     Copyright (C) 2003-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  *   In addition, as a special exception, the author gives permission to   *
  *   link the code of this program with the OpenSSL library released by    *
  *   the OpenSSL Project (or with modified versions of OpenSSL that use    *
  *   the same license as OpenSSL), and distribute linked combinations      *
  *   including the two.  You must obey the GNU General Public License in   *
  *   all respects for all of the code used other than OpenSSL.  If you     *
  *   modify this file, you may extend this exception to your version of    *
  *   the file, but you are not obligated to do so.  If you do not wish to  *
  *   do so, delete this exception statement from your version.             *
  *                                                                         *
  ***************************************************************************/
 
 #include <config.h>
 
 #include "z3950fetcher.h"
 #include "z3950connection.h"
 #include "../collection.h"
 #include "../fieldformat.h"
 #include "../translators/xslthandler.h"
 #include "../translators/tellicoimporter.h"
 #include "../translators/grs1importer.h"
 #include "../translators/adsimporter.h"
 #include "../gui/lineedit.h"
 #include "../gui/combobox.h"
 #include "../utils/isbnvalidator.h"
 #include "../utils/lccnvalidator.h"
 #include "../utils/datafileregistry.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KComboBox>
 #include <KAcceleratorManager>
 #include <KSeparator>
 #include <KConfig>
 
 #include <QSpinBox>
 #include <QFile>
 #include <QLabel>
 #include <QDomDocument>
 #include <QTextStream>
 #include <QTextCodec>
 #include <QGridLayout>
 #include <QIcon>
 
 namespace {
   static const int Z3950_DEFAULT_PORT = 210;
   static const char* Z3950_DEFAULT_ESN = "F";
 }
 
 using namespace Tellico;
 using Tellico::Fetch::Z3950Fetcher;
 
 Z3950Fetcher::Z3950Fetcher(QObject* parent_)
     : Fetcher(parent_), m_conn(nullptr), m_port(Z3950_DEFAULT_PORT), m_esn(QLatin1String(Z3950_DEFAULT_ESN)),
       m_started(false), m_done(true), m_MARC21XMLHandler(nullptr),
       m_UNIMARCXMLHandler(nullptr), m_MODSHandler(nullptr) {
 }
 
 Z3950Fetcher::Z3950Fetcher(QObject* parent_, const QString& preset_)
     : Fetcher(parent_), m_conn(nullptr), m_port(Z3950_DEFAULT_PORT), m_started(false), m_done(true), m_preset(preset_),
       m_MARC21XMLHandler(nullptr), m_UNIMARCXMLHandler(nullptr), m_MODSHandler(nullptr) {
   QString serverFile = DataFileRegistry::self()->locate(QStringLiteral("z3950-servers.cfg"));
   if(!serverFile.isEmpty()) {
     KConfig serverConfig(serverFile, KConfig::SimpleConfig);
     const QStringList servers = serverConfig.groupList();
     for(QStringList::ConstIterator server = servers.begin(); server != servers.end(); ++server) {
       if(*server == m_preset) {
         KConfigGroup cfg(&serverConfig, *server);
         m_host = cfg.readEntry("Host");
         m_port = cfg.readEntry("Port", Z3950_DEFAULT_PORT);
         m_dbname = cfg.readEntry("Database");
         m_sourceCharSet = cfg.readEntry("Charset");
         m_syntax = cfg.readEntry("Syntax");
         m_user = cfg.readEntry("User");
         m_password = cfg.readEntry("Password");
       }
     }
   } else {
     myDebug() << "z3950-servers.cfg not found";
   }
 }
 
 Z3950Fetcher::Z3950Fetcher(QObject* parent_, const QString& host_, int port_,
                            const QString& dbName_, const QString& syntax_)
     : Fetcher(parent_), m_conn(nullptr), m_host(host_), m_port(port_), m_dbname(dbName_)
     , m_syntax(syntax_), m_esn(QLatin1String(Z3950_DEFAULT_ESN))
     , m_started(false), m_done(true), m_MARC21XMLHandler(nullptr)
     , m_UNIMARCXMLHandler(nullptr), m_MODSHandler(nullptr) {
 }
 
 Z3950Fetcher::~Z3950Fetcher() {
   delete m_MARC21XMLHandler;
   m_MARC21XMLHandler = nullptr;
   delete m_UNIMARCXMLHandler;
   m_UNIMARCXMLHandler = nullptr;
   delete m_MODSHandler;
   m_MODSHandler = nullptr;
 
   if(m_conn) {
     m_conn->wait();
     m_conn->deleteLater();
     m_conn = nullptr;
   }
 }
 
 QString Z3950Fetcher::source() const {
   return m_name.isEmpty() ? defaultName() : m_name;
 }
 
 bool Z3950Fetcher::canFetch(int type) const {
   return type == Data::Collection::Book || type == Data::Collection::Bibtex;
 }
 
 void Z3950Fetcher::readConfigHook(const KConfigGroup& config_) {
   QString preset = config_.readEntry("Preset");
   if(preset.isEmpty()) {
     m_host = config_.readEntry("Host");
     int p = config_.readEntry("Port", Z3950_DEFAULT_PORT);
     if(p > 0) {
       m_port = p;
     }
     m_dbname = config_.readEntry("Database");
     m_sourceCharSet = config_.readEntry("Charset");
     m_syntax = config_.readEntry("Syntax");
     m_user = config_.readEntry("User");
     m_password = config_.readEntry("Password");
   } else {
     m_preset = preset;
     QString serverFile = DataFileRegistry::self()->locate(QStringLiteral("z3950-servers.cfg"));
     if(!serverFile.isEmpty()) {
       KConfig serverConfig(serverFile, KConfig::SimpleConfig);
       const QStringList servers = serverConfig.groupList();
       for(QStringList::ConstIterator server = servers.begin(); server != servers.end(); ++server) {
         if(*server == preset) {
           KConfigGroup cfg(&serverConfig, *server);
 //          const QString name = cfg.readEntry("Name");
           m_host = cfg.readEntry("Host");
           m_port = cfg.readEntry("Port", Z3950_DEFAULT_PORT);
           m_dbname = cfg.readEntry("Database");
           m_sourceCharSet = cfg.readEntry("Charset");
           m_syntax = cfg.readEntry("Syntax");
           m_user = cfg.readEntry("User");
           m_password = cfg.readEntry("Password");
         }
       }
     } else {
       myDebug() << "z3950-servers.cfg not found";
     }
   }
 }
 
 void Z3950Fetcher::saveConfigHook(KConfigGroup& config_) {
   config_.writeEntry("Syntax", m_syntax);
   config_.sync();
 }
 
 void Z3950Fetcher::search() {
 #ifdef HAVE_YAZ
   m_started = true;
   m_done = false;
   if(m_host.isEmpty() || m_dbname.isEmpty()) {
     myDebug() << "settings are not set!";
     stop();
     return;
   }
   m_started = true;
 
   QString svalue = request().value;
   QRegExp rx1(QLatin1String("['\"].*\\1"));
   if(!rx1.exactMatch(svalue)) {
     svalue = QLatin1Char('"') + svalue + QLatin1Char('"');
   }
 
   switch(request().key) {
     case Title:
       m_pqn = QLatin1String("@attr 1=4 ") + svalue;
       break;
     case Person:
 //      m_pqn = QLatin1String("@or ");
 //      m_pqn += QLatin1String("@attr 1=1 \"") + request().value + QLatin1Char('"');
       m_pqn = QLatin1String(" @attr 1=1003 ") + svalue;
       break;
     case ISBN:
       {
         m_pqn.clear();
         QString s = request().value;
         s.remove(QLatin1Char('-'));
         QStringList isbnList = FieldFormat::splitValue(s);
         // also search for isbn10 values
         for(QStringList::Iterator it = isbnList.begin(); it != isbnList.end(); ++it) {
           if((*it).startsWith(QLatin1String("978"))) {
             QString isbn10 = ISBNValidator::isbn10(*it);
             isbn10.remove(QLatin1Char('-'));
             it = isbnList.insert(it, isbn10);
             ++it;
           }
         }
         const int count = isbnList.count();
         if(count > 1) {
           m_pqn = QStringLiteral("@or ");
         }
         for(int i = 0; i < count; ++i) {
           m_pqn += QLatin1String(" @attr 1=7 ") + isbnList.at(i);
           if(count > 1 && i < count-2) {
             m_pqn += QLatin1String(" @or");
           }
         }
       }
       break;
     case LCCN:
       {
         m_pqn.clear();
         QString s = request().value;
         s.remove(QLatin1Char('-'));
         QStringList lccnList = FieldFormat::splitValue(s);
         while(!lccnList.isEmpty()) {
           m_pqn += QLatin1String(" @or @attr 1=9 ") + lccnList.front();
           if(lccnList.count() > 1) {
             m_pqn += QLatin1String(" @or");
           }
           m_pqn += QLatin1String(" @attr 1=9 ") + LCCNValidator::formalize(lccnList.front());
           lccnList.pop_front();
         }
       }
       break;
     case Keyword:
       m_pqn = QLatin1String("@attr 1=1016 ") + svalue;
       break;
     case Raw:
       m_pqn = request().value;
       break;
     default:
       myWarning() << "key not recognized: " << request().key;
       stop();
       return;
   }
 //  m_pqn = QLatin1String("@attr 1=7 0253333490");
 //  myLog() << "PQN query = " << m_pqn;
 
   if(m_conn) {
     m_conn->reset(); // reset counts
   }
 
   process();
 #else // HAVE_YAZ
   stop();
   return;
 #endif
 }
 
 void Z3950Fetcher::continueSearch() {
 #ifdef HAVE_YAZ
   m_started = true;
   process();
 #endif
 }
 
 void Z3950Fetcher::stop() {
   if(!m_started) {
     return;
   }
   m_started = false;
   if(m_conn) {
    // give it a second to cleanup
     m_conn->abort();
     m_conn->wait(1000);
   }
   emit signalDone(this);
 }
 
 bool Z3950Fetcher::initMARC21Handler() {
   if(m_MARC21XMLHandler) {
     return true;
   }
 
   QString xsltfile = DataFileRegistry::self()->locate(QStringLiteral("MARC21slim2MODS3.xsl"));
   if(xsltfile.isEmpty()) {
     myWarning() << "can not locate MARC21slim2MODS3.xsl.";
     return false;
   }
 
   QUrl u = QUrl::fromLocalFile(xsltfile);
 
   m_MARC21XMLHandler = new XSLTHandler(u);
   if(!m_MARC21XMLHandler->isValid()) {
     myWarning() << "error in MARC21slim2MODS3.xsl.";
     delete m_MARC21XMLHandler;
     m_MARC21XMLHandler = nullptr;
     return false;
   }
   return true;
 }
 
 bool Z3950Fetcher::initUNIMARCHandler() {
   if(m_UNIMARCXMLHandler) {
     return true;
   }
 
   QString xsltfile = DataFileRegistry::self()->locate(QStringLiteral("UNIMARC2MODS3.xsl"));
   if(xsltfile.isEmpty()) {
     myWarning() << "can not locate UNIMARC2MODS3.xsl.";
     return false;
   }
 
   QUrl u = QUrl::fromLocalFile(xsltfile);
 
   m_UNIMARCXMLHandler = new XSLTHandler(u);
   if(!m_UNIMARCXMLHandler->isValid()) {
     myWarning() << "error in UNIMARC2MODS3.xsl.";
     delete m_UNIMARCXMLHandler;
     m_UNIMARCXMLHandler = nullptr;
     return false;
   }
   return true;
 }
 
 bool Z3950Fetcher::initMODSHandler() {
   if(m_MODSHandler) {
     return true;
   }
 
   QString xsltfile = DataFileRegistry::self()->locate(QStringLiteral("mods2tellico.xsl"));
   if(xsltfile.isEmpty()) {
     myWarning() << "can not locate mods2tellico.xsl.";
     return false;
   }
 
   QUrl u = QUrl::fromLocalFile(xsltfile);
 
   m_MODSHandler = new XSLTHandler(u);
   if(!m_MODSHandler->isValid()) {
     myWarning() << "error in mods2tellico.xsl.";
     delete m_MODSHandler;
     m_MODSHandler = nullptr;
     // no use in keeping the MARC handlers now
     delete m_MARC21XMLHandler;
     m_MARC21XMLHandler = nullptr;
     delete m_UNIMARCXMLHandler;
     m_UNIMARCXMLHandler = nullptr;
     return false;
   }
   return true;
 }
 
 void Z3950Fetcher::process() {
   if(m_conn) {
     m_conn->wait();
   } else {
     m_conn = new Z3950Connection(this, m_host, m_port, m_dbname, m_sourceCharSet, m_syntax, m_esn);
     if(!m_user.isEmpty()) {
       m_conn->setUserPassword(m_user, m_password);
     }
   }
 
   m_conn->setQuery(m_pqn);
   m_conn->start();
 }
 
 void Z3950Fetcher::handleResult(const QString& result_) {
   if(result_.isEmpty()) {
     myDebug() << "empty record found, maybe the character encoding or record format is wrong?";
     return;
   }
   // possible to get a race condition where the fetcher has been stopped
   // even as new results come in
   if(!m_started) {
     return;
   }
 
 #if 0
   myWarning() << "Remove debug from z3950fetcher.cpp";
   {
     QFile f1(QLatin1String("/tmp/z3950.txt"));
     if(f1.open(QIODevice::WriteOnly)) {
 //      if(f1.open(QIODevice::WriteOnly | QIODevice::Append)) {
       QTextStream t(&f1);
       t.setCodec("UTF-8");
       t << result_;
     }
     f1.close();
   }
 #endif
   // assume always utf-8
   QString str, msg;
   Data::CollPtr coll;
   // not marc, has to be grs-1
   if(m_syntax == QLatin1String("grs-1")) {
     Import::GRS1Importer imp(result_);
     coll = imp.collection();
     msg = imp.statusMessage();
   } else if(m_syntax == QLatin1String("ads")) {
     Import::ADSImporter imp(result_);
     coll = imp.collection();
     msg = imp.statusMessage();
   } else { // now the MODS stuff
     if(m_syntax == QLatin1String("mods")) {
       str = result_;
     } else if(m_syntax == QLatin1String("unimarc") && initUNIMARCHandler()) {
       str = m_UNIMARCXMLHandler->applyStylesheet(result_);
     } else if(initMARC21Handler()) { // got to be usmarc/marc21
       str = m_MARC21XMLHandler->applyStylesheet(result_);
     }
     if(str.isEmpty() || !initMODSHandler()) {
       myDebug() << "empty string or can't init";
       stop();
       return;
     }
 #if 0
     myWarning() << "Remove debug from z3950fetcher.cpp";
     {
       QFile f2(QLatin1String("/tmp/mods.xml"));
 //      if(f2.open(QIODevice::WriteOnly)) {
       if(f2.open(QIODevice::WriteOnly | QIODevice::Append)) {
         QTextStream t(&f2);
         t.setCodec("UTF-8");
         t << str;
       }
       f2.close();
     }
 #endif
     Import::TellicoImporter imp(m_MODSHandler->applyStylesheet(str));
     imp.setOptions(imp.options() ^ Import::ImportProgress); // no progress needed
     coll = imp.collection();
     msg = imp.statusMessage();
   }
 
   if(!coll) {
     if(!msg.isEmpty()) {
       message(msg, MessageHandler::Warning);
     }
     myDebug() << "no collection pointer:" << msg;
     return;
   }
 
   if(coll->entryCount() == 0) {
 //    myDebug() << "no Tellico entry in result";
     return;
   }
 
   // since the Dewey and LoC field titles have a context in their i18n call here
   // but not in the mods2tellico.xsl stylesheet where the field is actually created
   // update the field titles here
   QHashIterator<QString, QString> i(allOptionalFields());
   while(i.hasNext()) {
     i.next();
     Data::FieldPtr field = coll->fieldByName(i.key());
     if(field) {
       field->setTitle(i.value());
       coll->modifyField(field);
     }
   }
 
   Data::EntryList entries = coll->entries();
   foreach(Data::EntryPtr entry, entries) {
     FetchResult* r = new FetchResult(Fetcher::Ptr(this), entry);
     m_entries.insert(r->uid, entry);
     emit signalResultFound(r);
   }
 }
 
 void Z3950Fetcher::done() {
   m_done = true;
   stop();
 }
 
 Tellico::Data::EntryPtr Z3950Fetcher::fetchEntryHook(uint uid_) {
   return m_entries[uid_];
 }
 
 void Z3950Fetcher::customEvent(QEvent* event_) {
   if(!m_conn) {
     return;
   }
 
   if(event_->type() == Z3950ResultFound::uid()) {
     if(m_done) {
       myWarning() << "result returned after done signal!";
     }
     Z3950ResultFound* e = static_cast<Z3950ResultFound*>(event_);
     handleResult(e->result());
   } else if(event_->type() == Z3950ConnectionDone::uid()) {
     Z3950ConnectionDone* e = static_cast<Z3950ConnectionDone*>(event_);
     if(e->messageType() > -1) {
       message(e->message(), e->messageType());
     }
     m_hasMoreResults = e->hasMoreResults();
     m_conn->wait();
     done();
   } else if(event_->type() == Z3950SyntaxChange::uid()) {
     if(m_done) {
       myWarning() << "syntax changed after done signal!";
     }
     Z3950SyntaxChange* e = static_cast<Z3950SyntaxChange*>(event_);
     if(m_syntax != e->syntax()) {
       m_syntax = e->syntax();
       // it gets saved when saveConfigHook() get's called from the Fetcher() d'tor
     }
   } else {
     myWarning() << "weird type: " << event_->type();
   }
 }
 
 Tellico::Fetch::FetchRequest Z3950Fetcher::updateRequest(Data::EntryPtr entry_) {
 //  myDebug() << source() << ": " << entry_->title();
   QString isbn = entry_->field(QStringLiteral("isbn"));
   if(!isbn.isEmpty()) {
     return FetchRequest(Fetch::ISBN, isbn);
   }
 
   QString lccn = entry_->field(QStringLiteral("lccn"));
   if(!lccn.isEmpty()) {
     return FetchRequest(Fetch::LCCN, lccn);
   }
 
   // optimistically try searching for title and rely on Collection::sameEntry() to figure things out
   QString t = entry_->field(QStringLiteral("title"));
   if(!t.isEmpty()) {
     return FetchRequest(Fetch::Title, t);
   }
   return FetchRequest();
 }
 
 Tellico::Fetch::ConfigWidget* Z3950Fetcher::configWidget(QWidget* parent_) const {
   return new Z3950Fetcher::ConfigWidget(parent_, this);
 }
 
 QString Z3950Fetcher::defaultName() {
   return i18n("z39.50 Server");
 }
 
 QString Z3950Fetcher::defaultIcon() {
 //  return QLatin1String("network-server"); // rather arbitrary
   return QStringLiteral("network-server-database"); // rather arbitrary
 }
 
 // static
 Tellico::StringHash Z3950Fetcher::allOptionalFields() {
   StringHash hash;
   hash[QStringLiteral("address")]  = i18n("Address");
   hash[QStringLiteral("abstract")] = i18n("Abstract");
   hash[QStringLiteral("illustrator")] = i18n("Illustrator");
   hash[QStringLiteral("dewey")] = i18nc("Dewey Decimal classification system", "Dewey Decimal");
   hash[QStringLiteral("lcc")] = i18nc("Library of Congress classification system", "LoC Classification");
   return hash;
 }
 
 Z3950Fetcher::ConfigWidget::ConfigWidget(QWidget* parent_, const Z3950Fetcher* fetcher_/*=0*/)
     : Fetch::ConfigWidget(parent_) {
   QGridLayout* l = new QGridLayout(optionsWidget());
   l->setSpacing(4);
   l->setColumnStretch(1, 10);
 
   int row = -1;
 
   m_usePreset = new QCheckBox(i18n("Use preset &server:"), optionsWidget());
   l->addWidget(m_usePreset, ++row, 0);
-  connect(m_usePreset, SIGNAL(toggled(bool)), SLOT(slotTogglePreset(bool)));
+  connect(m_usePreset, &QAbstractButton::toggled, this, &ConfigWidget::slotTogglePreset);
   m_serverCombo = new GUI::ComboBox(optionsWidget());
-  connect(m_serverCombo, SIGNAL(activated(int)), SLOT(slotPresetChanged()));
+  void (GUI::ComboBox::* activatedInt)(int) = &GUI::ComboBox::activated;
+  connect(m_serverCombo, activatedInt, this, &ConfigWidget::slotPresetChanged);
   l->addWidget(m_serverCombo, row, 1);
   ++row;
   l->addWidget(new KSeparator(optionsWidget()), row, 0, 1, 2);
   l->setRowMinimumHeight(row, 10);
 
   QLabel* label = new QLabel(i18n("Hos&t: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_hostEdit = new GUI::LineEdit(optionsWidget());
-  connect(m_hostEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
-  connect(m_hostEdit, SIGNAL(textChanged(QString)), SIGNAL(signalName(const QString&)));
+  connect(m_hostEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
+  connect(m_hostEdit, &QLineEdit::textChanged, this, &ConfigWidget::signalName);
   l->addWidget(m_hostEdit, row, 1);
   QString w = i18n("Enter the host name of the server.");
   label->setWhatsThis(w);
   m_hostEdit->setWhatsThis(w);
   label->setBuddy(m_hostEdit);
 
   label = new QLabel(i18n("&Port: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_portSpinBox = new QSpinBox(optionsWidget());
   m_portSpinBox->setMaximum(999999);
   m_portSpinBox->setMinimum(0);
   m_portSpinBox->setValue(Z3950_DEFAULT_PORT);
-  connect(m_portSpinBox, SIGNAL(valueChanged(int)), SLOT(slotSetModified()));
+  void (QSpinBox::* valueChanged)(int) = &QSpinBox::valueChanged;
+  connect(m_portSpinBox, valueChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_portSpinBox, row, 1);
   w = i18n("Enter the port number of the server. The default is %1.", Z3950_DEFAULT_PORT);
   label->setWhatsThis(w);
   m_portSpinBox->setWhatsThis(w);
   label->setBuddy(m_portSpinBox);
 
   label = new QLabel(i18n("&Database: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_databaseEdit = new GUI::LineEdit(optionsWidget());
-  connect(m_databaseEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_databaseEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_databaseEdit, row, 1);
   w = i18n("Enter the database name used by the server.");
   label->setWhatsThis(w);
   m_databaseEdit->setWhatsThis(w);
   label->setBuddy(m_databaseEdit);
 
   label = new QLabel(i18n("Ch&aracter set: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_charSetCombo = new KComboBox(true, optionsWidget());
   m_charSetCombo->addItem(QString());
   m_charSetCombo->addItem(QStringLiteral("marc8"));
   m_charSetCombo->addItem(QStringLiteral("iso-8859-1"));
   m_charSetCombo->addItem(QStringLiteral("utf-8"));
-  connect(m_charSetCombo, SIGNAL(currentTextChanged(QString)), SLOT(slotSetModified()));
+  connect(m_charSetCombo, &QComboBox::currentTextChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_charSetCombo, row, 1);
   w = i18n("Enter the character set encoding used by the z39.50 server. The most likely choice "
            "is MARC-8, although ISO-8859-1 is common as well.");
   label->setWhatsThis(w);
   m_charSetCombo->setWhatsThis(w);
   label->setBuddy(m_charSetCombo);
 
   label = new QLabel(i18n("&Format: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_syntaxCombo = new GUI::ComboBox(optionsWidget());
   m_syntaxCombo->addItem(i18n("Auto-detect"), QString());
   m_syntaxCombo->addItem(QStringLiteral("MODS"), QLatin1String("mods"));
   m_syntaxCombo->addItem(QStringLiteral("MARC21"), QLatin1String("marc21"));
   m_syntaxCombo->addItem(QStringLiteral("UNIMARC"), QLatin1String("unimarc"));
   m_syntaxCombo->addItem(QStringLiteral("USMARC"), QLatin1String("usmarc"));
   m_syntaxCombo->addItem(QStringLiteral("ADS"), QLatin1String("ads"));
   m_syntaxCombo->addItem(QStringLiteral("GRS-1"), QLatin1String("grs-1"));
-  connect(m_syntaxCombo, SIGNAL(currentTextChanged(QString)), SLOT(slotSetModified()));
+  connect(m_syntaxCombo, &QComboBox::currentTextChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_syntaxCombo, row, 1);
   w = i18n("Enter the data format used by the z39.50 server. Tellico will attempt to "
            "automatically detect the best setting if <i>auto-detect</i> is selected.");
   label->setWhatsThis(w);
   m_syntaxCombo->setWhatsThis(w);
   label->setBuddy(m_syntaxCombo);
 
   label = new QLabel(i18n("&User: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_userEdit = new GUI::LineEdit(optionsWidget());
   m_userEdit->setPlaceholderText(i18n("Optional"));
-  connect(m_userEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_userEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_userEdit, row, 1);
   w = i18n("Enter the authentication user name used by the z39.50 database. Most servers "
            "do not need one.");
   label->setWhatsThis(w);
   m_userEdit->setWhatsThis(w);
   label->setBuddy(m_userEdit);
 
   label = new QLabel(i18n("Pass&word: "), optionsWidget());
   l->addWidget(label, ++row, 0);
   m_passwordEdit = new GUI::LineEdit(optionsWidget());
   m_passwordEdit->setPlaceholderText(i18n("Optional"));
   m_passwordEdit->setEchoMode(QLineEdit::Password);
-  connect(m_passwordEdit, SIGNAL(textChanged(QString)), SLOT(slotSetModified()));
+  connect(m_passwordEdit, &QLineEdit::textChanged, this, &ConfigWidget::slotSetModified);
   l->addWidget(m_passwordEdit, row, 1);
   w = i18n("Enter the authentication password used by the z39.50 database. Most servers "
            "do not need one. The password will be saved in plain text in the Tellico "
            "configuration file.");
   label->setWhatsThis(w);
   m_passwordEdit->setWhatsThis(w);
   label->setBuddy(m_passwordEdit);
 
   l->setRowStretch(++row, 1);
 
   // now add additional fields widget
   addFieldsWidget(Z3950Fetcher::allOptionalFields(), fetcher_ ? fetcher_->optionalFields() : QStringList());
 
   loadPresets(fetcher_ ? fetcher_->m_preset : QString());
   if(fetcher_) {
     m_hostEdit->setText(fetcher_->m_host);
     m_portSpinBox->setValue(fetcher_->m_port);
     m_databaseEdit->setText(fetcher_->m_dbname);
     m_userEdit->setText(fetcher_->m_user);
     m_passwordEdit->setText(fetcher_->m_password);
     m_charSetCombo->setEditText(fetcher_->m_sourceCharSet);
     // the syntax is detected automatically by the fetcher
     // since the config group gets deleted in the config file,
     // the value needs to be retained here
     m_syntax = fetcher_->m_syntax;
     m_syntaxCombo->setCurrentData(m_syntax);
   }
   KAcceleratorManager::manage(optionsWidget());
 
   // start with presets turned off
   m_usePreset->setChecked(fetcher_ && !fetcher_->m_preset.isEmpty());
 
   slotTogglePreset(m_usePreset->isChecked());
 }
 
 Z3950Fetcher::ConfigWidget::~ConfigWidget() {
 }
 
 void Z3950Fetcher::ConfigWidget::saveConfigHook(KConfigGroup& config_) {
   if(m_usePreset->isChecked()) {
     QString presetID = m_serverCombo->currentData().toString();
     config_.writeEntry("Preset", presetID);
     return;
   }
   config_.deleteEntry("Preset");
 
   QString s = m_hostEdit->text().trimmed();
   if(!s.isEmpty()) {
     config_.writeEntry("Host", s);
   }
   int port = m_portSpinBox->value();
   if(port > 0) {
     config_.writeEntry("Port", port);
   }
   s = m_databaseEdit->text().trimmed();
   if(!s.isEmpty()) {
     config_.writeEntry("Database", s);
   }
   s = m_charSetCombo->currentText();
   if(!s.isEmpty()) {
     config_.writeEntry("Charset", s);
   }
   s = m_userEdit->text();
   if(!s.isEmpty()) {
     config_.writeEntry("User", s);
   }
   s = m_passwordEdit->text();
   if(!s.isEmpty()) {
     config_.writeEntry("Password", s);
   }
   s = m_syntaxCombo->currentData().toString();
   if(!s.isEmpty()) {
     m_syntax = s;
   }
   config_.writeEntry("Syntax", m_syntax);
 }
 
 void Z3950Fetcher::ConfigWidget::slotTogglePreset(bool on) {
   m_serverCombo->setEnabled(on);
   if(on) {
     emit signalName(m_serverCombo->currentText());
   }
   m_hostEdit->setEnabled(!on);
   if(!on && !m_hostEdit->text().isEmpty()) {
     emit signalName(m_hostEdit->text());
   }
   m_portSpinBox->setEnabled(!on);
   m_databaseEdit->setEnabled(!on);
   m_userEdit->setEnabled(!on);
   m_passwordEdit->setEnabled(!on);
   m_charSetCombo->setEnabled(!on);
   m_syntaxCombo->setEnabled(!on);
   if(on) {
     emit signalName(m_serverCombo->currentText());
   }
 }
 
 void Z3950Fetcher::ConfigWidget::slotPresetChanged() {
   emit signalName(m_serverCombo->currentText());
 }
 
 void Z3950Fetcher::ConfigWidget::loadPresets(const QString& current_) {
   const QString lang = QLocale().uiLanguages().constFirst();
   const QString lang2A = lang.contains(QLatin1Char('-')) ? lang.section(QLatin1Char('-'), 0, 0) : lang;
 
   QString serverFile = DataFileRegistry::self()->locate(QStringLiteral("z3950-servers.cfg"));
   if(serverFile.isEmpty()) {
     myWarning() << "no z3950 servers file found";
     return;
   }
 
   int idx = -1;
 
   KConfig serverConfig(serverFile, KConfig::SimpleConfig);
   const QStringList servers = serverConfig.groupList();
   // I want the list of servers sorted by name so use QMap instead of QHash
   QMap<QString, QString> serverNameMap;
   QHash<QString, QIcon> flags;
   for(QStringList::ConstIterator server = servers.constBegin(); server != servers.constEnd(); ++server) {
     if((*server).isEmpty()) {
       myDebug() << "empty id";
       continue;
     }
     KConfigGroup cfg(&serverConfig, *server);
     const QString name = cfg.readEntry("Name");
     if(!name.isEmpty()) {
       serverNameMap.insert(name, *server);
     }
   }
   for(QMap<QString, QString>::ConstIterator it = serverNameMap.constBegin(); it != serverNameMap.constEnd(); ++it) {
     const QString name = it.key();
     const QString group = it.value();
     KConfigGroup cfg(&serverConfig, group);
     const QString country = cfg.readEntry("Country", QString());
 
     QIcon icon;
     if(!country.isEmpty()) {
       QHash<QString, QIcon>::ConstIterator it = flags.constFind(country);
       if(it != flags.constEnd()) {
         icon = it.value();
       } else {
         const QString flag = QStandardPaths::locate(QStandardPaths::GenericDataLocation,
                                                     QStringLiteral("kf5/locale/countries/%1/flag.png").arg(country));
         if (!flag.isEmpty()) {
           icon = QIcon(flag);
           flags.insert(country, icon);
         }
       }
     }
     m_serverCombo->addItem(icon, name, group);
 
     if(current_.isEmpty() && idx == -1) {
       // set the initial selection to something depending on the language
       const QStringList locales = cfg.readEntry("Locale", QStringList());
       if(locales.contains(lang) || locales.contains(lang2A)) {
         idx = m_serverCombo->count() - 1;
       }
     } else if(group == current_) {
       idx = m_serverCombo->count() - 1;
     }
   }
   if(idx > -1) {
     m_serverCombo->setCurrentIndex(idx);
   }
 }
 
 QString Z3950Fetcher::ConfigWidget::preferredName() const {
   if(m_usePreset->isChecked()) {
     return m_serverCombo->currentText();
   }
   QString s = m_hostEdit->text();
   return s.isEmpty() ? i18n("z39.50 Server") : s;
 }
diff --git a/src/fetchdialog.cpp b/src/fetchdialog.cpp
index 9fb09875..b5a3b273 100644
--- a/src/fetchdialog.cpp
+++ b/src/fetchdialog.cpp
@@ -1,939 +1,948 @@
 /***************************************************************************
     Copyright (C) 2003-2011 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include <config.h>
 
 #include "fetchdialog.h"
 #include "fetch/fetchmanager.h"
 #include "fetch/fetcher.h"
 #include "fetch/fetchresult.h"
 #include "config/tellico_config.h"
 #include "entryview.h"
 #include "utils/isbnvalidator.h"
 #include "utils/upcvalidator.h"
 #include "tellico_kernel.h"
 #include "core/filehandler.h"
 #include "collection.h"
 #include "entry.h"
 #include "document.h"
 #include "field.h"
 #include "fieldformat.h"
 #include "gui/combobox.h"
 #include "utils/cursorsaver.h"
 #include "utils/stringset.h"
 #include "images/image.h"
 #include "tellico_debug.h"
 
 #ifdef ENABLE_WEBCAM
 #include "barcode/barcode.h"
 #endif
 
 #include <KLocalizedString>
 #include <KHTMLView>
 #include <KSharedConfig>
 #include <KAcceleratorManager>
 #include <KTextEdit>
 #include <KMessageBox>
 #include <KStandardGuiItem>
 #include <KWindowConfig>
 
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QLineEdit>
 #include <QGroupBox>
 #include <QSplitter>
 #include <QTimer>
 #include <QCheckBox>
 #include <QImage>
 #include <QLabel>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QProgressBar>
 #include <QTreeWidget>
 #include <QHeaderView>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QFileDialog>
 #include <QStatusBar>
 
 namespace {
   static const int FETCH_MIN_WIDTH = 600;
 
   static const char* FETCH_STRING_SEARCH = I18N_NOOP("&Search");
   static const char* FETCH_STRING_STOP   = I18N_NOOP("&Stop");
 
   static const int StringDataType = QEvent::User;
   static const int ImageDataType = QEvent::User+1;
 
   class StringDataEvent : public QEvent {
   public:
     StringDataEvent(const QString& str) : QEvent(static_cast<QEvent::Type>(StringDataType)), m_string(str) {}
     QString string() const { return m_string; }
   private:
     QString m_string;
   };
 
   class ImageDataEvent : public QEvent {
   public:
     ImageDataEvent(const QImage& img) : QEvent(static_cast<QEvent::Type>(ImageDataType)), m_image(img) {}
     QImage image() const { return m_image; }
   private:
     QImage m_image;
   };
 
   // class exists just to make sizeHintForColumn() public
   class TreeWidget : public QTreeWidget {
   public:
     TreeWidget(QWidget* p) : QTreeWidget(p) {}
     virtual int sizeHintForColumn(int c) const Q_DECL_OVERRIDE { return QTreeWidget::sizeHintForColumn(c); }
   };
 }
 
 using Tellico::FetchDialog;
 using barcodeRecognition::barcodeRecognitionThread;
 
 class FetchDialog::FetchResultItem : public QTreeWidgetItem {
   friend class FetchDialog;
   // always add to end
   FetchResultItem(QTreeWidget* lv, Fetch::FetchResult* r)
       : QTreeWidgetItem(lv), m_result(r) {
     setData(1, Qt::DisplayRole, r->title);
     setData(2, Qt::DisplayRole, r->desc);
     setData(3, Qt::DisplayRole, r->fetcher->source());
     setData(3, Qt::DecorationRole, Fetch::Manager::self()->fetcherIcon(r->fetcher));
   }
   Fetch::FetchResult* m_result;
 };
 
 FetchDialog::FetchDialog(QWidget* parent_)
     : QDialog(parent_)
     , m_timer(new QTimer(this))
     , m_started(false)
     , m_resultCount(0)
     , m_treeWasResized(false)
     , m_barcodePreview(nullptr)
     , m_barcodeRecognitionThread(nullptr) {
   setModal(false);
   setWindowTitle(i18n("Internet Search"));
 
   QVBoxLayout* mainLayout = new QVBoxLayout();
   setLayout(mainLayout);
 
   m_collType = Kernel::self()->collectionType();
 
   QWidget* mainWidget = new QWidget(this);
   mainLayout->addWidget(mainWidget);
   QBoxLayout* topLayout = new QVBoxLayout(mainWidget);
 
   QGroupBox* queryBox = new QGroupBox(i18n("Search Query"), mainWidget);
   QBoxLayout* queryLayout = new QVBoxLayout(queryBox);
   topLayout->addWidget(queryBox);
 
   QWidget* box1 = new QWidget(queryBox);
   QHBoxLayout* box1HBoxLayout = new QHBoxLayout(box1);
   box1HBoxLayout->setMargin(0);
   queryLayout->addWidget(box1);
 
   QLabel* label = new QLabel(i18nc("Start the search", "S&earch:"), box1);
   box1HBoxLayout->addWidget(label);
 
   m_valueLineEdit = new QLineEdit(box1);
   box1HBoxLayout->addWidget(m_valueLineEdit);
   label->setBuddy(m_valueLineEdit);
   m_valueLineEdit->setWhatsThis(i18n("Enter a search value. An ISBN search must include the full ISBN."));
 
   m_keyCombo = new GUI::ComboBox(box1);
   box1HBoxLayout->addWidget(m_keyCombo);
   Fetch::KeyMap map = Fetch::Manager::self()->keyMap();
   for(Fetch::KeyMap::ConstIterator it = map.constBegin(); it != map.constEnd(); ++it) {
     m_keyCombo->addItem(it.value(), it.key());
   }
-  connect(m_keyCombo, SIGNAL(activated(int)), SLOT(slotKeyChanged(int)));
+  void (QComboBox::* activatedInt)(int) = &QComboBox::activated;
+  connect(m_keyCombo, activatedInt, this, &FetchDialog::slotKeyChanged);
   m_keyCombo->setWhatsThis(i18n("Choose the type of search"));
 
   m_searchButton = new QPushButton(box1);
   box1HBoxLayout->addWidget(m_searchButton);
   KGuiItem::assign(m_searchButton, KGuiItem(i18n(FETCH_STRING_STOP),
                                             QIcon::fromTheme(QStringLiteral("dialog-cancel"))));
-  connect(m_searchButton, SIGNAL(clicked()), SLOT(slotSearchClicked()));
+  connect(m_searchButton, &QAbstractButton::clicked, this, &FetchDialog::slotSearchClicked);
   m_searchButton->setWhatsThis(i18n("Click to start or stop the search"));
 
   // the search button's text changes from search to stop
   // I don't want it resizing, so figure out the maximum size and set that
   m_searchButton->ensurePolished();
   int maxWidth = m_searchButton->sizeHint().width();
   int maxHeight = m_searchButton->sizeHint().height();
   KGuiItem::assign(m_searchButton, KGuiItem(i18n(FETCH_STRING_SEARCH),
                                             QIcon::fromTheme(QStringLiteral("edit-find"))));
   maxWidth = qMax(maxWidth, m_searchButton->sizeHint().width());
   maxHeight = qMax(maxHeight, m_searchButton->sizeHint().height());
   m_searchButton->setMinimumWidth(maxWidth);
   m_searchButton->setMinimumHeight(maxHeight);
 
   QWidget* box2 = new QWidget(queryBox);
   QHBoxLayout* box2HBoxLayout = new QHBoxLayout(box2);
   box2HBoxLayout->setMargin(0);
   queryLayout->addWidget(box2);
 
   m_multipleISBN = new QCheckBox(i18n("&Multiple ISBN/UPC search"), box2);
   box2HBoxLayout->addWidget(m_multipleISBN);
   m_multipleISBN->setWhatsThis(i18n("Check this box to search for multiple ISBN or UPC values."));
-  connect(m_multipleISBN, SIGNAL(toggled(bool)), SLOT(slotMultipleISBN(bool)));
+  connect(m_multipleISBN, &QAbstractButton::toggled, this, &FetchDialog::slotMultipleISBN);
 
   m_editISBN = new QPushButton(box2);
   KGuiItem::assign(m_editISBN, KGuiItem(i18n("Edit ISBN/UPC values..."),
                                         QIcon::fromTheme(QStringLiteral("format-justify-fill"))));
   box2HBoxLayout->addWidget(m_editISBN);
   m_editISBN->setEnabled(false);
   m_editISBN->setWhatsThis(i18n("Click to open a text edit box for entering or editing multiple ISBN or UPC values."));
-  connect(m_editISBN, SIGNAL(clicked()), SLOT(slotEditMultipleISBN()));
+  connect(m_editISBN, &QAbstractButton::clicked, this, &FetchDialog::slotEditMultipleISBN);
 
   // add for spacing
   box2HBoxLayout->setStretchFactor(new QWidget(box2), 10);
 
   label = new QLabel(i18n("Search s&ource:"), box2);
   box2HBoxLayout->addWidget(label);
   m_sourceCombo = new KComboBox(box2);
   box2HBoxLayout->addWidget(m_sourceCombo);
   label->setBuddy(m_sourceCombo);
   Fetch::FetcherVec sources = Fetch::Manager::self()->fetchers(m_collType);
   foreach(Fetch::Fetcher::Ptr fetcher, sources) {
     m_sourceCombo->addItem(Fetch::Manager::self()->fetcherIcon(fetcher), fetcher->source());
   }
-  connect(m_sourceCombo, SIGNAL(activated(const QString&)), SLOT(slotSourceChanged(const QString&)));
+  void (QComboBox::* activatedString)(const QString&) = &QComboBox::activated;
+  connect(m_sourceCombo, activatedString, this, &FetchDialog::slotSourceChanged);
   m_sourceCombo->setWhatsThis(i18n("Select the database to search"));
 
   // for whatever reason, the dialog window could get shrunk and truncate the text
   box2->setMinimumWidth(box2->minimumSizeHint().width());
 
   QSplitter* split = new QSplitter(Qt::Vertical, mainWidget);
   topLayout->addWidget(split);
   split->setChildrenCollapsible(false);
 
   // using <anonymous>::TreeWidget as a lazy step to make a protected method public
   m_treeWidget = new TreeWidget(split);
   m_treeWidget->sortItems(1, Qt::AscendingOrder);
   m_treeWidget->setAllColumnsShowFocus(true);
   m_treeWidget->setSortingEnabled(true);
   m_treeWidget->setRootIsDecorated(false);
   m_treeWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
   m_treeWidget->setHeaderLabels(QStringList() << QString()
                                               << i18n("Title")
                                               << i18n("Description")
                                               << i18n("Source"));
   m_treeWidget->model()->setHeaderData(0, Qt::Horizontal, Qt::AlignHCenter, Qt::TextAlignmentRole); // align checkmark in middle
   m_treeWidget->viewport()->installEventFilter(this);
   m_treeWidget->header()->setSortIndicatorShown(true);
   m_treeWidget->header()->setSectionResizeMode(0, QHeaderView::ResizeToContents); // will show a check mark when added
   m_treeWidget->header()->setSectionResizeMode(3, QHeaderView::ResizeToContents);
 
-  connect(m_treeWidget, SIGNAL(itemSelectionChanged()), SLOT(slotShowEntry()));
+  connect(m_treeWidget, &QTreeWidget::itemSelectionChanged, this, &FetchDialog::slotShowEntry);
   // double clicking should add the entry
-  connect(m_treeWidget, SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)), SLOT(slotAddEntry()));
-  connect(m_treeWidget->header(), SIGNAL(sectionResized(int, int, int)), SLOT(columnResized(int)));
+  connect(m_treeWidget, &QTreeWidget::itemDoubleClicked, this, &FetchDialog::slotAddEntry);
+  connect(m_treeWidget->header(), &QHeaderView::sectionResized, this, &FetchDialog::columnResized);
   m_treeWidget->setWhatsThis(i18n("As results are found, they are added to this list. Selecting one "
                                   "will fetch the complete entry and show it in the view below."));
 
   m_entryView = new EntryView(split);
   // don't bother creating funky gradient images for compact view
   m_entryView->setUseGradientImages(false);
   // set the xslt file AFTER setting the gradient image option
   m_entryView->setXSLTFile(QStringLiteral("Compact.xsl"));
   m_entryView->addXSLTStringParam("skip-fields", "id,mdate,cdate");
   m_entryView->view()->setWhatsThis(i18n("An entry may be shown here before adding it to the "
                                          "current collection by selecting it in the list above"));
 
   QWidget* box3 = new QWidget(mainWidget);
   QHBoxLayout* box3HBoxLayout = new QHBoxLayout(box3);
   box3HBoxLayout->setMargin(0);
   topLayout->addWidget(box3);
 
   m_addButton = new QPushButton(i18n("&Add Entry"), box3);
   box3HBoxLayout->addWidget(m_addButton);
   m_addButton->setEnabled(false);
   m_addButton->setIcon(QIcon::fromTheme(QLatin1String(":/icons/") + Kernel::self()->collectionTypeName()));
-  connect(m_addButton, SIGNAL(clicked()), SLOT(slotAddEntry()));
+  connect(m_addButton, &QAbstractButton::clicked, this, &FetchDialog::slotAddEntry);
   m_addButton->setWhatsThis(i18n("Add the selected entry to the current collection"));
 
   m_moreButton = new QPushButton(box3);
   KGuiItem::assign(m_moreButton, KGuiItem(i18n("Get More Results"), QIcon::fromTheme(QStringLiteral("edit-find"))));
   box3HBoxLayout->addWidget(m_moreButton);
   m_moreButton->setEnabled(false);
-  connect(m_moreButton, SIGNAL(clicked()), SLOT(slotMoreClicked()));
+  connect(m_moreButton, &QAbstractButton::clicked, this, &FetchDialog::slotMoreClicked);
   m_moreButton->setWhatsThis(i18n("Fetch more results from the current data source"));
 
   QPushButton* clearButton = new QPushButton(box3);
   KGuiItem::assign(clearButton, KStandardGuiItem::clear());
   box3HBoxLayout->addWidget(clearButton);
-  connect(clearButton, SIGNAL(clicked()), SLOT(slotClearClicked()));
+  connect(clearButton, &QAbstractButton::clicked, this, &FetchDialog::slotClearClicked);
   clearButton->setWhatsThis(i18n("Clear all search fields and results"));
 
   QWidget* bottombox = new QWidget(mainWidget);
   QHBoxLayout* bottomboxHBoxLayout = new QHBoxLayout(bottombox);
   bottomboxHBoxLayout->setMargin(0);
   topLayout->addWidget(bottombox);
 
   m_statusBar = new QStatusBar(bottombox);
   bottomboxHBoxLayout->addWidget(m_statusBar);
   m_statusLabel = new QLabel(m_statusBar);
   m_statusBar->addPermanentWidget(m_statusLabel, 1);
   m_progress = new QProgressBar(m_statusBar);
   m_progress->setMaximum(0);
   m_progress->setFixedHeight(fontMetrics().height()+2);
   m_progress->hide();
   m_statusBar->addPermanentWidget(m_progress);
   m_statusBar->setSizeGripEnabled(false);
 
   QPushButton* closeButton = new QPushButton(bottombox);
   KGuiItem::assign(closeButton, KStandardGuiItem::close());
   bottomboxHBoxLayout->addWidget(closeButton);
-  connect(closeButton, SIGNAL(clicked()), SLOT(accept()));
+  connect(closeButton, &QAbstractButton::clicked, this, &QDialog::accept);
 
-  connect(m_timer, SIGNAL(timeout()), SLOT(slotMoveProgress()));
+  connect(m_timer, &QTimer::timeout, this, &FetchDialog::slotMoveProgress);
 
   setMinimumWidth(qMax(minimumWidth(), qMax(FETCH_MIN_WIDTH, minimumSizeHint().width())));
   setStatus(i18n("Ready."));
 
   KConfigGroup config(KSharedConfig::openConfig(), "Fetch Dialog Options");
   QList<int> splitList = config.readEntry("Splitter Sizes", QList<int>());
   if(!splitList.empty()) {
     split->setSizes(splitList);
   }
 
-  connect(Fetch::Manager::self(), SIGNAL(signalResultFound(Tellico::Fetch::FetchResult*)),
-                                  SLOT(slotResultFound(Tellico::Fetch::FetchResult*)));
-  connect(Fetch::Manager::self(), SIGNAL(signalStatus(const QString&)),
-                                  SLOT(slotStatus(const QString&)));
-  connect(Fetch::Manager::self(), SIGNAL(signalDone()),
-                                  SLOT(slotFetchDone()));
+  connect(Fetch::Manager::self(), &Fetch::Manager::signalResultFound,
+                                  this, &FetchDialog::slotResultFound);
+  connect(Fetch::Manager::self(), &Fetch::Manager::signalStatus,
+                                  this, &FetchDialog::slotStatus);
+  connect(Fetch::Manager::self(), &Fetch::Manager::signalDone,
+                                  this, &FetchDialog::slotFetchDone);
 
   KAcceleratorManager::manage(this);
   // initialize combos
-  QTimer::singleShot(0, this, SLOT(slotInit()));
+  QTimer::singleShot(0, this, &FetchDialog::slotInit);
 }
 
 FetchDialog::~FetchDialog() {
 #ifdef ENABLE_WEBCAM
   if(m_barcodeRecognitionThread) {
     m_barcodeRecognitionThread->stop();
     if(!m_barcodeRecognitionThread->wait( 1000 )) {
       m_barcodeRecognitionThread->terminate();
     }
     delete m_barcodeRecognitionThread;
     m_barcodeRecognitionThread = nullptr;
   }
   if(m_barcodePreview) {
     delete m_barcodePreview;
     m_barcodePreview = nullptr;
   }
 #endif
 
   qDeleteAll(m_results);
   m_results.clear();
 
   // we might have downloaded a lot of images we don't need to keep
   Data::EntryList entriesToCheck;
   foreach(Data::EntryPtr entry, m_entries) {
     entriesToCheck.append(entry);
   }
   // no additional entries to check images to keep though
   Data::Document::self()->removeImagesNotInCollection(entriesToCheck, Data::EntryList());
 
   KConfigGroup config(KSharedConfig::openConfig(), QStringLiteral("Fetch Dialog Options"));
   KWindowConfig::saveWindowSize(windowHandle(), config);
 
   config.writeEntry("Splitter Sizes", static_cast<QSplitter*>(m_treeWidget->parentWidget())->sizes());
   config.writeEntry("Search Key", m_keyCombo->currentData().toInt());
   config.writeEntry("Search Source", m_sourceCombo->currentText());
 }
 
 void FetchDialog::closeEvent(QCloseEvent* event_) { // stop fetchers when the dialog is closed
   if(m_started) {
-    QTimer::singleShot(0, Fetch::Manager::self(), SLOT(stop()));
+    QTimer::singleShot(0, Fetch::Manager::self(), &Fetch::Manager::stop);
   }
   QDialog::closeEvent(event_);
 }
 
 void FetchDialog::slotSearchClicked() {
   m_valueLineEdit->selectAll();
   if(m_started) {
     setStatus(i18n("Cancelling the search..."));
     Fetch::Manager::self()->stop();
   } else {
     const QString value = m_valueLineEdit->text().simplified();
     if(value.isEmpty()) {
       return;
     }
     m_resultCount = 0;
     m_oldSearch = value;
     m_started = true;
     KGuiItem::assign(m_searchButton, KGuiItem(i18n(FETCH_STRING_STOP),
                                               QIcon::fromTheme(QStringLiteral("dialog-cancel"))));
     startProgress();
     setStatus(i18n("Searching..."));
     qApp->processEvents();
     Fetch::Manager::self()->startSearch(m_sourceCombo->currentText(),
                                         static_cast<Fetch::FetchKey>(m_keyCombo->currentData().toInt()),
                                         value);
   }
 }
 
 void FetchDialog::slotClearClicked() {
-  slotFetchDone(false);
+  fetchDone(false);
   m_treeWidget->clear();
   m_entryView->clear();
   Fetch::Manager::self()->stop();
   m_multipleISBN->setChecked(false);
   m_valueLineEdit->clear();
   m_valueLineEdit->setFocus();
   m_addButton->setEnabled(false);
   m_moreButton->setEnabled(false);
   m_isbnList.clear();
   m_statusMessages.clear();
   setStatus(i18n("Ready.")); // because slotFetchDone() writes text
 }
 
 void FetchDialog::slotStatus(const QString& status_) {
   m_statusMessages.push_back(status_);
   // if the queue was empty, start the timer
   if(m_statusMessages.count() == 1) {
     // wait 2 seconds
-    QTimer::singleShot(2000, this, SLOT(slotUpdateStatus()));
+    QTimer::singleShot(2000, this, &FetchDialog::slotUpdateStatus);
   }
 }
 
 void FetchDialog::slotUpdateStatus() {
   if(m_statusMessages.isEmpty()) {
     return;
   }
   setStatus(m_statusMessages.front());
   m_statusMessages.pop_front();
   if(!m_statusMessages.isEmpty()) {
     // wait 2 seconds
-    QTimer::singleShot(2000, this, SLOT(slotUpdateStatus()));
+    QTimer::singleShot(2000, this, &FetchDialog::slotUpdateStatus);
   }
 }
 
 void FetchDialog::setStatus(const QString& text_) {
   m_statusLabel->setText(QLatin1Char(' ') + text_);
 }
 
-void FetchDialog::slotFetchDone(bool checkISBN_ /* = true */) {
-//  myDebug() << "slotFetchDone";
+void FetchDialog::slotFetchDone() {
+  fetchDone(true);
+}
+
+void FetchDialog::fetchDone(bool checkISBN_) {
+//  myDebug() << "fetchDone";
   m_started = false;
   KGuiItem::assign(m_searchButton, KGuiItem(i18n(FETCH_STRING_SEARCH),
                                             QIcon::fromTheme(QStringLiteral("edit-find"))));
   stopProgress();
   if(m_resultCount == 0) {
     slotStatus(i18n("The search returned no items."));
   } else {
     /* TRANSLATORS: This is a plural form, you need to translate both lines (except "_n: ") */
     slotStatus(i18np("The search returned 1 item.",
                      "The search returned %1 items.",
                      m_resultCount));
   }
   m_moreButton->setEnabled(Fetch::Manager::self()->hasMoreResults());
 
   // if we're not checking isbn values, then, ok to return
   if(!checkISBN_) {
     return;
   }
 
   const Fetch::FetchKey key = static_cast<Fetch::FetchKey>(m_keyCombo->currentData().toInt());
   // no way to currently check EAN/UPC values for non-book items
   if(m_collType & (Data::Collection::Book | Data::Collection::Bibtex) &&
      m_multipleISBN->isChecked() &&
      (key == Fetch::ISBN || key == Fetch::UPC)) {
     QStringList searchValues = FieldFormat::splitValue(m_oldSearch.simplified());
     QStringList resultValues;
     resultValues.reserve(m_treeWidget->topLevelItemCount());
     for(int i = 0; i < m_treeWidget->topLevelItemCount(); ++i) {
       resultValues << static_cast<FetchResultItem*>(m_treeWidget->topLevelItem(i))->m_result->isbn;
     }
     // Google Book Search can have an error, returning a different ISBN in the initial search
     // than the one returned by fetchEntryHook(). As a small workaround, if only a single ISBN value
     // is in the search term, then don't show
     if(searchValues.count() > 1) {
       const QStringList valuesNotFound = ISBNValidator::listDifference(searchValues, resultValues);
       if(!valuesNotFound.isEmpty()) {
         KMessageBox::informationList(this,
                                      i18n("No results were found for the following ISBN values:"),
                                      valuesNotFound,
                                      i18n("No Results"));
       }
     }
   }
 }
 
 void FetchDialog::slotResultFound(Tellico::Fetch::FetchResult* result_) {
   m_results.append(result_);
   (void) new FetchResultItem(m_treeWidget, result_);
   // resize final column to size of contents if the user has never resized anything before
   if(!m_treeWasResized) {
     m_treeWidget->header()->setStretchLastSection(false);
 
     // do math to try to make a nice resizing, emphasizing sections 1 and 2 over 3
     const int w0 = m_treeWidget->columnWidth(0);
     const int w1 = m_treeWidget->columnWidth(1);
     const int w2 = m_treeWidget->columnWidth(2);
     const int w3 = m_treeWidget->columnWidth(3);
     const int wt = m_treeWidget->width();
 //    myDebug() << "OLD:" << w0 << w1 << w2 << w3 << wt << (w0+w1+w2+w3);
 
     // whatever is leftover from resizing 3, split between 1 and 2
     if(wt > (w0 + w1 + w2 + w3)) {
       const int w1rec = static_cast<TreeWidget*>(m_treeWidget)->sizeHintForColumn(1);
       const int w2rec = static_cast<TreeWidget*>(m_treeWidget)->sizeHintForColumn(2);
       const int w3rec = static_cast<TreeWidget*>(m_treeWidget)->sizeHintForColumn(3);
       if(w1 < w1rec || w2 < w2rec) {
         const int w3new = qMin(w3, w3rec);
         const int diff = wt - w0 - w1 - w2 - w3new;
         const int w1new = qBound(w1, w1rec, w1 + diff/2 - 4);
         const int w2new = qBound(w2, wt - w0 - w1new - w3new, w2rec);
         m_treeWidget->setColumnWidth(1, w1new);
         m_treeWidget->setColumnWidth(2, w2new);
         m_treeWidget->setColumnWidth(3, w3new);
 //        myDebug() << "New:" << w0 << w1new << w2new << w3new << wt << (w0+w1new+w2new+w3new);
       }
     }
     m_treeWidget->header()->setStretchLastSection(true);
     // because calling setColumnWidth() will change this
     m_treeWasResized = false;
   }
   ++m_resultCount;
 }
 
 void FetchDialog::slotAddEntry() {
   GUI::CursorSaver cs;
   Data::EntryList vec;
   foreach(QTreeWidgetItem* item_, m_treeWidget->selectedItems()) {
     FetchResultItem* item = static_cast<FetchResultItem*>(item_);
 
     Fetch::FetchResult* r = item->m_result;
     Data::EntryPtr entry = m_entries.value(r->uid);
     if(!entry) {
       setStatus(i18n("Fetching %1...", r->title));
       startProgress();
       entry = r->fetchEntry();
       if(!entry) {
         continue;
       }
       m_entries.insert(r->uid, entry);
       stopProgress();
       setStatus(i18n("Ready."));
     }
     if(entry->collection()->hasField(QStringLiteral("fetchdialog_source"))) {
       entry->collection()->removeField(QStringLiteral("fetchdialog_source"));
     }
     // add a copy, intentionally allowing multiple copies to be added
     vec.append(Data::EntryPtr(new Data::Entry(*entry)));
     item->setData(0, Qt::DecorationRole,
                   QIcon::fromTheme(QStringLiteral("checkmark"), QIcon(QLatin1String(":/icons/checkmark"))));
   }
   if(!vec.isEmpty()) {
     Kernel::self()->addEntries(vec, true);
   }
 }
 
 void FetchDialog::slotMoreClicked() {
   if(m_started) {
     myDebug() << "can't continue while running";
     return;
   }
 
   m_started = true;
   KGuiItem::assign(m_searchButton, KGuiItem(i18n(FETCH_STRING_STOP),
                                             QIcon::fromTheme(QStringLiteral("dialog-cancel"))));
   startProgress();
   setStatus(i18n("Searching..."));
   qApp->processEvents();
   Fetch::Manager::self()->continueSearch();
 }
 
 void FetchDialog::slotShowEntry() {
   // just in case
   m_statusMessages.clear();
 
   QList<QTreeWidgetItem*> items = m_treeWidget->selectedItems();
   if(items.isEmpty()) {
     m_addButton->setEnabled(false);
     return;
   }
 
   m_addButton->setEnabled(true);
   if(items.count() > 1) {
     m_entryView->clear();
     return;
   }
 
   FetchResultItem* item = static_cast<FetchResultItem*>(items.first());
   Fetch::FetchResult* r = item->m_result;
   setStatus(i18n("Fetching %1...", r->title));
   Data::EntryPtr entry = m_entries.value(r->uid);
   if(!entry) {
     GUI::CursorSaver cs;
     startProgress();
     entry = r->fetchEntry();
     if(entry) { // might conceivably be null
       m_entries.insert(r->uid, entry);
     }
     stopProgress();
   }
   if(!entry || !entry->collection())  {
     myDebug() << "no entry or collection pointer";
     setStatus(i18n("Ready."));
     return;
   }
   if(!entry->collection()->hasField(QStringLiteral("fetchdialog_source"))) {
     Data::FieldPtr f(new Data::Field(QStringLiteral("fetchdialog_source"), i18n("Attribution"), Data::Field::Para));
     entry->collection()->addField(f);
   }
 
   const QPixmap sourceIcon = Fetch::Manager::self()->fetcherIcon(r->fetcher);
   const QByteArray ba = Data::Image::byteArray(sourceIcon.toImage(), "PNG");
   QString text = QStringLiteral("<qt><img src='data:image/png;base64,%1'/> %2<br/>%3</qt>")
                  .arg(QLatin1String(ba.toBase64()), r->fetcher->source(), r->fetcher->attribution());
   entry->setField(QStringLiteral("fetchdialog_source"), text);
 
   setStatus(i18n("Ready."));
 
   m_entryView->showEntry(entry);
 }
 
 void FetchDialog::startProgress() {
   m_progress->show();
   m_timer->start(100);
 }
 
 void FetchDialog::slotMoveProgress() {
   m_progress->setValue(m_progress->value()+5);
 }
 
 void FetchDialog::stopProgress() {
   m_timer->stop();
   m_progress->hide();
 }
 
 void FetchDialog::slotInit() {
   // do this in the singleShot slot so it works
   // see note in entryeditdialog.cpp (Feb 2017)
   KConfigGroup config(KSharedConfig::openConfig(), "Fetch Dialog Options");
   KWindowConfig::restoreWindowSize(windowHandle(), config);
 
   if(!Fetch::Manager::self()->canFetch()) {
     m_searchButton->setEnabled(false);
     Kernel::self()->sorry(i18n("No Internet sources are available for your current collection type."), this);
   }
 
   int key = config.readEntry("Search Key", int(Fetch::FetchFirst));
   // only change key if valid
   if(key > Fetch::FetchFirst) {
     m_keyCombo->setCurrentData(key);
   }
   slotKeyChanged(m_keyCombo->currentIndex());
 
   QString source = config.readEntry("Search Source");
   if(!source.isEmpty()) {
     int idx = m_sourceCombo->findText(source);
     if(idx > -1) {
       m_sourceCombo->setCurrentIndex(idx);
     }
   }
   slotSourceChanged(m_sourceCombo->currentText());
 
   m_valueLineEdit->setFocus();
   m_searchButton->setDefault(true);
 }
 
 void FetchDialog::slotKeyChanged(int idx_) {
   int key = m_keyCombo->itemData(idx_).toInt();
   if(key == Fetch::ISBN || key == Fetch::UPC || key == Fetch::LCCN) {
     m_multipleISBN->setEnabled(true);
     if(key == Fetch::ISBN) {
       m_valueLineEdit->setValidator(new ISBNValidator(this));
     } else {
       UPCValidator* upc = new UPCValidator(this);
-      connect(upc, SIGNAL(signalISBN()), SLOT(slotUPC2ISBN()));
+      connect(upc, &UPCValidator::signalISBN, this, &FetchDialog::slotUPC2ISBN);
       m_valueLineEdit->setValidator(upc);
       // only want to convert to ISBN if ISBN is accepted by the fetcher
       Fetch::KeyMap map = Fetch::Manager::self()->keyMap(m_sourceCombo->currentText());
       upc->setCheckISBN(map.contains(Fetch::ISBN));
     }
   } else {
     m_multipleISBN->setChecked(false);
     m_multipleISBN->setEnabled(false);
 //    slotMultipleISBN(false);
     m_valueLineEdit->setValidator(nullptr);
   }
 
   if(key == Fetch::ISBN || key == Fetch::UPC) {
     openBarcodePreview();
   } else {
     closeBarcodePreview();
   }
 }
 
 void FetchDialog::slotSourceChanged(const QString& source_) {
   int curr = m_keyCombo->currentData().toInt();
   m_keyCombo->clear();
   Fetch::KeyMap map = Fetch::Manager::self()->keyMap(source_);
   for(Fetch::KeyMap::ConstIterator it = map.constBegin(); it != map.constEnd(); ++it) {
     m_keyCombo->addItem(it.value(), it.key());
   }
   m_keyCombo->setCurrentData(curr);
   slotKeyChanged(m_keyCombo->currentIndex());
 }
 
 void FetchDialog::slotMultipleISBN(bool toggle_) {
   bool wasEnabled = m_valueLineEdit->isEnabled();
   m_valueLineEdit->setEnabled(!toggle_);
   if(!wasEnabled && m_valueLineEdit->isEnabled()) {
     // if we enable it, it probably had multiple isbn values
     // the validator doesn't like that, so only keep the first value
     QString val = m_valueLineEdit->text().section(QLatin1Char(';'), 0, 0);
     m_valueLineEdit->setText(val);
   }
   m_editISBN->setEnabled(toggle_);
   if(toggle_) {
     // if we're editing multiple values, it makes sense to popup the dialog now
     slotEditMultipleISBN();
   }
 }
 
 void FetchDialog::slotEditMultipleISBN() {
   QDialog dlg(this);
   dlg.setModal(true);
   dlg.setWindowTitle(i18n("Edit ISBN/UPC Values"));
 
   QVBoxLayout* mainLayout = new QVBoxLayout();
   dlg.setLayout(mainLayout);
 
   QWidget* box = new QWidget(&dlg);
   QVBoxLayout* boxVBoxLayout = new QVBoxLayout(box);
   boxVBoxLayout->setMargin(0);
   boxVBoxLayout->setSpacing(10);
   mainLayout->addWidget(box);
 
   QString s = i18n("<qt>Enter the ISBN or UPC values, one per line.</qt>");
   QLabel* l = new QLabel(s, box);
   boxVBoxLayout->addWidget(l);
   m_isbnTextEdit = new KTextEdit(box);
   boxVBoxLayout->addWidget(m_isbnTextEdit);
   if(m_isbnList.isEmpty()) {
     m_isbnTextEdit->setText(m_valueLineEdit->text());
   } else {
     m_isbnTextEdit->setText(m_isbnList.join(QLatin1String("\n")));
   }
   m_isbnTextEdit->setWhatsThis(s);
-  connect(m_isbnTextEdit, SIGNAL(textChanged()), this, SLOT(slotISBNTextChanged()));
+  connect(m_isbnTextEdit.data(), &QTextEdit::textChanged, this, &FetchDialog::slotISBNTextChanged);
 
   QPushButton* fromFileBtn = new QPushButton(box);
   boxVBoxLayout->addWidget(fromFileBtn);
   KGuiItem::assign(fromFileBtn, KStandardGuiItem::open());
   fromFileBtn->setText(i18n("&Load From File..."));
   fromFileBtn->setWhatsThis(i18n("<qt>Load the list from a text file.</qt>"));
-  connect(fromFileBtn, SIGNAL(clicked()), SLOT(slotLoadISBNList()));
+  connect(fromFileBtn, &QAbstractButton::clicked, this, &FetchDialog::slotLoadISBNList);
 
   QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
   boxVBoxLayout->addWidget(buttonBox);
-  connect(buttonBox, SIGNAL(accepted()), &dlg, SLOT(accept()));
-  connect(buttonBox, SIGNAL(rejected()), &dlg, SLOT(reject()));
+  connect(buttonBox, &QDialogButtonBox::accepted, &dlg, &QDialog::accept);
+  connect(buttonBox, &QDialogButtonBox::rejected, &dlg, &QDialog::reject);
 
   dlg.setMinimumWidth(qMax(dlg.minimumWidth(), FETCH_MIN_WIDTH*2/3));
 
   if(dlg.exec() == QDialog::Accepted) {
     m_isbnList = m_isbnTextEdit->toPlainText().split(QStringLiteral("\n"));
     const QValidator* val = m_valueLineEdit->validator();
     if(val) {
       for(QStringList::Iterator it = m_isbnList.begin(); it != m_isbnList.end(); ++it) {
         val->fixup(*it);
         if((*it).isEmpty()) {
           it = m_isbnList.erase(it);
           // this is next item, shift backward
           --it;
         }
       }
     }
     if(m_isbnList.count() > 100) {
       Kernel::self()->sorry(i18n("<qt>An ISBN search can contain a maximum of 100 ISBN values. Only the "
                                  "first 100 values in your list will be used.</qt>"), this);
       m_isbnList = m_isbnList.mid(0, 100);
     }
     m_valueLineEdit->setText(m_isbnList.join(FieldFormat::delimiterString()));
   }
   m_isbnTextEdit = nullptr; // gets auto-deleted
 }
 
 void FetchDialog::slotLoadISBNList() {
   if(!m_isbnTextEdit) {
     return;
   }
   QUrl u = QUrl::fromLocalFile(QFileDialog::getOpenFileName(this, QString(), QString(), QString()));
   if(u.isValid()) {
     m_isbnTextEdit->setText(m_isbnTextEdit->toPlainText() + FileHandler::readTextFile(u));
     m_isbnTextEdit->moveCursor(QTextCursor::End);
     m_isbnTextEdit->ensureCursorVisible();
   }
 }
 
 void FetchDialog::slotISBNTextChanged() {
   if(!m_isbnTextEdit) {
     return;
   }
   const QValidator* val = m_valueLineEdit->validator();
   if(!val) {
     return;
   }
   const QString text = m_isbnTextEdit->toPlainText();
   if(text.isEmpty())  {
     return;
   }
   const QTextCursor cursor = m_isbnTextEdit->textCursor();
   // only try to validate if char before cursor is an eol
   if(cursor.atStart() || text.at(cursor.position()-1) != QLatin1Char('\n')) {
     return;
   }
   QStringList lines = text.left(cursor.position()-1).split(QStringLiteral("\n"));
   QString newLine = lines.last();
   int pos = 0;
   // validate() changes the input
   if(val->validate(newLine, pos) != QValidator::Acceptable) {
     return;
   }
   lines.replace(lines.count()-1, newLine);
   QString newText = lines.join(QLatin1String("\n")) + text.mid(cursor.position()-1);
   if(newText == text) {
     return;
   }
 
   if(newText.isEmpty()) {
     m_isbnTextEdit->clear();
   } else {
     m_isbnTextEdit->blockSignals(true);
     m_isbnTextEdit->setPlainText(newText);
     m_isbnTextEdit->setTextCursor(cursor);
     m_isbnTextEdit->blockSignals(false);
   }
 }
 
 void FetchDialog::slotUPC2ISBN() {
   int key = m_keyCombo->currentData().toInt();
   if(key == Fetch::UPC) {
     m_keyCombo->setCurrentData(Fetch::ISBN);
     slotKeyChanged(m_keyCombo->currentIndex());
   }
 }
 
 void FetchDialog::columnResized(int column_) {
   // only care about the middle two. First is the checkmark icon, last is not resizeable
   if(column_ == 1 || column_ == 2) {
     m_treeWasResized = true;
   }
 }
 
 void FetchDialog::slotResetCollection() {
   if(m_collType == Kernel::self()->collectionType()) {
     return;
   }
   m_collType = Kernel::self()->collectionType();
   m_sourceCombo->clear();
   Fetch::FetcherVec sources = Fetch::Manager::self()->fetchers(m_collType);
   foreach(Fetch::Fetcher::Ptr fetcher, sources) {
     m_sourceCombo->addItem(Fetch::Manager::self()->fetcherIcon(fetcher), fetcher->source());
   }
 
   m_addButton->setIcon(QIcon(QLatin1String(":/icons/") + Kernel::self()->collectionTypeName()));
 
   if(Fetch::Manager::self()->canFetch()) {
     m_searchButton->setEnabled(true);
   } else {
     m_searchButton->setEnabled(false);
     Kernel::self()->sorry(i18n("No Internet sources are available for your current collection type."), this);
   }
 }
 
 void FetchDialog::slotBarcodeRecognized(const QString& string_) {
   // attention: this slot is called in the context of another thread => do not use GUI-functions!
   StringDataEvent* e = new StringDataEvent(string_);
   qApp->postEvent(this, e); // the event loop will call FetchDialog::customEvent() in the context of the GUI thread
 }
 
 void FetchDialog::slotBarcodeGotImage(const QImage& img_)  {
   // attention: this slot is called in the context of another thread => do not use GUI-functions!
   ImageDataEvent* e = new ImageDataEvent(img_);
   qApp->postEvent(this, e); // the event loop will call FetchDialog::customEvent() in the context of the GUI thread
 }
 
 void FetchDialog::openBarcodePreview() {
   if(!Config::enableWebcam()) {
     return;
   }
 #ifdef ENABLE_WEBCAM
   if(m_barcodePreview) {
     m_barcodePreview->show();
     m_barcodeRecognitionThread->start();
     return;
   }
 
   // barcode recognition
   m_barcodeRecognitionThread = new barcodeRecognitionThread();
-  if (m_barcodeRecognitionThread->isWebcamAvailable()) {
+  if(m_barcodeRecognitionThread->isWebcamAvailable()) {
     m_barcodePreview = new QLabel(nullptr);
     m_barcodePreview->resize(m_barcodeRecognitionThread->getPreviewSize());
-    m_barcodePreview->move(QApplication::desktop()->screenGeometry(m_barcodePreview).width() - m_barcodePreview->frameGeometry().width(), 30);
+    m_barcodePreview->move(QApplication::desktop()->screenGeometry(m_barcodePreview).width()
+                           - m_barcodePreview->frameGeometry().width(), 30);
     m_barcodePreview->show();
 
-    connect( m_barcodeRecognitionThread, SIGNAL(recognized(const QString&)), this, SLOT(slotBarcodeRecognized(const QString&)) );
-    connect( m_barcodeRecognitionThread, SIGNAL(gotImage(const QImage&)), this, SLOT(slotBarcodeGotImage(const QImage&)) );
+    connect(m_barcodeRecognitionThread, &barcodeRecognition::barcodeRecognitionThread::recognized,
+            this, &FetchDialog::slotBarcodeRecognized);
+    connect(m_barcodeRecognitionThread, &barcodeRecognition::barcodeRecognitionThread::gotImage,
+            this, &FetchDialog::slotBarcodeGotImage);
 //    connect( m_barcodePreview, SIGNAL(destroyed(QObject *)), this, SLOT(slotBarcodeStop()) );
     m_barcodeRecognitionThread->start();
   }
 #endif
 }
 
 void FetchDialog::closeBarcodePreview() {
 #ifdef ENABLE_WEBCAM
   if(!m_barcodePreview || !m_barcodeRecognitionThread) {
     return;
   }
 
   m_barcodePreview->hide();
   m_barcodeRecognitionThread->stop();
 #endif
 }
 
 void FetchDialog::customEvent(QEvent* e) {
   if(!e) {
     return;
   }
   if(e->type() == StringDataType) {
     // slotBarcodeRecognized() queued call
     qApp->beep();
     m_valueLineEdit->setText(static_cast<StringDataEvent*>(e)->string());
     m_searchButton->animateClick();
   } else if(e->type() == ImageDataType) {
     // slotBarcodegotImage() queued call
     m_barcodePreview->setPixmap(QPixmap::fromImage(static_cast<ImageDataEvent*>(e)->image()));
   }
 }
diff --git a/src/fetchdialog.h b/src/fetchdialog.h
index d3821288..09639f6b 100644
--- a/src/fetchdialog.h
+++ b/src/fetchdialog.h
@@ -1,155 +1,157 @@
 /***************************************************************************
     Copyright (C) 2003-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef TELLICO_FETCHDIALOG_H
 #define TELLICO_FETCHDIALOG_H
 
 #include "datavectors.h"
 
 #include <QDialog>
 #include <QPointer>
 #include <QEvent>
 #include <QList>
 #include <QHash>
 
 namespace Tellico {
   class EntryView;
   namespace Fetch {
     class Fetcher;
     class FetchResult;
   }
   namespace GUI {
     class ComboBox;
     class ListView;
   }
 }
 
 namespace barcodeRecognition {
   class barcodeRecognitionThread;
 }
 
 class KComboBox;
 class KTextEdit;
 
 class QStatusBar;
 class QPushButton;
 class QLineEdit;
 class QLabel;
 class QProgressBar;
 class QTimer;
 class QCheckBox;
 class QTreeWidget;
 
 namespace Tellico {
 
 /**
  * @author Robby Stephenson
  */
 class FetchDialog : public QDialog {
 Q_OBJECT
 
 public:
   /**
    * Constructor
    */
   FetchDialog(QWidget* parent);
   ~FetchDialog();
 
 public Q_SLOTS:
   void slotResetCollection();
 
 protected:
   void closeEvent(QCloseEvent* event) Q_DECL_OVERRIDE;
 
 private Q_SLOTS:
   void slotSearchClicked();
   void slotClearClicked();
   void slotAddEntry();
   void slotMoreClicked();
   void slotShowEntry();
   void slotMoveProgress();
 
   void slotStatus(const QString& status);
   void slotUpdateStatus();
 
-  void slotFetchDone(bool checkISBN = true);
+  // for slot connection, can't use a default value for checkIsbn
+  void slotFetchDone();
   void slotResultFound(Tellico::Fetch::FetchResult* result);
   void slotKeyChanged(int);
   void slotSourceChanged(const QString& source);
   void slotMultipleISBN(bool toggle);
   void slotEditMultipleISBN();
   void slotInit();
   void slotLoadISBNList();
   void slotISBNTextChanged();
   void slotUPC2ISBN();
   void columnResized(int column);
 
   void slotBarcodeRecognized(const QString&);
   void slotBarcodeGotImage(const QImage&);
 
 private:
+  void fetchDone(bool checkISBN);
   void startProgress();
   void stopProgress();
   void setStatus(const QString& text);
 
   void openBarcodePreview();
   void closeBarcodePreview();
 
   void customEvent(QEvent* event) Q_DECL_OVERRIDE;
 
   class FetchResultItem;
 
   KComboBox* m_sourceCombo;
   GUI::ComboBox* m_keyCombo;
   QLineEdit* m_valueLineEdit;
   QPushButton* m_searchButton;
   QCheckBox* m_multipleISBN;
   QPushButton* m_editISBN;
   QTreeWidget* m_treeWidget;
   EntryView* m_entryView;
   QPushButton* m_addButton;
   QPushButton* m_moreButton;
   QStatusBar* m_statusBar;
   QLabel* m_statusLabel;
   QProgressBar* m_progress;
   QTimer* m_timer;
   QPointer<KTextEdit> m_isbnTextEdit;
 
   bool m_started;
   int m_resultCount;
   QString m_oldSearch;
   QStringList m_isbnList;
   QStringList m_statusMessages;
   QHash<int, Data::EntryPtr> m_entries;
   QList<Fetch::FetchResult*> m_results;
   int m_collType;
   bool m_treeWasResized;
 
   QLabel* m_barcodePreview;
   barcodeRecognition::barcodeRecognitionThread* m_barcodeRecognitionThread;
 };
 
 } //end namespace
 
 #endif
diff --git a/src/fetcherconfigdialog.cpp b/src/fetcherconfigdialog.cpp
index c775eb8a..1fcb9771 100644
--- a/src/fetcherconfigdialog.cpp
+++ b/src/fetcherconfigdialog.cpp
@@ -1,262 +1,263 @@
 /***************************************************************************
     Copyright (C) 2006-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "fetcherconfigdialog.h"
 #include "fetch/fetchmanager.h"
 #include "gui/combobox.h"
 #include "utils/string_utils.h"
 #include "tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KComboBox>
 #include <KIconLoader>
 #include <KHelpClient>
 
 #include <QLineEdit>
 #include <QLabel>
 #include <QLayout>
 #include <QStackedWidget>
 #include <QGroupBox>
 #include <QCheckBox>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QVBoxLayout>
 #include <QDialogButtonBox>
 #include <QPushButton>
 
 namespace {
   static const int FETCHER_CONFIG_MIN_WIDTH = 600;
 }
 
 using Tellico::FetcherConfigDialog;
 
 FetcherConfigDialog::FetcherConfigDialog(QWidget* parent_)
     : QDialog(parent_)
     , m_newSource(true)
     , m_useDefaultName(true)
     , m_configWidget(nullptr) {
   init(Fetch::Unknown);
 }
 
 FetcherConfigDialog::FetcherConfigDialog(const QString& sourceName_, Tellico::Fetch::Type type_, bool updateOverwrite_,
                                          Tellico::Fetch::ConfigWidget* configWidget_, QWidget* parent_)
     : QDialog(parent_)
     , m_newSource(false)
     , m_useDefaultName(false)
     , m_configWidget(configWidget_) {
   init(type_);
   m_nameEdit->setText(sourceName_);
   m_cbOverwrite->setChecked(updateOverwrite_);
 }
 
 void FetcherConfigDialog::init(Tellico::Fetch::Type type_) {
   setModal(true);
   setWindowTitle(i18n("Data Source Properties"));
 
   QVBoxLayout* mainLayout = new QVBoxLayout();
   setLayout(mainLayout);
 
   setMinimumWidth(FETCHER_CONFIG_MIN_WIDTH);
 
   QWidget* widget = new QWidget(this);
   QBoxLayout* topLayout = new QHBoxLayout(widget);
   widget->setLayout(topLayout);
 
   QBoxLayout* vlay1 = new QVBoxLayout();
   topLayout->addLayout(vlay1);
   m_iconLabel = new QLabel(widget);
   if(type_ == Fetch::Unknown) {
     m_iconLabel->setPixmap(KIconLoader::global()->loadIcon(QStringLiteral("network-wired"), KIconLoader::Panel, 64));
   } else {
     m_iconLabel->setPixmap(Fetch::Manager::self()->fetcherIcon(type_, KIconLoader::Panel, 64));
   }
   vlay1->addWidget(m_iconLabel);
   vlay1->addStretch(1);
 
   QBoxLayout* vlay2 = new QVBoxLayout();
   topLayout->addLayout(vlay2);
 
   QGridLayout* gl = new QGridLayout();
   vlay2->addLayout(gl);
   int row = -1;
 
   QLabel* label = new QLabel(i18n("&Source name: "), widget);
   gl->addWidget(label, ++row, 0);
   QString w = i18n("The name identifies the data source and should be unique and informative.");
   label->setWhatsThis(w);
 
   m_nameEdit = new QLineEdit(widget);
   gl->addWidget(m_nameEdit, row, 1);
   m_nameEdit->setFocus();
   m_nameEdit->setWhatsThis(w);
   label->setBuddy(m_nameEdit);
-  connect(m_nameEdit, SIGNAL(textChanged(const QString&)), SLOT(slotNameChanged(const QString&)));
+  connect(m_nameEdit, &QLineEdit::textChanged, this, &FetcherConfigDialog::slotNameChanged);
 
   if(m_newSource) {
     label = new QLabel(i18n("Source &type: "), widget);
   } else {
     // since the label doesn't have a buddy, we don't want an accel,
     // but also want to reuse string we already have
     label = new QLabel(KLocalizedString::removeAcceleratorMarker(i18n("Source &type: ")), widget);
   }
   gl->addWidget(label, ++row, 0);
   w = i18n("Tellico supports several different data sources.");
   label->setWhatsThis(w);
 
   if(m_newSource) {
     m_typeCombo = new GUI::ComboBox(widget);
     gl->addWidget(m_typeCombo, row, 1);
     m_typeCombo->setWhatsThis(w);
     label->setBuddy(m_typeCombo);
   } else {
     m_typeCombo = nullptr;
     QLabel* lab = new QLabel(Fetch::Manager::typeName(type_), widget);
     gl->addWidget(lab, row, 1);
     lab->setWhatsThis(w);
   }
   m_cbOverwrite = new QCheckBox(i18n("Updating from source should overwrite user data"), widget);
   ++row;
   gl->addWidget(m_cbOverwrite, row, 0, 1, 2);
   w = i18n("If checked, updating entries will overwrite any existing information.");
   m_cbOverwrite->setWhatsThis(w);
 
   if(m_newSource) {
     m_stack = new QStackedWidget(widget);
     vlay2->addWidget(m_stack);
-    connect(m_typeCombo, SIGNAL(activated(int)), SLOT(slotNewSourceSelected(int)));
+    void (QComboBox::* activatedInt)(int) = &QComboBox::activated;
+    connect(m_typeCombo, activatedInt, this, &FetcherConfigDialog::slotNewSourceSelected);
 
     int z3950_idx = 0;
     Fetch::NameTypeMap typeMap = Fetch::Manager::self()->nameTypeMap();
     // key is the fetcher name, value is the type
     for(Fetch::NameTypeMap::ConstIterator it = typeMap.constBegin(); it != typeMap.constEnd(); ++it) {
       m_typeCombo->addItem(Fetch::Manager::self()->fetcherIcon(it.value()), it.key(), it.value());
       if(it.value() == Fetch::Z3950) {
         z3950_idx = m_typeCombo->count()-1;
       }
     }
     // make sure first widget gets initialized
     // I'd like it to be the z39.50 widget
     m_typeCombo->setCurrentIndex(z3950_idx);
     slotNewSourceSelected(z3950_idx);
   } else {
     m_stack = nullptr;
     // just add config widget and reparent
     m_configWidget->setParent(widget);
     m_configWidget->show();
     vlay2->addWidget(m_configWidget);
-    connect(m_configWidget, SIGNAL(signalName(const QString&)), SLOT(slotPossibleNewName(const QString&)));
+    connect(m_configWidget, &Fetch::ConfigWidget::signalName, this, &FetcherConfigDialog::slotPossibleNewName);
   }
 
   mainLayout->addWidget(widget);
 
   QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|
                                                      QDialogButtonBox::Cancel|
                                                      QDialogButtonBox::Help);
   QPushButton* okButton = buttonBox->button(QDialogButtonBox::Ok);
   okButton->setDefault(true);
   okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
-  connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
-  connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
-  connect(buttonBox, SIGNAL(helpRequested()), this, SLOT(slotHelp()));
+  connect(buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
+  connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
+  connect(buttonBox, &QDialogButtonBox::helpRequested, this, &FetcherConfigDialog::slotHelp);
   mainLayout->addWidget(buttonBox);
 }
 
 QString FetcherConfigDialog::sourceName() const {
   return m_nameEdit->text();
 }
 
 bool FetcherConfigDialog::updateOverwrite() const {
   return m_cbOverwrite->isChecked();
 }
 
 Tellico::Fetch::ConfigWidget* FetcherConfigDialog::configWidget() const {
   if(m_newSource) {
     return dynamic_cast<Fetch::ConfigWidget*>(m_stack->currentWidget());
   }
   myWarning() << "called for modifying existing fetcher!";
   return m_configWidget;
 }
 
 Tellico::Fetch::Type FetcherConfigDialog::sourceType() const {
   if(!m_newSource || m_typeCombo->count() == 0) {
     myWarning() << "called for modifying existing fetcher!";
     return Fetch::Unknown;
   }
   return static_cast<Fetch::Type>(m_typeCombo->currentData().toInt());
 }
 
 void FetcherConfigDialog::slotNewSourceSelected(int idx_) {
   if(!m_newSource) {
     return;
   }
 
   // always change to default name
   m_useDefaultName = true;
 
   Fetch::ConfigWidget* cw = m_configWidgets[idx_];
   if(cw) {
     m_stack->setCurrentWidget(cw);
     slotPossibleNewName(cw->preferredName());
     return;
   }
 
   Fetch::Type type = sourceType();
   if(type == Fetch::Unknown) {
     myWarning() << "unknown source type";
     return;
   }
   m_iconLabel->setPixmap(Fetch::Manager::self()->fetcherIcon(type, KIconLoader::Panel, 64));
   cw = Fetch::Manager::self()->configWidget(m_stack, type, m_typeCombo->currentText());
   if(!cw) {
     // bad bad bad!
     myWarning() << "no config widget found for type" << type;
     m_typeCombo->setCurrentIndex(0);
     slotNewSourceSelected(0);
     return;
   }
-  connect(cw, SIGNAL(signalName(const QString&)), SLOT(slotPossibleNewName(const QString&)));
+  connect(cw, &Fetch::ConfigWidget::signalName, this, &FetcherConfigDialog::slotPossibleNewName);
   m_configWidgets.insert(idx_, cw);
   m_stack->addWidget(cw);
   m_stack->setCurrentWidget(cw);
   slotPossibleNewName(cw->preferredName());
 }
 
 void FetcherConfigDialog::slotNameChanged(const QString&) {
   m_useDefaultName = false;
 }
 
 void FetcherConfigDialog::slotPossibleNewName(const QString& name_) {
   if(name_.isEmpty()) {
     return;
   }
   Fetch::ConfigWidget* cw = m_stack ? static_cast<Fetch::ConfigWidget*>(m_stack->currentWidget()) : m_configWidget;
   if(m_useDefaultName || (cw && m_nameEdit->text() == cw->preferredName())) {
     m_nameEdit->setText(name_);
     m_useDefaultName = true; // it gets reset in slotNameChanged()
   }
 }
 
 void FetcherConfigDialog::slotHelp() {
   KHelpClient::invokeHelp(QStringLiteral("data-sources-options"));
 }
diff --git a/src/filterdialog.cpp b/src/filterdialog.cpp
index 40ba4265..67dbe41a 100644
--- a/src/filterdialog.cpp
+++ b/src/filterdialog.cpp
@@ -1,234 +1,235 @@
 /***************************************************************************
     Copyright (C) 2003-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 // The layout borrows heavily from kmsearchpatternedit.cpp in kmail
 // which is authored by Marc Mutz <Marc@Mutz.com> under the GPL
 
 #include "filterdialog.h"
 #include "tellico_kernel.h"
 #include "document.h"
 #include "collection.h"
 #include "fieldcompletion.h"
 #include "gui/filterrulewidgetlister.h"
 #include "gui/filterrulewidget.h"
 #include "tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KHelpClient>
 
 #include <QGroupBox>
 #include <QRadioButton>
 #include <QButtonGroup>
 #include <QLabel>
 #include <QApplication>
 #include <QFrame>
 #include <QVBoxLayout>
 #include <QPushButton>
 #include <QLineEdit>
 #include <QDialogButtonBox>
 
 using Tellico::FilterDialog;
 
 namespace {
   static const int FILTER_MIN_WIDTH = 600;
 }
 
 // modal dialog so I don't have to worry about updating stuff
 // don't show apply button if not saving, i.e. just modifying existing filter
 FilterDialog::FilterDialog(Mode mode_, QWidget* parent_)
     : QDialog(parent_), m_filter(nullptr), m_mode(mode_), m_saveFilter(nullptr) {
   setModal(true);
   setWindowTitle(mode_ == CreateFilter ? i18n("Advanced Filter") : i18n("Modify Filter"));
 
   QVBoxLayout* topLayout = new QVBoxLayout();
   setLayout(topLayout);
 
   QDialogButtonBox* buttonBox;
   if(mode_ == CreateFilter) {
     buttonBox = new QDialogButtonBox(QDialogButtonBox::Help|QDialogButtonBox::Ok|QDialogButtonBox::Cancel|QDialogButtonBox::Apply);
   } else {
     buttonBox = new QDialogButtonBox(QDialogButtonBox::Help|QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
   }
   m_okButton = buttonBox->button(QDialogButtonBox::Ok);
   m_applyButton = buttonBox->button(QDialogButtonBox::Apply);
-  connect(m_okButton, SIGNAL(clicked()), SLOT(slotOk()));
+  connect(m_okButton, &QAbstractButton::clicked, this, &FilterDialog::slotOk);
   if(m_applyButton) {
-    connect(m_applyButton, SIGNAL(clicked()), SLOT(slotApply()));
+    connect(m_applyButton, &QAbstractButton::clicked, this, &FilterDialog::slotApply);
   }
-  connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
-  connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
-  connect(buttonBox, SIGNAL(helpRequested()), this, SLOT(slotHelp()));
+  connect(buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
+  connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
+  connect(buttonBox, &QDialogButtonBox::helpRequested, this, &FilterDialog::slotHelp);
 
   QGroupBox* m_matchGroup = new QGroupBox(i18n("Filter Criteria"), this);
   QVBoxLayout* vlay = new QVBoxLayout(m_matchGroup);
   topLayout->addWidget(m_matchGroup);
   m_matchGroup->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
 
   m_matchAll = new QRadioButton(i18n("Match a&ll of the following"), m_matchGroup);
   m_matchAny = new QRadioButton(i18n("Match an&y of the following"), m_matchGroup);
   m_matchAll->setChecked(true);
 
   vlay->addWidget(m_matchAll);
   vlay->addWidget(m_matchAny);
 
   QButtonGroup* bg = new QButtonGroup(m_matchGroup);
   bg->addButton(m_matchAll);
   bg->addButton(m_matchAny);
-  connect(bg, SIGNAL(buttonClicked(int)), SLOT(slotFilterChanged()));
+  void (QButtonGroup::* buttonClicked)(int) = &QButtonGroup::buttonClicked;
+  connect(bg, buttonClicked, this, &FilterDialog::slotFilterChanged);
 
   m_ruleLister = new FilterRuleWidgetLister(m_matchGroup);
-  connect(m_ruleLister, SIGNAL(widgetRemoved()), SLOT(slotShrink()));
-  connect(m_ruleLister, SIGNAL(signalModified()), SLOT(slotFilterChanged()));
+  connect(m_ruleLister, &KWidgetLister::widgetRemoved, this, &FilterDialog::slotShrink);
+  connect(m_ruleLister, &FilterRuleWidgetLister::signalModified, this, &FilterDialog::slotFilterChanged);
   m_ruleLister->setFocus();
   vlay->addWidget(m_ruleLister);
 
   QHBoxLayout* blay = new QHBoxLayout();
   topLayout->addLayout(blay);
   QLabel* lab = new QLabel(i18n("Filter name:"), this);
   blay->addWidget(lab);
 
   m_filterName = new QLineEdit(this);
   blay->addWidget(m_filterName);
-  connect(m_filterName, SIGNAL(textChanged(const QString&)), SLOT(slotFilterChanged()));
+  connect(m_filterName, &QLineEdit::textChanged, this, &FilterDialog::slotFilterChanged);
 
   // only when creating a new filter can it be saved
   if(m_mode == CreateFilter) {
     m_saveFilter = new QPushButton(QIcon::fromTheme(QStringLiteral("view-filter")), i18n("&Save Filter"), this);
     blay->addWidget(m_saveFilter);
     m_saveFilter->setEnabled(false);
-    connect(m_saveFilter, SIGNAL(clicked()), SLOT(slotSaveFilter()));
+    connect(m_saveFilter, &QAbstractButton::clicked, this, &FilterDialog::slotSaveFilter);
     m_applyButton->setEnabled(false);
   }
   m_okButton->setEnabled(false); // disable at start
   buttonBox->button(QDialogButtonBox::Cancel)->setDefault(true);
   setMinimumWidth(qMax(minimumWidth(), FILTER_MIN_WIDTH));
   topLayout->addWidget(buttonBox);
 }
 
 Tellico::FilterPtr FilterDialog::currentFilter(bool alwaysCreateNew_) {
   FilterPtr newFilter(new Filter(Filter::MatchAny));
 
   if(m_matchAll->isChecked()) {
     newFilter->setMatch(Filter::MatchAll);
   } else {
     newFilter->setMatch(Filter::MatchAny);
   }
 
   foreach(QWidget* widget, m_ruleLister->widgetList()) {
     FilterRuleWidget* rw = static_cast<FilterRuleWidget*>(widget);
     FilterRule* rule = rw->rule();
     if(rule && !rule->isEmpty()) {
       newFilter->append(rule);
     } else {
       delete rule;
     }
   }
   newFilter->setName(m_filterName->text());
   if(!m_filter || !alwaysCreateNew_) {
     m_filter = newFilter;
   }
   return newFilter;
 }
 
 void FilterDialog::setFilter(Tellico::FilterPtr filter_) {
   if(!filter_) {
     slotClear();
     return;
   }
 
   if(filter_->op() == Filter::MatchAll) {
     m_matchAll->setChecked(true);
   } else {
     m_matchAny->setChecked(true);
   }
 
   m_ruleLister->setFilter(filter_);
   m_filterName->setText(filter_->name());
   m_filter = filter_;
 }
 
 void FilterDialog::slotOk() {
   slotApply();
   accept();
 }
 
 void FilterDialog::slotApply() {
   emit signalUpdateFilter(currentFilter());
 }
 
 void FilterDialog::slotHelp() {
   KHelpClient::invokeHelp(QStringLiteral("filter-dialog"));
 }
 
 void FilterDialog::slotClear() {
 //  myDebug();
   m_matchAll->setChecked(true);
   m_ruleLister->reset();
   m_filterName->clear();
 }
 
 void FilterDialog::slotShrink() {
   updateGeometry();
   QApplication::sendPostedEvents();
   resize(width(), sizeHint().height());
 }
 
 void FilterDialog::slotFilterChanged() {
   const bool hadFilter = m_filter && !m_filter->isEmpty();
   const bool emptyFilter = currentFilter(true)->isEmpty();
   // an empty filter can be ok if the filter was originally not empty
   const bool enableOk = !currentFilter()->isEmpty() || hadFilter;
   if(m_saveFilter) {
     m_saveFilter->setEnabled(!m_filterName->text().isEmpty() && !emptyFilter);
     if(m_applyButton) {
       m_applyButton->setEnabled(!emptyFilter);
     }
   }
   if(m_applyButton) {
     m_applyButton->setEnabled(enableOk);
   }
   m_okButton->setEnabled(enableOk);
   m_okButton->setDefault(enableOk);
 }
 
 void FilterDialog::slotSaveFilter() {
   // non-op if editing an existing filter
   if(m_mode != CreateFilter) {
     return;
   }
 
   // in this case, currentFilter() either creates a new filter or
   // updates the current one. If creating a new one, then I want to copy it
   const bool wasEmpty = !m_filter;
   FilterPtr filter(new Filter(*currentFilter()));
   if(wasEmpty) {
     m_filter = filter;
   }
   // this keeps the saving completely decoupled from the filter setting in the detailed view
   if(filter->isEmpty()) {
     m_filter = FilterPtr();
     return;
   }
   Kernel::self()->addFilter(filter);
 }
diff --git a/src/filterview.cpp b/src/filterview.cpp
index 5bb80615..cb87e5ed 100644
--- a/src/filterview.cpp
+++ b/src/filterview.cpp
@@ -1,213 +1,213 @@
 /***************************************************************************
     Copyright (C) 2005-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "filterview.h"
 #include "controller.h"
 #include "entry.h"
 #include "collection.h"
 #include "tellico_kernel.h"
 #include "../tellico_debug.h"
 #include "models/filtermodel.h"
 #include "models/entrysortmodel.h"
 #include "models/models.h"
 #include "gui/countdelegate.h"
 
 #include <KLocalizedString>
 
 #include <QMenu>
 #include <QIcon>
 #include <QHeaderView>
 #include <QContextMenuEvent>
 
 using namespace Tellico;
 using Tellico::FilterView;
 
 FilterView::FilterView(QWidget* parent_)
     : GUI::TreeView(parent_), m_notSortedYet(true) {
   header()->setSectionResizeMode(QHeaderView::Stretch);
   setHeaderHidden(false);
   setSelectionMode(QAbstractItemView::ExtendedSelection);
 
-  connect(this, SIGNAL(doubleClicked(const QModelIndex&)),
-          SLOT(slotDoubleClicked(const QModelIndex&)));
+  connect(this, &QAbstractItemView::doubleClicked,
+          this, &FilterView::slotDoubleClicked);
 
-  connect(header(), SIGNAL(sortIndicatorChanged(int,Qt::SortOrder)),
-          SLOT(slotSortingChanged(int,Qt::SortOrder)));
+  connect(header(), &QHeaderView::sortIndicatorChanged,
+          this, &FilterView::slotSortingChanged);
 
   FilterModel* filterModel = new FilterModel(this);
   EntrySortModel* sortModel = new EntrySortModel(this);
   sortModel->setSourceModel(filterModel);
   setModel(sortModel);
   setItemDelegate(new GUI::CountDelegate(this));
 }
 
 Tellico::FilterModel* FilterView::sourceModel() const {
   return static_cast<FilterModel*>(sortModel()->sourceModel());
 }
 
 void FilterView::addCollection(Tellico::Data::CollPtr coll_) {
   m_coll = coll_;
   sourceModel()->clear();
   sourceModel()->addFilters(m_coll->filters());
 }
 
 void FilterView::addEntries(Tellico::Data::EntryList entries_) {
   invalidate(entries_);
 }
 
 void FilterView::modifyEntries(Tellico::Data::EntryList entries_) {
   invalidate(entries_);
 }
 
 void FilterView::removeEntries(Tellico::Data::EntryList entries_) {
   invalidate(entries_);
 }
 
 void FilterView::slotReset() {
   sourceModel()->clear();
 }
 
 void FilterView::addFilter(Tellico::FilterPtr filter_) {
   Q_ASSERT(filter_);
   sourceModel()->addFilter(filter_);
 }
 
 void FilterView::slotModifyFilter() {
   QModelIndex index = currentIndex();
   // parent means a top-level item
   if(!index.isValid() || index.parent().isValid()) {
     return;
   }
 
   QModelIndex realIndex = sortModel()->mapToSource(index);
   Kernel::self()->modifyFilter(sourceModel()->filter(realIndex));
 }
 
 void FilterView::slotDeleteFilter() {
   QModelIndex index = currentIndex();
   // parent means a top-level item
   if(!index.isValid() || index.parent().isValid()) {
     return;
   }
 
   QModelIndex realIndex = sortModel()->mapToSource(index);
   Kernel::self()->removeFilter(sourceModel()->filter(realIndex));
 }
 
 void FilterView::removeFilter(Tellico::FilterPtr filter_) {
   Q_ASSERT(filter_);
   sourceModel()->removeFilter(filter_);
 }
 
 void FilterView::contextMenuEvent(QContextMenuEvent* event_) {
   QModelIndex index = indexAt(event_->pos());
   if(!index.isValid()) {
     return;
   }
 
   QMenu menu(this);
   // no parent means it's a top-level item
   if(!index.parent().isValid()) {
     menu.addAction(QIcon::fromTheme(QStringLiteral("view-filter")),
-                    i18n("Modify Filter"), this, SLOT(slotModifyFilter()));
+                    i18n("Modify Filter"), this, &FilterView::slotModifyFilter);
     menu.addAction(QIcon::fromTheme(QStringLiteral("edit-delete")),
-                    i18n("Delete Filter"), this, SLOT(slotDeleteFilter()));
+                    i18n("Delete Filter"), this, &FilterView::slotDeleteFilter);
   } else {
     Controller::self()->plugEntryActions(&menu);
   }
   menu.exec(event_->globalPos());
 }
 
 void FilterView::selectionChanged(const QItemSelection& selected_, const QItemSelection& deselected_) {
 //  DEBUG_BLOCK;
   // in Controller::slotUpdateFilter(), filterView->clearSelection() gets called when the filter is empty
   // which happens when only entries are selected here
   GUI::TreeView::selectionChanged(selected_, deselected_);
   FilterPtr filter;
   foreach(const QModelIndex& index, selectionModel()->selectedIndexes()) {
     QModelIndex realIndex = sortModel()->mapToSource(index);
     Data::EntryPtr entry = sourceModel()->entry(realIndex);
     if(!entry && !filter) {
       filter = sourceModel()->filter(realIndex);
       break;
     }
   }
   // emitting signal with a null filter is ok and accounts for clearing the selection
   emit signalUpdateFilter(filter);
 }
 
 void FilterView::slotDoubleClicked(const QModelIndex& index_) {
   QModelIndex realIndex = sortModel()->mapToSource(index_);
   Data::EntryPtr entry = sourceModel()->entry(realIndex);
   if(entry) {
     Controller::self()->editEntry(entry);
   } else {
     FilterPtr filter = sourceModel()->filter(realIndex);
     if(filter) {
       Kernel::self()->modifyFilter(filter);
     }
   }
 }
 
 // this gets called when header() is clicked, so cycle through
 void FilterView::slotSortingChanged(int col_, Qt::SortOrder order_) {
   Q_UNUSED(col_);
   if(order_ == Qt::AscendingOrder && !m_notSortedYet) { // cycle through after ascending
     if(sortModel()->sortRole() == RowCountRole) {
       sortModel()->setSortRole(Qt::DisplayRole);
     } else {
       sortModel()->setSortRole(RowCountRole);
     }
   }
 
   updateHeader();
   m_notSortedYet = false;
 }
 
 void FilterView::updateHeader() {
   if(sortModel()->sortRole() == Qt::DisplayRole) {
     model()->setHeaderData(0, Qt::Horizontal, i18n("Filter"));
   } else {
     model()->setHeaderData(0, Qt::Horizontal, i18n("Filter (Sort by Count)"));
   }
 }
 
 void FilterView::invalidate(Tellico::Data::EntryList entries_) {
   const int rows = model()->rowCount();
   for(int row = 0; row < rows; ++row) {
     QModelIndex index = sourceModel()->index(row, 0);
     FilterPtr filter = sourceModel()->filter(index);
     if(!filter) {
       continue;
     }
     // two cases: if the filter used to match the entry and no longer does, then check the children indexes
     // if the filter matches now, check the actual match
     foreach(Data::EntryPtr entry, entries_) {
       if(sourceModel()->indexContainsEntry(index, entry) || filter->matches(entry)) {
         sourceModel()->invalidate(index);
         break;
       }
     }
   }
 }
diff --git a/src/groupview.cpp b/src/groupview.cpp
index bdc8ad6f..50b8579d 100644
--- a/src/groupview.cpp
+++ b/src/groupview.cpp
@@ -1,413 +1,413 @@
 /***************************************************************************
     Copyright (C) 2001-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "groupview.h"
 #include "collection.h"
 #include "field.h"
 #include "entry.h"
 #include "entrygroup.h"
 #include "filter.h"
 #include "controller.h"
 #include "models/entrygroupmodel.h"
 #include "models/groupsortmodel.h"
 #include "models/modelmanager.h"
 #include "models/models.h"
 #include "gui/countdelegate.h"
 #include "tellico_debug.h"
 
 #include <KLocalizedString>
 
 #include <QMenu>
 #include <QIcon>
 #include <QStringList>
 #include <QColor>
 #include <QRegExp>
 #include <QHeaderView>
 #include <QContextMenuEvent>
 
 using Tellico::GroupView;
 
 GroupView::GroupView(QWidget* parent_)
     : GUI::TreeView(parent_), m_notSortedYet(true) {
   header()->setSectionResizeMode(QHeaderView::Stretch);
   setHeaderHidden(false);
   setSelectionMode(QAbstractItemView::ExtendedSelection);
 
   connect(this, &GroupView::expanded, this, &GroupView::slotExpanded);
   connect(this, &GroupView::collapsed, this, &GroupView::slotCollapsed);
   connect(this, &GroupView::doubleClicked, this, &GroupView::slotDoubleClicked);
   connect(header(), &QHeaderView::sortIndicatorChanged, this, &GroupView::slotSortingChanged);
 
   m_groupOpenIconName = QStringLiteral("folder-open");
   m_groupClosedIconName = QStringLiteral("folder");
   EntryGroupModel* groupModel = new EntryGroupModel(this);
   GroupSortModel* sortModel = new GroupSortModel(this);
   sortModel->setSourceModel(groupModel);
   setModel(sortModel);
   setItemDelegate(new GUI::CountDelegate(this));
 
   ModelManager::self()->setGroupModel(model());
 }
 
 Tellico::EntryGroupModel* GroupView::sourceModel() const {
   return static_cast<EntryGroupModel*>(sortModel()->sourceModel());
 }
 
 void GroupView::addCollection(Tellico::Data::CollPtr coll_) {
   if(!coll_) {
     myWarning() << "null coll pointer!";
     return;
   }
 
   m_coll = coll_;
   // if the collection doesn't have the grouped field, and it's not the pseudo-group,
   // change it to default
   if(m_groupBy.isEmpty() || (!coll_->hasField(m_groupBy) && m_groupBy != Data::Collection::s_peopleGroupName)) {
     m_groupBy = coll_->defaultGroupField();
   }
 
   // when the coll gets set for the first time, the pixmaps need to be updated
   if((m_coll->hasField(m_groupBy) && m_coll->fieldByName(m_groupBy)->formatType() == FieldFormat::FormatName)
      || m_groupBy == Data::Collection::s_peopleGroupName) {
     m_groupOpenIconName = QStringLiteral(":/icons/person-open");
     m_groupClosedIconName = QStringLiteral(":/icons/person");
   }
 
   updateHeader();
   populateCollection();
 }
 
 void GroupView::removeCollection(Tellico::Data::CollPtr coll_) {
   if(!coll_) {
     myWarning() << "null coll pointer!";
     return;
   }
 
   blockSignals(true);
   slotReset();
   blockSignals(false);
 }
 
 void GroupView::populateCollection() {
   if(!m_coll) {
     return;
   }
 
 //  myDebug() << m_groupBy;
   if(m_groupBy.isEmpty()) {
     m_groupBy = m_coll->defaultGroupField();
   }
 
   setUpdatesEnabled(false);
   sourceModel()->clear(); // delete all groups
 
   // if there's no group field, just return
   if(m_groupBy.isEmpty()) {
     setUpdatesEnabled(true);
     return;
   }
 
   Data::EntryGroupDict* dict = m_coll->entryGroupDictByName(m_groupBy);
   if(!dict) { // could happen if m_groupBy is non empty, but there are no entries with a value
     setUpdatesEnabled(true);
     return;
   }
 
   // add all the groups
   sourceModel()->addGroups(dict->values(), m_groupClosedIconName);
   // still need to change icon for empty group
   foreach(Data::EntryGroup* group, *dict) {
     if(group->hasEmptyGroupName()) {
       QModelIndex emptyGroupIndex = sourceModel()->indexFromGroup(group);
       sourceModel()->setData(emptyGroupIndex, QLatin1String("folder-red"), Qt::DecorationRole);
       break;
     }
   }
 
   setUpdatesEnabled(true);
   // must re-sort in order to update view
   model()->sort(0, sortOrder());
 }
 
 // don't 'shadow' QListView::setSelected
 void GroupView::setEntrySelected(Tellico::Data::EntryPtr entry_) {
 //  DEBUG_LINE;
   // if entry_ is null pointer, set no selected
   if(!entry_) {
     // don't move this one outside the block since it calls setCurrentItem(0)
     clearSelection();
     return;
   }
 
   // if the selected entry is the same as the current one, just return
   QModelIndex curr = currentIndex();
   if(entry_ == sourceModel()->entry(curr)) {
     return;
   }
 
   // have to find a group whose field is the same as currently shown
   if(m_groupBy.isEmpty()) {
     myDebug() << "no group field";
     return;
   }
 
   Data::EntryGroup* group = nullptr;
   foreach(Data::EntryGroup* tmpGroup, entry_->groups()) {
     if(tmpGroup->fieldName() == m_groupBy) {
       group = tmpGroup;
       break;
     }
   }
   if(!group) {
     myDebug() << "entry is not in any current groups!";
     return;
   }
 
   QModelIndex index = sourceModel()->indexFromGroup(group);
 
   clearSelection();
   for(; index.isValid(); index = index.sibling(index.row()+1, 0)) {
     if(sourceModel()->entry(index) == entry_) {
       blockSignals(true);
       selectionModel()->select(index, QItemSelectionModel::Select);
       setCurrentIndex(index);
       blockSignals(false);
       scrollTo(index);
       break;
     }
   }
 }
 
 void GroupView::modifyField(Tellico::Data::CollPtr, Tellico::Data::FieldPtr, Tellico::Data::FieldPtr newField_) {
   if(newField_->name() == m_groupBy) {
     updateHeader(newField_);
   }
   // if the grouping changed at all, our groups got deleted out from under us
   populateCollection();
 }
 
 void GroupView::slotReset() {
   sourceModel()->clear();
 }
 
 void GroupView::slotModifyGroups(Tellico::Data::CollPtr coll_, QList<Tellico::Data::EntryGroup*> groups_) {
   if(!coll_ || groups_.isEmpty()) {
     myWarning() << "null coll or group pointer!";
     return;
   }
 
   /* for each group
      - remove existing empty ones
      - modify existing ones
      - add new ones
   */
   foreach(Data::EntryGroup* group, groups_) {
     // if the entries aren't grouped by field of the modified group,
     // we don't care, so skip
     if(m_groupBy != group->fieldName()) {
       continue;
     }
 
 //    myDebug() << group->fieldName() << "/" << group->groupName();
     QModelIndex groupIndex = sourceModel()->indexFromGroup(group);
     if(groupIndex.isValid()) {
       if(group->isEmpty()) {
         sourceModel()->removeGroup(group);
         continue;
       }
       sourceModel()->modifyGroup(group);
     } else {
       if(group->isEmpty()) {
         myDebug() << "trying to add empty group";
         continue;
       }
       addGroup(group);
     }
   }
   // don't want any selected
   clearSelection();
 }
 
 void GroupView::contextMenuEvent(QContextMenuEvent* event_) {
   QModelIndex index = indexAt(event_->pos());
   if(!index.isValid()) {
     return;
   }
 
   QMenu menu(this);
   // no parent means it's a top-level item
   if(!index.parent().isValid()) {
     menu.addAction(QIcon::fromTheme(QStringLiteral("arrow-down-double")),
-                   i18n("Expand All Groups"), this, SLOT(expandAll()));
+                   i18n("Expand All Groups"), this, &QTreeView::expandAll);
     menu.addAction(QIcon::fromTheme(QStringLiteral("arrow-up-double")),
-                   i18n("Collapse All Groups"), this, SLOT(collapseAll()));
+                   i18n("Collapse All Groups"), this, &QTreeView::collapseAll);
     menu.addAction(QIcon::fromTheme(QStringLiteral("view-filter")),
-                   i18n("Filter by Group"), this, SLOT(slotFilterGroup()));
+                   i18n("Filter by Group"), this, &GroupView::slotFilterGroup);
   } else {
     Controller::self()->plugEntryActions(&menu);
   }
   menu.exec(event_->globalPos());
 }
 
 void GroupView::slotCollapsed(const QModelIndex& index_) {
   if(model()->data(index_, Qt::DecorationRole).toString() == m_groupOpenIconName) {
     model()->setData(index_, m_groupClosedIconName, Qt::DecorationRole);
   }
 }
 
 void GroupView::slotExpanded(const QModelIndex& index_) {
   if(model()->data(index_, Qt::DecorationRole).toString() == m_groupClosedIconName) {
     model()->setData(index_, m_groupOpenIconName, Qt::DecorationRole);
   }
 }
 
 void GroupView::setGroupField(const QString& groupField_) {
 //  myDebug() << groupField_;
   if(groupField_.isEmpty() || groupField_ == m_groupBy) {
     return;
   }
 
   m_groupBy = groupField_;
   if(!m_coll) {
     return; // can't do anything yet, but still need to set the variable
   }
   if((m_coll->hasField(groupField_) && m_coll->fieldByName(groupField_)->formatType() == Tellico::FieldFormat::FormatName)
      || groupField_ == Tellico::Data::Collection::s_peopleGroupName) {
     m_groupOpenIconName = QStringLiteral(":/icons/person-open");
     m_groupClosedIconName = QStringLiteral(":/icons/person");
   } else {
     m_groupOpenIconName = QStringLiteral("folder-open");
     m_groupClosedIconName = QStringLiteral("folder");
   }
   updateHeader();
   populateCollection();
 }
 
 void GroupView::slotFilterGroup() {
   QModelIndexList indexes = selectionModel()->selectedIndexes();
   if(indexes.isEmpty()) {
     return;
   }
 
   FilterPtr filter(new Filter(Filter::MatchAny));
   foreach(const QModelIndex& index, indexes) {
     // the indexes pointing to a group have no parent
     if(index.parent().isValid()) {
       continue;
     }
 
     if(!model()->hasChildren(index)) { //ignore empty items
       continue;
     }
     // need to check for people group
     if(m_groupBy == Data::Collection::s_peopleGroupName) {
       QModelIndex firstChild = model()->index(0, 0, index);
       QModelIndex sourceIndex = sortModel()->mapToSource(firstChild);
       Data::EntryPtr entry = sourceModel()->entry(sourceIndex);
       Q_ASSERT(entry);
       Data::FieldList fields = entry->collection()->peopleFields();
       foreach(Data::FieldPtr field, fields) {
         filter->append(new FilterRule(field->name(), model()->data(index).toString(), FilterRule::FuncContains));
       }
     } else {
       Data::EntryGroup* group = model()->data(index, GroupPtrRole).value<Data::EntryGroup*>();
       if(group) {
         if(group->hasEmptyGroupName()) {
           filter->append(new FilterRule(m_groupBy, QString(), FilterRule::FuncEquals));
         } else {
           // TODO:: should not hard-code the semi-colon. Use FieldFormat::delimiterString()
           // but without trailing space
           // TODO:: switch to QRegularExpression one day
           const QString rxPattern(QLatin1String("(^|;\\s)") +
                                   QRegExp::escape(group->groupName()) +
                                   QLatin1String("($|;)"));
           filter->append(new FilterRule(m_groupBy, rxPattern, FilterRule::FuncRegExp));
         }
       }
     }
   }
 
   if(!filter->isEmpty()) {
     emit signalUpdateFilter(filter);
   }
 }
 
 void GroupView::slotDoubleClicked(const QModelIndex& index_) {
   QModelIndex realIndex = sortModel()->mapToSource(index_);
   Data::EntryPtr entry = sourceModel()->entry(realIndex);
   if(entry) {
     Controller::self()->editEntry(entry);
   }
 }
 
 // this gets called when header() is clicked, so cycle through
 void GroupView::slotSortingChanged(int col_, Qt::SortOrder order_) {
   Q_UNUSED(col_);
   if(order_ == Qt::AscendingOrder && !m_notSortedYet) { // cycle through after ascending
     if(sortModel()->sortRole() == RowCountRole) {
       sortModel()->setSortRole(Qt::DisplayRole);
     } else {
       sortModel()->setSortRole(RowCountRole);
     }
   }
 
   updateHeader();
   m_notSortedYet = false;
 }
 
 void GroupView::updateHeader(Tellico::Data::FieldPtr field_/*=0*/) {
   QString t = field_ ? field_->title() : groupTitle();
   if(sortModel()->sortRole() == Qt::DisplayRole) {
     model()->setHeaderData(0, Qt::Horizontal, t);
   } else {
     model()->setHeaderData(0, Qt::Horizontal, i18n("%1 (Sort by Count)", t));
   }
 }
 
 QString GroupView::groupTitle() {
   QString title;
   if(!m_coll || m_groupBy.isEmpty()) {
     title = i18nc("Group Name Header", "Group");
   } else {
     Data::FieldPtr f = m_coll->fieldByName(m_groupBy);
     if(f) {
       title = f->title();
     } else if(m_groupBy == Data::Collection::s_peopleGroupName) {
       title = i18n("People");
     }
   }
   return title;
 }
 
 void GroupView::addGroup(Tellico::Data::EntryGroup* group_) {
   if(group_->isEmpty()) {
     return;
   }
   QModelIndex index = sourceModel()->addGroup(group_);
   if(group_->hasEmptyGroupName()) {
     sourceModel()->setData(index, QLatin1String("folder-red"), Qt::DecorationRole);
   } else {
     sourceModel()->setData(index, m_groupClosedIconName, Qt::DecorationRole);
   }
 }
diff --git a/src/images/imagejob.cpp b/src/images/imagejob.cpp
index 6d470212..03d2c8d4 100644
--- a/src/images/imagejob.cpp
+++ b/src/images/imagejob.cpp
@@ -1,130 +1,130 @@
 /***************************************************************************
     Copyright (C) 2017 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "imagejob.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 
 #include <QTimer>
 #include <QFileInfo>
 #include <QBuffer>
 #include <QImageReader>
 
 using Tellico::ImageJob;
 
 ImageJob::ImageJob(const QUrl& url_, const QString& id_, bool quiet_) : KIO::Job()
     , m_url(url_), m_id(id_), m_linkOnly(false), m_quiet(quiet_) {
-  QTimer::singleShot(0, this, SLOT(slotStart()));
+  QTimer::singleShot(0, this, &ImageJob::slotStart);
 }
 
 ImageJob::~ImageJob() {
 }
 
 QString ImageJob::errorString() const {
   // by default, KIO::Job returns an error string depending on the error code and
   // using errorText() as a url or file name. Instead, just set a full error text and use it
   return errorText();
 }
 
 const Tellico::Data::Image& ImageJob::image() const {
   return m_image;
 }
 
 void ImageJob::setLinkOnly(bool linkOnly_) {
   m_linkOnly = linkOnly_;
 }
 
 void ImageJob::setReferrer(const QUrl& referrer_) {
   m_referrer = referrer_;
 }
 
 void ImageJob::slotStart() {
   if(!m_url.isValid()) {
     setError(KIO::ERR_MALFORMED_URL);
     emitResult();
   } else if(m_url.isLocalFile()) {
     const QString fileName = m_url.toLocalFile();
     if(!QFileInfo(fileName).isReadable()) {
       setError(KIO::ERR_CANNOT_OPEN_FOR_READING);
       setErrorText(i18n("Tellico is unable to load the image - %1.", fileName));
     } else {
       m_image = Data::Image(fileName, m_id);
       if(m_image.isNull()) {
         setError(KIO::ERR_UNKNOWN);
         m_image = Data::Image::null;
       }
       if(m_linkOnly) {
         m_image.setLinkOnly(true);
         m_image.setID(m_url.url());
       }
     }
     emitResult();
   } else {
     KIO::JobFlags flags = KIO::DefaultFlags;
     if(m_quiet) {
       flags |= KIO::HideProgressInfo;
     }
     // non-local valid url
     // KIO::storedGet seems to handle Content-Encoding: gzip ok
     KIO::StoredTransferJob* getJob = KIO::storedGet(m_url, KIO::NoReload, flags);
     QObject::connect(getJob, &KJob::result, this, &ImageJob::getJobResult);
     if(!m_referrer.isEmpty()) {
       getJob->addMetaData(QStringLiteral("referrer"), m_referrer.url());
     }
     addSubjob(getJob);
     // don't emit result, it will be taken care of by the subjob handling
   }
 }
 
 void ImageJob::getJobResult(KJob* job_) {
   KIO::StoredTransferJob* getJob = qobject_cast<KIO::StoredTransferJob*>(job_);
   if(!getJob || getJob->error()) {
     // error handling for subjob is handled by KCompositeJob
     setErrorText(i18n("Tellico is unable to load the image - %1.", m_url.toDisplayString()));
     return;
   }
 
   // If we used the Image() c'tor that take a bytearray of data, I'm not sure how to
   // figure out the image format directly. Instead, write into a buffer and use QImageReader
   QByteArray data = getJob->data();
   QBuffer buffer(&data);
   buffer.open(QIODevice::ReadOnly);
   m_image = Data::Image(data, QString::fromLatin1(QImageReader::imageFormat(&buffer)), m_id);
   if(m_image.isNull()) {
     setError(KIO::ERR_UNKNOWN);
     m_image = Data::Image::null;
   } else {
     // if we can't write the input format, then change to one we can
     m_image.setFormat(Data::Image::outputFormat(m_image.format()));
     if(m_id.isEmpty()) {
       m_image.calculateID();
     }
     if(m_linkOnly) {
       m_image.setLinkOnly(true);
       m_image.setID(m_url.url());
     }
   }
   emitResult();
 }
diff --git a/src/loandialog.cpp b/src/loandialog.cpp
index 95d72bdc..2c2ccb35 100644
--- a/src/loandialog.cpp
+++ b/src/loandialog.cpp
@@ -1,345 +1,345 @@
 /***************************************************************************
     Copyright (C) 2005-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include <config.h>
 
 #include "loandialog.h"
 #include "borrowerdialog.h"
 #include "gui/datewidget.h"
 #include "collection.h"
 #include "commands/addloans.h"
 #include "commands/modifyloans.h"
 #include "utils/string_utils.h"
 #include "tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KLineEdit>
 #include <KTextEdit>
 #include <KJob>
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <KWindowConfig>
 
 #ifdef HAVE_KABC
 #include <kcontacts/addressee.h>
 #include <Akonadi/Contact/ContactSearchJob>
 #endif
 
 #include <QLabel>
 #include <QCheckBox>
 #include <QGridLayout>
 #include <QPushButton>
 #include <QDialogButtonBox>
 #include <QVBoxLayout>
 #include <QTimer>
 
 namespace {
   static const char* dialogOptionsString = "Loan Dialog Options";
 }
 
 using Tellico::LoanDialog;
 
 LoanDialog::LoanDialog(const Tellico::Data::EntryList& entries_, QWidget* parent_)
     : QDialog(parent_),
       m_mode(Add), m_borrower(nullptr), m_entries(entries_), m_loan(nullptr) {
   setModal(true);
   setWindowTitle(i18n("Loan Dialog"));
 
   init();
 }
 
 LoanDialog::LoanDialog(Tellico::Data::LoanPtr loan_, QWidget* parent_)
     : QDialog(parent_),
       m_mode(Modify), m_borrower(loan_->borrower()), m_loan(loan_) {
   m_entries.append(m_loan->entry());
 
   setModal(true);
   setWindowTitle(i18n("Modify Loan"));
 
   init();
 
   m_borrowerEdit->setText(m_loan->borrower()->name());
   m_loanDate->setDate(m_loan->loanDate());
   if(m_loan->dueDate().isValid()) {
     m_dueDate->setDate(m_loan->dueDate());
 #ifdef HAVE_KCAL
     m_addEvent->setEnabled(true);
     if(m_loan->inCalendar()) {
       m_addEvent->setChecked(true);
     }
 #endif
   }
   m_note->setPlainText(m_loan->note());
 }
 
 void LoanDialog::init() {
   QVBoxLayout* mainLayout = new QVBoxLayout(this);
   setLayout(mainLayout);
 
   QWidget* mainWidget = new QWidget(this);
   mainLayout->addWidget(mainWidget);
 
   QGridLayout* topLayout = new QGridLayout(mainWidget);
   // middle column gets to be the widest
   topLayout->setColumnStretch(1, 1);
 
   int row = -1;
 
   QLabel* pixLabel = new QLabel(mainWidget);
   mainLayout->addWidget(pixLabel);
   pixLabel->setPixmap(QIcon::fromTheme(QStringLiteral("tellico"),
                                        QIcon(QLatin1String(":/icons/tellico")))
                                       .pixmap(QSize(64, 64)));
   pixLabel->setAlignment(Qt::Alignment(Qt::AlignLeft) | Qt::AlignTop);
   topLayout->addWidget(pixLabel, ++row, 0);
 
   QString entryString = QStringLiteral("<qt><p>");
   if(m_mode == Add) {
     entryString += i18n("The following items are being checked out:");
     entryString += QLatin1String("</p><ol>");
     foreach(Data::EntryPtr entry, m_entries) {
       entryString += QLatin1String("<li>") + entry->title() + QLatin1String("</li>");
     }
   } else {
     entryString += i18n("The following item is on-loan:");
     entryString += QLatin1String("</p><ol>");
     entryString += QLatin1String("<li>") + m_loan->entry()->title() + QLatin1String("</li>");
   }
   entryString += QLatin1String("</ol></qt>");
   KTextEdit* entryLabel = new KTextEdit(mainWidget);
   mainLayout->addWidget(entryLabel);
   entryLabel->setHtml(entryString);
   entryLabel->setReadOnly(true);
   topLayout->addWidget(entryLabel, row, 1, 1, 2);
 
   QLabel* l = new QLabel(i18n("&Lend to:"), mainWidget);
   mainLayout->addWidget(l);
   topLayout->addWidget(l, ++row, 0);
   m_borrowerEdit = new KLineEdit(mainWidget); //krazy:exclude=qclasses
   mainLayout->addWidget(m_borrowerEdit);
   topLayout->addWidget(m_borrowerEdit, row, 1);
   l->setBuddy(m_borrowerEdit);
   m_borrowerEdit->completionObject()->setIgnoreCase(true);
-  connect(m_borrowerEdit, SIGNAL(textChanged(const QString&)),
-          SLOT(slotBorrowerNameChanged(const QString&)));
+  connect(m_borrowerEdit, &QLineEdit::textChanged,
+          this, &LoanDialog::slotBorrowerNameChanged);
   QPushButton* pb = new QPushButton(QIcon::fromTheme(QStringLiteral("kaddressbook")), QString(), mainWidget);
   mainLayout->addWidget(pb);
   topLayout->addWidget(pb, row, 2);
-  connect(pb, SIGNAL(clicked()), SLOT(slotGetBorrower()));
+  connect(pb, &QAbstractButton::clicked, this, &LoanDialog::slotGetBorrower);
   QString whats = i18n("Enter the name of the person borrowing the items from you. "
                        "Clicking the button allows you to select from your address book.");
   l->setWhatsThis(whats);
   // only enable for new loans
   if(m_mode == Modify) {
     m_borrowerEdit->setEnabled(false);
     pb->setEnabled(false);
   }
 
   l = new QLabel(i18n("&Loan date:"), mainWidget);
   mainLayout->addWidget(l);
   topLayout->addWidget(l, ++row, 0);
   m_loanDate = new GUI::DateWidget(mainWidget);
   m_loanDate->setDate(QDate::currentDate());
   l->setBuddy(m_loanDate);
   topLayout->addWidget(m_loanDate, row, 1, 1, 2);
   whats = i18n("The check-out date is the date that you lent the items. By default, "
                "today's date is used.");
   l->setWhatsThis(whats);
   m_loanDate->setWhatsThis(whats);
   // only enable for new loans
   if(m_mode == Modify) {
     m_loanDate->setEnabled(false);
   }
 
   l = new QLabel(i18n("D&ue date:"), mainWidget);
   mainLayout->addWidget(l);
   topLayout->addWidget(l, ++row, 0);
   m_dueDate = new GUI::DateWidget(mainWidget);
   l->setBuddy(m_dueDate);
   topLayout->addWidget(m_dueDate, row, 1, 1, 2);
   // valid due dates will enable the calendar adding checkbox
-  connect(m_dueDate, SIGNAL(signalModified()), SLOT(slotDueDateChanged()));
+  connect(m_dueDate, &GUI::DateWidget::signalModified, this, &LoanDialog::slotDueDateChanged);
   whats = i18n("The due date is when the items are due to be returned. The due date "
                "is not required, unless you want to add the loan to your active calendar.");
   l->setWhatsThis(whats);
   m_dueDate->setWhatsThis(whats);
 
   l = new QLabel(i18n("&Note:"), mainWidget);
   mainLayout->addWidget(l);
   topLayout->addWidget(l, ++row, 0);
   m_note = new KTextEdit(mainWidget);
   mainLayout->addWidget(m_note);
   l->setBuddy(m_note);
   topLayout->addWidget(m_note, row, 1, 1, 2);
   topLayout->setRowStretch(row, 1);
   whats = i18n("You can add notes about the loan.");
   l->setWhatsThis(whats);
   m_note->setWhatsThis(whats);
 
   m_addEvent = new QCheckBox(i18n("&Add a reminder to the active calendar"), mainWidget);
   mainLayout->addWidget(m_addEvent);
   topLayout->addWidget(m_addEvent, ++row, 0, 1, 3);
   m_addEvent->setEnabled(false); // gets enabled when valid due date is entered
   m_addEvent->setWhatsThis(i18n("<qt>Checking this box will add a <em>To-do</em> item "
                                    "to your active calendar, which can be viewed using KOrganizer. "
                                    "The box is only active if you set a due date.</qt>"));
 
 #ifdef HAVE_KABC
   // Search for all existing contacts
   Akonadi::ContactSearchJob* job = new Akonadi::ContactSearchJob();
   connect(job, SIGNAL(result(KJob*)), this, SLOT(akonadiSearchResult(KJob*)));
 #endif
   populateBorrowerList();
 
   m_buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
   QPushButton* okButton = m_buttonBox->button(QDialogButtonBox::Ok);
   okButton->setDefault(true);
   okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
   okButton->setEnabled(false); // disable until a name is entered
-  connect(m_buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
-  connect(m_buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
+  connect(m_buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
+  connect(m_buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
 
   mainLayout->addWidget(m_buttonBox);
 
-  QTimer::singleShot(0, this, SLOT(slotUpdateSize()));
+  QTimer::singleShot(0, this, &LoanDialog::slotUpdateSize);
 }
 
 LoanDialog::~LoanDialog() {
   KConfigGroup config(KSharedConfig::openConfig(), QStringLiteral("Loan Dialog Options"));
   KWindowConfig::saveWindowSize(windowHandle(), config);
 }
 
 void LoanDialog::slotBorrowerNameChanged(const QString& str_) {
   m_buttonBox->button(QDialogButtonBox::Ok)->setEnabled(!str_.isEmpty());
 }
 
 void LoanDialog::slotDueDateChanged() {
 #ifdef HAVE_KCAL
   m_addEvent->setEnabled(m_dueDate->date().isValid());
 #endif
 }
 
 void LoanDialog::slotGetBorrower() {
   Data::BorrowerPtr borrower = BorrowerDialog::getBorrower(this);
   if(borrower) {
     m_borrowerEdit->setText(borrower->name());
     m_uid = borrower->uid();
   }
 }
 
 void LoanDialog::akonadiSearchResult(KJob* job_) {
   if(job_->error() != 0) {
     myDebug() << job_->errorString();
     return;
   }
 
 #ifdef HAVE_KABC
   Akonadi::ContactSearchJob* searchJob = qobject_cast<Akonadi::ContactSearchJob*>(job_);
   Q_ASSERT(searchJob);
 
   populateBorrowerList();
 
   foreach(const KContacts::Addressee& addressee, searchJob->contacts()) {
     // skip people with no name
     const QString name = addressee.realName().trimmed();
     if(name.isEmpty()) {
       continue;
     }
     m_borrowerEdit->completionObject()->addItem(name);
   }
 #endif
 }
 
 void LoanDialog::populateBorrowerList() {
   m_borrowerEdit->completionObject()->clear();
 
   // add current borrowers
   Data::BorrowerList borrowers = m_entries.at(0)->collection()->borrowers();
   foreach(Data::BorrowerPtr borrower, borrowers) {
     m_borrowerEdit->completionObject()->addItem(borrower->name());
   }
 }
 
 QUndoCommand* LoanDialog::createCommand() {
   // first, check to see if the borrower is empty
   QString name = m_borrowerEdit->text();
   if(name.isEmpty()) {
     return nullptr;
   }
 
   // ok, first handle creating new loans
   if(m_mode == Add) {
     return addLoansCommand();
   } else {
     return modifyLoansCommand();
   }
 }
 
 QUndoCommand* LoanDialog::addLoansCommand() {
   if(m_entries.isEmpty()) {
     return nullptr;
   }
 
   const QString name = m_borrowerEdit->text();
 
   // see if there's a borrower with this name already
   m_borrower = nullptr;
   Data::BorrowerList borrowers = m_entries.at(0)->collection()->borrowers();
   foreach(Data::BorrowerPtr borrower, borrowers) {
     if(borrower->name() == name) {
       m_borrower = borrower;
       break;
     }
   }
 
   if(!m_borrower) {
     if(m_uid.isEmpty()) {
       m_uid = Tellico::uid();
     }
     m_borrower = new Data::Borrower(name, m_uid);
   }
 
   Data::LoanList loans;
   foreach(Data::EntryPtr entry, m_entries) {
     loans.append(Data::LoanPtr(new Data::Loan(entry, m_loanDate->date(), m_dueDate->date(), m_note->toPlainText())));
   }
 
   return new Command::AddLoans(m_borrower, loans, m_addEvent->isChecked());
 }
 
 QUndoCommand* LoanDialog::modifyLoansCommand() {
   if(!m_loan) {
     return nullptr;
   }
 
   Data::LoanPtr newLoan(new Data::Loan(*m_loan));
   newLoan->setDueDate(m_dueDate->date());
   newLoan->setNote(m_note->toPlainText());
   return new Command::ModifyLoans(m_loan, newLoan, m_addEvent->isChecked());
 }
 
 void LoanDialog::slotUpdateSize() {
   KConfigGroup config(KSharedConfig::openConfig(), QLatin1String(dialogOptionsString));
   KWindowConfig::restoreWindowSize(windowHandle(), config);
 }
diff --git a/src/loanview.cpp b/src/loanview.cpp
index c42cc569..a218ef0e 100644
--- a/src/loanview.cpp
+++ b/src/loanview.cpp
@@ -1,204 +1,204 @@
 /***************************************************************************
     Copyright (C) 2005-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "loanview.h"
 #include "controller.h"
 #include "borrower.h"
 #include "entry.h"
 #include "collection.h"
 #include "tellico_kernel.h"
 #include "tellico_debug.h"
 #include "models/borrowermodel.h"
 #include "models/entrysortmodel.h"
 #include "models/models.h"
 #include "gui/countdelegate.h"
 
 #include <KLocalizedString>
 
 #include <QMenu>
 #include <QIcon>
 #include <QHeaderView>
 #include <QContextMenuEvent>
 
 using Tellico::LoanView;
 
 LoanView::LoanView(QWidget* parent_) : GUI::TreeView(parent_), m_notSortedYet(true) {
   header()->setSectionResizeMode(QHeaderView::Stretch);
   setHeaderHidden(false);
   setSelectionMode(QAbstractItemView::ExtendedSelection);
 
-  connect(this, SIGNAL(doubleClicked(const QModelIndex&)),
-          SLOT(slotDoubleClicked(const QModelIndex&)));
+  connect(this, &QAbstractItemView::doubleClicked,
+          this, &LoanView::slotDoubleClicked);
 
-  connect(header(), SIGNAL(sortIndicatorChanged(int,Qt::SortOrder)),
-          SLOT(slotSortingChanged(int,Qt::SortOrder)));
+  connect(header(), &QHeaderView::sortIndicatorChanged,
+          this, &LoanView::slotSortingChanged);
 
   BorrowerModel* borrowerModel = new BorrowerModel(this);
   EntrySortModel* sortModel = new EntrySortModel(this);
   sortModel->setSourceModel(borrowerModel);
   setModel(sortModel);
   setItemDelegate(new GUI::CountDelegate(this));
   updateHeader();
 }
 
 /*
 bool LoanView::isSelectable(GUI::ListViewItem* item_) const {
   if(!GUI::ListView::isSelectable(item_)) {
     return false;
   }
 
   // because the popup menu has modify, only
   // allow one loan item to get selected
   if(item_->isLoanItem()) {
     return selectedItems().isEmpty();
   }
 
   return true;
 }
 */
 Tellico::BorrowerModel* LoanView::sourceModel() const {
   return static_cast<BorrowerModel*>(sortModel()->sourceModel());
 }
 
 void LoanView::addCollection(Tellico::Data::CollPtr coll_) {
   m_coll = coll_;
   sourceModel()->clear();
   sourceModel()->addBorrowers(m_coll->borrowers());
 }
 
 void LoanView::slotReset() {
   sourceModel()->clear();
 }
 
 void LoanView::addBorrower(Tellico::Data::BorrowerPtr borrower_) {
   Q_ASSERT(borrower_);
   sourceModel()->addBorrower(borrower_);
 }
 
 void LoanView::modifyBorrower(Tellico::Data::BorrowerPtr borrower_) {
   Q_ASSERT(borrower_);
   sourceModel()->modifyBorrower(borrower_);
 }
 
 void LoanView::removeBorrower(Tellico::Data::BorrowerPtr borrower_) {
   Q_ASSERT(borrower_);
   sourceModel()->removeBorrower(borrower_);
 }
 
 void LoanView::contextMenuEvent(QContextMenuEvent* event_) {
   QModelIndex index = indexAt(event_->pos());
   if(!index.isValid()) {
     return;
   }
 
   // no parent means it's a top-level item
   if(index.parent().isValid()) {
     QMenu menu(this);
     menu.addAction(QIcon::fromTheme(QStringLiteral("arrow-down-double")),
-                   i18n("Check-in"), this, SLOT(slotCheckIn()));
+                   i18n("Check-in"), this, &LoanView::slotCheckIn);
     menu.addAction(QIcon::fromTheme(QStringLiteral("arrow-down-double")),
-                   i18n("Modify Loan..."), this, SLOT(slotModifyLoan()));
+                   i18n("Modify Loan..."), this, &LoanView::slotModifyLoan);
     menu.exec(event_->globalPos());
   }
 }
 
 void LoanView::slotDoubleClicked(const QModelIndex& index_) {
   QModelIndex realIndex = sortModel()->mapToSource(index_);
   Data::LoanPtr loan = sourceModel()->loan(realIndex);
   if(loan) {
     Kernel::self()->modifyLoan(loan);
   }
 }
 
 // this gets called when header() is clicked, so cycle through
 void LoanView::slotSortingChanged(int col_, Qt::SortOrder order_) {
   Q_UNUSED(col_);
   if(order_ == Qt::AscendingOrder && !m_notSortedYet) { // cycle through after ascending
     if(sortModel()->sortRole() == RowCountRole) {
       sortModel()->setSortRole(Qt::DisplayRole);
     } else {
       sortModel()->setSortRole(RowCountRole);
     }
   }
 
   updateHeader();
   m_notSortedYet = false;
 }
 
 /*
 BorrowerItem* item = static_cast<BorrowerItem*>(item_);
   Data::LoanList loans = item->borrower()->loans();
   foreach(Data::LoanPtr loan, loans) {
     new LoanItem(item, loan);
   }
 */
 
 void LoanView::slotCheckIn() {
   QModelIndexList indexes = selectionModel()->selectedIndexes();
   if(indexes.isEmpty()) {
     return;
   }
 
   Data::EntryList entries;
   foreach(const QModelIndex& index, indexes) {
     // the indexes pointing to a borrower have no parent, skip them
     if(!index.parent().isValid()) {
       continue;
     }
     if(model()->hasChildren(index)) { //ignore items with children
       continue;
     }
     QModelIndex sourceIndex = sortModel()->mapToSource(index);
     Data::EntryPtr entry = sourceModel()->entry(sourceIndex);
     if(entry) {
       entries += entry;
     }
   }
 
   Controller::self()->slotCheckIn(entries);
   Controller::self()->slotClearSelection(); // so the checkout menu item gets disabled
 }
 
 void LoanView::slotModifyLoan() {
   QModelIndexList indexes = selectionModel()->selectedIndexes();
   if(indexes.isEmpty()) {
     return;
   }
 
   foreach(const QModelIndex& index, indexes) {
     QModelIndex sourceIndex = sortModel()->mapToSource(index);
     Data::LoanPtr loan = sourceModel()->loan(sourceIndex);
     if(loan) {
       Kernel::self()->modifyLoan(loan);
     }
   }
 }
 
 void LoanView::updateHeader() {
   if(sortModel()->sortRole() == Qt::DisplayRole) {
     model()->setHeaderData(0, Qt::Horizontal, i18n("Borrower"));
   } else {
     model()->setHeaderData(0, Qt::Horizontal, i18n("Borrower (Sort by Count)"));
   }
 }
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index b4c6ba5a..d8348e80 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -1,2384 +1,2387 @@
 /***************************************************************************
     Copyright (C) 2001-2014 Robby Stephenson <robby@periapsis.org>
     Copyright (C) 2011 Pedro Miguel Carvalho <kde@pmc.com.pt>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                     *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "mainwindow.h"
 #include "tellico_kernel.h"
 #include "document.h"
 #include "detailedlistview.h"
 #include "entryeditdialog.h"
 #include "groupview.h"
 #include "viewstack.h"
 #include "collection.h"
 #include "collectionfactory.h"
 #include "entry.h"
 #include "configdialog.h"
 #include "filter.h"
 #include "filterdialog.h"
 #include "collectionfieldsdialog.h"
 #include "controller.h"
 #include "importdialog.h"
 #include "exportdialog.h"
 #include "core/filehandler.h" // needed so static mainWindow variable can be set
 #include "translators/htmlexporter.h" // for printing
 #include "entryview.h"
 #include "entryiconview.h"
 #include "images/imagefactory.h" // needed so tmp files can get cleaned
 #include "collections/collectioninitializer.h"
 #include "collections/bibtexcollection.h" // needed for bibtex string macro dialog
 #include "utils/bibtexhandler.h" // needed for bibtex options
 #include "utils/datafileregistry.h"
 #include "fetchdialog.h"
 #include "reportdialog.h"
 #include "bibtexkeydialog.h"
 #include "core/tellico_strings.h"
 #include "filterview.h"
 #include "loanview.h"
 #include "fetch/fetchmanager.h"
 #include "fetch/fetcherinitializer.h"
 #include "cite/actionmanager.h"
 #include "config/tellico_config.h"
 #include "core/netaccess.h"
 #include "dbusinterface.h"
 #include "models/models.h"
 #include "models/entryiconmodel.h"
 #include "models/entryselectionmodel.h"
 #include "newstuff/manager.h"
 #include "gui/drophandler.h"
 #include "gui/stringmapdialog.h"
 #include "gui/lineedit.h"
 #include "gui/statusbar.h"
 #include "gui/tabwidget.h"
 #include "gui/dockwidget.h"
 #include "utils/cursorsaver.h"
 #include "utils/guiproxy.h"
 #include "tellico_debug.h"
 
 #include <KComboBox>
 #include <KToolBar>
 #include <KLocalizedString>
 #include <KConfig>
 #include <KStandardAction>
 #include <KWindowSystem>
 #include <KWindowConfig>
 #include <KHTMLView>
 #include <KMessageBox>
 #include <KTipDialog>
 #include <KRecentDocument>
 #include <KRecentDirs>
 #include <KEditToolBar>
 #include <KShortcutsDialog>
 #include <KRecentFilesAction>
 #include <KToggleAction>
 #include <KActionCollection>
 #include <KActionMenu>
 #include <KAboutData>
 #include <KFileWidget>
 #include <KDualAction>
 #include <KXMLGUIFactory>
 
 #include <QApplication>
 #include <QUndoStack>
 #include <QAction>
 #include <QSignalMapper>
 #include <QTimer>
 #include <QMetaObject> // needed for copy, cut, paste slots
 #include <QMimeDatabase>
 #include <QMimeType>
 #include <QMenuBar>
 #include <QFileDialog>
 
 #include <unistd.h>
 
 namespace {
   static const int MAIN_WINDOW_MIN_WIDTH = 600;
   static const int MAX_IMAGES_WARN_PERFORMANCE = 200;
 
 QIcon mimeIcon(const char* s) {
   QMimeDatabase db;
   QMimeType ptr = db.mimeTypeForName(QLatin1String(s));
   if(!ptr.isValid()) {
     myDebug() << "*** no icon for" << s;
   }
   return ptr.isValid() ? QIcon::fromTheme(ptr.iconName()) : QIcon();
 }
 
 QIcon mimeIcon(const char* s1, const char* s2) {
   QMimeDatabase db;
   QMimeType ptr = db.mimeTypeForName(QLatin1String(s1));
   if(!ptr.isValid()) {
     ptr = db.mimeTypeForName(QLatin1String(s2));
     if(!ptr.isValid()) {
       myDebug() << "*** no icon for" << s1 << "or" << s2;
     }
   }
   return ptr.isValid() ? QIcon::fromTheme(ptr.iconName()) : QIcon();
 }
 
 }
 
 using namespace Tellico;
 using Tellico::MainWindow;
 
 MainWindow::MainWindow(QWidget* parent_/*=0*/) : KXmlGuiWindow(parent_),
     m_updateAll(nullptr),
     m_statusBar(nullptr),
     m_editDialog(nullptr),
     m_groupView(nullptr),
     m_filterView(nullptr),
     m_loanView(nullptr),
     m_configDlg(nullptr),
     m_filterDlg(nullptr),
     m_collFieldsDlg(nullptr),
     m_stringMacroDlg(nullptr),
     m_bibtexKeyDlg(nullptr),
     m_fetchDlg(nullptr),
     m_reportDlg(nullptr),
     m_queuedFilters(0),
     m_initialized(false),
     m_newDocument(true),
     m_dontQueueFilter(false),
     m_savingImageLocationChange(false) {
 
   Controller::init(this); // the only time this is ever called!
   // has to be after controller init
   Kernel::init(this); // the only time this is ever called!
   GUI::Proxy::setMainWidget(this);
 
   setWindowIcon(QIcon::fromTheme(QStringLiteral("tellico"),
                                  QIcon(QLatin1String(":/icons/tellico"))));
 
   // initialize the status bar and progress bar
   initStatusBar();
 
   // initialize all the collection types
   // which must be done before the document is created
   CollectionInitializer initCollections;
   // register all the fetcher types
   Fetch::FetcherInitializer initFetchers;
 
   // create a document, which also creates an empty book collection
   // must be done before the different widgets are created
   initDocument();
 
   // set up all the actions, some connect to the document, so this must be after initDocument()
   initActions();
 
   // create the different widgets in the view, some widgets connect to actions, so must be after initActions()
   initView();
 
   // The edit dialog is not created until after the main window is initialized, so it can be a child.
   // So don't make any connections, don't read options for it until initFileOpen
   readOptions();
 
   setAcceptDrops(true);
   DropHandler* drophandler = new DropHandler(this);
   installEventFilter(drophandler);
 
   new ApplicationInterface(this);
   new CollectionInterface(this);
 
   MARK_LINE;
-  QTimer::singleShot(0, this, SLOT(slotInit()));
+  QTimer::singleShot(0, this, &MainWindow::slotInit);
 }
 
 MainWindow::~MainWindow() {
   qDeleteAll(m_fetchActions);
   m_fetchActions.clear();
 }
 
 void MainWindow::slotInit() {
   MARK;
   // if the edit dialog exists, we know we've already called this function
   if(m_editDialog) {
     return;
   }
 
   m_editDialog = new EntryEditDialog(this);
   Controller::self()->addObserver(m_editDialog);
 
   m_toggleEntryEditor->setChecked(Config::showEditWidget());
   slotToggleEntryEditor();
   m_lockLayout->setActive(Config::lockLayout());
 
   initConnections();
-  connect(ImageFactory::self(), SIGNAL(imageLocationMismatch()),
-          SLOT(slotImageLocationMismatch()));
+  connect(ImageFactory::self(), &ImageFactory::imageLocationMismatch,
+          this, &MainWindow::slotImageLocationMismatch);
   // Init DBUS
   NewStuff::Manager::self();
 }
 
 void MainWindow::initStatusBar() {
   MARK;
   m_statusBar = new Tellico::StatusBar(this);
   setStatusBar(m_statusBar);
 }
 
 void MainWindow::initActions() {
   MARK;
   /*************************************************
    * File->New menu
    *************************************************/
   QSignalMapper* collectionMapper = new QSignalMapper(this);
-  connect(collectionMapper, SIGNAL(mapped(int)),
-          this, SLOT(slotFileNew(int)));
+  void (QSignalMapper::* mappedInt)(int) = &QSignalMapper::mapped;
+  connect(collectionMapper, mappedInt,
+          this, &MainWindow::slotFileNew);
 
   KActionMenu* fileNewMenu = new KActionMenu(i18n("New"), this);
   fileNewMenu->setIcon(QIcon::fromTheme(QStringLiteral("document-new")));
   fileNewMenu->setToolTip(i18n("Create a new collection"));
   fileNewMenu->setDelayed(false);
   actionCollection()->addAction(QStringLiteral("file_new_collection"), fileNewMenu);
 
   QAction* action;
 
+  void (QSignalMapper::* mapVoid)() = &QSignalMapper::map;
 #define COLL_ACTION(TYPE, NAME, TEXT, TIP, ICON) \
-  action = actionCollection()->addAction(QStringLiteral(NAME), collectionMapper, SLOT(map())); \
+  action = actionCollection()->addAction(QStringLiteral(NAME), collectionMapper, mapVoid); \
   action->setText(TEXT); \
   action->setToolTip(TIP); \
   action->setIcon(QIcon(QStringLiteral(":/icons/" ICON))); \
   fileNewMenu->addAction(action); \
   collectionMapper->setMapping(action, Data::Collection::TYPE);
 
   COLL_ACTION(Book, "new_book_collection", i18n("New &Book Collection"),
               i18n("Create a new book collection"), "book");
 
   COLL_ACTION(Bibtex, "new_bibtex_collection", i18n("New B&ibliography"),
               i18n("Create a new bibtex bibliography"), "bibtex");
 
   COLL_ACTION(ComicBook, "new_comic_book_collection", i18n("New &Comic Book Collection"),
               i18n("Create a new comic book collection"), "comic");
 
   COLL_ACTION(Video, "new_video_collection", i18n("New &Video Collection"),
               i18n("Create a new video collection"), "video");
 
   COLL_ACTION(Album, "new_music_collection", i18n("New &Music Collection"),
               i18n("Create a new music collection"), "album");
 
   COLL_ACTION(Coin, "new_coin_collection", i18n("New C&oin Collection"),
               i18n("Create a new coin collection"), "coin");
 
   COLL_ACTION(Stamp, "new_stamp_collection", i18n("New &Stamp Collection"),
               i18n("Create a new stamp collection"), "stamp");
 
   COLL_ACTION(Card, "new_card_collection", i18n("New C&ard Collection"),
               i18n("Create a new trading card collection"), "card");
 
   COLL_ACTION(Wine, "new_wine_collection", i18n("New &Wine Collection"),
               i18n("Create a new wine collection"), "wine");
 
   COLL_ACTION(Game, "new_game_collection", i18n("New &Game Collection"),
               i18n("Create a new game collection"), "game");
 
   COLL_ACTION(BoardGame, "new_boardgame_collection", i18n("New Boa&rd Game Collection"),
               i18n("Create a new board game collection"), "boardgame");
 
   COLL_ACTION(File, "new_file_catalog", i18n("New &File Catalog"),
               i18n("Create a new file catalog"), "file");
 
-  action = actionCollection()->addAction(QStringLiteral("new_custom_collection"), collectionMapper, SLOT(map()));
+  action = actionCollection()->addAction(QStringLiteral("new_custom_collection"), collectionMapper, mapVoid);
   action->setText(i18n("New C&ustom Collection"));
   action->setToolTip(i18n("Create a new custom collection"));
   action->setIcon(QIcon::fromTheme(QStringLiteral("document-new")));
   fileNewMenu->addAction(action);
   collectionMapper->setMapping(action, Data::Collection::Base);
 
 #undef COLL_ACTION
 
   /*************************************************
    * File menu
    *************************************************/
   action = KStandardAction::open(this, SLOT(slotFileOpen()), actionCollection());
   action->setToolTip(i18n("Open an existing document"));
   m_fileOpenRecent = KStandardAction::openRecent(this, SLOT(slotFileOpenRecent(const QUrl&)), actionCollection());
   m_fileOpenRecent->setToolTip(i18n("Open a recently used file"));
   m_fileSave = KStandardAction::save(this, SLOT(slotFileSave()), actionCollection());
   m_fileSave->setToolTip(i18n("Save the document"));
   action = KStandardAction::saveAs(this, SLOT(slotFileSaveAs()), actionCollection());
   action->setToolTip(i18n("Save the document as a different file..."));
   action = KStandardAction::print(this, SLOT(slotFilePrint()), actionCollection());
   {
     KHTMLPart w;
     // KHTMLPart printing was broken in KDE until KHTML 5.16
     const QString version =  w.componentData().version();
     const uint major = version.section(QLatin1Char('.'), 0, 0).toUInt();
     const uint minor = version.section(QLatin1Char('.'), 1, 1).toUInt();
     if(major == 5 && minor < 16) {
       myWarning() << "Printing is broken for KDE Frameworks < 5.16. Please upgrade";
       action->setEnabled(false);
     }
   }
 
   action->setToolTip(i18n("Print the contents of the document..."));
   action = KStandardAction::quit(this, SLOT(slotFileQuit()), actionCollection());
   action->setToolTip(i18n("Quit the application"));
 
 /**************** Import Menu ***************************/
 
   QSignalMapper* importMapper = new QSignalMapper(this);
-  connect(importMapper, SIGNAL(mapped(int)),
-          this, SLOT(slotFileImport(int)));
+  connect(importMapper, mappedInt,
+          this, &MainWindow::slotFileImport);
 
   KActionMenu* importMenu = new KActionMenu(i18n("&Import"), this);
   importMenu->setIcon(QIcon::fromTheme(QStringLiteral("document-import")));
   importMenu->setToolTip(i18n("Import the collection data from other formats"));
   importMenu->setDelayed(false);
   actionCollection()->addAction(QStringLiteral("file_import"), importMenu);
 
 #define IMPORT_ACTION(TYPE, NAME, TEXT, TIP, ICON) \
-  action = actionCollection()->addAction(QStringLiteral(NAME), importMapper, SLOT(map())); \
+  action = actionCollection()->addAction(QStringLiteral(NAME), importMapper, mapVoid); \
   action->setText(TEXT); \
   action->setToolTip(TIP); \
   action->setIcon(ICON); \
   importMenu->addAction(action); \
   importMapper->setMapping(action, TYPE);
 
   IMPORT_ACTION(Import::TellicoXML, "file_import_tellico", i18n("Import Tellico Data..."),
                 i18n("Import another Tellico data file"),
                 QIcon::fromTheme(QStringLiteral("tellico"), QIcon(QLatin1String(":/icons/tellico"))));
 
   IMPORT_ACTION(Import::CSV, "file_import_csv", i18n("Import CSV Data..."),
                 i18n("Import a CSV file"), mimeIcon("text/csv", "text/x-csv"));
 
   IMPORT_ACTION(Import::MODS, "file_import_mods", i18n("Import MODS Data..."),
                 i18n("Import a MODS data file"), mimeIcon("text/xml"));
 
   IMPORT_ACTION(Import::Alexandria, "file_import_alexandria", i18n("Import Alexandria Data..."),
                 i18n("Import data from the Alexandria book collection manager"),
                 QIcon::fromTheme(QStringLiteral("alexandria"), QIcon(QLatin1String(":/icons/alexandria"))));
 
   IMPORT_ACTION(Import::Delicious, "file_import_delicious", i18n("Import Delicious Library Data..."),
                 i18n("Import data from Delicious Library"),
                 QIcon::fromTheme(QStringLiteral("deliciouslibrary"), QIcon(QLatin1String(":/icons/deliciouslibrary"))));
 
   IMPORT_ACTION(Import::Referencer, "file_import_referencer", i18n("Import Referencer Data..."),
                 i18n("Import data from Referencer"),
                 QIcon::fromTheme(QStringLiteral("referencer"), QIcon(QLatin1String(":/icons/referencer"))));
 
   IMPORT_ACTION(Import::Bibtex, "file_import_bibtex", i18n("Import Bibtex Data..."),
                 i18n("Import a bibtex bibliography file"), mimeIcon("text/x-bibtex"));
 
   IMPORT_ACTION(Import::Bibtexml, "file_import_bibtexml", i18n("Import Bibtexml Data..."),
                 i18n("Import a Bibtexml bibliography file"), mimeIcon("text/xml"));
 
   IMPORT_ACTION(Import::RIS, "file_import_ris", i18n("Import RIS Data..."),
                 i18n("Import an RIS reference file"), QIcon::fromTheme(QStringLiteral(":/icons/cite")));
 
   IMPORT_ACTION(Import::Goodreads, "file_import_goodreads", i18n("Import Goodreads Collection..."),
                 i18n("Import a collection from Goodreads.com"), QIcon::fromTheme(QStringLiteral(":/icons/goodreads")));
 
   IMPORT_ACTION(Import::PDF, "file_import_pdf", i18n("Import PDF File..."),
                 i18n("Import a PDF file"), mimeIcon("application/pdf"));
 
   IMPORT_ACTION(Import::AudioFile, "file_import_audiofile", i18n("Import Audio File Metadata..."),
                 i18n("Import meta-data from audio files"), mimeIcon("audio/mp3", "audio/x-mp3"));
 #ifndef HAVE_TAGLIB
   action->setEnabled(false);
 #endif
 
   IMPORT_ACTION(Import::FreeDB, "file_import_freedb", i18n("Import Audio CD Data..."),
                 i18n("Import audio CD information"), mimeIcon("media/audiocd", "application/x-cda"));
 #if !defined (HAVE_KCDDB) && !defined (HAVE_KF5KCDDB)
   action->setEnabled(false);
 #endif
 
   IMPORT_ACTION(Import::GCstar, "file_import_gcstar", i18n("Import GCstar Data..."),
                 i18n("Import a GCstar data file"),
                 QIcon::fromTheme(QStringLiteral("gcstar"), QIcon(QLatin1String(":/icons/gcstar"))));
 
   IMPORT_ACTION(Import::Griffith, "file_import_griffith", i18n("Import Griffith Data..."),
                 i18n("Import a Griffith database"),
                 QIcon::fromTheme(QStringLiteral("griffith"), QIcon(QLatin1String(":/icons/griffith"))));
 
   IMPORT_ACTION(Import::AMC, "file_import_amc", i18n("Import Ant Movie Catalog Data..."),
                 i18n("Import an Ant Movie Catalog data file"),
                 QIcon::fromTheme(QStringLiteral("amc"), QIcon(QLatin1String(":/icons/amc"))));
 
   IMPORT_ACTION(Import::BoardGameGeek, "file_import_boardgamegeek", i18n("Import BoardGameGeek Collection..."),
                 i18n("Import a collection from BoardGameGeek.com"), QIcon(QLatin1String(":/icons/boardgamegeek")));
 
   IMPORT_ACTION(Import::VinoXML, "file_import_vinoxml", i18n("Import VinoXML..."),
                 i18n("Import VinoXML data"), QIcon(QLatin1String(":/icons/vinoxml")));
 
   IMPORT_ACTION(Import::FileListing, "file_import_filelisting", i18n("Import File Listing..."),
                 i18n("Import information about files in a folder"), mimeIcon("inode/directory"));
 
   IMPORT_ACTION(Import::XSLT, "file_import_xslt", i18n("Import XSL Transform..."),
                 i18n("Import using an XSL Transform"), mimeIcon("application/xslt+xml", "text/x-xslt"));
 
 #undef IMPORT_ACTION
 
 /**************** Export Menu ***************************/
 
   QSignalMapper* exportMapper = new QSignalMapper(this);
-  connect(exportMapper, SIGNAL(mapped(int)),
-          this, SLOT(slotFileExport(int)));
+  connect(exportMapper, mappedInt,
+          this, &MainWindow::slotFileExport);
 
   KActionMenu* exportMenu = new KActionMenu(i18n("&Export"), this);
   exportMenu->setIcon(QIcon::fromTheme(QStringLiteral("document-export")));
   exportMenu->setToolTip(i18n("Export the collection data to other formats"));
   exportMenu->setDelayed(false);
   actionCollection()->addAction(QStringLiteral("file_export"), exportMenu);
 
 #define EXPORT_ACTION(TYPE, NAME, TEXT, TIP, ICON) \
-  action = actionCollection()->addAction(QStringLiteral(NAME), exportMapper, SLOT(map())); \
+  action = actionCollection()->addAction(QStringLiteral(NAME), exportMapper, mapVoid); \
   action->setText(TEXT); \
   action->setToolTip(TIP); \
   action->setIcon(ICON); \
   exportMenu->addAction(action); \
   exportMapper->setMapping(action, TYPE);
 
   EXPORT_ACTION(Export::TellicoXML, "file_export_xml", i18n("Export to XML..."),
                 i18n("Export to a Tellico XML file"),
                 QIcon::fromTheme(QStringLiteral("tellico"), QIcon(QStringLiteral(":/icons/tellico"))));
 
   EXPORT_ACTION(Export::TellicoZip, "file_export_zip", i18n("Export to Zip..."),
                 i18n("Export to a Tellico Zip file"),
                 QIcon::fromTheme(QStringLiteral("tellico"), QIcon(QStringLiteral(":/icons/tellico"))));
 
   EXPORT_ACTION(Export::HTML, "file_export_html", i18n("Export to HTML..."),
                 i18n("Export to an HTML file"), mimeIcon("text/html"));
 
   EXPORT_ACTION(Export::CSV, "file_export_csv", i18n("Export to CSV..."),
                 i18n("Export to a comma-separated values file"), mimeIcon("text/csv", "text/x-csv"));
 
   EXPORT_ACTION(Export::Alexandria, "file_export_alexandria", i18n("Export to Alexandria..."),
                 i18n("Export to an Alexandria library"),
                 QIcon::fromTheme(QStringLiteral("alexandria"), QIcon(QStringLiteral(":/icons/alexandria"))));
 
   EXPORT_ACTION(Export::Bibtex, "file_export_bibtex", i18n("Export to Bibtex..."),
                 i18n("Export to a bibtex file"), mimeIcon("text/x-bibtex"));
 
   EXPORT_ACTION(Export::Bibtexml, "file_export_bibtexml", i18n("Export to Bibtexml..."),
                 i18n("Export to a Bibtexml file"), mimeIcon("text/xml"));
 
   EXPORT_ACTION(Export::ONIX, "file_export_onix", i18n("Export to ONIX..."),
                 i18n("Export to an ONIX file"), mimeIcon("text/xml"));
 
   EXPORT_ACTION(Export::GCstar, "file_export_gcstar", i18n("Export to GCstar..."),
                 i18n("Export to a GCstar data file"),
                 QIcon::fromTheme(QStringLiteral("gcstar"), QIcon(QStringLiteral(":/icons/gcstar"))));
 
   EXPORT_ACTION(Export::XSLT, "file_export_xslt", i18n("Export XSL Transform..."),
                 i18n("Export using an XSL Transform"), mimeIcon("application/xslt+xml", "text/x-xslt"));
 
 #undef EXPORT_ACTION
 
   /*************************************************
    * Edit menu
    *************************************************/
   KStandardAction::undo(Kernel::self()->commandHistory(), SLOT(undo()), actionCollection());
   KStandardAction::redo(Kernel::self()->commandHistory(), SLOT(undo()), actionCollection());
 
   action = KStandardAction::cut(this, SLOT(slotEditCut()), actionCollection());
   action->setToolTip(i18n("Cut the selected text and puts it in the clipboard"));
   action = KStandardAction::copy(this, SLOT(slotEditCopy()), actionCollection());
   action->setToolTip(i18n("Copy the selected text to the clipboard"));
   action = KStandardAction::paste(this, SLOT(slotEditPaste()), actionCollection());
   action->setToolTip(i18n("Paste the clipboard contents"));
   action = KStandardAction::selectAll(this, SLOT(slotEditSelectAll()), actionCollection());
   action->setToolTip(i18n("Select all the entries in the collection"));
   action = KStandardAction::deselect(this, SLOT(slotEditDeselect()), actionCollection());
   action->setToolTip(i18n("Deselect all the entries in the collection"));
 
   action = actionCollection()->addAction(QStringLiteral("edit_search_internet"), this, SLOT(slotShowFetchDialog()));
   action->setText(i18n("Internet Search..."));
   action->setIconText(i18n("Search"));  // find a better word for this?
   action->setIcon(QIcon::fromTheme(QStringLiteral("tools-wizard")));
   actionCollection()->setDefaultShortcut(action, Qt::CTRL + Qt::Key_I);
   action->setToolTip(i18n("Search the internet..."));
 
   action = actionCollection()->addAction(QStringLiteral("filter_dialog"), this, SLOT(slotShowFilterDialog()));
   action->setText(i18n("Advanced &Filter..."));
   action->setIconText(i18n("Filter"));
   action->setIcon(QIcon::fromTheme(QStringLiteral("view-filter")));
   actionCollection()->setDefaultShortcut(action, Qt::CTRL + Qt::Key_J);
   action->setToolTip(i18n("Filter the collection"));
 
   /*************************************************
    * Collection menu
    *************************************************/
   m_newEntry = actionCollection()->addAction(QStringLiteral("coll_new_entry"),
                                              this, SLOT(slotNewEntry()));
   m_newEntry->setText(i18n("&New Entry..."));
   m_newEntry->setIcon(QIcon::fromTheme(QStringLiteral("document-new")));
   m_newEntry->setIconText(i18n("New"));
   actionCollection()->setDefaultShortcut(m_newEntry, Qt::CTRL + Qt::Key_N);
   m_newEntry->setToolTip(i18n("Create a new entry"));
 
   m_editEntry = actionCollection()->addAction(QStringLiteral("coll_edit_entry"),
                                               this, SLOT(slotShowEntryEditor()));
   m_editEntry->setText(i18n("&Edit Entry..."));
   m_editEntry->setIcon(QIcon::fromTheme(QStringLiteral("document-properties")));
   actionCollection()->setDefaultShortcut(m_editEntry, Qt::CTRL + Qt::Key_E);
   m_editEntry->setToolTip(i18n("Edit the selected entries"));
 
   m_copyEntry = actionCollection()->addAction(QStringLiteral("coll_copy_entry"),
                                               Controller::self(), SLOT(slotCopySelectedEntries()));
   m_copyEntry->setText(i18n("D&uplicate Entry"));
   m_copyEntry->setIcon(QIcon::fromTheme(QStringLiteral("edit-copy")));
   actionCollection()->setDefaultShortcut(m_copyEntry, Qt::CTRL + Qt::Key_Y);
   m_copyEntry->setToolTip(i18n("Copy the selected entries"));
 
   m_deleteEntry = actionCollection()->addAction(QStringLiteral("coll_delete_entry"),
                                                 Controller::self(), SLOT(slotDeleteSelectedEntries()));
   m_deleteEntry->setText(i18n("&Delete Entry"));
   m_deleteEntry->setIcon(QIcon::fromTheme(QStringLiteral("edit-delete")));
   actionCollection()->setDefaultShortcut(m_deleteEntry, Qt::CTRL + Qt::Key_D);
   m_deleteEntry->setToolTip(i18n("Delete the selected entries"));
 
   m_mergeEntry = actionCollection()->addAction(QStringLiteral("coll_merge_entry"),
                                                Controller::self(), SLOT(slotMergeSelectedEntries()));
   m_mergeEntry->setText(i18n("&Merge Entries"));
   m_mergeEntry->setIcon(QIcon::fromTheme(QStringLiteral("document-import")));
 //  CTRL+G is ambiguous, pick another
 //  actionCollection()->setDefaultShortcut(m_mergeEntry, Qt::CTRL + Qt::Key_G);
   m_mergeEntry->setToolTip(i18n("Merge the selected entries"));
   m_mergeEntry->setEnabled(false); // gets enabled when more than 1 entry is selected
 
   m_checkOutEntry = actionCollection()->addAction(QStringLiteral("coll_checkout"), Controller::self(), SLOT(slotCheckOut()));
   m_checkOutEntry->setText(i18n("Check-&out..."));
   m_checkOutEntry->setIcon(QIcon::fromTheme(QStringLiteral("arrow-up-double")));
   m_checkOutEntry->setToolTip(i18n("Check-out the selected items"));
 
   m_checkInEntry = actionCollection()->addAction(QStringLiteral("coll_checkin"), Controller::self(), SLOT(slotCheckIn()));
   m_checkInEntry->setText(i18n("Check-&in"));
   m_checkInEntry->setIcon(QIcon::fromTheme(QStringLiteral("arrow-down-double")));
   m_checkInEntry->setToolTip(i18n("Check-in the selected items"));
 
   action = actionCollection()->addAction(QStringLiteral("coll_rename_collection"), this, SLOT(slotRenameCollection()));
   action->setText(i18n("&Rename Collection..."));
   action->setIcon(QIcon::fromTheme(QStringLiteral("edit-rename")));
   actionCollection()->setDefaultShortcut(action, Qt::CTRL + Qt::Key_R);
   action->setToolTip(i18n("Rename the collection"));
 
   action = actionCollection()->addAction(QStringLiteral("coll_fields"), this, SLOT(slotShowCollectionFieldsDialog()));
   action->setText(i18n("Collection &Fields..."));
   action->setIconText(i18n("Fields"));
   action->setIcon(QIcon::fromTheme(QStringLiteral("preferences-other")));
   actionCollection()->setDefaultShortcut(action, Qt::CTRL + Qt::Key_U);
   action->setToolTip(i18n("Modify the collection fields"));
 
   action = actionCollection()->addAction(QStringLiteral("coll_reports"), this, SLOT(slotShowReportDialog()));
   action->setText(i18n("&Generate Reports..."));
   action->setIconText(i18n("Reports"));
   action->setIcon(QIcon::fromTheme(QStringLiteral("text-rdf")));
   action->setToolTip(i18n("Generate collection reports"));
 
   action = actionCollection()->addAction(QStringLiteral("coll_convert_bibliography"), this, SLOT(slotConvertToBibliography()));
   action->setText(i18n("Convert to &Bibliography"));
   action->setIcon(QIcon(QLatin1String(":/icons/bibtex")));
   action->setToolTip(i18n("Convert a book collection to a bibliography"));
 
   action = actionCollection()->addAction(QStringLiteral("coll_string_macros"), this, SLOT(slotShowStringMacroDialog()));
   action->setText(i18n("String &Macros..."));
   action->setIcon(QIcon::fromTheme(QStringLiteral("view-list-text")));
   action->setToolTip(i18n("Edit the bibtex string macros"));
 
   action = actionCollection()->addAction(QStringLiteral("coll_key_manager"), this, SLOT(slotShowBibtexKeyDialog()));
   action->setText(i18n("Check for Duplicate Keys..."));
   action->setIcon(mimeIcon("text/x-bibtex"));
   action->setToolTip(i18n("Check for duplicate citation keys"));
 
   QSignalMapper* citeMapper = new QSignalMapper(this);
-  connect(citeMapper, SIGNAL(mapped(int)),
-          this, SLOT(slotCiteEntry(int)));
+  connect(citeMapper, mappedInt,
+          this, &MainWindow::slotCiteEntry);
 
-  action = actionCollection()->addAction(QStringLiteral("cite_clipboard"), citeMapper, SLOT(map()));
+  action = actionCollection()->addAction(QStringLiteral("cite_clipboard"), citeMapper, mapVoid);
   action->setText(i18n("Copy Bibtex to Cli&pboard"));
   action->setToolTip(i18n("Copy bibtex citations to the clipboard"));
   action->setIcon(QIcon::fromTheme(QStringLiteral("edit-paste")));
   citeMapper->setMapping(action, Cite::CiteClipboard);
 
-  action = actionCollection()->addAction(QStringLiteral("cite_lyxpipe"), citeMapper, SLOT(map()));
+  action = actionCollection()->addAction(QStringLiteral("cite_lyxpipe"), citeMapper, mapVoid);
   action->setText(i18n("Cite Entry in &LyX"));
   action->setToolTip(i18n("Cite the selected entries in LyX"));
   action->setIcon(QIcon::fromTheme(QStringLiteral("lyx"), QIcon(QLatin1String(":/icons/lyx"))));
   citeMapper->setMapping(action, Cite::CiteLyxpipe);
 
   m_updateMapper = new QSignalMapper(this);
-  connect(m_updateMapper, SIGNAL(mapped(const QString&)),
-          Controller::self(), SLOT(slotUpdateSelectedEntries(const QString&)));
+  void (QSignalMapper::* mappedString)(const QString&) = &QSignalMapper::mapped;
+  connect(m_updateMapper, mappedString,
+          Controller::self(), &Controller::slotUpdateSelectedEntries);
 
   m_updateEntryMenu = new KActionMenu(i18n("&Update Entry"), this);
   m_updateEntryMenu->setIcon(QIcon::fromTheme(QStringLiteral("document-export")));
   m_updateEntryMenu->setIconText(i18nc("Update Entry", "Update"));
   m_updateEntryMenu->setDelayed(false);
   actionCollection()->addAction(QStringLiteral("coll_update_entry"), m_updateEntryMenu);
 
-  m_updateAll = actionCollection()->addAction(QStringLiteral("update_entry_all"), m_updateMapper, SLOT(map()));
+  m_updateAll = actionCollection()->addAction(QStringLiteral("update_entry_all"), m_updateMapper, mapVoid);
   m_updateAll->setText(i18n("All Sources"));
   m_updateAll->setToolTip(i18n("Update entry data from all available sources"));
   m_updateMapper->setMapping(m_updateAll, QStringLiteral("_all"));
 
   /*************************************************
    * Settings menu
    *************************************************/
   setStandardToolBarMenuEnabled(true);
   createStandardStatusBarAction();
 
   m_lockLayout = new KDualAction(this);
-  connect(m_lockLayout, SIGNAL(activeChanged(bool)), SLOT(slotToggleLayoutLock(bool)));
+  connect(m_lockLayout, &KDualAction::activeChanged, this, &MainWindow::slotToggleLayoutLock);
   m_lockLayout->setActiveText(i18n("Unlock Layout"));
   m_lockLayout->setActiveToolTip(i18n("Unlock the window's layout"));
   m_lockLayout->setActiveIcon(QIcon::fromTheme(QStringLiteral("object-unlocked")));
   m_lockLayout->setInactiveText(i18n("Lock Layout"));
   m_lockLayout->setInactiveToolTip(i18n("Lock the window's layout"));
   m_lockLayout->setInactiveIcon(QIcon::fromTheme(QStringLiteral("object-locked")));
   actionCollection()->addAction(QStringLiteral("lock_layout"), m_lockLayout);
 
   action = actionCollection()->addAction(QStringLiteral("reset_layout"), this, SLOT(slotResetLayout()));
   action->setText(i18n("Reset Layout"));
   action->setToolTip(i18n("Reset the window's layout"));
   action->setIcon(QIcon::fromTheme(QStringLiteral("resetview")));
 
   m_toggleEntryEditor = new KToggleAction(i18n("Entry &Editor"), this);
-  connect(m_toggleEntryEditor, SIGNAL(triggered()), SLOT(slotToggleEntryEditor()));
+  connect(m_toggleEntryEditor, &QAction::triggered, this, &MainWindow::slotToggleEntryEditor);
   m_toggleEntryEditor->setToolTip(i18n("Enable/disable the editor"));
   actionCollection()->addAction(QStringLiteral("toggle_edit_widget"), m_toggleEntryEditor);
 
   KStandardAction::preferences(this, SLOT(slotShowConfigDialog()), actionCollection());
 
   /*************************************************
    * Help menu
    *************************************************/
   KStandardAction::tipOfDay(this, SLOT(slotShowTipOfDay()), actionCollection());
 
   /*************************************************
    * Short cuts
    *************************************************/
   KStandardAction::fullScreen(this, SLOT(slotToggleFullScreen()), this, actionCollection());
   KStandardAction::showMenubar(this, SLOT(slotToggleMenuBarVisibility()), actionCollection());
 
   /*************************************************
    * Collection Toolbar
    *************************************************/
   action = actionCollection()->addAction(QStringLiteral("change_entry_grouping_accel"), this, SLOT(slotGroupLabelActivated()));
   action->setText(i18n("Change Grouping"));
   actionCollection()->setDefaultShortcut(action, Qt::CTRL + Qt::Key_G);
 
   m_entryGrouping = new KSelectAction(i18n("&Group Selection"), this);
   m_entryGrouping->setToolTip(i18n("Change the grouping of the collection"));
-  // really bad hack, but I can't figure out how to make the combobox resize when the contents change
-  // see note in slotUpdateCollectionToolBar() - found a hackier solution
-//  m_entryGrouping->addAction(QString(50, QLatin1Char(' ')));
-  connect(m_entryGrouping, SIGNAL(triggered(int)), SLOT(slotChangeGrouping()));
+  void (KSelectAction::* triggeredInt)(int) = &KSelectAction::triggered;
+  connect(m_entryGrouping, triggeredInt, this, &MainWindow::slotChangeGrouping);
   actionCollection()->addAction(QStringLiteral("change_entry_grouping"), m_entryGrouping);
 
   action = actionCollection()->addAction(QStringLiteral("quick_filter_accel"), this, SLOT(slotFilterLabelActivated()));
   action->setText(i18n("Filter"));
   actionCollection()->setDefaultShortcut(action, Qt::CTRL + Qt::Key_F);
 
   m_quickFilter = new GUI::LineEdit(this);
   m_quickFilter->setPlaceholderText(i18n("Filter here...")); // same text as kdepim and amarok
   m_quickFilter->setClearButtonEnabled(true);
   // same as Dolphin text edit
   m_quickFilter->setMinimumWidth(150);
   m_quickFilter->setMaximumWidth(300);
   // want to update every time the filter text changes
-  connect(m_quickFilter, SIGNAL(textChanged(const QString&)),
-          this, SLOT(slotQueueFilter()));
-  connect(m_quickFilter, SIGNAL(clearButtonClicked()),
-          this, SLOT(slotClearFilter()));
+  connect(m_quickFilter, &QLineEdit::textChanged,
+          this, &MainWindow::slotQueueFilter);
+  connect(m_quickFilter, &KLineEdit::clearButtonClicked,
+          this, &MainWindow::slotClearFilter);
   m_quickFilter->installEventFilter(this); // intercept keyEvents
 
   QWidgetAction* widgetAction = new QWidgetAction(this);
   widgetAction->setDefaultWidget(m_quickFilter);
   widgetAction->setText(i18n("Filter"));
   widgetAction->setToolTip(i18n("Filter the collection"));
   widgetAction->setProperty("isShortcutConfigurable", false);
   actionCollection()->addAction(QStringLiteral("quick_filter"), widgetAction);
 
   // final GUI setup is in initView()
 }
 
 #undef mimeIcon
 
 void MainWindow::initDocument() {
   MARK;
   Data::Document* doc = Data::Document::self();
   Kernel::self()->resetHistory();
 
   KConfigGroup config(KSharedConfig::openConfig(), "General Options");
   doc->setLoadAllImages(config.readEntry("Load All Images", false));
 
   // allow status messages from the document
-  connect(doc, SIGNAL(signalStatusMsg(const QString&)),
-          SLOT(slotStatusMsg(const QString&)));
+  connect(doc, &Data::Document::signalStatusMsg,
+          this, &MainWindow::slotStatusMsg);
 
   // do stuff that changes when the doc is modified
-  connect(doc, SIGNAL(signalModified(bool)),
-          SLOT(slotEnableModifiedActions(bool)));
+  connect(doc, &Data::Document::signalModified,
+          this, &MainWindow::slotEnableModifiedActions);
 
-  connect(doc, SIGNAL(signalCollectionAdded(Tellico::Data::CollPtr)),
-          Controller::self(), SLOT(slotCollectionAdded(Tellico::Data::CollPtr)));
-  connect(doc, SIGNAL(signalCollectionDeleted(Tellico::Data::CollPtr)),
-          Controller::self(), SLOT(slotCollectionDeleted(Tellico::Data::CollPtr)));
+  connect(doc, &Data::Document::signalCollectionAdded,
+          Controller::self(), &Controller::slotCollectionAdded);
+  connect(doc, &Data::Document::signalCollectionDeleted,
+          Controller::self(), &Controller::slotCollectionDeleted);
 
-  connect(Kernel::self()->commandHistory(), SIGNAL(cleanChanged(bool)),
-          doc, SLOT(slotSetClean(bool)));
+  connect(Kernel::self()->commandHistory(), &QUndoStack::cleanChanged,
+          doc, &Data::Document::slotSetClean);
 }
 
 void MainWindow::initView() {
   MARK;
   // initialize the image factory before the entry models are created
   ImageFactory::init();
 
   m_entryView = new EntryView(this);
-  connect(m_entryView, SIGNAL(signalAction(const QUrl&)),
-          SLOT(slotURLAction(const QUrl&)));
+  connect(m_entryView, &EntryView::signalAction,
+          this, &MainWindow::slotURLAction);
   m_entryView->view()->setWhatsThis(i18n("<qt>The <i>Entry View</i> shows a formatted view of the entry's contents.</qt>"));
 
   // trick to make sure the group views always extend along the entire left or right side
   // using QMainWindow::setCorner does not seem to work
   // https://wiki.qt.io/Technical_FAQ#Is_it_possible_for_either_the_left_or_right_dock_areas_to_have_full_height_of_their_side_rather_than_having_the_bottom_take_the_full_width.3F
   m_dummyWindow = new QMainWindow(this);
   m_dummyWindow->setCentralWidget(m_entryView->view());
   m_dummyWindow->setWindowFlags(Qt::Widget);
   setCentralWidget(m_dummyWindow);
 
   m_collectionViewDock = new GUI::DockWidget(i18n("Collection View"), m_dummyWindow);
   m_collectionViewDock->setObjectName(QStringLiteral("collection_dock"));
 
   m_viewStack = new ViewStack(this);
 
   m_detailedView = m_viewStack->listView();
   Controller::self()->addObserver(m_detailedView);
   m_detailedView->setWhatsThis(i18n("<qt>The <i>Column View</i> shows the value of multiple fields "
                                        "for each entry.</qt>"));
-  connect(Data::Document::self(), SIGNAL(signalCollectionImagesLoaded(Tellico::Data::CollPtr)),
-          m_detailedView, SLOT(slotRefreshImages()));
+  connect(Data::Document::self(), &Data::Document::signalCollectionImagesLoaded,
+          m_detailedView, &DetailedListView::slotRefreshImages);
 
   m_iconView = m_viewStack->iconView();
   EntryIconModel* iconModel = new EntryIconModel(m_iconView);
   iconModel->setSourceModel(m_detailedView->model());
   m_iconView->setModel(iconModel);
   Controller::self()->addObserver(m_iconView);
   m_iconView->setWhatsThis(i18n("<qt>The <i>Icon View</i> shows each entry in the collection or group using "
                                 "an icon, which may be an image in the entry.</qt>"));
 
   m_collectionViewDock->setWidget(m_viewStack);
   m_dummyWindow->addDockWidget(Qt::TopDockWidgetArea, m_collectionViewDock);
   actionCollection()->addAction(QStringLiteral("toggle_column_widget"), m_collectionViewDock->toggleViewAction());
 
   m_groupViewDock = new GUI::DockWidget(i18n("Group View"), this);
   m_groupViewDock->setObjectName(QStringLiteral("group_dock"));
   m_groupViewDock->setAllowedAreas(Qt::DockWidgetAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea));
 
   m_viewTabs = new GUI::TabWidget(this);
   m_viewTabs->setTabBarHidden(true);
   m_viewTabs->setDocumentMode(true);
   m_groupView = new GroupView(m_viewTabs);
   Controller::self()->addObserver(m_groupView);
   m_viewTabs->addTab(m_groupView, QIcon::fromTheme(QStringLiteral("folder")), i18n("Groups"));
   m_groupView->setWhatsThis(i18n("<qt>The <i>Group View</i> sorts the entries into groupings "
                                     "based on a selected field.</qt>"));
   m_groupViewDock->setWidget(m_viewTabs);
   addDockWidget(Qt::LeftDockWidgetArea, m_groupViewDock);
   actionCollection()->addAction(QStringLiteral("toggle_group_widget"), m_groupViewDock->toggleViewAction());
 
   EntrySelectionModel* proxySelect = new EntrySelectionModel(m_iconView->model(),
                                                              m_detailedView->selectionModel(),
                                                              this);
   m_iconView->setSelectionModel(proxySelect);
 
   setMinimumWidth(MAIN_WINDOW_MIN_WIDTH);
   // setting up GUI now rather than in initActions
   setupGUI(Keys | ToolBar);
   createGUI();
 }
 
 void MainWindow::initConnections() {
   // have to toggle the menu item if the dialog gets closed
-  connect(m_editDialog, SIGNAL(finished(int)),
-          this, SLOT(slotEditDialogFinished()));
+  connect(m_editDialog, &QDialog::finished,
+          this, &MainWindow::slotEditDialogFinished);
 
   EntrySelectionModel* proxySelect = static_cast<EntrySelectionModel*>(m_iconView->selectionModel());
   connect(proxySelect, &EntrySelectionModel::entriesSelected,
           Controller::self(), &Controller::slotUpdateSelection);
   connect(proxySelect, &EntrySelectionModel::entriesSelected,
           m_editDialog, &EntryEditDialog::setContents);
   connect(proxySelect, &EntrySelectionModel::entriesSelected,
           m_entryView, &EntryView::showEntries);
 
   // let the group view call filters, too
-  connect(m_groupView, SIGNAL(signalUpdateFilter(Tellico::FilterPtr)),
-          this, SLOT(slotUpdateFilter(Tellico::FilterPtr)));
+  connect(m_groupView, &GroupView::signalUpdateFilter,
+          this, &MainWindow::slotUpdateFilter);
   // use the EntrySelectionModel as a proxy so when entries get selected in the group view
   // the edit dialog and entry view are updated
   proxySelect->addSelectionProxy(m_groupView->selectionModel());
 }
 
 void MainWindow::initFileOpen(bool nofile_) {
   MARK;
   slotInit();
   // check to see if most recent file should be opened
   bool happyStart = false;
   if(!nofile_ && Config::reopenLastFile()) {
     // Config::lastOpenFile() is the full URL, protocol included
     QUrl lastFile(Config::lastOpenFile()); // empty string is actually ok, it gets handled
     if(!lastFile.isEmpty() && lastFile.isValid()) {
       slotFileOpen(lastFile);
       happyStart = true;
     }
   }
   if(!happyStart) {
     // the document is created with an initial book collection, continue with that
     Controller::self()->slotCollectionAdded(Data::Document::self()->collection());
 
     m_fileSave->setEnabled(false);
     slotEnableOpenedActions();
     slotEnableModifiedActions(false);
 
     slotEntryCount();
     // tell the entry views and models that there are no images to load
     m_detailedView->slotRefreshImages();
   }
 
   // show welcome text, even when opening an existing collection
   const int type = Kernel::self()->collectionType();
   QString welcomeFile = DataFileRegistry::self()->locate(QStringLiteral("welcome.html"));
   QString text = FileHandler::readTextFile(QUrl::fromLocalFile(welcomeFile));
   text.replace(QLatin1String("$FGCOLOR$"), Config::templateTextColor(type).name());
   text.replace(QLatin1String("$BGCOLOR$"), Config::templateBaseColor(type).name());
   text.replace(QLatin1String("$COLOR1$"),  Config::templateHighlightedTextColor(type).name());
   text.replace(QLatin1String("$COLOR2$"),  Config::templateHighlightedBaseColor(type).name());
   text.replace(QLatin1String("$IMGDIR$"),  QUrl::fromLocalFile(ImageFactory::tempDir()).url());
   text.replace(QLatin1String("$BANNER$"),
                 i18n("Welcome to the Tellico Collection Manager"));
   text.replace(QLatin1String("$WELCOMETEXT$"),
                 i18n("<h3>Tellico is a tool for managing collections of books, "
                     "videos, music, and whatever else you want to catalog.</h3>"
                     "<h3>New entries can be added to your collection by "
                     "<a href=\"tc:///coll_new_entry\">entering data manually</a> or by "
                     "<a href=\"tc:///edit_search_internet\">downloading data</a> from "
                     "various Internet sources.</h3>"));
   m_entryView->showText(text);
 
   m_initialized = true;
 }
 
 // These are general options.
 // The options that can be changed in the "Configuration..." dialog
 // are taken care of by the ConfigDialog object.
 void MainWindow::saveOptions() {
   KConfigGroup config(KSharedConfig::openConfig(), "Main Window Options");
   saveMainWindowSettings(config);
   config.writeEntry(QStringLiteral("Central Dock State"), m_dummyWindow->saveState());
 
   Config::setShowEditWidget(m_toggleEntryEditor->isChecked());
   // check any single dock widget, they all get locked together
   Config::setLockLayout(m_groupViewDock->isLocked());
 
   KConfigGroup filesConfig(KSharedConfig::openConfig(), "Recent Files");
   m_fileOpenRecent->saveEntries(filesConfig);
   if(!isNewDocument()) {
     Config::setLastOpenFile(Data::Document::self()->URL().url());
   }
 
   Config::setViewWidget(m_viewStack->currentWidget());
 
   // historical reasons
   // sorting by count was faked by sorting by phantom second column
   const int sortColumn = m_groupView->sortRole() == RowCountRole ? 1 : 0;
   Config::setGroupViewSortColumn(sortColumn); // ok to use SortColumn key, save semantics
   Config::setGroupViewSortAscending(m_groupView->sortOrder() == Qt::AscendingOrder);
 
   if(m_loanView) {
     const int sortColumn = m_loanView->sortRole() == RowCountRole ? 1 : 0;
     Config::setLoanViewSortAscending(sortColumn); // ok to use SortColumn key, save semantics
     Config::setLoanViewSortAscending(m_loanView->sortOrder() == Qt::AscendingOrder);
   }
 
   if(m_filterView) {
     const int sortColumn = m_filterView->sortRole() == RowCountRole ? 1 : 0;
     Config::setFilterViewSortAscending(sortColumn); // ok to use SortColumn key, save semantics
     Config::setFilterViewSortAscending(m_filterView->sortOrder() == Qt::AscendingOrder);
   }
 
   // this is used in the EntryEditDialog constructor, too
   KConfigGroup editDialogConfig(KSharedConfig::openConfig(), "Edit Dialog Options");
   KWindowConfig::saveWindowSize(m_editDialog->windowHandle(), editDialogConfig);
 
   saveCollectionOptions(Data::Document::self()->collection());
   Config::self()->save();
 }
 
 void MainWindow::readCollectionOptions(Tellico::Data::CollPtr coll_) {
   if(!coll_) {
     myDebug() << "Bad, no collection in MainWindow::readCollectionOptions()";
     return;
   }
   const QString configGroup = QStringLiteral("Options - %1").arg(CollectionFactory::typeName(coll_));
   KConfigGroup group(KSharedConfig::openConfig(), configGroup);
 
   QString defaultGroup = coll_->defaultGroupField();
   QString entryGroup;
   if(coll_->type() != Data::Collection::Base) {
     entryGroup = group.readEntry("Group By", defaultGroup);
   } else {
     QUrl url = Kernel::self()->URL();
     for(int i = 0; i < Config::maxCustomURLSettings(); ++i) {
       QUrl u(group.readEntry(QStringLiteral("URL_%1").arg(i)));
       if(url == u) {
         entryGroup = group.readEntry(QStringLiteral("Group By_%1").arg(i), defaultGroup);
         break;
       }
     }
     // fall back to old setting
     if(entryGroup.isEmpty()) {
       entryGroup = group.readEntry("Group By", defaultGroup);
     }
   }
   if(entryGroup.isEmpty() ||
      (!coll_->entryGroups().contains(entryGroup) && entryGroup != Data::Collection::s_peopleGroupName)) {
     entryGroup = defaultGroup;
   }
   m_groupView->setGroupField(entryGroup);
 
   QString entryXSLTFile = Config::templateName(coll_->type());
   if(entryXSLTFile.isEmpty()) {
     entryXSLTFile = QStringLiteral("Fancy"); // should never happen, but just in case
   }
   m_entryView->setXSLTFile(entryXSLTFile + QLatin1String(".xsl"));
 
   // make sure the right combo element is selected
   slotUpdateCollectionToolBar(coll_);
 }
 
 void MainWindow::saveCollectionOptions(Tellico::Data::CollPtr coll_) {
   // don't save initial collection options, or empty collections
   if(!coll_ || coll_->entryCount() == 0 || isNewDocument()) {
     return;
   }
 
   int configIndex = -1;
   QString configGroup = QStringLiteral("Options - %1").arg(CollectionFactory::typeName(coll_));
   KConfigGroup config(KSharedConfig::openConfig(), configGroup);
   QString groupName;
   if(m_entryGrouping->currentItem() > -1 &&
      static_cast<int>(coll_->entryGroups().count()) > m_entryGrouping->currentItem()) {
     if(m_entryGrouping->currentText() == (QLatin1Char('<') + i18n("People") + QLatin1Char('>'))) {
       groupName = Data::Collection::s_peopleGroupName;
     } else {
       groupName = Kernel::self()->fieldNameByTitle(m_entryGrouping->currentText());
     }
     if(coll_->type() != Data::Collection::Base) {
       config.writeEntry("Group By", groupName);
     }
   }
 
   if(coll_->type() == Data::Collection::Base) {
     // all of this is to have custom settings on a per file basis
     QUrl url = Kernel::self()->URL();
     QList<QUrl> urls = QList<QUrl>() << url;
     QStringList groupBys = QStringList() << groupName;
     for(int i = 0; i < Config::maxCustomURLSettings(); ++i) {
       QUrl u = config.readEntry(QStringLiteral("URL_%1").arg(i), QUrl());
       QString g = config.readEntry(QStringLiteral("Group By_%1").arg(i), QString());
       if(!u.isEmpty() && url != u) {
         urls.append(u);
         groupBys.append(g);
       } else if(!u.isEmpty()) {
         configIndex = i;
       }
     }
     int limit = qMin(urls.count(), Config::maxCustomURLSettings());
     for(int i = 0; i < limit; ++i) {
       config.writeEntry(QStringLiteral("URL_%1").arg(i), urls[i].url());
       config.writeEntry(QStringLiteral("Group By_%1").arg(i), groupBys[i]);
     }
   }
   m_detailedView->saveConfig(coll_, configIndex);
 }
 
 void MainWindow::readOptions() {
   KConfigGroup mainWindowConfig(KSharedConfig::openConfig(), "Main Window Options");
   applyMainWindowSettings(mainWindowConfig);
   m_dummyWindow->restoreState(mainWindowConfig.readEntry(QStringLiteral("Central Dock State"), QByteArray()));
 
   m_viewStack->setCurrentWidget(Config::viewWidget());
   m_iconView->setMaxAllowedIconWidth(Config::maxIconSize());
 
-  connect(toolBar(QStringLiteral("collectionToolBar")), SIGNAL(iconSizeChanged(const QSize&)), SLOT(slotUpdateToolbarIcons()));
+  connect(toolBar(QStringLiteral("collectionToolBar")), &QToolBar::iconSizeChanged, this, &MainWindow::slotUpdateToolbarIcons);
 
   // initialize the recent file list
   KConfigGroup filesConfig(KSharedConfig::openConfig(), "Recent Files");
   m_fileOpenRecent->loadEntries(filesConfig);
 
   // sort by count if column = 1
   int sortRole = Config::groupViewSortColumn() == 0 ? static_cast<int>(Qt::DisplayRole) : static_cast<int>(RowCountRole);
   Qt::SortOrder sortOrder = Config::groupViewSortAscending() ? Qt::AscendingOrder : Qt::DescendingOrder;
   m_groupView->setSorting(sortOrder, sortRole);
 
   BibtexHandler::s_quoteStyle = Config::useBraces() ? BibtexHandler::BRACES : BibtexHandler::QUOTES;
 
   // Don't read any options for the edit dialog here, since it's not yet initialized.
   // Put them in init()
 }
 
 bool MainWindow::querySaveModified() {
   bool completed = true;
 
   if(Data::Document::self()->isModified()) {
     QString str = i18n("The current file has been modified.\n"
                        "Do you want to save it?");
     int want_save = KMessageBox::warningYesNoCancel(this, str, i18n("Unsaved Changes"),
                                                     KStandardGuiItem::save(), KStandardGuiItem::discard());
     switch(want_save) {
       case KMessageBox::Yes:
         completed = fileSave();
         break;
 
       case KMessageBox::No:
-        Data::Document::self()->slotSetModified(false);
+        Data::Document::self()->setModified(false);
         completed = true;
         break;
 
       case KMessageBox::Cancel:
       default:
         completed = false;
         break;
     }
   }
 
   return completed;
 }
 
 bool MainWindow::queryClose() {
   // in case we're still loading the images, cancel that
   Data::Document::self()->cancelImageWriting();
   const bool willClose = m_editDialog->queryModified() && querySaveModified();
   if (willClose) {
     ImageFactory::clean(true);
     saveOptions();
   }
   return willClose;
 }
 
 void MainWindow::slotFileNew(int type_) {
   slotStatusMsg(i18n("Creating new document..."));
 
   // close the fields dialog
   slotHideCollectionFieldsDialog();
 
   if(m_editDialog->queryModified() && querySaveModified()) {
     // remove filter and loan tabs, they'll get re-added if needed
     if(m_filterView) {
       m_viewTabs->removeTab(m_viewTabs->indexOf(m_filterView));
       Controller::self()->removeObserver(m_filterView);
       delete m_filterView;
       m_filterView = nullptr;
     }
     if(m_loanView) {
       m_viewTabs->removeTab(m_viewTabs->indexOf(m_loanView));
       Controller::self()->removeObserver(m_loanView);
       delete m_loanView;
       m_loanView = nullptr;
     }
     m_viewTabs->setTabBarHidden(true);
     Data::Document::self()->newDocument(type_);
     Kernel::self()->resetHistory();
     m_fileOpenRecent->setCurrentItem(-1);
     slotEnableOpenedActions();
     slotEnableModifiedActions(false);
     m_newDocument = true;
     ImageFactory::clean(false);
   }
 
   StatusBar::self()->clearStatus();
 }
 
 void MainWindow::slotFileOpen() {
   slotStatusMsg(i18n("Opening file..."));
 
   if(m_editDialog->queryModified() && querySaveModified()) {
     QString filter = i18n("Tellico Files") + QLatin1String(" (*.tc *.bc)");
     filter += QLatin1String(";;");
     filter += i18n("XML Files") + QLatin1String(" (*.xml)");
     filter += QLatin1String(";;");
     filter += i18n("All Files") + QLatin1String(" (*)");
     // keyword 'open'
     QString fileClass;
     const QUrl startUrl = KFileWidget::getStartUrl(QUrl(QStringLiteral("kfiledialog:///open")), fileClass);
     QUrl url = QFileDialog::getOpenFileUrl(this, i18n("Open File"), startUrl, filter);
     if(!url.isEmpty() && url.isValid()) {
       slotFileOpen(url);
       if(url.isLocalFile()) {
         KRecentDirs::add(fileClass, url.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash).path());
       }
     }
   }
   StatusBar::self()->clearStatus();
 }
 
 void MainWindow::slotFileOpen(const QUrl& url_) {
   slotStatusMsg(i18n("Opening file..."));
 
   // close the fields dialog
   slotHideCollectionFieldsDialog();
 
   // there seems to be a race condition at start between slotInit() and initFileOpen()
   // which means the edit dialog might not have been created yet
   if((!m_editDialog || m_editDialog->queryModified()) && querySaveModified()) {
     if(openURL(url_)) {
       m_fileOpenRecent->addUrl(url_);
       m_fileOpenRecent->setCurrentItem(-1);
     }
   }
 
   StatusBar::self()->clearStatus();
 }
 
 void MainWindow::slotFileOpenRecent(const QUrl& url_) {
   slotStatusMsg(i18n("Opening file..."));
 
   // close the fields dialog
   slotHideCollectionFieldsDialog();
 
   if(m_editDialog->queryModified() && querySaveModified()) {
     if(!openURL(url_)) {
       m_fileOpenRecent->removeUrl(url_);
       m_fileOpenRecent->setCurrentItem(-1);
     }
   } else {
     // the QAction shouldn't be checked now
     m_fileOpenRecent->setCurrentItem(-1);
   }
 
   StatusBar::self()->clearStatus();
 }
 
 void MainWindow::openFile(const QString& file_) {
   QUrl url(file_);
   if(!url.isEmpty() && url.isValid()) {
     slotFileOpen(url);
   }
 }
 
 bool MainWindow::openURL(const QUrl& url_) {
   MARK;
   // try to open document
   GUI::CursorSaver cs(Qt::WaitCursor);
 
   bool success = Data::Document::self()->openDocument(url_);
 
   if(success) {
     Kernel::self()->resetHistory();
     m_quickFilter->clear();
     slotEnableOpenedActions();
     m_newDocument = false;
     slotEnableModifiedActions(Data::Document::self()->isModified()); // doc might add some stuff
   } else if(!m_initialized) {
     // special case on startup when openURL() is called with a command line argument
     // and that URL can't be opened. The window still needs to be initialized
     // the doc object is created with an initial book collection, continue with that
     Controller::self()->slotCollectionAdded(Data::Document::self()->collection());
 
     m_fileSave->setEnabled(false);
     slotEnableOpenedActions();
     slotEnableModifiedActions(false);
 
     slotEntryCount();
   }
   // slotFileOpen(URL) gets called when opening files on the command line
   // so go ahead and make sure m_initialized is set.
   m_initialized = true;
 
   // remove filter and loan tabs, they'll get re-added if needed
   if(m_filterView && m_filterView->isEmpty()) {
     m_viewTabs->removeTab(m_viewTabs->indexOf(m_filterView));
     Controller::self()->removeObserver(m_filterView);
     delete m_filterView;
     m_filterView = nullptr;
   }
   if(m_loanView && m_loanView->isEmpty()) {
     m_viewTabs->removeTab(m_viewTabs->indexOf(m_loanView));
     Controller::self()->removeObserver(m_loanView);
     delete m_loanView;
     m_loanView = nullptr;
   }
   Controller::self()->hideTabs(); // does conditional check
 
   return success;
 }
 
 void MainWindow::slotFileSave() {
   fileSave();
 }
 
 bool MainWindow::fileSave() {
   if(!m_editDialog->queryModified()) {
     return false;
   }
   slotStatusMsg(i18n("Saving file..."));
 
   bool ret = true;
   if(isNewDocument()) {
     ret = fileSaveAs();
   } else {
     // special check: if there are more than 200 images AND the "Write Images In File" config key
     // is set, then warn user that performance may suffer, and write result
     if(Config::imageLocation() == Config::ImagesInFile &&
        Config::askWriteImagesInFile() &&
        Data::Document::self()->imageCount() > MAX_IMAGES_WARN_PERFORMANCE) {
       QString msg = i18n("<qt><p>You are saving a file with many images, which causes Tellico to "
                          "slow down significantly. Do you want to save the images separately in "
                          "Tellico's data directory to improve performance?</p><p>Your choice can "
                          "always be changed in the configuration dialog.</p></qt>");
 
       KGuiItem yes(i18n("Save Images Separately"));
       KGuiItem no(i18n("Save Images in File"));
 
       int res = KMessageBox::warningYesNo(this, msg, QString() /* caption */, yes, no);
       if(res == KMessageBox::No) {
         Config::setImageLocation(Config::ImagesInAppDir);
       }
       Config::setAskWriteImagesInFile(false);
     }
 
     GUI::CursorSaver cs(Qt::WaitCursor);
     if(Data::Document::self()->saveDocument(Data::Document::self()->URL())) {
       Kernel::self()->resetHistory();
       m_newDocument = false;
       updateCaption(false);
       m_fileSave->setEnabled(false);
       // TODO: call a method of the model instead of the view here
       m_detailedView->resetEntryStatus();
     } else {
       ret = false;
     }
   }
 
   StatusBar::self()->clearStatus();
   return ret;
 }
 
 void MainWindow::slotFileSaveAs() {
   fileSaveAs();
 }
 
 bool MainWindow::fileSaveAs() {
   if(!m_editDialog->queryModified()) {
     return false;
   }
 
   slotStatusMsg(i18n("Saving file with a new filename..."));
 
   QString filter = i18n("Tellico Files") + QLatin1String(" (*.tc *.bc)");
   filter += QLatin1String(";;");
   filter += i18n("All Files") + QLatin1String(" (*)");
 
   // keyword 'open'
   QString fileClass;
   const QUrl startUrl = KFileWidget::getStartUrl(QUrl(QStringLiteral("kfiledialog:///open")), fileClass);
   const QUrl url = QFileDialog::getSaveFileUrl(this, i18n("Save As"), startUrl, filter);
 
   if(url.isEmpty()) {
     StatusBar::self()->clearStatus();
     return false;
   }
   if(url.isLocalFile()) {
     KRecentDirs::add(fileClass, url.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash).path());
   }
 
   bool ret = true;
   if(url.isValid()) {
     GUI::CursorSaver cs(Qt::WaitCursor);
     m_savingImageLocationChange = true;
     // Overwriting an existing file was already confirmed in QFileDialog::getSaveFileUrl()
     if(Data::Document::self()->saveDocument(url, true /* force */)) {
       Kernel::self()->resetHistory();
       KRecentDocument::add(url);
       m_fileOpenRecent->addUrl(url);
       updateCaption(false);
       m_newDocument = false;
       m_fileSave->setEnabled(false);
       m_detailedView->resetEntryStatus();
     } else {
       ret = false;
     }
     m_savingImageLocationChange = false;
   }
 
   StatusBar::self()->clearStatus();
   return ret;
 }
 
 void MainWindow::slotFilePrint() {
   slotStatusMsg(i18n("Printing..."));
 
   bool printGrouped = Config::printGrouped();
   bool printHeaders = Config::printFieldHeaders();
   int imageWidth = Config::maxImageWidth();
   int imageHeight = Config::maxImageHeight();
 
   // If the collection is being filtered, warn the user
   if(m_detailedView->filter()) {
     QString str = i18n("The collection is currently being filtered to show a limited subset of "
                        "the entries. Only the visible entries will be printed. Continue?");
     int ret = KMessageBox::warningContinueCancel(this, str, QString(), KStandardGuiItem::print(),
                                                  KStandardGuiItem::cancel(), QStringLiteral("WarnPrintVisible"));
     if(ret == KMessageBox::Cancel) {
       StatusBar::self()->clearStatus();
       return;
     }
   }
 
   GUI::CursorSaver cs(Qt::WaitCursor);
 
   Export::HTMLExporter exporter(Data::Document::self()->collection());
   // only print visible entries
   exporter.setEntries(m_detailedView->visibleEntries());
   exporter.setXSLTFile(QStringLiteral("tellico-printing.xsl"));
   exporter.setPrintHeaders(printHeaders);
   exporter.setPrintGrouped(printGrouped);
   exporter.setGroupBy(Controller::self()->expandedGroupBy());
   if(!printGrouped) { // the sort titles are only used if the entries are not grouped
     exporter.setSortTitles(Controller::self()->sortTitles());
   }
   exporter.setColumns(m_detailedView->visibleColumns());
   exporter.setMaxImageSize(imageWidth, imageHeight);
 
   slotStatusMsg(i18n("Processing document..."));
   if(Config::printFormatted()) {
     exporter.setOptions(Export::ExportUTF8 | Export::ExportFormatted);
   } else {
     exporter.setOptions(Export::ExportUTF8);
   }
   QString html = exporter.text();
   if(html.isEmpty()) {
     XSLTError();
     StatusBar::self()->clearStatus();
     return;
   }
 
   // don't have busy cursor when showing the print dialog
   cs.restore();
 //  myDebug() << html;
   slotStatusMsg(i18n("Printing..."));
   doPrint(html);
 
   StatusBar::self()->clearStatus();
 }
 
 void MainWindow::slotFileQuit() {
   slotStatusMsg(i18n("Exiting..."));
 
   close(); // will call queryClose()
 
   StatusBar::self()->clearStatus();
 }
 
 void MainWindow::slotEditCut() {
   activateEditSlot("cut()");
 }
 
 void MainWindow::slotEditCopy() {
   activateEditSlot("copy()");
 }
 
 void MainWindow::slotEditPaste() {
   activateEditSlot("paste()");
 }
 
 void MainWindow::activateEditSlot(const char* slot_) {
   // the edit widget is the only one that copies, cuts, and pastes
   QWidget* w;
   if(m_editDialog->isVisible()) {
     w = m_editDialog->focusWidget();
   } else {
     w = qApp->focusWidget();
   }
 
   if(w && w->isVisible()) {
     const QMetaObject* meta = w->metaObject();
     const int idx = meta->indexOfSlot(slot_);
     if(idx > -1) {
       //myDebug() << "MainWindow invoking" << meta->method(idx).signature();
       meta->method(idx).invoke(w, Qt::DirectConnection);
     }
   }
 }
 
 void MainWindow::slotEditSelectAll() {
   m_detailedView->selectAllVisible();
 }
 
 void MainWindow::slotEditDeselect() {
   Controller::self()->slotUpdateSelection(Data::EntryList());
 }
 
 void MainWindow::slotToggleEntryEditor() {
   if(m_toggleEntryEditor->isChecked()) {
     m_editDialog->show();
   } else {
     m_editDialog->hide();
   }
 }
 
 void MainWindow::slotShowConfigDialog() {
   if(!m_configDlg) {
     m_configDlg = new ConfigDialog(this);
-    connect(m_configDlg, SIGNAL(signalConfigChanged()),
-            SLOT(slotHandleConfigChange()));
-    connect(m_configDlg, SIGNAL(finished(int)),
-            SLOT(slotHideConfigDialog()));
+    connect(m_configDlg, &ConfigDialog::signalConfigChanged,
+            this, &MainWindow::slotHandleConfigChange);
+    connect(m_configDlg, &QDialog::finished,
+            this, &MainWindow::slotHideConfigDialog);
   } else {
     KWindowSystem::activateWindow(m_configDlg->winId());
   }
   m_configDlg->show();
 }
 
 void MainWindow::slotHideConfigDialog() {
   if(m_configDlg) {
     m_configDlg->hide();
     m_configDlg->deleteLater();
     m_configDlg = nullptr;
   }
 }
 
 void MainWindow::slotShowTipOfDay(bool force_/*=true*/) {
   KTipDialog::showTip(this, QStringLiteral("tellico/tellico.tips"), force_);
 }
 
 void MainWindow::slotStatusMsg(const QString& text_) {
   m_statusBar->setStatus(text_);
 }
 
 void MainWindow::slotClearStatus() {
   StatusBar::self()->clearStatus();
 }
 
 void MainWindow::slotEntryCount() {
   Data::CollPtr coll = Data::Document::self()->collection();
   if(!coll) {
     return;
   }
 
   int count = coll->entryCount();
   QString text = i18n("Total entries: %1", count);
 
   int selectCount = Controller::self()->selectedEntries().count();
   int filterCount = m_detailedView->visibleItems();
   // if more than one book is selected, add the number of selected books
   if(filterCount < count && selectCount > 1) {
     text += QLatin1Char(' ');
     text += i18n("(%1 filtered; %2 selected)", filterCount, selectCount);
   } else if(filterCount < count) {
     text += QLatin1Char(' ');
     text += i18n("(%1 filtered)", filterCount);
   } else if(selectCount > 1) {
     text += QLatin1Char(' ');
     text += i18n("(%1 selected)", selectCount);
   }
 
   m_statusBar->setCount(text);
 }
 
 void MainWindow::slotEnableOpenedActions() {
   slotUpdateToolbarIcons();
 
   updateCollectionActions();
 
   // close the filter dialog when a new collection is opened
   slotHideFilterDialog();
   slotStringMacroDialogFinished();
 }
 
 void MainWindow::slotEnableModifiedActions(bool modified_ /*= true*/) {
   updateCaption(modified_);
   updateCollectionActions();
   m_fileSave->setEnabled(modified_);
 }
 
 void MainWindow::slotHandleConfigChange() {
   const int imageLocation = Config::imageLocation();
   const bool autoCapitalize = Config::autoCapitalization();
   const bool autoFormat = Config::autoFormat();
   const QStringList articles = Config::articleList();
   const QStringList nocaps = Config::noCapitalizationList();
   const QStringList suffixes = Config::nameSuffixList();
   const QStringList prefixes = Config::surnamePrefixList();
 
   m_configDlg->saveConfiguration();
 
   // only modified if there are entries and image location is changed
   if(imageLocation != Config::imageLocation() && !Data::Document::self()->isEmpty()) {
     slotImageLocationChanged();
   }
 
   if(autoCapitalize != Config::autoCapitalization() ||
     autoFormat != Config::autoFormat() ||
     articles != Config::articleList() ||
     nocaps != Config::noCapitalizationList() ||
     suffixes != Config::nameSuffixList() ||
     prefixes != Config::surnamePrefixList()) {
     // invalidate all groups
     Data::Document::self()->collection()->invalidateGroups();
     // refreshing the title causes the group view to refresh
     Controller::self()->slotRefreshField(Data::Document::self()->collection()->fieldByName(QStringLiteral("title")));
   }
 
   QString entryXSLTFile = Config::templateName(Kernel::self()->collectionType());
   m_entryView->setXSLTFile(entryXSLTFile + QLatin1String(".xsl"));
 }
 
 void MainWindow::slotUpdateCollectionToolBar(Tellico::Data::CollPtr coll_) {
   if(!coll_) {
     myWarning() << "no collection pointer!";
     return;
   }
 
   QString current = m_groupView->groupBy();
   if(current.isEmpty() || !coll_->entryGroups().contains(current)) {
     current = coll_->defaultGroupField();
   }
 
   const QStringList groups = coll_->entryGroups();
   if(groups.isEmpty()) {
     m_entryGrouping->clear();
     return;
   }
 
   QMap<QString, QString> groupMap; // use a map so they get sorted
   foreach(const QString& groupName, groups) {
     // special case for people "pseudo-group"
     if(groupName == Data::Collection::s_peopleGroupName) {
       groupMap.insert(groupName, QLatin1Char('<') + i18n("People") + QLatin1Char('>'));
     } else {
       groupMap.insert(groupName, coll_->fieldTitleByName(groupName));
     }
   }
 
   const QStringList titles = groupMap.values();
   if(titles == m_entryGrouping->items()) {
     // no need to update anything
     return;
   }
   const QStringList names = groupMap.keys();
   int index = names.indexOf(current);
   if(index == -1) {
     current = names[0];
     index = 0;
   }
   m_entryGrouping->setItems(titles);
   m_entryGrouping->setCurrentItem(index);
   // in case the current grouping field get modified to be non-grouping...
   m_groupView->setGroupField(current); // don't call slotChangeGrouping() since it adds an undo item
 
   // TODO::I have no idea how to get the combobox to update its size
   // this is the hackiest of hacks, taken from KXmlGuiWindow::saveNewToolbarConfig()
   // the window flickers as toolbar resizes, unavoidable?
   // crashes if removeCLient//addClient is called here, need to do later in event loop
   QTimer::singleShot(0, this, &MainWindow::guiFactoryReset);
 }
 
 void MainWindow::slotChangeGrouping() {
   const QString title = m_entryGrouping->currentText();
 
   QString groupName = Kernel::self()->fieldNameByTitle(title);
   if(groupName.isEmpty()) {
     if(title == (QLatin1Char('<') + i18n("People") + QLatin1Char('>'))) {
       groupName = Data::Collection::s_peopleGroupName;
     } else {
       groupName = Data::Document::self()->collection()->defaultGroupField();
     }
   }
   m_groupView->setGroupField(groupName);
   m_viewTabs->setCurrentWidget(m_groupView);
 }
 
 void MainWindow::slotShowReportDialog() {
   if(!m_reportDlg) {
     m_reportDlg = new ReportDialog(this);
-    connect(m_reportDlg, SIGNAL(finished(int)),
-            SLOT(slotHideReportDialog()));
+    connect(m_reportDlg, &QDialog::finished,
+            this, &MainWindow::slotHideReportDialog);
   } else {
     KWindowSystem::activateWindow(m_reportDlg->winId());
   }
   m_reportDlg->show();
 }
 
 void MainWindow::slotHideReportDialog() {
   if(m_reportDlg) {
     m_reportDlg->hide();
     m_reportDlg->deleteLater();
     m_reportDlg = nullptr;
   }
 }
 
 void MainWindow::doPrint(const QString& html_) {
   KHTMLPart w;
 
   // KHTMLPart printing was broken in KDE until KHTML 5.16
   // see https://git.reviewboard.kde.org/r/125681/
   const QString version =  w.componentData().version();
   const uint major = version.section(QLatin1Char('.'), 0, 0).toUInt();
   const uint minor = version.section(QLatin1Char('.'), 1, 1).toUInt();
   if(major == 5 && minor < 16) {
     myWarning() << "Printing is broken for KDE Frameworks < 5.16. Please upgrade";
     return;
   }
 
   w.setJScriptEnabled(false);
   w.setJavaEnabled(false);
   w.setMetaRefreshEnabled(false);
   w.setPluginsEnabled(false);
   w.begin(Data::Document::self()->URL());
   w.write(html_);
   w.end();
 
 // the problem with doing my own layout is that the text gets truncated, both at the
 // top and at the bottom. Even adding the overlap parameter, there were problems.
 // KHTMLView takes care of that with a truncatedAt() parameter, but that's hidden in
 // the khtml::render_root class. So for now, just use the KHTMLView::print() method.
   w.view()->print();
 }
 
 void MainWindow::XSLTError() {
   QString str = i18n("Tellico encountered an error in XSLT processing.") + QLatin1Char('\n');
   str += i18n("Please check your installation.");
   Kernel::self()->sorry(str);
 }
 
 void MainWindow::slotShowFilterDialog() {
   if(!m_filterDlg) {
     m_filterDlg = new FilterDialog(FilterDialog::CreateFilter, this); // allow saving
     m_quickFilter->setEnabled(false);
-    connect(m_filterDlg, SIGNAL(signalCollectionModified()),
-            Data::Document::self(), SLOT(slotSetModified()));
-    connect(m_filterDlg, SIGNAL(signalUpdateFilter(Tellico::FilterPtr)),
-            this, SLOT(slotUpdateFilter(Tellico::FilterPtr)));
-    connect(m_filterDlg, SIGNAL(finished(int)),
-            SLOT(slotHideFilterDialog()));
+    connect(m_filterDlg, &FilterDialog::signalCollectionModified,
+            Data::Document::self(), &Data::Document::slotSetModified);
+    connect(m_filterDlg, &FilterDialog::signalUpdateFilter,
+            this, &MainWindow::slotUpdateFilter);
+    connect(m_filterDlg, &QDialog::finished,
+            this, &MainWindow::slotHideFilterDialog);
   } else {
     KWindowSystem::activateWindow(m_filterDlg->winId());
   }
   m_filterDlg->setFilter(m_detailedView->filter());
   m_filterDlg->show();
 }
 
 void MainWindow::slotHideFilterDialog() {
 //  m_quickFilter->blockSignals(false);
   m_quickFilter->setEnabled(true);
   if(m_filterDlg) {
     m_filterDlg->hide();
     m_filterDlg->deleteLater();
     m_filterDlg = nullptr;
   }
 }
 
 void MainWindow::slotQueueFilter() {
   if(m_dontQueueFilter) {
     return;
   }
   m_queuedFilters++;
-  QTimer::singleShot(200, this, SLOT(slotUpdateFilter()));
+  QTimer::singleShot(200, this, &MainWindow::slotCheckFilterQueue);
 }
 
-void MainWindow::slotUpdateFilter() {
+void MainWindow::slotCheckFilterQueue() {
   m_queuedFilters--;
   if(m_queuedFilters > 0) {
     return;
   }
 
   setFilter(m_quickFilter->text());
 }
 
 void MainWindow::slotUpdateFilter(FilterPtr filter_) {
   // Can't just block signals because clear button won't show then
   m_dontQueueFilter = true;
   m_quickFilter->setText(QStringLiteral(" ")); // To be able to clear custom filter
   Controller::self()->slotUpdateFilter(filter_);
   m_dontQueueFilter = false;
 }
 
 void MainWindow::setFilter(const QString& text_) {
   QString text = text_.trimmed();
   FilterPtr filter;
   if(!text.isEmpty()) {
     filter = new Filter(Filter::MatchAll);
     QString fieldName; // empty field name means match on any field
     // if the text contains '=' assume it's a field name or title
     if(text.indexOf(QLatin1Char('=')) > -1) {
       fieldName = text.section(QLatin1Char('='), 0, 0).trimmed();
       text = text.section(QLatin1Char('='), 1).trimmed();
       // check that the field name might be a title
       if(!Data::Document::self()->collection()->hasField(fieldName)) {
         fieldName = Data::Document::self()->collection()->fieldNameByTitle(fieldName);
       }
     }
     // if the text contains any non-word characters, assume it's a regexp
     // but \W in qt is letter, number, or '_', I want to be a bit less strict
     QRegExp rx(QLatin1String("[^\\w\\s-']"));
     if(rx.indexIn(text) == -1) {
       // split by whitespace, and add rules for each word
       const QStringList tokens = text.split(QRegExp(QLatin1String("\\s")));
       foreach(const QString& token, tokens) {
         // an empty field string means check every field
         filter->append(new FilterRule(fieldName, token, FilterRule::FuncContains));
       }
     } else {
       // if it isn't valid, hold off on applying the filter
       QRegExp tx(text);
       if(!tx.isValid()) {
         text = QRegExp::escape(text);
         tx.setPattern(text);
       }
       if(!tx.isValid()) {
         myDebug() << "invalid regexp:" << text;
         return;
       }
       filter->append(new FilterRule(fieldName, text, FilterRule::FuncRegExp));
     }
     // also want to update the line edit in case the filter was set by DBUS
     if(m_quickFilter->text() != text_) {
       m_quickFilter->setText(text_);
     }
   }
   // only update filter if one exists or did exist
   if(filter || m_detailedView->filter()) {
     Controller::self()->slotUpdateFilter(filter);
   }
 }
 
 void MainWindow::slotShowCollectionFieldsDialog() {
   if(!m_collFieldsDlg) {
     m_collFieldsDlg = new CollectionFieldsDialog(Data::Document::self()->collection(), this);
-    connect(m_collFieldsDlg, SIGNAL(finished(int)),
-            SLOT(slotHideCollectionFieldsDialog()));
+    connect(m_collFieldsDlg, &QDialog::finished,
+            this, &MainWindow::slotHideCollectionFieldsDialog);
   } else {
     KWindowSystem::activateWindow(m_collFieldsDlg->winId());
   }
   m_collFieldsDlg->show();
 }
 
 void MainWindow::slotHideCollectionFieldsDialog() {
   if(m_collFieldsDlg) {
     m_collFieldsDlg->hide();
     m_collFieldsDlg->deleteLater();
     m_collFieldsDlg = nullptr;
   }
 }
 
 void MainWindow::slotFileImport(int format_) {
   slotStatusMsg(i18n("Importing data..."));
   m_quickFilter->clear();
 
   Import::Format format = static_cast<Import::Format>(format_);
   bool checkURL = true;
   QUrl url;
   switch(ImportDialog::importTarget(format)) {
     case Import::File:
       {
         QString fileClass;
         const QUrl startUrl = KFileWidget::getStartUrl(QUrl(QStringLiteral("kfiledialog:///import")), fileClass);
         url = QFileDialog::getOpenFileUrl(this, i18n("Import File"), startUrl, ImportDialog::fileFilter(format));
         KRecentDirs::add(fileClass, url.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash).path());
       }
       break;
 
     case Import::Dir:
       // TODO: allow remote audiofile importing
       {
         const QString fileClass(QStringLiteral("ImportDir"));
         QString dirName = ImportDialog::startDir(format);
         if(dirName.isEmpty()) {
           dirName = KRecentDirs::dir(fileClass);
         }
         url = QUrl::fromLocalFile(QFileDialog::getExistingDirectory(this, i18n("Import Directory"), dirName));
         KRecentDirs::add(fileClass, url.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash).path());
       }
       break;
 
     case Import::None:
     default:
       checkURL = false;
       break;
   }
 
   if(checkURL) {
     bool ok = !url.isEmpty() && url.isValid() && QFile::exists(url.toLocalFile());
     if(!ok) {
       StatusBar::self()->clearStatus();
       return;
     }
   }
   importFile(format, QList<QUrl>() << url);
   StatusBar::self()->clearStatus();
 }
 
 void MainWindow::slotFileExport(int format_) {
   slotStatusMsg(i18n("Exporting data..."));
 
   Export::Format format = static_cast<Export::Format>(format_);
   ExportDialog dlg(format, Data::Document::self()->collection(), this);
 
   if(dlg.exec() == QDialog::Rejected) {
     StatusBar::self()->clearStatus();
     return;
   }
 
   switch(ExportDialog::exportTarget(format)) {
     case Export::None:
       dlg.exportURL();
       break;
 
     case Export::Dir:
       myDebug() << "ExportDir not implemented!";
       break;
 
     case Export::File:
     {
       QString fileClass;
       const QUrl startUrl = KFileWidget::getStartUrl(QUrl(QStringLiteral("kfiledialog:///export")), fileClass);
       QUrl url = QFileDialog::getSaveFileUrl(this, i18n("Export As"), startUrl, dlg.fileFilter());
       if(url.isEmpty()) {
         StatusBar::self()->clearStatus();
         return;
       }
 
       if(url.isValid()) {
         if(url.isLocalFile()) {
           KRecentDirs::add(fileClass, url.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash).path());
         }
         GUI::CursorSaver cs(Qt::WaitCursor);
         dlg.exportURL(url);
       }
     }
     break;
   }
 
   StatusBar::self()->clearStatus();
 }
 
 void MainWindow::slotShowStringMacroDialog() {
   if(Data::Document::self()->collection()->type() != Data::Collection::Bibtex) {
     return;
   }
 
   if(!m_stringMacroDlg) {
     const Data::BibtexCollection* c = static_cast<Data::BibtexCollection*>(Data::Document::self()->collection().data());
     m_stringMacroDlg = new StringMapDialog(c->macroList(), this, false);
     m_stringMacroDlg->setWindowTitle(i18n("String Macros"));
     m_stringMacroDlg->setLabels(i18n("Macro"), i18n("String"));
-    connect(m_stringMacroDlg, SIGNAL(finished(int)), SLOT(slotStringMacroDialogFinished(int)));
+    connect(m_stringMacroDlg, &QDialog::finished, this, &MainWindow::slotStringMacroDialogFinished);
   } else {
     KWindowSystem::activateWindow(m_stringMacroDlg->winId());
   }
   m_stringMacroDlg->show();
 }
 
 void MainWindow::slotStringMacroDialogFinished(int result_) {
   // no point in checking if collection is bibtex, as dialog would never have been created
   if(!m_stringMacroDlg) {
     return;
   }
   if(result_ == QDialog::Accepted) {
     static_cast<Data::BibtexCollection*>(Data::Document::self()->collection().data())->setMacroList(m_stringMacroDlg->stringMap());
-    Data::Document::self()->slotSetModified(true);
+    Data::Document::self()->setModified(true);
   }
   m_stringMacroDlg->hide();
   m_stringMacroDlg->deleteLater();
   m_stringMacroDlg = nullptr;
 }
 
 void MainWindow::slotShowBibtexKeyDialog() {
   if(Data::Document::self()->collection()->type() != Data::Collection::Bibtex) {
     return;
   }
 
   if(!m_bibtexKeyDlg) {
     m_bibtexKeyDlg = new BibtexKeyDialog(Data::Document::self()->collection(), this);
-    connect(m_bibtexKeyDlg, SIGNAL(finished(int)), SLOT(slotHideBibtexKeyDialog()));
-    connect(m_bibtexKeyDlg, SIGNAL(signalUpdateFilter(Tellico::FilterPtr)),
-            this, SLOT(slotUpdateFilter(Tellico::FilterPtr)));
+    connect(m_bibtexKeyDlg, &QDialog::finished, this, &MainWindow::slotHideBibtexKeyDialog);
+    connect(m_bibtexKeyDlg, &BibtexKeyDialog::signalUpdateFilter,
+            this, &MainWindow::slotUpdateFilter);
   } else {
     KWindowSystem::activateWindow(m_bibtexKeyDlg->winId());
   }
   m_bibtexKeyDlg->show();
 }
 
 void MainWindow::slotHideBibtexKeyDialog() {
   if(m_bibtexKeyDlg) {
     m_bibtexKeyDlg->deleteLater();
     m_bibtexKeyDlg = nullptr;
   }
 }
 
 void MainWindow::slotNewEntry() {
   m_toggleEntryEditor->setChecked(true);
   slotToggleEntryEditor();
   m_editDialog->slotHandleNew();
 }
 
 void MainWindow::slotEditDialogFinished() {
   m_toggleEntryEditor->setChecked(false);
 }
 
 void MainWindow::slotShowEntryEditor() {
   m_toggleEntryEditor->setChecked(true);
   m_editDialog->show();
 
   KWindowSystem::activateWindow(m_editDialog->winId());
 }
 
 void MainWindow::slotConvertToBibliography() {
   // only book collections can be converted to bibtex
   Data::CollPtr coll = Data::Document::self()->collection();
   if(!coll || coll->type() != Data::Collection::Book) {
     return;
   }
 
   GUI::CursorSaver cs;
 
   // need to make sure all images are transferred
   Data::Document::self()->loadAllImagesNow();
 
   Data::CollPtr newColl = Data::BibtexCollection::convertBookCollection(coll);
   if(newColl) {
     m_newDocument = true;
     Kernel::self()->replaceCollection(newColl);
     m_fileOpenRecent->setCurrentItem(-1);
     slotUpdateToolbarIcons();
     updateCollectionActions();
   } else {
     myWarning() << "ERROR: no bibliography created!";
   }
 }
 
 void MainWindow::slotCiteEntry(int action_) {
   StatusBar::self()->setStatus(i18n("Creating citations..."));
   Cite::ActionManager* man = Cite::ActionManager::self();
   man->cite(static_cast<Cite::CiteAction>(action_), Controller::self()->selectedEntries());
   if(man->hasError()) {
     Kernel::self()->sorry(man->errorString());
   }
   StatusBar::self()->clearStatus();
 }
 
 void MainWindow::slotShowFetchDialog() {
   if(!m_fetchDlg) {
     m_fetchDlg = new FetchDialog(this);
-    connect(m_fetchDlg, SIGNAL(finished(int)), SLOT(slotHideFetchDialog()));
-    connect(Controller::self(), SIGNAL(collectionAdded(int)), m_fetchDlg, SLOT(slotResetCollection()));
+    connect(m_fetchDlg, &QDialog::finished, this, &MainWindow::slotHideFetchDialog);
+    connect(Controller::self(), &Controller::collectionAdded, m_fetchDlg, &FetchDialog::slotResetCollection);
   } else {
     KWindowSystem::activateWindow(m_fetchDlg->winId());
   }
   m_fetchDlg->show();
 }
 
 void MainWindow::slotHideFetchDialog() {
   if(m_fetchDlg) {
     m_fetchDlg->hide();
     m_fetchDlg->deleteLater();
     m_fetchDlg = nullptr;
   }
 }
 
 bool MainWindow::importFile(Tellico::Import::Format format_, const QUrl& url_, Tellico::Import::Action action_) {
   // try to open document
   GUI::CursorSaver cs(Qt::WaitCursor);
 
   bool failed = false;
   Data::CollPtr coll;
   if(!url_.isEmpty() && url_.isValid() && NetAccess::exists(url_, true, this)) {
     coll = ImportDialog::importURL(format_, url_);
   } else {
     Kernel::self()->sorry(i18n(errorLoad, url_.fileName()));
     failed = true;
   }
 
   if(!coll && !m_initialized) {
     // special case on startup when openURL() is called with a command line argument
     // and that URL can't be opened. The window still needs to be initialized
     // the doc object is created with an initial book collection, continue with that
     Controller::self()->slotCollectionAdded(Data::Document::self()->collection());
     m_fileSave->setEnabled(false);
     slotEnableOpenedActions();
     slotEnableModifiedActions(false);
     slotEntryCount();
     m_fileOpenRecent->setCurrentItem(-1);
     m_initialized = true;
     failed = true;
   } else if(coll) {
     // this is rather dumb, but I'm too lazy to find the bug
     // if the document isn't initialized, then Tellico crashes
     // since Document::replaceCollection() ends up calling lots of stuff that isn't initialized
     if(!m_initialized) {
       Controller::self()->slotCollectionAdded(Data::Document::self()->collection());
       m_initialized = true;
     }
     failed = !importCollection(coll, action_);
   }
 
   StatusBar::self()->clearStatus();
   return !failed; // return true means success
 }
 
 bool MainWindow::exportCollection(Tellico::Export::Format format_, const QUrl& url_, bool filtered_) {
   if(!url_.isValid()) {
     myDebug() << "invalid URL:" << url_;
     return false;
   }
 
   GUI::CursorSaver cs;
   const Data::CollPtr coll = Data::Document::self()->collection();
   if(!coll) {
     return false;
   }
 
   // only bibliographies can export to bibtex or bibtexml
   const bool isBibtex = (coll->type() == Data::Collection::Bibtex);
   if(!isBibtex && (format_ == Export::Bibtex || format_ == Export::Bibtexml)) {
     return false;
   }
   // only books and bibliographies can export to alexandria
   const bool isBook = (coll->type() == Data::Collection::Book);
   if(!isBibtex && !isBook && format_ == Export::Alexandria) {
     return false;
   }
 
   return ExportDialog::exportCollection(coll, filtered_ ? Controller::self()->visibleEntries() : coll->entries(),
                                         format_, url_);
 }
 
 bool MainWindow::showEntry(Data::ID id) {
   Data::EntryPtr entry = Data::Document::self()->collection()->entryById(id);
   if(entry) {
     m_entryView->showEntry(entry);
   }
   return entry;
 }
 
 void MainWindow::addFilterView() {
   if(m_filterView) {
     return;
   }
 
   m_filterView = new FilterView(m_viewTabs);
   Controller::self()->addObserver(m_filterView);
   m_viewTabs->insertTab(1, m_filterView, QIcon::fromTheme(QStringLiteral("view-filter")), i18n("Filters"));
   m_filterView->setWhatsThis(i18n("<qt>The <i>Filter View</i> shows the entries which meet certain "
                                   "filter rules.</qt>"));
 
-  connect(m_filterView, SIGNAL(signalUpdateFilter(Tellico::FilterPtr)),
-          this, SLOT(slotUpdateFilter(Tellico::FilterPtr)));
+  connect(m_filterView, &FilterView::signalUpdateFilter,
+          this, &MainWindow::slotUpdateFilter);
   // use the EntrySelectionModel as a proxy so when entries get selected in the filter view
   // the edit dialog and entry view are updated
   // TODO: consider using KSelectionProxyModel
   static_cast<EntrySelectionModel*>(m_iconView->selectionModel())->addSelectionProxy(m_filterView->selectionModel());
 
   // sort by count if column = 1
   int sortRole = Config::filterViewSortColumn() == 0 ? static_cast<int>(Qt::DisplayRole) : static_cast<int>(RowCountRole);
   Qt::SortOrder sortOrder = Config::filterViewSortAscending() ? Qt::AscendingOrder : Qt::DescendingOrder;
   m_filterView->setSorting(sortOrder, sortRole);
 }
 
 void MainWindow::addLoanView() {
   if(m_loanView) {
     return;
   }
 
   m_loanView = new LoanView(m_viewTabs);
   Controller::self()->addObserver(m_loanView);
   m_viewTabs->insertTab(2, m_loanView, QIcon::fromTheme(QStringLiteral("kaddressbook")), i18n("Loans"));
   m_loanView->setWhatsThis(i18n("<qt>The <i>Loan View</i> shows a list of all the people who "
                                 "have borrowed items from your collection.</qt>"));
 
   // use the EntrySelectionModel as a proxy so when entries get selected in the loan view
   // the edit dialog and entry view are updated
   // TODO: consider using KSelectionProxyModel
   static_cast<EntrySelectionModel*>(m_iconView->selectionModel())->addSelectionProxy(m_loanView->selectionModel());
 
   // sort by count if column = 1
   int sortRole = Config::loanViewSortColumn() == 0 ? static_cast<int>(Qt::DisplayRole) : static_cast<int>(RowCountRole);
   Qt::SortOrder sortOrder = Config::loanViewSortAscending() ? Qt::AscendingOrder : Qt::DescendingOrder;
   m_loanView->setSorting(sortOrder, sortRole);
 }
 
 void MainWindow::updateCaption(bool modified_) {
   QString caption;
   if(Data::Document::self()->collection()) {
     caption = Data::Document::self()->collection()->title();
   }
   if(!m_newDocument) {
     if(!caption.isEmpty()) {
        caption += QLatin1String(" - ");
     }
     QUrl u = Data::Document::self()->URL();
     if(u.isLocalFile()) {
       // for new files, the filename is set to Untitled in Data::Document
       if(u.fileName() == i18n(Tellico::untitledFilename)) {
         caption += u.fileName();
       } else {
         caption += u.path();
       }
     } else {
       caption += u.toDisplayString();
     }
   }
   setCaption(caption, modified_);
 }
 
 void MainWindow::slotUpdateToolbarIcons() {
   // first change the icon for the menu item
   if(Kernel::self()->collectionType() == Data::Collection::Base) {
     m_newEntry->setIcon(QIcon::fromTheme(QStringLiteral("document-new")));
   } else {
     m_newEntry->setIcon(QIcon(QLatin1String(":/icons/") + Kernel::self()->collectionTypeName()));
   }
 }
 
 void MainWindow::slotGroupLabelActivated() {
   // need entry grouping combo id
   foreach(QWidget* widget, m_entryGrouping->associatedWidgets()) {
     if(::qobject_cast<KToolBar*>(widget)) {
       QWidget* container = m_entryGrouping->requestWidget(widget);
       QComboBox* combo = ::qobject_cast<QComboBox*>(container); //krazy:exclude=qclasses
       if(combo) {
         combo->showPopup();
         break;
       }
     }
   }
 }
 
 void MainWindow::slotFilterLabelActivated() {
   m_quickFilter->setFocus();
   m_quickFilter->selectAll();
 }
 
 void MainWindow::slotClearFilter() {
   m_quickFilter->clear();
   slotQueueFilter();
 }
 
 void MainWindow::slotRenameCollection() {
   Kernel::self()->renameCollection();
 }
 
 void MainWindow::slotImageLocationMismatch() {
   // TODO: having a single image location mismatch should not be reason to completely save the whole document
-  QTimer::singleShot(0, this, SLOT(slotImageLocationChanged()));
+  QTimer::singleShot(0, this, &MainWindow::slotImageLocationChanged);
 }
 
 void MainWindow::slotImageLocationChanged() {
   if(m_savingImageLocationChange) {
     return;
   }
   m_savingImageLocationChange = true;
   Data::Document::self()->slotSetModified();
   KMessageBox::information(this, QLatin1String("<qt>") +
                                  i18n("Some images are not saved in the configured location. The current file "
                                       "must be saved and the images will be transferred to the new location.") +
                                  QLatin1String("</qt>"));
   fileSave();
   m_savingImageLocationChange = false;
 }
 
 void MainWindow::updateCollectionActions() {
   if(!Data::Document::self()->collection()) {
     return;
   }
 
   stateChanged(QStringLiteral("collection_reset"));
 
   Data::Collection::Type type = Data::Document::self()->collection()->type();
   stateChanged(QLatin1String("is_") + CollectionFactory::typeName(type));
 
   Controller::self()->updateActions();
   // special case when there are no available data sources
   if(m_fetchActions.isEmpty() && m_updateAll) {
     m_updateAll->setEnabled(false);
   }
 }
 
 void MainWindow::updateEntrySources() {
   unplugActionList(QStringLiteral("update_entry_actions"));
   foreach(QAction* action, m_fetchActions) {
     foreach(QWidget* widget, action->associatedWidgets()) {
       widget->removeAction(action);
     }
     m_updateMapper->removeMappings(action);
   }
   qDeleteAll(m_fetchActions);
   m_fetchActions.clear();
 
   Fetch::FetcherVec vec = Fetch::Manager::self()->fetchers(Kernel::self()->collectionType());
   foreach(Fetch::Fetcher::Ptr fetcher, vec) {
     QAction* action = new QAction(Fetch::Manager::fetcherIcon(fetcher), fetcher->source(), actionCollection());
     action->setToolTip(i18n("Update entry data from %1", fetcher->source()));
-    connect(action, SIGNAL(triggered()), m_updateMapper, SLOT(map()));
+    void (QAction::* triggeredBool)(bool) = &QAction::triggered;
+    void (QSignalMapper::* mapVoid)() = &QSignalMapper::map;
+    connect(action, triggeredBool, m_updateMapper, mapVoid);
     m_updateMapper->setMapping(action, fetcher->source());
     m_fetchActions.append(action);
   }
 
   plugActionList(QStringLiteral("update_entry_actions"), m_fetchActions);
 }
 
 void MainWindow::importFile(Tellico::Import::Format format_, const QList<QUrl>& urls_) {
   QList<QUrl> urls = urls_;
   // update as DropHandler and Importer classes are updated
   if(urls_.count() > 1 &&
      format_ != Import::Bibtex &&
      format_ != Import::RIS &&
      format_ != Import::CIW &&
      format_ != Import::PDF) {
     QUrl u = urls_.front();
     QString url = u.isLocalFile() ? u.path() : u.toDisplayString();
     Kernel::self()->sorry(i18n("Tellico can only import one file of this type at a time. "
                                "Only %1 will be imported.", url));
     urls.clear();
     urls += u;
   }
 
   ImportDialog dlg(format_, urls, this);
   if(dlg.exec() != QDialog::Accepted) {
     return;
   }
 
 //  if edit dialog is saved ok and if replacing, then the doc is saved ok
   if(m_editDialog->queryModified() &&
      (dlg.action() != Import::Replace || querySaveModified())) {
     GUI::CursorSaver cs(Qt::WaitCursor);
     Data::CollPtr coll = dlg.collection();
     if(!coll) {
       if(!dlg.statusMessage().isEmpty()) {
         Kernel::self()->sorry(dlg.statusMessage());
       }
       return;
     }
     importCollection(coll, dlg.action());
   }
 }
 
 void MainWindow::importText(Tellico::Import::Format format_, const QString& text_) {
   if(text_.isEmpty()) {
     return;
   }
   Data::CollPtr coll = ImportDialog::importText(format_, text_);
   if(coll) {
     importCollection(coll, Import::Merge);
   }
 }
 
 bool MainWindow::importCollection(Tellico::Data::CollPtr coll_, Tellico::Import::Action action_) {
   bool failed = false;
   switch(action_) {
     case Import::Append:
       {
         // only append if match, but special case importing books into bibliographies
         Data::CollPtr c = Data::Document::self()->collection();
         if(c->type() == coll_->type()
           || (c->type() == Data::Collection::Bibtex && coll_->type() == Data::Collection::Book)) {
           Kernel::self()->appendCollection(coll_);
           slotEnableModifiedActions(true);
         } else {
           Kernel::self()->sorry(i18n(errorAppendType));
           failed = true;
         }
       }
       break;
 
     case Import::Merge:
       {
         // only merge if match, but special case importing books into bibliographies
         Data::CollPtr c = Data::Document::self()->collection();
         if(c->type() == coll_->type()
           || (c->type() == Data::Collection::Bibtex && coll_->type() == Data::Collection::Book)) {
           Kernel::self()->mergeCollection(coll_);
           slotEnableModifiedActions(true);
         } else {
           Kernel::self()->sorry(i18n(errorMergeType));
           failed = true;
         }
       }
       break;
 
     default: // replace
       Kernel::self()->replaceCollection(coll_);
       m_fileOpenRecent->setCurrentItem(-1);
       m_newDocument = true;
       slotEnableOpenedActions();
       slotEnableModifiedActions(false);
       break;
   }
   // tell the entry views and models that there are no further images to load
   m_detailedView->slotRefreshImages();
   return !failed;
 }
 
 void MainWindow::slotURLAction(const QUrl& url_) {
   Q_ASSERT(url_.scheme() == QLatin1String("tc"));
   QString actionName = url_.fileName();
   QAction* action = this->action(actionName.toLatin1().constData());
   if(action) {
     action->activate(QAction::Trigger);
   } else {
     myWarning() << "unknown action: " << actionName;
   }
 }
 
 bool MainWindow::eventFilter(QObject* obj_, QEvent* ev_) {
   if(ev_->type() == QEvent::KeyPress && obj_ == m_quickFilter) {
     switch(static_cast<QKeyEvent*>(ev_)->key()) {
       case Qt::Key_Escape:
         m_quickFilter->clear();
         return true;
     }
   }
   return KXmlGuiWindow::eventFilter(obj_, ev_);
 }
 
 void MainWindow::slotToggleFullScreen() {
   Qt::WindowStates ws = windowState();
   setWindowState((ws & Qt::WindowFullScreen) ? (ws & ~Qt::WindowFullScreen) : (ws | Qt::WindowFullScreen));
 }
 
 void MainWindow::slotToggleMenuBarVisibility() {
   QMenuBar* mb = menuBar();
   mb->isHidden() ? mb->show() : mb->hide();
 }
 
 void MainWindow::slotToggleLayoutLock(bool lock_) {
   m_groupViewDock->setLocked(lock_);
   m_collectionViewDock->setLocked(lock_);
 }
 
 void MainWindow::slotResetLayout() {
   removeDockWidget(m_groupViewDock);
   addDockWidget(Qt::LeftDockWidgetArea, m_groupViewDock);
   m_groupViewDock->show();
 
   m_dummyWindow->removeDockWidget(m_collectionViewDock);
   m_dummyWindow->addDockWidget(Qt::TopDockWidgetArea, m_collectionViewDock);
   m_collectionViewDock->show();
 }
 
 void MainWindow::guiFactoryReset() {
   guiFactory()->removeClient(this);
   guiFactory()->reset();
   guiFactory()->addClient(this);
 }
diff --git a/src/mainwindow.h b/src/mainwindow.h
index 87e6e7f4..db661960 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -1,529 +1,529 @@
 /***************************************************************************
     Copyright (C) 2001-2009 Robby Stephenson <robby@periapsis.org>
     Copyright (C) 2011 Pedro Miguel Carvalho <kde@pmc.com.pt>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef TELLICO_MAINWINDOW_H
 #define TELLICO_MAINWINDOW_H
 
 #include <config.h>
 
 #include "translators/translators.h"
 #include "datavectors.h"
 
 #include <KXmlGuiWindow>
 
 #include <QUrl>
 #include <QList>
 
 class KToolBar;
 class QAction;
 class KSelectAction;
 class KToggleAction;
 class KDualAction;
 class KRecentFilesAction;
 class KActionMenu;
 
 class QCloseEvent;
 class QDockWidget;
 class QSignalMapper;
 
 namespace Tellico {
 // forward declarations
   namespace GUI {
     class LineEdit;
     class TabWidget;
     class DockWidget;
   }
   class Controller;
   class ViewStack;
   class DetailedListView;
   class EntryIconView;
   class EntryView;
   class FilterDialog;
   class EntryEditDialog;
   class GroupView;
   class FilterView;
   class LoanView;
   class ConfigDialog;
   class CollectionFieldsDialog;
   class StringMapDialog;
   class BibtexKeyDialog;
   class EntryItem;
   class FetchDialog;
   class ReportDialog;
   class StatusBar;
   class DropHandler;
 
 /**
  * The base class for Tellico application windows. It sets up the main
  * window and reads the config file as well as providing a menubar, toolbar
  * and statusbar. Tellico reimplements the methods that KMainWindow provides
  * for main window handling and supports full session management as well as
  * using QActions.
  *
  * @author Robby Stephenson
  */
 class MainWindow : public KXmlGuiWindow {
 Q_OBJECT
 
 friend class Controller;
 friend class DropHandler;
 
 public:
   /**
    * The main window constructor, calls all init functions to create the application.
    */
   MainWindow(QWidget* parent=nullptr);
   ~MainWindow();
 
   /**
    * Opens the initial file.
    *
    * @param nofile If true, even if the config option to reopen last file is set, no file is opened
    */
   void initFileOpen(bool nofile);
   /**
    * Saves the document
    *
    * @return Returns @p true if successful
    */
   bool fileSave();
   /**
    * Saves a document by a new filename
    *
    * @return Returns @p true if successful
    */
   bool fileSaveAs();
   /**
    * @return Returns whether the current collection is still the non-saved default one
    */
   bool isNewDocument() const { return m_newDocument; }
   /**
    * Used by main() and DBUS to import file.
    *
    * @param format The file format
    * @param url The url
    */
   virtual bool importFile(Import::Format format, const QUrl& url, Import::Action action);
   /**
    * Used by DBUS to export to a file.
    */
   virtual bool exportCollection(Export::Format format, const QUrl& url, bool filtered);
   /**
    * Used by DBUS
    */
   virtual void openFile(const QString& file);
   virtual void setFilter(const QString& text);
   virtual bool showEntry(Data::ID id);
 
   bool eventFilter(QObject* watched, QEvent* event) Q_DECL_OVERRIDE;
 
 public Q_SLOTS:
   /**
    * Initializes some stuff after the object is created.
    */
   void slotInit();
   /**
    * Cleans up everything and then opens a new document.
    *
    * @param type Type of collection to add
    */
   void slotFileNew(int type);
   /**
    * Opens a file and loads it into the document
    */
   void slotFileOpen();
   /**
    * Opens a file by URL and loads it into the document
    *
    * @param url The url to open
    */
   void slotFileOpen(const QUrl& url);
   /**
    * Opens a file from the recent files menu
    *
    * @param url The url sent by the RecentFilesAction
    */
   void slotFileOpenRecent(const QUrl& url);
   /**
    * Saves the document
    */
   void slotFileSave();
   /**
    * Saves a document by a new filename
    */
   void slotFileSaveAs();
   /**
    * Prints the current document.
    */
   void slotFilePrint();
   /**
    * Quits the application.
    */
   void slotFileQuit();
   /**
    * Puts the marked text/object into the clipboard and removes it from the document.
    */
   void slotEditCut();
   /*
    * Puts the marked text/object into the clipboard.
    */
   void slotEditCopy();
   /**
    * Pastes the clipboard into the document.
    */
   void slotEditPaste();
   /**
    * Selects all the entries in the collection.
    */
   void slotEditSelectAll();
   /**
    * Deselects all the entries in the collection.
    */
   void slotEditDeselect();
   /**
    * Toggles the edit widget.
    */
   void slotToggleEntryEditor();
   /**
    * Shows the configuration dialog for the application.
    */
   void slotShowConfigDialog();
   /**
    * Hides the configuration dialog for the application.
    */
   void slotHideConfigDialog();
   /**
    * Shows the fetch dialog.
    */
   void slotShowFetchDialog();
   /**
    * Hides the fetch dialog.
    */
   void slotHideFetchDialog();
   /**
    * Changes the statusbar contents for the standard label permanently,
    * used to indicate current actions being made.
    *
    * @param text The text that is displayed in the statusbar
    */
   void slotStatusMsg(const QString& text);
   void slotClearStatus();
   /**
    * Updates the entry count in the status bar.
    */
   void slotEntryCount();
   /**
    * Handles updating everything when the configuration is changed
    * via the configuration dialog. This slot is called when the OK or Apply
    * button is clicked in the dialog
    */
   void slotHandleConfigChange();
   /**
    * Changes the grouping of the entries in the @ref GroupView. The current value
    * of the combobox in the toolbar is used.
    */
   void slotChangeGrouping();
   /**
    * Imports data.
    *
    * @param format The import format
    */
   void slotFileImport(int format);
   /**
    * Exports the current document.
    *
    * @param format The export format
    */
   void slotFileExport(int format);
   /**
    * Shows the filter dialog for the application.
    */
   void slotShowFilterDialog();
   /**
    * Hides the filter dialog for the application.
    */
   void slotHideFilterDialog();
   /**
    * Shows the collection properties dialog for the application.
    */
   void slotShowCollectionFieldsDialog();
   /**
    * Hides the collection properties dialog for the application.
    */
   void slotHideCollectionFieldsDialog();
   /**
    * Shows the "Tip of the Day" dialog.
    *
    * @param force Whether the configuration setting should be ignored
    */
   void slotShowTipOfDay(bool force=true);
   /**
    * Shows the string macro editor dialog for the application.
    */
   void slotShowStringMacroDialog();
   /**
    * Shows the citation key dialog
    */
   void slotShowBibtexKeyDialog();
   /**
    * Hides the citation key dialog
    */
   void slotHideBibtexKeyDialog();
   /**
    * Handle a url that indicates some actino should be taken
    */
   void slotURLAction(const QUrl& url);
 
 private:
   /**
    * Saves the general options like all toolbar positions and status as well as the
    * geometry and the recent file list to the configuration file.
    */
   void saveOptions();
   /**
    * Reads the specific options.
    */
   void readOptions();
   /**
    * Initializes the QActions of the application
    */
   void initActions();
   /**
    * Sets up the statusbar for the main window by initializing a status label
    * and inserting a progress bar and entry counter.
    */
   void initStatusBar();
   /**
    * Initiates the view, setting up all the dock windows and so on.
    */
   void initView();
   /**
    * Initiates the document.
    */
   void initDocument();
   /**
    * Initiates all the signal and slot connections between major objects in the view.
    */
   void initConnections();
 
   bool querySaveModified();
 
   /**
    * Called before the window is closed, either by the user or indirectly by the
    * session manager.
    *
    * The purpose of this function is to prepare the window in a way that it is safe to close it,
    * i.e. without the user losing some data.
    * @see KMainWindow::queryClose
    */
   bool queryClose() Q_DECL_OVERRIDE;
   /**
    * Actual method used when opening a URL. Updating for the list views is turned off
    * as well as sorting, in order to more quickly load the document.
    *
    * @param url The url to open
    */
   bool openURL(const QUrl& url);
   /*
    * Helper method to handle the printing duties.
    *
    * @param html The HTML string representing the doc to print
    */
   void doPrint(const QString& html);
 
   void XSLTError();
   /**
    * Helper function to activate a slot in the edit widget.
    * Primarily used for copy, cut, and paste.
    *
    * @param slot The slot name
    */
   void activateEditSlot(const char* slot);
   void addFilterView();
   void addLoanView();
   void updateCaption(bool modified);
   void updateCollectionActions();
   void updateEntrySources();
 
 private Q_SLOTS:
   /**
    * Updates the actions when a file is opened.
    */
   void slotEnableOpenedActions();
   /**
    * Updates the save action and the caption when the document is modified.
    */
   void slotEnableModifiedActions(bool modified = true);
   /**
    * Read the options specific to a collection
    *
    * @param coll The collection pointer
    */
   void readCollectionOptions(Tellico::Data::CollPtr coll);
   /**
    * Saves the options relevant for a collection. I was having problems with the collection
    * being destructed before I could save info.
    *
    * @param coll A pointer to the collection
    */
   void saveCollectionOptions(Tellico::Data::CollPtr coll);
   /**
    * Queue a filter update. The timer adds a 200 millisecond delay before actually
    * updating the filter.
    */
   void slotQueueFilter();
   /**
    * Update the filter to match any field with text. If a non-word character appears, the
    * text is interpreted as a regexp.
    */
-  void slotUpdateFilter();
+  void slotCheckFilterQueue();
   void slotUpdateFilter(Tellico::FilterPtr filter);
   /**
    * Updates the collection toolbar.
    */
   void slotUpdateCollectionToolBar(Tellico::Data::CollPtr coll);
   /**
    * Make sure the edit dialog is visible and start a new entry.
    */
   void slotNewEntry();
   /**
    * Handle the entry editor dialog being closed.
    */
   void slotEditDialogFinished();
   /**
    * Handle the Ok button being clicked in the string macros dialog.
    */
   void slotStringMacroDialogFinished(int result=-1);
   /**
    * Since I use an application icon in the toolbar, I need to change its size whenever
    * the toolbar changes mode
    */
   void slotUpdateToolbarIcons();
   /**
    * Convert current collection to a bibliography.
    */
   void slotConvertToBibliography();
   /**
    * Send a citation for the selected entries
    */
   void slotCiteEntry(int action);
   /**
    * Show the entry editor and update menu item.
    */
   void slotShowEntryEditor();
   /**
    * Show the report window.
    */
   void slotShowReportDialog();
   /**
    * Show the report window.
    */
   void slotHideReportDialog();
   /**
    * Focus the filter
    */
   void slotGroupLabelActivated();
   void slotFilterLabelActivated();
   void slotClearFilter();
   void slotRenameCollection();
   void slotImageLocationMismatch();
   void slotImageLocationChanged();
   /**
    * Toggle full screen mode
    */
   void slotToggleFullScreen();
   /**
    * Toggle menubar visibility
    */
   void slotToggleMenuBarVisibility();
   void slotToggleLayoutLock(bool lock);
   void slotResetLayout();
   void guiFactoryReset();
 
 private:
   void importFile(Import::Format format, const QList<QUrl>& kurls);
   void importText(Import::Format format, const QString& text);
   bool importCollection(Data::CollPtr coll, Import::Action action);
 
   // the reason that I have to keep pointers to all these
   // is because they get plugged into menus later in Controller
   KRecentFilesAction* m_fileOpenRecent;
   QAction* m_fileSave;
   QAction* m_newEntry;
   QAction* m_editEntry;
   QAction* m_copyEntry;
   QAction* m_deleteEntry;
   QAction* m_mergeEntry;
   KActionMenu* m_updateEntryMenu;
   QAction* m_updateAll;
   QAction* m_checkInEntry;
   QAction* m_checkOutEntry;
   KToggleAction* m_toggleEntryEditor;
   KDualAction* m_lockLayout;
 
   KSelectAction* m_entryGrouping;
   GUI::LineEdit* m_quickFilter;
 
   QMainWindow* m_dummyWindow;
   GUI::DockWidget* m_groupViewDock;
   GUI::DockWidget* m_collectionViewDock;
 
   Tellico::StatusBar* m_statusBar;
 
   DetailedListView* m_detailedView;
   EntryEditDialog* m_editDialog;
   GUI::TabWidget* m_viewTabs;
   GroupView* m_groupView;
   FilterView* m_filterView;
   LoanView* m_loanView;
   EntryView* m_entryView;
   EntryIconView* m_iconView;
   ViewStack* m_viewStack;
   QSignalMapper* m_updateMapper;
 
   ConfigDialog* m_configDlg;
   FilterDialog* m_filterDlg;
   CollectionFieldsDialog* m_collFieldsDlg;
   StringMapDialog* m_stringMacroDlg;
   BibtexKeyDialog* m_bibtexKeyDlg;
   FetchDialog* m_fetchDlg;
   ReportDialog* m_reportDlg;
 
   QList<QAction*> m_fetchActions;
 
   // keep track of the number of queued filter updates
   uint m_queuedFilters;
 
   // keep track whether everything gets initialized
   bool m_initialized;
   // need to keep track of whether the current collection has never been saved
   bool m_newDocument;
   // Don't queue filter if true
   bool m_dontQueueFilter;
   bool m_savingImageLocationChange;
 };
 
 } // end namespace
 #endif // TELLICO_MAINWINDOW_H
diff --git a/src/models/entrysortmodel.cpp b/src/models/entrysortmodel.cpp
index 2974c50a..cf5fd0b8 100644
--- a/src/models/entrysortmodel.cpp
+++ b/src/models/entrysortmodel.cpp
@@ -1,126 +1,126 @@
 /***************************************************************************
     Copyright (C) 2008-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "entrysortmodel.h"
 #include "models.h"
 #include "fieldcomparison.h"
 #include "../field.h"
 #include "../entry.h"
 
 using Tellico::EntrySortModel;
 
 EntrySortModel::EntrySortModel(QObject* parent) : AbstractSortModel(parent) {
   setDynamicSortFilter(true);
   setSortLocaleAware(true);
-  connect(this, SIGNAL(modelReset()), SLOT(clearData()));
+  connect(this, &QAbstractItemModel::modelReset, this, &EntrySortModel::clearData);
 }
 
 void EntrySortModel::setFilter(Tellico::FilterPtr filter_) {
   if(m_filter != filter_ || (m_filter && *m_filter != *filter_)) {
     m_filter = filter_;
     invalidateFilter();
   }
 }
 
 Tellico::FilterPtr EntrySortModel::filter() const {
   return m_filter;
 }
 
 bool EntrySortModel::filterAcceptsRow(int row_, const QModelIndex& parent_) const {
   if(!m_filter) {
     return true;
   }
   QModelIndex index = sourceModel()->index(row_, 0, parent_);
   Q_ASSERT(index.isValid());
   Data::EntryPtr entry = index.data(EntryPtrRole).value<Data::EntryPtr>();
   Q_ASSERT(entry);
   return m_filter->matches(entry);
 }
 
 bool EntrySortModel::lessThan(const QModelIndex& left_, const QModelIndex& right_) const {
   if(sortRole() != EntryPtrRole) {
     return AbstractSortModel::lessThan(left_, right_);
   }
   Data::EntryPtr leftEntry = left_.data(EntryPtrRole).value<Data::EntryPtr>();
   Data::EntryPtr rightEntry = right_.data(EntryPtrRole).value<Data::EntryPtr>();
   if(!leftEntry) {
     if(rightEntry) {
       return true;
     } else {
       return false;
     }
   } else if(leftEntry && !rightEntry) {
     return false;
   }
 
   QModelIndex left = left_;
   QModelIndex right = right_;
 
   for(int i = 0; i < 3; ++i) {
     FieldComparison* comp = getComparison(left);
     if(!comp || !left.isValid() || !right.isValid()) {
       return false;
     }
 
     const int res = comp->compare(leftEntry, rightEntry);
     if(res == 0) {
       switch (i) {
         case 0:
           left = left.model()->index(left.row(), secondarySortColumn());
           right = right.model()->index(right.row(), secondarySortColumn());
           break;
         case 1:
           left = left.model()->index(left.row(), tertiarySortColumn());
           right = right.model()->index(right.row(), tertiarySortColumn());
           break;
         case 2:
           return false;
       }
     } else {
       return res < 0;
     }
   }
   return AbstractSortModel::lessThan(left_, right_);
 }
 
 void EntrySortModel::clearData() {
   m_filter = FilterPtr();
   qDeleteAll(m_comparisons);
   m_comparisons.clear();
 }
 
 Tellico::FieldComparison* EntrySortModel::getComparison(const QModelIndex& index_) const {
   if(m_comparisons.contains(index_.column())) {
     return m_comparisons.value(index_.column());
   }
   FieldComparison* comp = nullptr;
   if(index_.isValid()) {
     Data::FieldPtr field = index_.model()->headerData(index_.column(), Qt::Horizontal, FieldPtrRole).value<Data::FieldPtr>();
     if(field) {
       comp = FieldComparison::create(field);
       m_comparisons.insert(index_.column(), comp);
     }
   }
   return comp;
 }
diff --git a/src/models/groupsortmodel.cpp b/src/models/groupsortmodel.cpp
index 3280cf5f..59308fa6 100644
--- a/src/models/groupsortmodel.cpp
+++ b/src/models/groupsortmodel.cpp
@@ -1,123 +1,123 @@
 /***************************************************************************
     Copyright (C) 2008-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "groupsortmodel.h"
 #include "models.h"
 #include "stringcomparison.h"
 #include "../field.h"
 #include "../entrygroup.h"
 #include "../document.h"
 #include "../tellico_debug.h"
 
 using Tellico::GroupSortModel;
 
 GroupSortModel::GroupSortModel(QObject* parent) : AbstractSortModel(parent)
      , m_titleComparison(new TitleComparison())
      , m_groupComparison(nullptr) {
 }
 
 GroupSortModel::~GroupSortModel() {
   delete m_titleComparison;
   m_titleComparison = nullptr;
   delete m_groupComparison;
   m_groupComparison = nullptr;
 }
 
 void GroupSortModel::setSourceModel(QAbstractItemModel* sourceModel_) {
   AbstractSortModel::setSourceModel(sourceModel_);
   if(sourceModel_) {
-    connect(sourceModel_, SIGNAL(modelReset()),
-            this, SLOT(clearGroupComparison()));
+    connect(sourceModel_, &QAbstractItemModel::modelReset,
+            this, &GroupSortModel::clearGroupComparison);
   }
 }
 
 bool GroupSortModel::lessThan(const QModelIndex& left_, const QModelIndex& right_) const {
   // if the index have parents, then they represent entries, compare by title
   // calling index.parent() is expensive for the EntryGroupModel
   /// all we really need to know is whether the parent is valid
   const bool leftParentValid = sourceModel()->data(left_, ValidParentRole).toBool();
   const bool rightParentValid = sourceModel()->data(right_, ValidParentRole).toBool();
   if(!leftParentValid || !rightParentValid) {
     // now if we're using count, just pass up the line
     if(sortRole() == RowCountRole) {
       return AbstractSortModel::lessThan(left_, right_);
     }
 
     // we're dealing with groups
     Data::EntryGroup* leftGroup = sourceModel()->data(left_, GroupPtrRole).value<Data::EntryGroup*>();
     Data::EntryGroup* rightGroup = sourceModel()->data(right_, GroupPtrRole).value<Data::EntryGroup*>();
 
     // no matter what the sortRole is, the empty group is always first
     const bool emptyLeft = (!leftGroup || leftGroup->hasEmptyGroupName());
     const bool emptyRight = (!rightGroup || rightGroup->hasEmptyGroupName());
 
     bool reverseOrder = false;
     // sortOrder() was added in qt 4.5
 #if (QT_VERSION >= QT_VERSION_CHECK(4, 5, 0))
     if (sortOrder() == Qt::DescendingOrder) reverseOrder = true;
 #endif
 
     // yeah, I should figure out some bit-wise operations...whatever
     if(emptyLeft && !emptyRight) {
       return reverseOrder ? false : true;
     } else if(!emptyLeft && emptyRight) {
       return reverseOrder ? true : false;
     } else if(emptyLeft && emptyRight) {
       return reverseOrder ? true : false;
     }
 
    // if we can get the fields' type, then for certain non-text-only
     // types use the sort defined for that type.
     if(!m_groupComparison) {
       m_groupComparison = getComparison(leftGroup);
     }
     if(m_groupComparison) {
       return m_groupComparison->compare(leftGroup->groupName(), rightGroup->groupName()) < 0;
     }
     // couldn't determine the type or it's a type we want to sort
     // alphabetically, so sort by locale
     return left_.data().toString().localeAwareCompare(right_.data().toString()) < 0;
   }
 
   // for ordinary entries, just compare with title comparison
   return m_titleComparison->compare(left_.data().toString(), right_.data().toString()) < 0;
 }
 
 void GroupSortModel::clearGroupComparison() {
   delete m_groupComparison;
   m_groupComparison = nullptr;
 }
 
 // if 'group_' contains a type of field that merits a non-alphabetic
 // sort, return a pointer to the proper sort function.
 Tellico::StringComparison* GroupSortModel::getComparison(Data::EntryGroup* group_) const {
   StringComparison* comp = nullptr;
   if(group_) {
     Data::CollPtr coll = Data::Document::self()->collection();
     if(coll && coll->hasField(group_->fieldName())) {
       comp = StringComparison::create(coll->fieldByName(group_->fieldName()));
     }
   }
   return comp;
 }
diff --git a/src/reportdialog.cpp b/src/reportdialog.cpp
index 9b0f6c1c..0bdb7d48 100644
--- a/src/reportdialog.cpp
+++ b/src/reportdialog.cpp
@@ -1,256 +1,256 @@
 /***************************************************************************
     Copyright (C) 2005-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "reportdialog.h"
 #include "translators/htmlexporter.h"
 #include "images/imagefactory.h"
 #include "tellico_kernel.h"
 #include "collection.h"
 #include "document.h"
 #include "entry.h"
 #include "controller.h"
 #include "tellico_debug.h"
 #include "gui/combobox.h"
 #include "utils/cursorsaver.h"
 #include "utils/datafileregistry.h"
 #include "utils/tellico_utils.h"
 #include "config/tellico_config.h"
 
 #include <KLocalizedString>
 #include <KHTMLPart>
 #include <KHTMLView>
 #include <KStandardGuiItem>
 #include <KWindowConfig>
 #include <KConfigGroup>
 
 #include <QFile>
 #include <QLabel>
 #include <QFileInfo>
 #include <QTimer>
 #include <QTextStream>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QPushButton>
 #include <QFileDialog>
 #include <QDialogButtonBox>
 
 namespace {
   static const int REPORT_MIN_WIDTH = 600;
   static const int REPORT_MIN_HEIGHT = 420;
   static const char* dialogOptionsString = "Report Dialog Options";
 }
 
 using Tellico::ReportDialog;
 
 // default button is going to be used as a print button, so it's separated
 ReportDialog::ReportDialog(QWidget* parent_)
     : QDialog(parent_), m_exporter(nullptr) {
   setModal(false);
   setWindowTitle(i18n("Collection Report"));
 
   QWidget* mainWidget = new QWidget(this);
   QVBoxLayout* mainLayout = new QVBoxLayout();
   setLayout(mainLayout);
   mainLayout->addWidget(mainWidget);
 
   QVBoxLayout* topLayout = new QVBoxLayout(mainWidget);
 
   QBoxLayout* hlay = new QHBoxLayout();
   topLayout->addLayout(hlay);
   QLabel* l = new QLabel(i18n("&Report template:"), mainWidget);
   hlay->addWidget(l);
 
   QStringList files = Tellico::locateAllFiles(QStringLiteral("tellico/report-templates/*.xsl"));
   QMap<QString, QString> templates; // gets sorted by title
   foreach(const QString& file, files) {
     QFileInfo fi(file);
     QString lfile = fi.fileName();
     QString name = lfile.section(QLatin1Char('.'), 0, -2);
     name.replace(QLatin1Char('_'), QLatin1Char(' '));
     QString title = i18nc((name + QLatin1String(" XSL Template")).toUtf8().constData(), name.toUtf8().constData());
     templates.insert(title, lfile);
   }
 
   m_templateCombo = new GUI::ComboBox(mainWidget);
   for(QMap<QString, QString>::ConstIterator it = templates.constBegin(); it != templates.constEnd(); ++it) {
     m_templateCombo->addItem(it.key(), it.value());
   }
   hlay->addWidget(m_templateCombo);
   l->setBuddy(m_templateCombo);
 
   QPushButton* pb1 = new QPushButton(mainWidget);
   KGuiItem::assign(pb1, KGuiItem(i18n("&Generate"), QStringLiteral("application-x-executable")));
   hlay->addWidget(pb1);
-  connect(pb1, SIGNAL(clicked()), SLOT(slotGenerate()));
+  connect(pb1, &QAbstractButton::clicked, this, &ReportDialog::slotGenerate);
 
   hlay->addStretch();
 
   QPushButton* pb2 = new QPushButton(mainWidget);
   KGuiItem::assign(pb2, KStandardGuiItem::saveAs());
   hlay->addWidget(pb2);
-  connect(pb2, SIGNAL(clicked()), SLOT(slotSaveAs()));
+  connect(pb2, &QAbstractButton::clicked, this, &ReportDialog::slotSaveAs);
 
   QPushButton* pb3 = new QPushButton(mainWidget);
   KGuiItem::assign(pb3, KStandardGuiItem::print());
   hlay->addWidget(pb3);
-  connect(pb3, SIGNAL(clicked()), SLOT(slotPrint()));
+  connect(pb3, &QAbstractButton::clicked, this, &ReportDialog::slotPrint);
 
   m_HTMLPart = new KHTMLPart(mainWidget);
   m_HTMLPart->setJScriptEnabled(true);
   m_HTMLPart->setJavaEnabled(false);
   m_HTMLPart->setMetaRefreshEnabled(false);
   m_HTMLPart->setPluginsEnabled(false);
   topLayout->addWidget(m_HTMLPart->view());
 
   QColor color = palette().color(QPalette::Link);
   QString text = QString::fromLatin1("<html><style>p{font-weight:bold;width:50%;"
                                      "margin:20% auto auto auto;text-align:center;"
                                      "color:%1;}</style><body><p>").arg(color.name())
                + i18n("Select a report template and click <em>Generate</em>.") + QLatin1Char(' ')
                + i18n("Some reports may take several seconds to generate for large collections.")
                + QLatin1String("</p></body></html>");
   m_HTMLPart->begin();
   m_HTMLPart->write(text);
   m_HTMLPart->end();
 
   QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
   mainLayout->addWidget(buttonBox);
-  connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
-  connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
+  connect(buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
+  connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
   buttonBox->button(QDialogButtonBox::Close)->setDefault(true);
 
   setMinimumWidth(qMax(minimumWidth(), REPORT_MIN_WIDTH));
   setMinimumHeight(qMax(minimumHeight(), REPORT_MIN_HEIGHT));
 
-  QTimer::singleShot(0, this, SLOT(slotUpdateSize()));
+  QTimer::singleShot(0, this, &ReportDialog::slotUpdateSize);
 }
 
 ReportDialog::~ReportDialog() {
   delete m_exporter;
   m_exporter = nullptr;
 
   KConfigGroup config(KSharedConfig::openConfig(), QLatin1String(dialogOptionsString));
   KWindowConfig::saveWindowSize(windowHandle(), config);
 }
 
 void ReportDialog::slotGenerate() {
   GUI::CursorSaver cs(Qt::WaitCursor);
 
   QString fileName = QLatin1String("report-templates/") + m_templateCombo->currentData().toString();
   QString xsltFile = DataFileRegistry::self()->locate(fileName);
   if(xsltFile.isEmpty()) {
     myWarning() << "can't locate " << m_templateCombo->currentData().toString();
     return;
   }
   // if it's the same XSL file, no need to reload the XSLTHandler, just refresh
   if(xsltFile == m_xsltFile) {
     slotRefresh();
     return;
   }
 
   m_xsltFile = xsltFile;
 
   delete m_exporter;
   m_exporter = new Export::HTMLExporter(Data::Document::self()->collection());
   m_exporter->setXSLTFile(m_xsltFile);
   m_exporter->setPrintHeaders(false); // the templates should take care of this themselves
   m_exporter->setPrintGrouped(true); // allow templates to take advantage of added DOM
 
   slotRefresh();
 }
 
 void ReportDialog::slotRefresh() {
   if(!m_exporter) {
     myWarning() << "no exporter";
     return;
   }
 
   m_exporter->setGroupBy(Controller::self()->expandedGroupBy());
   m_exporter->setSortTitles(Controller::self()->sortTitles());
   m_exporter->setColumns(Controller::self()->visibleColumns());
   // only print visible entries
   m_exporter->setEntries(Controller::self()->visibleEntries());
 
   long options = Export::ExportUTF8 | Export::ExportComplete | Export::ExportImages;
   if(Config::autoFormat()) {
     options |= Export::ExportFormatted;
   }
   m_exporter->setOptions(options);
 
   // by setting the xslt file as the URL, any images referenced in the xslt "theme" can be found
   // by simply using a relative path in the xslt file
   QUrl u = QUrl::fromLocalFile(m_xsltFile);
   m_HTMLPart->begin(u);
   m_HTMLPart->write(m_exporter->text());
 #if 0
   myDebug() << "Remove debug from reportdialog.cpp";
   QFile f(QLatin1String("/tmp/test.html"));
   if(f.open(QIODevice::WriteOnly)) {
     QTextStream t(&f);
     t << m_exporter->text();
   }
   f.close();
 #endif
   m_HTMLPart->end();
   // is this needed?
 //  view()->layout();
 }
 
 // actually the print button
 void ReportDialog::slotPrint() {
   m_HTMLPart->view()->print();
 }
 
 void ReportDialog::slotSaveAs() {
   QString filter = i18n("HTML Files") + QLatin1String(" (*.html)")
                  + QLatin1String(";;")
                  + i18n("All Files") + QLatin1String(" (*)");
   QUrl u = QFileDialog::getSaveFileUrl(this, QString(), QUrl(), filter);
   if(!u.isEmpty() && u.isValid()) {
     KConfigGroup config(KSharedConfig::openConfig(), "ExportOptions");
     bool encode = config.readEntry("EncodeUTF8", true);
     long oldOpt = m_exporter->options();
 
     // turn utf8 off
     long options = oldOpt & ~Export::ExportUTF8;
     // now turn it on if true
     if(encode) {
       options |= Export::ExportUTF8;
     }
 
     QUrl oldURL = m_exporter->url();
     m_exporter->setOptions(options);
     m_exporter->setURL(u);
 
     m_exporter->exec();
 
     m_exporter->setURL(oldURL);
     m_exporter->setOptions(oldOpt);
   }
 }
 
 void ReportDialog::slotUpdateSize() {
   KConfigGroup config(KSharedConfig::openConfig(), QLatin1String(dialogOptionsString));
   KWindowConfig::restoreWindowSize(windowHandle(), config);
 }
diff --git a/src/translators/audiofileimporter.cpp b/src/translators/audiofileimporter.cpp
index 2f7c208e..3e25d8fb 100644
--- a/src/translators/audiofileimporter.cpp
+++ b/src/translators/audiofileimporter.cpp
@@ -1,484 +1,484 @@
 /***************************************************************************
     Copyright (C) 2004-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include <config.h>
 
 #include "audiofileimporter.h"
 #include "../collections/musiccollection.h"
 #include "../entry.h"
 #include "../field.h"
 #include "../fieldformat.h"
 #include "../images/imagefactory.h"
 #include "../utils/string_utils.h"
 #include "../utils/tellico_utils.h"
 #include "../tellico_kernel.h"
 #include "../progressmanager.h"
 #include "../tellico_debug.h"
 
 #ifdef HAVE_TAGLIB
 #include <fileref.h>
 #include <tag.h>
 #include <id3v2tag.h>
 #include <mpegfile.h>
 #include <vorbisfile.h>
 #include <flacfile.h>
 #include <audioproperties.h>
 #endif
 
 #include <KLocalizedString>
 
 #include <QLabel>
 #include <QGroupBox>
 #include <QCheckBox>
 #include <QDir>
 #include <QTextStream>
 #include <QVBoxLayout>
 #include <QApplication>
 
 using Tellico::Import::AudioFileImporter;
 
 AudioFileImporter::AudioFileImporter(const QUrl& url_) : Tellico::Import::Importer(url_)
     , m_widget(nullptr)
     , m_recursive(nullptr)
     , m_addFilePath(nullptr)
     , m_addBitrate(nullptr)
     , m_cancelled(false) {
 }
 
 bool AudioFileImporter::canImport(int type) const {
   return type == Data::Collection::Album;
 }
 
 Tellico::Data::CollPtr AudioFileImporter::collection() {
 #ifndef HAVE_TAGLIB
   return Data::CollPtr();
 #else
 
   if(m_coll) {
     return m_coll;
   }
 
   ProgressItem& item = ProgressManager::self()->newProgressItem(this, i18n("Scanning audio files..."), true);
   item.setTotalSteps(100);
   connect(&item, &Tellico::ProgressItem::signalCancelled, this, &Tellico::Import::AudioFileImporter::slotCancel);
   ProgressItem::Done done(this);
 
   // TODO: allow remote audio file importing
   QStringList dirs;
   dirs += url().path();
   if(m_recursive->isChecked()) {
     dirs += Tellico::findAllSubDirs(dirs[0]);
   }
 
   if(m_cancelled) {
     return Data::CollPtr();
   }
 
   const bool showProgress = options() & ImportProgress;
 
   QStringList files;
   for(QStringList::ConstIterator it = dirs.constBegin(); !m_cancelled && it != dirs.constEnd(); ++it) {
     if((*it).isEmpty()) {
       continue;
     }
 
     QDir dir(*it);
     dir.setFilter(QDir::Files | QDir::Readable | QDir::Hidden); // hidden since I want directory files
     const QStringList list = dir.entryList();
     for(QStringList::ConstIterator it2 = list.begin(); it2 != list.end(); ++it2) {
       files += dir.absoluteFilePath(*it2);
     }
 //    qApp->processEvents(); not needed ?
   }
 
   if(m_cancelled) {
     return Data::CollPtr();
   }
   item.setTotalSteps(files.count());
 
   const QString title    = QStringLiteral("title");
   const QString artist   = QStringLiteral("artist");
   const QString year     = QStringLiteral("year");
   const QString genre    = QStringLiteral("genre");
   const QString track    = QStringLiteral("track");
   const QString comments = QStringLiteral("comments");
   const QString file     = QStringLiteral("file");
 
   m_coll = new Data::MusicCollection(true);
 
   const bool addFile = m_addFilePath->isChecked();
   const bool addBitrate = m_addBitrate->isChecked();
 
   Data::FieldPtr f;
   if(addFile) {
     f = m_coll->fieldByName(file);
     if(!f) {
       f = new Data::Field(file, i18n("Files"), Data::Field::Table);
       m_coll->addField(f);
     }
     f->setProperty(QStringLiteral("column1"), i18n("Files"));
     if(addBitrate) {
       f->setProperty(QStringLiteral("columns"), QStringLiteral("2"));
       f->setProperty(QStringLiteral("column2"), i18n("Bitrate"));
     } else {
       f->setProperty(QStringLiteral("columns"), QStringLiteral("1"));
     }
   }
 
   QHash<QString, Data::EntryPtr> albumMap;
 
   QStringList directoryFiles;
   const uint stepSize = qMax(1, files.count() / 100);
 
   bool changeTrackTitle = true;
   uint j = 0;
   for(QStringList::ConstIterator it = files.constBegin(); !m_cancelled && it != files.constEnd(); ++it, ++j) {
     TagLib::FileRef f(QFile::encodeName(*it).data());
     if(f.isNull() || !f.tag()) {
       if((*it).endsWith(QLatin1String("/.directory"))) {
         directoryFiles += *it;
       }
       continue;
     }
 
     TagLib::Tag* tag = f.tag();
     QString album = TStringToQString(tag->album()).trimmed();
     if(album.isEmpty()) {
       // can't do anything since tellico entries are by album
       myWarning() << "Skipping: no album listed for " << *it;
       continue;
     }
     int disc = discNumber(f);
     if(disc > 1 && !m_coll->hasField(QStringLiteral("track%1").arg(disc))) {
       Data::FieldPtr f2(new Data::Field(QStringLiteral("track%1").arg(disc),
                                         i18n("Tracks (Disc %1)", disc),
                                         Data::Field::Table));
       f2->setFormatType(FieldFormat::FormatTitle);
       f2->setProperty(QStringLiteral("columns"), QStringLiteral("3"));
       f2->setProperty(QStringLiteral("column1"), i18n("Title"));
       f2->setProperty(QStringLiteral("column2"), i18n("Artist"));
       f2->setProperty(QStringLiteral("column3"), i18n("Length"));
       m_coll->addField(f2);
       if(changeTrackTitle) {
         Data::FieldPtr newTrack(new Data::Field(*m_coll->fieldByName(track)));
         newTrack->setTitle(i18n("Tracks (Disc %1)", 1));
         m_coll->modifyField(newTrack);
         changeTrackTitle = false;
       }
     }
     bool exists = true;
     Data::EntryPtr entry;
 /*
     Let's assume an album already exists (has already been imported) if an
     album entry with same Album Title and Album Artist is found; indeed,
     multiple albums can have the same title (but from different artists),
     but this is very unlikely the same artist release multiple albums with
     the same title. Therefore, we propose to make an album entry ID as follows:
     "<album title>::<album artist>" if album artist info is available,
     "<album title>" if not.
 */
     QString albumKey = album.toLower();
 /*
     For MP3 files, get the Album Artist from the ID3v2 TPE2 frame.
     See http://www.id3.org/id3v2.4.0-frames for a description of this frame.
     Although this is not standard in ID3, using a specific frame for album
     artist is a solution to the problem of tagging albums that feature
     various artists but still have an identified Album Artist, such as
     Remix and DJ albums. Example:
     Album title: Some Title; Album artist: Some DJ;
                  Track 1: Some Track Title - Some Artist(s);
                  Track 2: Some Other Track Title - Some Other Artist(s), etc.
     We read the Album Artist from the TPE2 frame to be compatible with
     Amarok as the most popular music player by KDE, but also Apple (iTunes),
     Microsoft (Windows Media Player) and others which use this frame to
     read/write the album artist too.
     See Amarok source file src/collectionscanner/CollectionScanner.cpp,
     method AttributeHash CollectionScanner::readTags(...).
 */
     // TODO: find another way for non-MP3 files
     QString albumArtist;
 /*  As mpeg implementation on TagLib uses a Tag class that's not defined on the headers,
     we have to cast the files, not the tags!
 */
     TagLib::MPEG::File* mpegFile = dynamic_cast<TagLib::MPEG::File*>(f.file());
     if(mpegFile && mpegFile->ID3v2Tag() && !mpegFile->ID3v2Tag()->frameListMap()["TPE2"].isEmpty()) {
       albumArtist = TStringToQString(mpegFile->ID3v2Tag()->frameListMap()["TPE2"].front()->toString()).trimmed();
       if(!albumArtist.isEmpty()) {
         albumKey += FieldFormat::columnDelimiterString() + albumArtist.toLower();
       }
     }
 
     entry = albumMap[albumKey];
     if(!entry) {
       entry = Data::EntryPtr(new Data::Entry(m_coll));
       albumMap.insert(albumKey, entry);
       exists = false;
     }
     // album entries use the album name as the title
     entry->setField(title, album);
     QString a = TStringToQString(tag->artist()).trimmed();
     // If no album artist identified, we use track artist as album artist, or  "(Various)" if tracks have various artists.
     if(!albumArtist.isEmpty()) {
       entry->setField(artist, albumArtist);
     } else if(!a.isEmpty()) {
       if(exists && entry->field(artist).toLower() != a.toLower()) {
         entry->setField(artist, i18n("(Various)"));
       } else {
         entry->setField(artist, a);
       }
     }
     if(tag->year() > 0) {
       entry->setField(year, QString::number(tag->year()));
     }
     if(!tag->genre().isEmpty()) {
       entry->setField(genre, TStringToQString(tag->genre()).trimmed());
     }
 
     if(!tag->title().isEmpty()) {
       int trackNum = tag->track();
       if(trackNum <= 0) { // try to figure out track number from file name
         QFileInfo f(*it);
         QString fileName = f.baseName();
         QString numString;
         int i = 0;
         const int len = fileName.length();
         while(fileName[i].isNumber() && i < len) {
           i++;
         }
         if(i == 0) { // does not start with a number
           i = len - 1;
           while(i >= 0 && fileName[i].isNumber()) {
             i--;
           }
           // file name ends with a number
           if(i != len - 1) {
             numString = fileName.mid(i + 1);
           }
         } else {
           numString = fileName.mid(0, i);
         }
         bool ok;
         int number = numString.toInt(&ok);
         if(ok) {
           trackNum = number;
         }
       }
       if(trackNum > 0) {
         QString t = TStringToQString(tag->title()).trimmed();
         t += FieldFormat::columnDelimiterString() + a;
         const int len = f.audioProperties()->length();
         if(len > 0) {
           t += FieldFormat::columnDelimiterString() + Tellico::minutes(len);
         }
         QString realTrack = disc > 1 ? track + QString::number(disc) : track;
         entry->setField(realTrack, insertValue(entry->field(realTrack), t, trackNum));
         if(addFile) {
           QString fileValue = *it;
           if(addBitrate) {
             fileValue += FieldFormat::columnDelimiterString() + QString::number(f.audioProperties()->bitrate());
           }
           entry->setField(file, insertValue(entry->field(file), fileValue, trackNum));
         }
       } else {
         myDebug() << *it << " contains no track number and track number cannot be determined, so the track is not imported.";
       }
     } else {
       myDebug() << *it << " has an empty title, so the track is not imported.";
     }
     if(!tag->comment().stripWhiteSpace().isEmpty()) {
       QString c = entry->field(comments);
       if(!c.isEmpty()) {
         c += QLatin1String("<br/>");
       }
       if(!tag->title().isEmpty()) {
         c += QLatin1String("<em>") + TStringToQString(tag->title()).trimmed() + QLatin1String("</em> - ");
       }
       c += TStringToQString(tag->comment().stripWhiteSpace());
       entry->setField(comments, c);
     }
 
     if(!exists) {
       m_coll->addEntries(entry);
     }
     if(showProgress && j%stepSize == 0) {
       ProgressManager::self()->setTotalSteps(this, files.count() + directoryFiles.count());
       ProgressManager::self()->setProgress(this, j);
       qApp->processEvents();
     }
 
 /*    myDebug() << "-- TAG --";
     myDebug() << "title   - \"" << tag->title().to8Bit()   << "\"";
     myDebug() << "artist  - \"" << tag->artist().to8Bit()  << "\"";
     myDebug() << "album   - \"" << tag->album().to8Bit()   << "\"";
     myDebug() << "year    - \"" << tag->year()             << "\"";
     myDebug() << "comment - \"" << tag->comment().to8Bit() << "\"";
     myDebug() << "track   - \"" << tag->track()            << "\"";
     myDebug() << "genre   - \"" << tag->genre().to8Bit()   << "\"";*/
   }
 
   if(m_cancelled) {
     m_coll = Data::CollPtr();
     return m_coll;
   }
 
   QTextStream ts;
   QRegExp iconRx(QLatin1String("Icon\\s*=\\s*(.*)"));
   for(QStringList::ConstIterator it = directoryFiles.constBegin(); !m_cancelled && it != directoryFiles.constEnd(); ++it, ++j) {
     QFile file(*it);
     if(!file.open(QIODevice::ReadOnly)) {
       continue;
     }
     ts.setDevice(&file);
     for(QString line = ts.readLine(); !line.isNull(); line = ts.readLine()) {
       if(!iconRx.exactMatch(line)) {
         continue;
       }
       QDir thisDir(*it);
       thisDir.cdUp();
       QFileInfo fi(thisDir, iconRx.cap(1));
       Data::EntryPtr entry = albumMap[thisDir.dirName()];
       if(!entry) {
         continue;
       }
       QUrl u;
       u.setPath(fi.absoluteFilePath());
       QString id = ImageFactory::addImage(u, true);
       if(!id.isEmpty()) {
         entry->setField(QStringLiteral("cover"), id);
       }
       break;
     }
 
     if(showProgress && j%stepSize == 0) {
       ProgressManager::self()->setProgress(this, j);
       qApp->processEvents();
     }
   }
 
   if(m_cancelled) {
     m_coll = Data::CollPtr();
   }
 
   return m_coll;
 #endif
 }
 
 QWidget* AudioFileImporter::widget(QWidget* parent_) {
   if(m_widget) {
     return m_widget;
   }
 
   m_widget = new QWidget(parent_);
   QVBoxLayout* l = new QVBoxLayout(m_widget);
 
   QGroupBox* gbox = new QGroupBox(i18n("Audio File Options"), m_widget);
   QVBoxLayout* vlay = new QVBoxLayout(gbox);
 
   m_recursive = new QCheckBox(i18n("Recursive &folder search"), gbox);
   m_recursive->setWhatsThis(i18n("If checked, folders are recursively searched for audio files."));
   // by default, make it checked
   m_recursive->setChecked(true);
 
   m_addFilePath = new QCheckBox(i18n("Include file &location"), gbox);
   m_addFilePath->setWhatsThis(i18n("If checked, the file names for each track are added to the entries."));
   m_addFilePath->setChecked(false);
-  connect(m_addFilePath, SIGNAL(toggled(bool)), SLOT(slotAddFileToggled(bool)));
+  connect(m_addFilePath, &QAbstractButton::toggled, this, &AudioFileImporter::slotAddFileToggled);
 
   m_addBitrate = new QCheckBox(i18n("Include &bitrate"), gbox);
   m_addBitrate->setWhatsThis(i18n("If checked, the bitrate for each track is added to the entries."));
   m_addBitrate->setChecked(false);
   m_addBitrate->setEnabled(false);
 
   vlay->addWidget(m_recursive);
   vlay->addWidget(m_addFilePath);
   vlay->addWidget(m_addBitrate);
 
   l->addWidget(gbox);
   l->addStretch(1);
   return m_widget;
 }
 
 // pos_ is NOT zero-indexed!
 QString AudioFileImporter::insertValue(const QString& str_, const QString& value_, int pos_) {
   QStringList list = FieldFormat::splitTable(str_);
   for(int i = list.count(); i < pos_; ++i) {
     list.append(QString());
   }
   if(!list.at(pos_-1).isEmpty()) {
     myDebug() << "overwriting track " << pos_;
     myDebug() << "*** Old value: " << list[pos_-1];
     myDebug() << "*** New value: " << value_;
   }
   list[pos_-1] = value_;
   return list.join(FieldFormat::rowDelimiterString());
 }
 
 void AudioFileImporter::slotCancel() {
   m_cancelled = true;
 }
 
 void AudioFileImporter::slotAddFileToggled(bool on_) {
   m_addBitrate->setEnabled(on_);
   if(!on_) {
     m_addBitrate->setChecked(false);
   }
 }
 
 int AudioFileImporter::discNumber(const TagLib::FileRef& ref_) const {
   // default to 1 unless otherwise
   int num = 1;
 #ifdef HAVE_TAGLIB
   QString disc;
   if(TagLib::MPEG::File* file = dynamic_cast<TagLib::MPEG::File*>(ref_.file())) {
     if(file->ID3v2Tag() && !file->ID3v2Tag()->frameListMap()["TPOS"].isEmpty()) {
       disc = TStringToQString(file->ID3v2Tag()->frameListMap()["TPOS"].front()->toString()).trimmed();
     }
   } else if(TagLib::Ogg::Vorbis::File* file = dynamic_cast<TagLib::Ogg::Vorbis::File*>(ref_.file())) {
     if(file->tag() && !file->tag()->fieldListMap()["DISCNUMBER"].isEmpty()) {
       disc = TStringToQString(file->tag()->fieldListMap()["DISCNUMBER"].front()).trimmed();
     }
   } else if(TagLib::FLAC::File* file = dynamic_cast<TagLib::FLAC::File*>(ref_.file())) {
     if(file->xiphComment() && !file->xiphComment()->fieldListMap()["DISCNUMBER"].isEmpty()) {
       disc = TStringToQString(file->xiphComment()->fieldListMap()["DISCNUMBER"].front()).trimmed();
     }
   }
 
   if(!disc.isEmpty()) {
     int pos = disc.indexOf(QLatin1Char('/'));
     int n;
     bool ok;
     if(pos == -1) {
       n = disc.toInt(&ok);
     } else {
       n = disc.leftRef(pos).toInt(&ok);
     }
     if(ok && n > 0) {
       num = n;
     }
   }
 #else
   Q_UNUSED(ref_);
 #endif
   return num;
 }
diff --git a/src/translators/csvexporter.cpp b/src/translators/csvexporter.cpp
index a50e22b9..9698662d 100644
--- a/src/translators/csvexporter.cpp
+++ b/src/translators/csvexporter.cpp
@@ -1,254 +1,254 @@
 /***************************************************************************
     Copyright (C) 2003-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "csvexporter.h"
 #include "../collection.h"
 #include "../core/filehandler.h"
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 
 #include <QLineEdit>
 #include <QGroupBox>
 #include <QCheckBox>
 #include <QRadioButton>
 #include <QGridLayout>
 #include <QVBoxLayout>
 #include <QLabel>
 
 using namespace Tellico;
 using Tellico::Export::CSVExporter;
 
 CSVExporter::CSVExporter(Data::CollPtr coll_) : Tellico::Export::Exporter(coll_),
     m_includeTitles(true),
     m_delimiter(QStringLiteral(",")),
     m_colDelimiter(QStringLiteral(":")),
     m_rowDelimiter(QStringLiteral("|")),
     m_widget(nullptr),
     m_checkIncludeTitles(nullptr),
     m_radioComma(nullptr),
     m_radioSemicolon(nullptr),
     m_radioTab(nullptr),
     m_radioOther(nullptr),
     m_editOther(nullptr),
     m_colDelimiterEdit(nullptr),
     m_rowDelimiterEdit(nullptr) {
 }
 
 QString CSVExporter::formatString() const {
   return i18n("CSV");
 }
 
 QString CSVExporter::fileFilter() const {
   return i18n("CSV Files") + QLatin1String(" (*.csv)") + QLatin1String(";;") + i18n("All Files") + QLatin1String(" (*)");
 }
 
 QString& CSVExporter::escapeText(QString& text_) const {
   bool quotes = false;
   if(text_.contains(QLatin1Char('"'))) {
     quotes = true;
     // quotation marks will be escaped by using a double pair
     text_.replace(QLatin1Char('"'), QLatin1String("\"\""));
   }
   // if the text contains quotes or the delimiter, it needs to be surrounded by quotes
   if(quotes || text_.contains(m_delimiter) || text_.contains(QLatin1Char('\n'))) {
     text_.prepend(QLatin1Char('"'));
     text_.append(QLatin1Char('"'));
   }
   return text_;
 }
 
 bool CSVExporter::exec() {
   if(!collection()) {
     return false;
   }
 
   return FileHandler::writeTextURL(url(), text(), options() & ExportUTF8, options() & Export::ExportForce);
 }
 
 QString CSVExporter::text() const {
   QString text;
 
   if(m_includeTitles) {
     foreach(Data::FieldPtr fIt, fields()) {
       QString title = fIt->title();
       // because of Microsoft Excel bug, http://support.microsoft.com/kb/323626
       if(text.isEmpty() && title == QLatin1String("ID")) {
         title = QStringLiteral("Id");
       }
       text += escapeText(title) + m_delimiter;
     }
     // remove last delimiter
     text.truncate(text.length() - m_delimiter.length());
     text += QLatin1Char('\n');
   }
 
   FieldFormat::Request format = (options() & Export::ExportFormatted ?
                                                 FieldFormat::ForceFormat :
                                                 FieldFormat::AsIsFormat);
 
   const bool replaceColDelimiter = (m_colDelimiter != FieldFormat::columnDelimiterString());
   const bool replaceRowDelimiter = (m_rowDelimiter != FieldFormat::rowDelimiterString());
 
   foreach(Data::EntryPtr entryIt, entries()) {
     QStringList values;
     foreach(Data::FieldPtr fIt, fields()) {
       QString value = entryIt->formattedField(fIt->name(), format);
       if(replaceColDelimiter) {
         value.replace(FieldFormat::columnDelimiterString(), m_colDelimiter);
       }
       if(replaceRowDelimiter) {
         value.replace(FieldFormat::rowDelimiterString(), m_rowDelimiter);
       }
       values += escapeText(value);
     }
     text += values.join(m_delimiter) + QLatin1Char('\n');
   }
   return text;
 }
 
 QWidget* CSVExporter::widget(QWidget* parent_) {
   if(m_widget && m_widget->parent() == parent_) {
     return m_widget;
   }
 
   m_widget = new QWidget(parent_);
   QVBoxLayout* l = new QVBoxLayout(m_widget);
 
   QGroupBox* gbox = new QGroupBox(i18n("CSV Options"), m_widget);
   QVBoxLayout* vlay = new QVBoxLayout(gbox);
 
   m_checkIncludeTitles = new QCheckBox(i18n("Include field titles as column headers"), gbox);
   m_checkIncludeTitles->setChecked(m_includeTitles);
   m_checkIncludeTitles->setWhatsThis(i18n("If checked, a header row will be added with the "
                                           "field titles."));
 
   QGroupBox* delimiterGroup = new QGroupBox(i18n("Delimiter"), gbox);
   QGridLayout* m_delimiterGroupLayout = new QGridLayout(delimiterGroup);
   m_delimiterGroupLayout->setAlignment(Qt::AlignTop);
   delimiterGroup->setWhatsThis(i18n("In addition to a comma, other characters may be used as "
                                     "a delimiter, separating each value in the file."));
 
   m_radioComma = new QRadioButton(delimiterGroup);
   m_radioComma->setText(i18n("Comma"));
   m_radioComma->setChecked(true);
   m_radioComma->setWhatsThis(i18n("Use a comma as the delimiter."));
   m_delimiterGroupLayout->addWidget(m_radioComma, 0, 0);
 
   m_radioSemicolon = new QRadioButton( delimiterGroup);
   m_radioSemicolon->setText(i18n("Semicolon"));
   m_radioSemicolon->setWhatsThis(i18n("Use a semi-colon as the delimiter."));
   m_delimiterGroupLayout->addWidget(m_radioSemicolon, 0, 1);
 
   m_radioTab = new QRadioButton(delimiterGroup);
   m_radioTab->setText(i18n("Tab"));
   m_radioTab->setWhatsThis(i18n("Use a tab as the delimiter."));
   m_delimiterGroupLayout->addWidget(m_radioTab, 1, 0);
 
   m_radioOther = new QRadioButton(delimiterGroup);
   m_radioOther->setText(i18n("Other"));
   m_radioOther->setWhatsThis(i18n("Use a custom string as the delimiter."));
   m_delimiterGroupLayout->addWidget(m_radioOther, 1, 1);
 
   m_editOther = new QLineEdit(delimiterGroup);
   m_editOther->setEnabled(m_radioOther->isChecked());
   m_editOther->setWhatsThis(i18n("A custom string, such as a colon, may be used as a delimiter."));
   m_delimiterGroupLayout->addWidget(m_editOther, 1, 2);
-  QObject::connect(m_radioOther, SIGNAL(toggled(bool)),
-                   m_editOther, SLOT(setEnabled(bool)));
+  QObject::connect(m_radioOther, &QAbstractButton::toggled,
+                   m_editOther, &QWidget::setEnabled);
 
   if(m_delimiter == QLatin1String(",")) {
     m_radioComma->setChecked(true);
   } else if(m_delimiter == QLatin1String(";")) {
     m_radioSemicolon->setChecked(true);
   } else if(m_delimiter == QLatin1String("\t")) {
     m_radioTab->setChecked(true);
   } else if(!m_delimiter.isEmpty()) {
     m_radioOther->setChecked(true);
     m_editOther->setEnabled(true);
     m_editOther->setText(m_delimiter);
   }
 
   QLabel* label = new QLabel(i18n("Table column delimiter:"), gbox);
   m_colDelimiterEdit = new QLineEdit(gbox);
   m_colDelimiterEdit->setText(m_colDelimiter);
   m_delimiterGroupLayout->addWidget(label, 2, 0, 1, 2);
   m_delimiterGroupLayout->addWidget(m_colDelimiterEdit, 2, 2);
   QString w = i18n("The column delimiter separates values in each column of a <i>Table</i> field.");
   label->setWhatsThis(w);
   m_colDelimiterEdit->setWhatsThis(w);
 
   label = new QLabel(i18n("Table row delimiter:"), gbox);
   m_rowDelimiterEdit = new QLineEdit(gbox);
   m_rowDelimiterEdit->setText(m_rowDelimiter);
   m_delimiterGroupLayout->addWidget(label, 3, 0, 1, 2);
   m_delimiterGroupLayout->addWidget(m_rowDelimiterEdit, 3, 2);
   w = i18n("The row delimiter separates values in each row of a <i>Table</i> field.");
   label->setWhatsThis(w);
   m_rowDelimiterEdit->setWhatsThis(w);
 
   vlay->addWidget(m_checkIncludeTitles);
   vlay->addWidget(delimiterGroup);
 
   l->addWidget(gbox);
   l->addStretch(1);
   return m_widget;
 }
 
 void CSVExporter::readOptions(KSharedConfigPtr config_) {
   KConfigGroup group(config_, QStringLiteral("ExportOptions - %1").arg(formatString()));
   m_includeTitles = group.readEntry("Include Titles", m_includeTitles);
   m_delimiter = group.readEntry("Delimiter", m_delimiter);
   m_rowDelimiter = group.readEntry("RowDelimiter", m_rowDelimiter);
   m_colDelimiter = group.readEntry("ColumnDelimiter", m_colDelimiter);
 }
 
 void CSVExporter::saveOptions(KSharedConfigPtr config_) {
   m_includeTitles = m_checkIncludeTitles->isChecked();
   if(m_radioComma->isChecked()) {
     m_delimiter = QLatin1Char(',');
   } else if(m_radioSemicolon->isChecked()) {
     m_delimiter = QLatin1Char(';');
   } else if(m_radioTab->isChecked()) {
     m_delimiter = QLatin1Char('\t');
   } else {
     m_delimiter = m_editOther->text();
   }
 
   QString s = m_colDelimiterEdit->text();
   if(!s.isEmpty()) {
     m_colDelimiter = s;
   }
 
   s = m_rowDelimiterEdit->text();
   if(!s.isEmpty()) {
     m_rowDelimiter = s;
   }
 
   KConfigGroup group(config_, QStringLiteral("ExportOptions - %1").arg(formatString()));
   group.writeEntry("Include Titles", m_includeTitles);
   group.writeEntry("Delimiter", m_delimiter);
   group.writeEntry("RowDelimiter", m_rowDelimiter);
   group.writeEntry("ColumnDelimiter", m_colDelimiter);
 }
diff --git a/src/translators/csvimporter.cpp b/src/translators/csvimporter.cpp
index 6f9aaf05..2cda7138 100644
--- a/src/translators/csvimporter.cpp
+++ b/src/translators/csvimporter.cpp
@@ -1,651 +1,654 @@
 /***************************************************************************
     Copyright (C) 2003-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "csvimporter.h"
 #include "csvparser.h"
 #include "translators.h" // needed for ImportAction
 #include "../collectionfieldsdialog.h"
 #include "../collection.h"
 #include "../tellico_debug.h"
 #include "../collectionfactory.h"
 #include "../gui/collectiontypecombo.h"
 #include "../utils/stringset.h"
 
 #include <KComboBox>
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <KMessageBox>
 #include <KLocalizedString>
 
 #include <QSpinBox>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QGroupBox>
 #include <QLabel>
 #include <QCheckBox>
 #include <QRadioButton>
 #include <QTableWidget>
 #include <QHeaderView>
 #include <QRegExp>
 #include <QGridLayout>
 #include <QByteArray>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QButtonGroup>
 #include <QApplication>
 
 using Tellico::Import::CSVImporter;
 
 CSVImporter::CSVImporter(const QUrl& url_) : Tellico::Import::TextImporter(url_),
     m_existingCollection(nullptr),
     m_firstRowHeader(false),
     m_delimiter(QStringLiteral(",")),
     m_cancelled(false),
     m_widget(nullptr),
     m_comboColl(nullptr),
     m_checkFirstRowHeader(nullptr),
     m_radioComma(nullptr),
     m_radioSemicolon(nullptr),
     m_radioTab(nullptr),
     m_radioOther(nullptr),
     m_editOther(nullptr),
     m_editColDelimiter(nullptr),
     m_editRowDelimiter(nullptr),
     m_table(nullptr),
     m_colSpinBox(nullptr),
     m_comboField(nullptr),
     m_setColumnBtn(nullptr),
     m_hasAssignedFields(false),
     m_isLibraryThing(false),
     m_parser(new CSVParser(text())) {
   m_parser->setDelimiter(m_delimiter);
 }
 
 CSVImporter::~CSVImporter() {
   delete m_parser;
   m_parser = nullptr;
 }
 
 Tellico::Data::CollPtr CSVImporter::collection() {
   // don't just check if m_coll is non-null since the collection can be created elsewhere
   if(m_coll && m_coll->entryCount() > 0) {
     return m_coll;
   }
 
   if(!m_coll) {
     createCollection();
   }
 
   const QStringList existingNames = m_coll->fieldNames();
 
   QList<int> cols;
   cols.reserve(m_table->columnCount());
   QStringList names;
   names.reserve(m_table->columnCount());
   for(int col = 0; col < m_table->columnCount(); ++col) {
     QString t = m_table->horizontalHeaderItem(col)->text();
     if(m_coll->fieldByTitle(t)) {
       cols << col;
       names << m_coll->fieldNameByTitle(t);
     }
   }
 
   if(names.isEmpty()) {
     myDebug() << "no fields assigned";
     return Data::CollPtr();
   }
 
   m_parser->reset(text());
 
   // if the first row are headers, skip it
   if(m_firstRowHeader) {
     m_parser->skipLine();
   }
 
   const uint numChars = text().size();
   const uint stepSize = qMax(s_stepSize, numChars/100);
   const bool showProgress = options() & ImportProgress;
 
   // do we need to replace column or row delimiters
   const bool replaceColDelimiter = (!m_colDelimiter.isEmpty() && m_colDelimiter != FieldFormat::columnDelimiterString());
   const bool replaceRowDelimiter = (!m_rowDelimiter.isEmpty() && m_rowDelimiter != FieldFormat::rowDelimiterString());
 
   uint j = 0;
   while(!m_cancelled && m_parser->hasNext()) {
     bool empty = true;
     Data::EntryPtr entry(new Data::Entry(m_coll));
     QStringList values = m_parser->nextTokens();
     for(int i = 0; i < names.size(); ++i) {
       if(cols[i] >= values.size()) {
         break;
       }
       QString value = values[cols[i]].trimmed();
       // only replace delimiters for tables
       // see https://forum.kde.org/viewtopic.php?f=200&t=142712
       if(replaceColDelimiter && m_coll->fieldByName(names[i])->type() == Data::Field::Table) {
         value.replace(m_colDelimiter, FieldFormat::columnDelimiterString());
       }
       if(replaceRowDelimiter && m_coll->fieldByName(names[i])->type() == Data::Field::Table) {
         value.replace(m_rowDelimiter, FieldFormat::rowDelimiterString());
       }
       if(m_isLibraryThing) {
         // special cases for LibraryThing import
         if(names[i] == QLatin1String("isbn")) {
           // ISBN values are enclosed by brackets
           value.remove(QLatin1Char('[')).remove(QLatin1Char(']'));
         } else if(names[i] == QLatin1String("keyword")) {
           // LT values are comma-separated
           value.replace(QLatin1String(","), FieldFormat::delimiterString());
         } else if(names[i] == QLatin1String("cdate")) {
           // only want date, not time. 10 characters since it's zero-padded
           value.truncate(10);
         }
       }
       bool success = entry->setField(names[i], value);
       // we might need to add a new allowed value
       // assume that if the user is importing the value, it should be allowed
       if(!success && m_coll->fieldByName(names[i])->type() == Data::Field::Choice) {
         Data::FieldPtr f = m_coll->fieldByName(names[i]);
         StringSet allow;
         allow.add(f->allowed());
         allow.add(value);
         f->setAllowed(allow.toList());
         m_coll->modifyField(f);
         success = entry->setField(names[i], value);
       }
       if(empty && success) {
         empty = false;
       }
       j += value.size();
     }
     if(!empty) {
       m_coll->addEntries(entry);
     }
 
     if(showProgress && j%stepSize == 0) {
       emit signalProgress(this, 100*j/numChars);
       qApp->processEvents();
     }
   }
 
   {
     KConfigGroup config(KSharedConfig::openConfig(), QStringLiteral("ImportOptions - CSV"));
     config.writeEntry("Delimiter", m_delimiter);
     config.writeEntry("ColumnDelimiter", m_colDelimiter);
     config.writeEntry("RowDelimiter", m_rowDelimiter);
     config.writeEntry("First Row Titles", m_firstRowHeader);
   }
 
   return m_coll;
 }
 
 QWidget* CSVImporter::widget(QWidget* parent_) {
   if(m_widget && m_widget->parent() == parent_) {
     return m_widget;
   }
 
   m_widget = new QWidget(parent_);
   QVBoxLayout* l = new QVBoxLayout(m_widget);
 
   QGroupBox* groupBox = new QGroupBox(i18n("CSV Options"), m_widget);
   QVBoxLayout* vlay = new QVBoxLayout(groupBox);
 
   QHBoxLayout* hlay = new QHBoxLayout();
   vlay->addLayout(hlay);
   QLabel* lab = new QLabel(i18n("Collection &type:"), groupBox);
   hlay->addWidget(lab);
   m_comboColl = new GUI::CollectionTypeCombo(groupBox);
   hlay->addWidget(m_comboColl);
   lab->setBuddy(m_comboColl);
   m_comboColl->setWhatsThis(i18n("Select the type of collection being imported."));
-  connect(m_comboColl, SIGNAL(activated(int)), SLOT(slotTypeChanged()));
+  void (QComboBox::* activatedInt)(int) = &QComboBox::activated;
+  connect(m_comboColl, activatedInt, this, &CSVImporter::slotTypeChanged);
 
   m_checkFirstRowHeader = new QCheckBox(i18n("&First row contains field titles"), groupBox);
   m_checkFirstRowHeader->setWhatsThis(i18n("If checked, the first row is used as field titles."));
-  connect(m_checkFirstRowHeader, SIGNAL(toggled(bool)), SLOT(slotFirstRowHeader(bool)));
+  connect(m_checkFirstRowHeader, &QAbstractButton::toggled, this, &CSVImporter::slotFirstRowHeader);
   hlay->addWidget(m_checkFirstRowHeader);
 
   hlay->addStretch(10);
 
   QHBoxLayout* delimiterLayout = new QHBoxLayout();
   vlay->addLayout(delimiterLayout);
 
   lab = new QLabel(i18n("Delimiter:"), groupBox);
   lab->setWhatsThis(i18n("In addition to a comma, other characters may be used as "
                          "a delimiter, separating each value in the file."));
   delimiterLayout->addWidget(lab);
 
   m_radioComma = new QRadioButton(groupBox);
   m_radioComma->setText(i18n("&Comma"));
   m_radioComma->setChecked(true);
   m_radioComma->setWhatsThis(i18n("Use a comma as the delimiter."));
   delimiterLayout->addWidget(m_radioComma);
 
   m_radioSemicolon = new QRadioButton( groupBox);
   m_radioSemicolon->setText(i18n("&Semicolon"));
   m_radioSemicolon->setWhatsThis(i18n("Use a semi-colon as the delimiter."));
   delimiterLayout->addWidget(m_radioSemicolon);
 
   m_radioTab = new QRadioButton(groupBox);
   m_radioTab->setText(i18n("Ta&b"));
   m_radioTab->setWhatsThis(i18n("Use a tab as the delimiter."));
   delimiterLayout->addWidget(m_radioTab);
 
   m_radioOther = new QRadioButton(groupBox);
   m_radioOther->setText(i18n("Ot&her:"));
   m_radioOther->setWhatsThis(i18n("Use a custom string as the delimiter."));
   delimiterLayout->addWidget(m_radioOther);
 
   m_editOther = new QLineEdit(groupBox);
   m_editOther->setEnabled(false);
   m_editOther->setFixedWidth(m_widget->fontMetrics().width(QLatin1Char('X')) * 4);
   m_editOther->setMaxLength(1);
   m_editOther->setWhatsThis(i18n("A custom string, such as a colon, may be used as a delimiter."));
   m_editOther->setEnabled(false);
   delimiterLayout->addWidget(m_editOther);
-  connect(m_radioOther, SIGNAL(toggled(bool)),
-          m_editOther, SLOT(setEnabled(bool)));
-  connect(m_editOther, SIGNAL(textChanged(const QString&)), SLOT(slotDelimiter()));
+  connect(m_radioOther, &QAbstractButton::toggled,
+          m_editOther, &QWidget::setEnabled);
+  connect(m_editOther, &QLineEdit::textChanged, this, &CSVImporter::slotDelimiter);
   delimiterLayout->addStretch(10);
 
   QButtonGroup* buttonGroup = new QButtonGroup(groupBox);
   buttonGroup->addButton(m_radioComma);
   buttonGroup->addButton(m_radioSemicolon);
   buttonGroup->addButton(m_radioTab);
   buttonGroup->addButton(m_radioOther);
-  connect(buttonGroup, SIGNAL(buttonClicked(int)), SLOT(slotDelimiter()));
+  void (QButtonGroup::* buttonClickedInt)(int) = &QButtonGroup::buttonClicked;
+  connect(buttonGroup, buttonClickedInt, this, &CSVImporter::slotDelimiter);
 
   QHBoxLayout* delimiterLayout2 = new QHBoxLayout();
   vlay->addLayout(delimiterLayout2);
 
   QString w = i18n("The column delimiter separates values in each column of a <i>Table</i> field.");
   lab = new QLabel(i18n("Table column delimiter:"), groupBox);
   lab->setWhatsThis(w);
   delimiterLayout2->addWidget(lab);
   m_editColDelimiter = new QLineEdit(groupBox);
   m_editColDelimiter->setWhatsThis(w);
   m_editColDelimiter->setFixedWidth(m_widget->fontMetrics().width(QLatin1Char('X')) * 4);
   m_editColDelimiter->setMaxLength(1);
   delimiterLayout2->addWidget(m_editColDelimiter);
-  connect(m_editColDelimiter, SIGNAL(textChanged(const QString&)), SLOT(slotDelimiter()));
+  connect(m_editColDelimiter, &QLineEdit::textChanged, this, &CSVImporter::slotDelimiter);
 
   w = i18n("The row delimiter separates values in each row of a <i>Table</i> field.");
   lab = new QLabel(i18n("Table row delimiter:"), groupBox);
   lab->setWhatsThis(w);
   delimiterLayout2->addWidget(lab);
   m_editRowDelimiter = new QLineEdit(groupBox);
   m_editRowDelimiter->setWhatsThis(w);
   m_editRowDelimiter->setFixedWidth(m_widget->fontMetrics().width(QLatin1Char('X')) * 4);
   m_editRowDelimiter->setMaxLength(1);
   delimiterLayout2->addWidget(m_editRowDelimiter);
-  connect(m_editRowDelimiter, SIGNAL(textChanged(const QString&)), SLOT(slotDelimiter()));
+  connect(m_editRowDelimiter, &QLineEdit::textChanged, this, &CSVImporter::slotDelimiter);
 
   delimiterLayout2->addStretch(10);
 
   m_table = new QTableWidget(5, 0, groupBox);
   vlay->addWidget(m_table);
   m_table->setSelectionMode(QAbstractItemView::SingleSelection);
   m_table->setSelectionBehavior(QAbstractItemView::SelectColumns);
   m_table->verticalHeader()->hide();
   m_table->horizontalHeader()->setSectionsClickable(true);
   m_table->setMinimumHeight(m_widget->fontMetrics().lineSpacing() * 8);
   m_table->setWhatsThis(i18n("The table shows up to the first five lines of the CSV file."));
-  connect(m_table, SIGNAL(currentCellChanged(int, int, int, int)), SLOT(slotCurrentChanged(int, int)));
-  connect(m_table->horizontalHeader(), SIGNAL(sectionClicked(int)), SLOT(slotHeaderClicked(int)));
+  connect(m_table, &QTableWidget::currentCellChanged, this, &CSVImporter::slotCurrentChanged);
+  connect(m_table->horizontalHeader(), &QHeaderView::sectionClicked, this, &CSVImporter::slotHeaderClicked);
 
   QHBoxLayout* hlay3 = new QHBoxLayout();
   vlay->addLayout(hlay3);
 
   QString what = i18n("<qt>Set each column to correspond to a field in the collection by choosing "
                       "a column, selecting the field, then clicking the <i>Assign Field</i> button.</qt>");
   lab = new QLabel(i18n("Co&lumn:"), groupBox);
   hlay3->addWidget(lab);
   lab->setWhatsThis(what);
   m_colSpinBox = new QSpinBox(groupBox);
   hlay3->addWidget(m_colSpinBox);
   m_colSpinBox->setWhatsThis(what);
   m_colSpinBox->setMinimum(1);
-  connect(m_colSpinBox, SIGNAL(valueChanged(int)), SLOT(slotSelectColumn(int)));
+  void (QSpinBox::* valueChangedInt)(int) = &QSpinBox::valueChanged;
+  connect(m_colSpinBox, valueChangedInt, this, &CSVImporter::slotSelectColumn);
   lab->setBuddy(m_colSpinBox);
 
   hlay3->addSpacing(10);
 
   lab = new QLabel(i18n("&Data field in this column:"), groupBox);
   hlay3->addWidget(lab);
   lab->setWhatsThis(what);
   m_comboField = new KComboBox(groupBox);
   hlay3->addWidget(m_comboField);
   m_comboField->setWhatsThis(what);
   m_comboField->setFixedWidth(m_widget->fontMetrics().width(QLatin1Char('X')) * 20);
 //  m_comboField->setSizeAdjustPolicy(QComboBox::AdjustToContents);
-  connect(m_comboField, SIGNAL(activated(int)), SLOT(slotFieldChanged(int)));
+  connect(m_comboField, activatedInt, this, &CSVImporter::slotFieldChanged);
   lab->setBuddy(m_comboField);
 
   hlay3->addSpacing(10);
 
   m_setColumnBtn = new QPushButton(i18n("&Assign Field"), groupBox);
   hlay3->addWidget(m_setColumnBtn);
   m_setColumnBtn->setWhatsThis(what);
   m_setColumnBtn->setIcon(QIcon::fromTheme(QStringLiteral("dialog-ok-apply")));
-  connect(m_setColumnBtn, SIGNAL(clicked()), SLOT(slotSetColumnTitle()));
+  connect(m_setColumnBtn, &QAbstractButton::clicked, this, &CSVImporter::slotSetColumnTitle);
 //  hlay3->addStretch(10);
 
   l->addWidget(groupBox);
   l->addStretch(1);
 
   KConfigGroup config(KSharedConfig::openConfig(), QStringLiteral("ImportOptions - CSV"));
   m_delimiter = config.readEntry("Delimiter", m_delimiter);
   m_colDelimiter = config.readEntry("ColumnDelimiter", m_colDelimiter);
   m_rowDelimiter = config.readEntry("RowDelimiter", m_rowDelimiter);
   m_firstRowHeader = config.readEntry("First Row Titles", m_firstRowHeader);
 
   m_checkFirstRowHeader->setChecked(m_firstRowHeader);
   if(m_delimiter == QLatin1String(",")) {
     m_radioComma->setChecked(true);
   } else if(m_delimiter == QLatin1String(";")) {
     m_radioSemicolon->setChecked(true);
   } else if(m_delimiter == QLatin1String("\t")) {
     m_radioTab->setChecked(true);
   } else if(!m_delimiter.isEmpty()) {
     m_radioOther->setChecked(true);
     m_editOther->setEnabled(true);
     m_editOther->setText(m_delimiter);
   }
   slotDelimiter(); // initialize the parser and then load the text
 
   return m_widget;
 }
 
 bool CSVImporter::validImport() const {
   // at least one column has to be defined
   if(!m_hasAssignedFields) {
     KMessageBox::sorry(m_widget, i18n("At least one column must be assigned to a field. "
                                       "Only assigned columns will be imported."));
   }
   return m_hasAssignedFields;
 }
 
 void CSVImporter::fillTable() {
   if(!m_table) {
     return;
   }
 
   m_parser->reset(text());
   // not skipping first row since the updateHeader() call depends on it
 
   int maxCols = 0;
   int row = 0;
   for( ; m_parser->hasNext() && row < m_table->rowCount(); ++row) {
     QStringList values = m_parser->nextTokens();
     if(static_cast<int>(values.count()) > m_table->columnCount()) {
       m_table->setColumnCount(values.count());
       m_colSpinBox->setMaximum(values.count());
     }
     int col = 0;
     foreach(const QString& value, values) {
       m_table->setItem(row, col, new QTableWidgetItem(value));
       m_table->resizeColumnToContents(col);
       ++col;
     }
     if(col > maxCols) {
       maxCols = col;
     }
     // special case, check if the header row matches LibraryThing CSV export
     // assume LT export always uses identical header row and verify against first 7 columns
     if(row == 0 && values.count() > 7) {
       m_isLibraryThing = (values.at(0) == QLatin1String("'TITLE'") &&
                           values.at(1) == QLatin1String("'AUTHOR (first, last)'") &&
                           values.at(2) == QLatin1String("'AUTHOR (last, first)'") &&
                           values.at(3) == QLatin1String("'DATE'") &&
                           values.at(4) == QLatin1String("'LCC'") &&
                           values.at(5) == QLatin1String("'DDC'") &&
                           values.at(6) == QLatin1String("'ISBNs'"));
     }
   }
   for( ; row < m_table->rowCount(); ++row) {
     for(int col = 0; col < m_table->columnCount(); ++col) {
       delete m_table->takeItem(row, col);
     }
   }
 
   m_table->setColumnCount(maxCols);
 
   if(m_isLibraryThing) {
     // do not call slotFirstRowHeader since it will loop
     m_firstRowHeader = true;
     updateHeader();
   }
 }
 
 void CSVImporter::slotTypeChanged() {
   createCollection();
 
   updateHeader();
   updateFieldCombo();
 
   // hack to force a resize
   m_comboField->setFont(m_comboField->font());
   m_comboField->updateGeometry();
 }
 
 void CSVImporter::slotFirstRowHeader(bool b_) {
   m_firstRowHeader = b_;
   updateHeader();
   fillTable();
 }
 
 void CSVImporter::slotDelimiter() {
   if(m_radioComma->isChecked()) {
     m_delimiter = QStringLiteral(",");
   } else if(m_radioSemicolon->isChecked()) {
     m_delimiter = QStringLiteral(";");
   } else if(m_radioTab->isChecked()) {
     m_delimiter = QStringLiteral("\t");
   } else {
     m_editOther->setFocus();
     m_delimiter = m_editOther->text();
   }
   m_colDelimiter = m_editColDelimiter->text();
   m_rowDelimiter = m_editRowDelimiter->text();
   if(!m_delimiter.isEmpty()) {
     m_parser->setDelimiter(m_delimiter);
     fillTable();
     updateHeader();
   }
 }
 
 void CSVImporter::slotCurrentChanged(int, int col_) {
   const int pos = col_+1;
   m_colSpinBox->setValue(pos); //slotSelectColumn() gets called because of the signal
 }
 
 void CSVImporter::slotHeaderClicked(int col_) {
   const int pos = col_+1;
   m_colSpinBox->setValue(pos); //slotSelectColumn() gets called because of the signal
 }
 
 void CSVImporter::slotSelectColumn(int pos_) {
   // pos is really the number of the position of the column
   const int col = pos_ - 1;
   m_table->scrollToItem(m_table->item(0, col));
   m_table->selectColumn(col);
   m_comboField->setCurrentItem(m_table->horizontalHeaderItem(col)->text());
 }
 
 void CSVImporter::slotSetColumnTitle() {
   int col = m_colSpinBox->value()-1;
   const QString title = m_comboField->currentText();
   m_table->horizontalHeaderItem(col)->setText(title);
   m_hasAssignedFields = true;
   // make sure none of the other columns have this title
   bool found = false;
   for(int i = 0; i < col; ++i) {
     if(m_table->horizontalHeaderItem(i)->text() == title) {
       m_table->horizontalHeaderItem(i)->setText(QString::number(i+1));
       found = true;
       break;
     }
   }
   // if found, then we're done
   if(found) {
     return;
   }
   for(int i = col+1; i < m_table->columnCount(); ++i) {
     if(m_table->horizontalHeaderItem(i)->text() == title) {
       m_table->horizontalHeaderItem(i)->setText(QString::number(i+1));
       break;
     }
   }
 }
 
 void CSVImporter::updateHeader() {
   if(!m_table) {
     return;
   }
 
   for(int col = 0; col < m_table->columnCount(); ++col) {
     QTableWidgetItem* headerItem = m_table->horizontalHeaderItem(col);
     if(!headerItem) {
       headerItem = new QTableWidgetItem();
       m_table->setHorizontalHeaderItem(col, headerItem);
     }
 
     QTableWidgetItem* item = m_table->item(0, col);
     Data::FieldPtr field;
     if(item && m_coll) {
       QString itemValue = item->text();
       // check against LibraryThing import
       if(m_isLibraryThing && m_coll->type() == Data::Collection::Book) {
         static QHash<QString, QString> ltFields;
         if(ltFields.isEmpty()) {
           ltFields[QStringLiteral("TITLE")]                = QStringLiteral("title");
           ltFields[QStringLiteral("AUTHOR (first, last)")] = QStringLiteral("author");
           ltFields[QStringLiteral("DATE")]                 = QStringLiteral("pub_year");
           ltFields[QStringLiteral("ISBNs")]                = QStringLiteral("isbn");
           ltFields[QStringLiteral("RATINGS")]              = QStringLiteral("rating");
           ltFields[QStringLiteral("ENTRY DATE")]           = QStringLiteral("cdate");
           ltFields[QStringLiteral("TAGS")]                 = QStringLiteral("keyword");
           ltFields[QStringLiteral("COMMENT")]              = QStringLiteral("comments");
           ltFields[QStringLiteral("REVIEWS")]              = QStringLiteral("review");
         }
         // strip leading and trailing single quotes
         itemValue.remove(0,1).chop(1);
         itemValue = ltFields.value(itemValue);
 
         // review is a new field, we're going to add it by default
         if(itemValue == QLatin1String("review") && !m_coll->hasField(itemValue)) {
           Data::FieldPtr field(new Data::Field(QStringLiteral("review"), i18n("Review"), Data::Field::Para));
           m_coll->addField(field);
           updateFieldCombo();
           m_comboField->setCurrentIndex(m_comboField->count()-2);
         }
       }
       field = m_coll->fieldByTitle(itemValue);
       if(!field) {
         field = m_coll->fieldByName(itemValue);
       }
     }
     if(m_firstRowHeader && field) {
       headerItem->setText(field->title());
       m_hasAssignedFields = true;
     } else {
       headerItem->setText(QString::number(col+1));
     }
   }
 }
 
 void CSVImporter::slotFieldChanged(int idx_) {
   // only care if it's the last item -> add new field
   if(idx_ < m_comboField->count()-1) {
     return;
   }
 
   CollectionFieldsDialog dlg(m_coll, m_widget);
   dlg.setNotifyKernel(false);
 
   if(dlg.exec() == QDialog::Accepted) {
     updateFieldCombo();
     fillTable();
   }
 
   // set the combo to the item before last
   m_comboField->setCurrentIndex(m_comboField->count()-2);
 }
 
 void CSVImporter::slotActionChanged(int action_) {
   Data::CollPtr currColl = currentCollection();
   if(!currColl) {
     m_existingCollection = nullptr;
     return;
   }
 
   switch(action_) {
     case Import::Replace:
       {
         int currType = m_comboColl->currentType();
         m_comboColl->reset();
         m_comboColl->setCurrentType(currType);
         m_existingCollection = nullptr;
       }
       break;
 
     case Import::Append:
     case Import::Merge:
      {
         m_comboColl->clear();
         QString name = CollectionFactory::nameHash().value(currColl->type());
         m_comboColl->addItem(name, currColl->type());
         m_existingCollection = currColl;
      }
      break;
   }
   slotTypeChanged();
 }
 
 void CSVImporter::slotCancel() {
   m_cancelled = true;
 }
 
 void CSVImporter::createCollection() {
   Data::Collection::Type type = static_cast<Data::Collection::Type>(m_comboColl->currentType());
   m_coll = CollectionFactory::collection(type, true);
   if(m_existingCollection) {
     // if we're using the existing collection, then we
     // want the newly created collection to have the same fields
     foreach(Data::FieldPtr field, m_coll->fields()) {
       m_coll->removeField(field, true /* force */);
     }
     foreach(Data::FieldPtr field, m_existingCollection->fields()) {
       m_coll->addField(Data::FieldPtr(new Data::Field(*field)));
     }
   }
 }
 
 void CSVImporter::updateFieldCombo() {
   m_comboField->clear();
   foreach(Data::FieldPtr field, m_coll->fields()) {
     m_comboField->addItem(field->title());
   }
   m_comboField->addItem(i18n("<New Field>"));
 }
diff --git a/src/translators/filelistingimporter.cpp b/src/translators/filelistingimporter.cpp
index b2b7db9d..e528a31f 100644
--- a/src/translators/filelistingimporter.cpp
+++ b/src/translators/filelistingimporter.cpp
@@ -1,322 +1,322 @@
 /***************************************************************************
     Copyright (C) 2005-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include <config.h>
 
 #include "filelistingimporter.h"
 #include "../collections/filecatalog.h"
 #include "../entry.h"
 #include "../field.h"
 #include "../fieldformat.h"
 #include "../images/imagefactory.h"
 #include "../utils/tellico_utils.h"
 #include "../utils/guiproxy.h"
 #include "../progressmanager.h"
 #include "../core/netaccess.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KJobWidgets/KJobWidgets>
 #include <KIO/Job>
 #include <Solid/Device>
 #include <Solid/StorageVolume>
 #include <Solid/StorageAccess>
 
 #ifdef HAVE_KFILEMETADATA
 #include <KFileMetaData/Extractor>
 #include <KFileMetaData/ExtractorCollection>
 #include <KFileMetaData/SimpleExtractionResult>
 #include <KFileMetaData/PropertyInfo>
 #endif
 
 #include <QDate>
 #include <QDir>
 #include <QCheckBox>
 #include <QGroupBox>
 #include <QFile>
 #include <QFileInfo>
 #include <QVBoxLayout>
 #include <QApplication>
 
 namespace {
   static const int FILE_PREVIEW_SIZE = 128;
 }
 
 using Tellico::Import::FileListingImporter;
 
 FileListingImporter::FileListingImporter(const QUrl& url_) : Importer(url_), m_coll(nullptr), m_widget(nullptr),
     m_recursive(nullptr), m_filePreview(nullptr), m_job(nullptr), m_cancelled(false) {
 }
 
 bool FileListingImporter::canImport(int type) const {
   return type == Data::Collection::File;
 }
 
 Tellico::Data::CollPtr FileListingImporter::collection() {
   if(m_coll) {
     return m_coll;
   }
 
   ProgressItem& item = ProgressManager::self()->newProgressItem(this, i18n("Scanning files..."), true);
   item.setTotalSteps(100);
-  connect(&item, &Tellico::ProgressItem::signalCancelled, this, &Tellico::Import::FileListingImporter::slotCancel);
+  connect(&item, &Tellico::ProgressItem::signalCancelled, this, &FileListingImporter::slotCancel);
   ProgressItem::Done done(this);
 
   // going to assume only one volume will ever be imported
   const QString volume = volumeName();
 
   // the importer might be running without a gui/widget
   m_job = (m_widget && m_recursive->isChecked())
           ? KIO::listRecursive(url(), KIO::DefaultFlags, false /* include hidden */)
           : KIO::listDir(url(), KIO::DefaultFlags, false /* include hidden */);
   KJobWidgets::setWindow(m_job, GUI::Proxy::widget());
-  connect(m_job, SIGNAL(entries(KIO::Job*, const KIO::UDSEntryList&)),
-          SLOT(slotEntries(KIO::Job*, const KIO::UDSEntryList&)));
+  void (KIO::ListJob::* jobEntries)(KIO::Job*, const KIO::UDSEntryList&) = &KIO::ListJob::entries;
+  connect(static_cast<KIO::ListJob*>(m_job.data()), jobEntries, this, &FileListingImporter::slotEntries);
 
   if(!m_job->exec() || m_cancelled) {
     myDebug() << "did not run job:" << m_job->errorString();
     return Data::CollPtr();
   }
 
 #ifdef HAVE_KFILEMETADATA
   KFileMetaData::ExtractorCollection extractors;
   QHash<KFileMetaData::Property::Property, QString> propertyNameHash;
 #endif
 
   QStringList metaIgnore = QStringList()
                          << QStringLiteral("mimeType")
                          << QStringLiteral("url")
                          << QStringLiteral("fileName")
                          << QStringLiteral("lastModified")
                          << QStringLiteral("contentSize")
                          << QStringLiteral("type");
 
   const bool usePreview = m_widget && m_filePreview->isChecked();
 
   const QString title    = QStringLiteral("title");
   const QString url      = QStringLiteral("url");
   const QString desc     = QStringLiteral("description");
   const QString vol      = QStringLiteral("volume");
   const QString folder   = QStringLiteral("folder");
   const QString type     = QStringLiteral("mimetype");
   const QString size     = QStringLiteral("size");
   const QString perm     = QStringLiteral("permissions");
   const QString owner    = QStringLiteral("owner");
   const QString group    = QStringLiteral("group");
   const QString created  = QStringLiteral("created");
   const QString modified = QStringLiteral("modified");
   const QString metainfo = QStringLiteral("metainfo");
   const QString icon     = QStringLiteral("icon");
 
   // cache the icon image ids to avoid repeated creation of Data::Image objects
   QHash<QString, QString> iconImageId;
 
   m_coll = new Data::FileCatalog(true);
   QString tmp;
   const uint stepSize = qMax(1, m_files.count()/100);
   const bool showProgress = options() & ImportProgress;
 
   item.setTotalSteps(m_files.count());
   uint j = 0;
   foreach(const KFileItem& item, m_files) {
     if(m_cancelled) {
       break;
     }
 
     Data::EntryPtr entry(new Data::Entry(m_coll));
 
     const QUrl u = item.url();
     entry->setField(title,  u.fileName());
     entry->setField(url,    u.url());
     entry->setField(desc,   item.mimeComment());
     entry->setField(vol,    volume);
     tmp = QDir(this->url().toLocalFile()).relativeFilePath(u.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash).path());
     // use empty string for root folder instead of "."
     entry->setField(folder, tmp == QLatin1String(".") ? QString() : tmp);
     entry->setField(type,   item.mimetype());
     entry->setField(size,   KIO::convertSize(item.size()));
     entry->setField(perm,   item.permissionsString());
     entry->setField(owner,  item.user());
     entry->setField(group,  item.group());
 
     QDateTime dt(item.time(KFileItem::CreationTime));
     if(!dt.isNull()) {
       entry->setField(created, dt.date().toString(Qt::ISODate));
     }
     dt = QDateTime(item.time(KFileItem::ModificationTime));
     if(!dt.isNull()) {
       entry->setField(modified, dt.date().toString(Qt::ISODate));
     }
 
 #ifdef HAVE_KFILEMETADATA
     KFileMetaData::SimpleExtractionResult result(u.toLocalFile(),
                                                  item.mimetype(),
                                                  KFileMetaData::ExtractionResult::ExtractMetaData);
     QList<KFileMetaData::Extractor*> exList = extractors.fetchExtractors(item.mimetype());
     foreach(KFileMetaData::Extractor* ex, exList) {
 // initializing exempi can cause a crash in Exiv for files with XMP data
 // crude workaround is to avoid using the exivextractor and the only apparent way is to
 // matach against the mimetypes
 // see https://bugs.kde.org/show_bug.cgi?id=390744
 #ifdef HAVE_EXEMPI
       if(!ex->mimetypes().contains(QStringLiteral("image/x-exv"))) {
 #else
       if(true) {
 #endif
         ex->extract(&result);
       }
     }
     QStringList strings;
     KFileMetaData::PropertyMap properties = result.properties();
     KFileMetaData::PropertyMap::const_iterator it = properties.constBegin();
     for( ; it != properties.constEnd(); ++it) {
       const QString value = it.value().toString();
       if(!value.isEmpty()) {
         QString label;
         if(propertyNameHash.contains(it.key())) {
           label = propertyNameHash.value(it.key());
         } else {
           label = KFileMetaData::PropertyInfo(it.key()).displayName();
           propertyNameHash.insert(it.key(), label);
         }
 //        myDebug() << label << value;
         if(!metaIgnore.contains(label)) {
           strings << label + FieldFormat::columnDelimiterString() + value;
         }
       }
     }
     entry->setField(metainfo, strings.join(FieldFormat::rowDelimiterString()));
 #endif
 
     QPixmap pixmap;
     if(!m_cancelled && usePreview) {
       pixmap = Tellico::NetAccess::filePreview(item, FILE_PREVIEW_SIZE);
     }
     if(pixmap.isNull()) {
       if(iconImageId.contains(item.iconName())) {
         entry->setField(icon, iconImageId.value(item.iconName()));
       } else {
         pixmap = QIcon::fromTheme(item.iconName()).pixmap(QSize(FILE_PREVIEW_SIZE, FILE_PREVIEW_SIZE));
         const QString id = ImageFactory::addImage(pixmap, QStringLiteral("PNG"));
         if(!id.isEmpty()) {
           entry->setField(icon, id);
           iconImageId.insert(item.iconName(), id);
         }
       }
     } else {
       const QString id = ImageFactory::addImage(pixmap, QStringLiteral("PNG"));
       if(!id.isEmpty()) {
         entry->setField(icon, id);
       }
     }
 
     m_coll->addEntries(entry);
 
     if(showProgress && j%stepSize == 0) {
       ProgressManager::self()->setProgress(this, j);
       qApp->processEvents();
     }
     ++j;
   }
 
   if(m_cancelled) {
     m_coll = Data::CollPtr();
     return m_coll;
   }
 
   return m_coll;
 }
 
 QWidget* FileListingImporter::widget(QWidget* parent_) {
   if(m_widget) {
     return m_widget;
   }
 
   m_widget = new QWidget(parent_);
   QVBoxLayout* l = new QVBoxLayout(m_widget);
 
   QGroupBox* gbox = new QGroupBox(i18n("File Listing Options"), m_widget);
   QVBoxLayout* vlay = new QVBoxLayout(gbox);
 
   m_recursive = new QCheckBox(i18n("Recursive folder search"), gbox);
   m_recursive->setWhatsThis(i18n("If checked, folders are recursively searched for all files."));
   // by default, make it checked
   m_recursive->setChecked(true);
 
   m_filePreview = new QCheckBox(i18n("Generate file previews"), gbox);
   m_filePreview->setWhatsThis(i18n("If checked, previews of the file contents are generated, which can slow down "
                                       "the folder listing."));
   // by default, make it no previews
   m_filePreview->setChecked(false);
 
   vlay->addWidget(m_recursive);
   vlay->addWidget(m_filePreview);
 
   l->addWidget(gbox);
   l->addStretch(1);
   return m_widget;
 }
 
 void FileListingImporter::slotEntries(KIO::Job* job_, const KIO::UDSEntryList& list_) {
   if(m_cancelled) {
     job_->kill();
     m_job = nullptr;
     return;
   }
 
   for(KIO::UDSEntryList::ConstIterator it = list_.begin(); it != list_.end(); ++it) {
     KFileItem item(*it, url(), false, true);
     if(item.isFile()) {
       m_files.append(item);
     }
   }
 }
 
 QString FileListingImporter::volumeName() const {
   const QString filePath = url().toLocalFile();
   QString matchingPath, volume;
   QList<Solid::Device> devices = Solid::Device::listFromType(Solid::DeviceInterface::StorageVolume, QString());
   foreach(const Solid::Device& device, devices) {
     const Solid::StorageAccess* acc = device.as<const Solid::StorageAccess>();
     if(acc && !acc->filePath().isEmpty() && filePath.startsWith(acc->filePath())) {
       // it might be possible for one volume to be mounted at /dir1 and another to be mounted at /dir1/dir2
       // so we need to find the longest natching filePath
       if(acc->filePath().length() > matchingPath.length()) {
         matchingPath = acc->filePath();
         const Solid::StorageVolume* vol = device.as<const Solid::StorageVolume>();
         if(vol) {
           volume = vol->label();
         }
       }
     }
   }
   return volume;
 }
 
 void FileListingImporter::slotCancel() {
   m_cancelled = true;
   if(m_job) {
     m_job->kill();
   }
 }
diff --git a/src/translators/freedbimporter.cpp b/src/translators/freedbimporter.cpp
index 6262a587..f76e667d 100644
--- a/src/translators/freedbimporter.cpp
+++ b/src/translators/freedbimporter.cpp
@@ -1,574 +1,575 @@
 /***************************************************************************
     Copyright (C) 2004-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 /*
  * We could use KCompactDisc now, but it's very buggy,
  * see https://bugs.kde.org/show_bug.cgi?id=183520
  *     https://bugs.kde.org/show_bug.cgi?id=183521
  *     http://lists.kde.org/?l=kde-multimedia&m=123397778013726&w=2
  */
 
 #include <config.h>
 
 #include "freedbimporter.h"
 #include "../collections/musiccollection.h"
 #include "../entry.h"
 #include "../field.h"
 #include "../fieldformat.h"
 #include "../utils/tellico_utils.h"
 #include "../utils/string_utils.h"
 #include "../utils/guiproxy.h"
 #include "../progressmanager.h"
 #include "../utils/cursorsaver.h"
 #include "../tellico_debug.h"
 
 #if defined HAVE_KF5KCDDB
 #include <KCddb/Client>
 #elif defined HAVE_KCDDB
 #include <libkcddb/client.h>
 #endif
 
 #include <KComboBox>
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 #include <QInputDialog>
 #include <QFile>
 #include <QDir>
 #include <QLabel>
 #include <QGroupBox>
 #include <QRadioButton>
 #include <QButtonGroup>
 #include <QCheckBox>
 #include <QTextStream>
 #include <QVBoxLayout>
 #include <QTextCodec>
 #include <QApplication>
 
 using Tellico::Import::FreeDBImporter;
 
 FreeDBImporter::FreeDBImporter() : Tellico::Import::Importer()
     , m_widget(nullptr)
     , m_buttonGroup(nullptr)
     , m_radioCDROM(nullptr)
     , m_radioCache(nullptr)
     , m_driveCombo(nullptr)
     , m_cancelled(false) {
 }
 
 bool FreeDBImporter::canImport(int type) const {
   return type == Data::Collection::Album;
 }
 
 Tellico::Data::CollPtr FreeDBImporter::collection() {
   if(m_coll) {
     return m_coll;
   }
 
   m_cancelled = false;
   if(m_radioCDROM->isChecked()) {
     readCDROM();
   } else {
     readCache();
   }
   if(m_cancelled) {
     m_coll = Data::CollPtr();
   }
   return m_coll;
 }
 
 void FreeDBImporter::readCDROM() {
 #if defined (HAVE_KCDDB) || defined (HAVE_KF5KCDDB)
   QString drivePath = m_driveCombo->currentText();
   if(drivePath.isEmpty()) {
     setStatusMessage(i18n("<qt>Tellico was unable to access the CD-ROM device - <i>%1</i>.</qt>", drivePath));
     myDebug() << "no drive!";
     return;
   }
 
   // now it's ok to add device to saved list
   m_driveCombo->addItem(drivePath);
   QStringList drives;
   for(int i = 0; i < m_driveCombo->count(); ++i) {
     if(drives.indexOf(m_driveCombo->itemText(i)) == -1) {
       drives += m_driveCombo->itemText(i);
     }
   }
 
   {
     KConfigGroup config(KSharedConfig::openConfig(), QStringLiteral("ImportOptions - FreeDB"));
     config.writeEntry("CD-ROM Devices", drives);
     config.writeEntry("Last Device", drivePath);
     config.writeEntry("Cache Files Only", false);
   }
 
   QByteArray drive = QFile::encodeName(drivePath);
   QList<uint> lengths;
   KCDDB::TrackOffsetList list;
 #if 0
   // a1107d0a - Kruder & Dorfmeister - The K&D Sessions - Disc One.
 /*  list
     << 150      // First track start.
     << 29462
     << 66983
     << 96785
     << 135628
     << 168676
     << 194147
     << 222158
     << 247076
     << 278203   // Last track start.
     << 316732;  // Disc end.
 */
 /*
   list
     << 150      // First track start.
     << 3296
     << 14437
     << 41279
     << 51362
     << 56253
     << 59755
     << 61324
     << 66059
     << 69073
     << 77790
     << 83214
     << 89726
     << 92078
     << 106325
     << 113117
     << 116040
     << 119877
     << 124377
     << 145466
     << 157583
     << 167208
     << 173486
     << 180120
     << 185279
     << 193270
     << 206451
     << 217303   // Last track start.
     << 224925;  // Disc end.
   list
     << 150
     << 106965
     << 127220
     << 151925
     << 176085
     << 234500;
 */
 #else
   list = offsetList(drive, lengths);
 #endif
 
   if(list.isEmpty()) {
     setStatusMessage(i18n("<qt>Tellico was unable to access the CD-ROM device - <i>%1</i>.</qt>", drivePath));
     return;
   }
 //  myDebug() << list;
 
   // the result info, could be multiple ones
   KCDDB::CDInfo info;
   KCDDB::Client client;
   client.setBlockingMode(true);
 
   KCDDB::Result r = client.lookup(list);
   const KCDDB::CDInfoList responseList = client.lookupResponse();
   // KCDDB sometimes doesn't return MultipleRecordFound properly, so check length of response, too
   if(r == KCDDB::MultipleRecordFound || responseList.count() > 1) {
     QStringList list;
     foreach(const KCDDB::CDInfo& info, responseList) {
       list.append(QStringLiteral("%1, %2, %3").arg(info.get(KCDDB::Artist).toString(),
                                                         info.get(KCDDB::Title).toString(),
                                                         info.get(KCDDB::Genre).toString()));
     }
 
     // switch back to pointer cursor
     GUI::CursorSaver cs(Qt::ArrowCursor);
     bool ok;
     QString res = QInputDialog::getItem(GUI::Proxy::widget(),
                                         i18n("Select CDDB Entry"),
                                         i18n("Select a CDDB entry:"),
                                         list, 0, false, &ok);
     if(ok) {
       int i = 0;
       foreach(const QString& listValue, list) {
         if(listValue == res) {
           break;
         }
         ++i;
       }
       if(i < responseList.size()) {
         info = responseList.at(i);
       }
     } else { // cancelled dialog
       m_cancelled = true;
     }
   } else if(r == KCDDB::Success && !responseList.isEmpty()) {
     info = responseList.first();
   } else {
     myDebug() << "no success! Return value = " << r;
     QString s;
     switch(r) {
       case KCDDB::NoRecordFound:
         s = i18n("<qt>No records were found to match the CD.</qt>");
         break;
       case KCDDB::ServerError:
         myDebug() << "Server Error";
         break;
       case KCDDB::HostNotFound:
         myDebug() << "Host Not Found";
         break;
       case KCDDB::NoResponse:
         myDebug() << "No Response";
         break;
       case KCDDB::UnknownError:
         myDebug() << "Unknown Error";
         break;
       default:
         break;
     }
     if(s.isEmpty()) {
       s = i18n("<qt>Tellico was unable to complete the CD lookup.</qt>");
     }
     setStatusMessage(s);
     return;
   }
 
   if(!info.isValid()) {
     // go ahead and try to read cd-text if we weren't cancelled
     // could be the case we don't have net access
     if(!m_cancelled) {
       readCDText(drive);
     }
     return;
   }
 
   m_coll = new Data::MusicCollection(true);
 
   Data::EntryPtr entry(new Data::Entry(m_coll));
   // obviously a CD
   entry->setField(QStringLiteral("medium"), i18n("Compact Disc"));
   entry->setField(QStringLiteral("title"),  info.get(KCDDB::Title).toString());
   entry->setField(QStringLiteral("artist"), info.get(KCDDB::Artist).toString());
   entry->setField(QStringLiteral("genre"),  info.get(KCDDB::Genre).toString());
   if(!info.get(KCDDB::Year).isNull()) {
     entry->setField(QStringLiteral("year"), info.get(KCDDB::Year).toString());
   }
   entry->setField(QStringLiteral("keyword"), info.get(KCDDB::Category).toString());
   QString extd = info.get(QStringLiteral("EXTD")).toString();
   extd.replace(QLatin1Char('\n'), QLatin1String("<br/>"));
   entry->setField(QStringLiteral("comments"), extd);
 
   QStringList trackList;
   trackList.reserve(info.numberOfTracks());
   for(int i = 0; i < info.numberOfTracks(); ++i) {
     QString s = info.track(i).get(KCDDB::Title).toString() + FieldFormat::columnDelimiterString();
     const QString trackArtist = info.track(i).get(KCDDB::Artist).toString().trimmed();
     s += trackArtist.isEmpty() ? info.get(KCDDB::Artist).toString() : trackArtist;
     if(i < lengths.count()) {
       s += FieldFormat::columnDelimiterString() + Tellico::minutes(lengths[i]);
     }
     trackList << s;
   }
   entry->setField(QStringLiteral("track"), trackList.join(FieldFormat::rowDelimiterString()));
 
   m_coll->addEntries(entry);
   readCDText(drive);
 #endif
 }
 
 void FreeDBImporter::readCache() {
 #if defined (HAVE_KCDDB) || defined (HAVE_KF5KCDDB)
   {
     // remember the import options
     KConfigGroup config(KSharedConfig::openConfig(), QStringLiteral("ImportOptions - FreeDB"));
     config.writeEntry("Cache Files Only", true);
   }
 
   KCDDB::Config cfg;
   cfg.load();
 
   QStringList dirs = cfg.cacheLocations();
   foreach(const QString& dirName, dirs) {
     dirs += Tellico::findAllSubDirs(dirName);
   }
 
   // using a QMap is a lazy man's way of getting unique keys
   // the cddb info may be in multiple files, all with the same filename, the cddb id
   QMap<QString, QString> files;
   foreach(const QString& dirName, dirs) {
     if(dirName.isEmpty()) {
       continue;
     }
 
     QDir dir(dirName);
     dir.setFilter(QDir::Files | QDir::Readable | QDir::Hidden); // hidden since I want directory files
     const QStringList list = dir.entryList();
     foreach(const QString& listEntry, list) {
       files.insert(listEntry, dir.absoluteFilePath(listEntry));
     }
 //    qApp->processEvents(); // really needed ?
   }
 
   const QString title    = QStringLiteral("title");
   const QString artist   = QStringLiteral("artist");
   const QString year     = QStringLiteral("year");
   const QString genre    = QStringLiteral("genre");
   const QString medium   = QStringLiteral("medium");
   const QString keyword  = QStringLiteral("keyword");
   const QString track    = QStringLiteral("track");
   const QString comments = QStringLiteral("comments");
   int numFiles = files.count();
 
   if(numFiles == 0) {
     myDebug() << "no files found";
     return;
   }
 
   m_coll = new Data::MusicCollection(true);
 
   const uint stepSize = qMax(1, numFiles / 100);
   const bool showProgress = options() & ImportProgress;
 
   ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true);
   item.setTotalSteps(numFiles);
-  connect(&item, &Tellico::ProgressItem::signalCancelled, this, &Tellico::Import::FreeDBImporter::slotCancel);
+  connect(&item, &Tellico::ProgressItem::signalCancelled, this, &FreeDBImporter::slotCancel);
   ProgressItem::Done done(this);
 
   uint step = 1;
 
   KCDDB::CDInfo info;
   for(QMap<QString, QString>::ConstIterator it = files.constBegin(); !m_cancelled && it != files.constEnd(); ++it, ++step) {
     // open file and read content
     QFileInfo fileinfo(it.value()); // skip files larger than 10 kB
     if(!fileinfo.exists() || !fileinfo.isReadable() || fileinfo.size() > 10*1024) {
       myDebug() << "skipping " << it.value();
       continue;
     }
     QFile file(it.value());
     if(!file.open(QIODevice::ReadOnly)) {
       continue;
     }
     QTextStream ts(&file);
     // libkcddb always writes the cache files in utf-8
     ts.setCodec(QTextCodec::codecForName("UTF-8"));
     QString cddbData = ts.readAll();
     file.close();
 
     if(cddbData.isEmpty() || !info.load(cddbData) || !info.isValid()) {
       myDebug() << "Error - CDDB record is not valid";
       myDebug() << "File = " << it.value();
       continue;
     }
 
     // create a new entry and set fields
     Data::EntryPtr entry(new Data::Entry(m_coll));
     // obviously a CD
     entry->setField(medium, i18n("Compact Disc"));
     entry->setField(title, info.get(KCDDB::Title).toString());
     entry->setField(artist, info.get(KCDDB::Artist).toString());
     entry->setField(genre, info.get(KCDDB::Genre).toString());
     if(!info.get(KCDDB::Year).isNull()) {
       entry->setField(year, info.get(KCDDB::Year).toString());
     }
     entry->setField(keyword, info.get(KCDDB::Category).toString());
     QString extd = info.get(QStringLiteral("EXTD")).toString();
     extd.replace(QLatin1Char('\n'), QLatin1String("<br/>"));
     entry->setField(comments, extd);
 
     // step through trackList
     QStringList trackList;
     trackList.reserve(info.numberOfTracks());
     for(int i = 0; i < info.numberOfTracks(); ++i) {
       trackList << info.track(i).get(KCDDB::Title).toString();
     }
     entry->setField(track, trackList.join(FieldFormat::rowDelimiterString()));
 
 #if 0
     // add CDDB info
     const QString br = QLatin1String("<br/>");
     QString comment;
     if(!info.extd.isEmpty()) {
       comment.append(info.extd + br);
     }
     if(!info.id.isEmpty()) {
       comment.append(QLatin1String("CDDB-ID: ") + info.id + br);
     }
     if(info.length > 0) {
       comment.append("Length: " + QString::number(info.length) + br);
     }
     if(info.revision > 0) {
       comment.append("Revision: " + QString::number(info.revision) + br);
     }
     entry->setField(comments, comment);
 #endif
 
     // add this entry to the music collection
     m_coll->addEntries(entry);
 
     if(showProgress && step%stepSize == 0) {
       ProgressManager::self()->setProgress(this, step);
       qApp->processEvents();
     }
   }
 #endif
 }
 
 #define SETFIELD(name,value) \
   if(entry->field(QStringLiteral(name)).isEmpty()) { \
     entry->setField(QStringLiteral(name), value); \
   }
 
 void FreeDBImporter::readCDText(const QByteArray& drive_) {
 #ifdef ENABLE_CDTEXT
   Data::EntryPtr entry;
   if(m_coll) {
     if(m_coll->entryCount() > 0) {
       entry = m_coll->entries().front();
     }
   } else {
     m_coll = new Data::MusicCollection(true);
   }
   if(!entry) {
     entry = new Data::Entry(m_coll);
     entry->setField(QStringLiteral("medium"), i18n("Compact Disc"));
     m_coll->addEntries(entry);
   }
 
   CDText cdtext = getCDText(drive_);
 /*
   myDebug() << "CDText - title: " << cdtext.title;
   myDebug() << "CDText - title: " << cdtext.artist;
   for(int i = 0; i < cdtext.trackTitles.size(); ++i) {
     myDebug() << i << "--" << cdtext.trackTitles[i] << " - " << cdtext.trackArtists[i];
   }
 */
 
   QString artist = cdtext.artist;
   SETFIELD("title",    cdtext.title);
   SETFIELD("artist",   artist);
   SETFIELD("comments", cdtext.message);
   QStringList tracks;
   tracks.reserve(cdtext.trackTitles.size());
   for(int i = 0; i < cdtext.trackTitles.size(); ++i) {
     tracks << cdtext.trackTitles[i] + FieldFormat::columnDelimiterString() + cdtext.trackArtists[i];
     if(artist.isEmpty()) {
       artist = cdtext.trackArtists[i];
     }
     if(!artist.isEmpty() && artist.toLower() != cdtext.trackArtists[i].toLower()) {
       artist = i18n("Various");
     }
   }
   SETFIELD("track", tracks.join(FieldFormat::rowDelimiterString()));
 
   // something special for compilations and such
   SETFIELD("artist", artist);
 #else
   Q_UNUSED(drive_);
 #endif
 }
 #undef SETFIELD
 
 QWidget* FreeDBImporter::widget(QWidget* parent_) {
   if(m_widget) {
     return m_widget;
   }
   m_widget = new QWidget(parent_);
   QVBoxLayout* l = new QVBoxLayout(m_widget);
 
   QGroupBox* gbox = new QGroupBox(i18n("Audio CD Options"), m_widget);
   QVBoxLayout* vlay = new QVBoxLayout(gbox);
 
   // cdrom stuff
   QHBoxLayout* hlay = new QHBoxLayout();
   vlay->addLayout(hlay);
 
   m_radioCDROM = new QRadioButton(i18n("Read data from CD-ROM device"), gbox);
   m_driveCombo = new KComboBox(true, gbox);
   m_driveCombo->setDuplicatesEnabled(false);
   QString w = i18n("Select or input the CD-ROM device location.");
   m_radioCDROM->setWhatsThis(w);
   m_driveCombo->setWhatsThis(w);
 
   hlay->addWidget(m_radioCDROM);
   hlay->addWidget(m_driveCombo);
 
   /********************************************************************************/
 
   m_radioCache = new QRadioButton(i18n("Read all CDDB cache files only"), gbox);
   m_radioCache->setWhatsThis(i18n("Read data recursively from all the CDDB cache files "
                                   "contained in the default cache folders."));
   vlay->addWidget(m_radioCache);
 
   // cddb cache stuff
   m_buttonGroup = new QButtonGroup(gbox);
   m_buttonGroup->addButton(m_radioCDROM);
   m_buttonGroup->addButton(m_radioCache);
-  connect(m_buttonGroup, SIGNAL(buttonClicked(int)), SLOT(slotClicked(int)));
+  void (QButtonGroup::* buttonClickedInt)(int) = &QButtonGroup::buttonClicked;
+  connect(m_buttonGroup, buttonClickedInt, this, &FreeDBImporter::slotClicked);
 
   l->addWidget(gbox);
   l->addStretch(1);
 
   // now read config options
   KConfigGroup config(KSharedConfig::openConfig(), QStringLiteral("ImportOptions - FreeDB"));
   QStringList devices = config.readEntry("CD-ROM Devices", QStringList());
   if(devices.isEmpty()) {
 #if defined(__OpenBSD__)
     devices += QLatin1String("/dev/rcd0c");
 #endif
     devices += QStringLiteral("/dev/cdrom");
     devices += QStringLiteral("/dev/dvd");
   }
   m_driveCombo->addItems(devices);
   QString device = config.readEntry("Last Device");
   if(!device.isEmpty()) {
     m_driveCombo->setEditText(device);
   }
   if(config.readEntry("Cache Files Only", false)) {
     m_radioCache->setChecked(true);
   } else {
     m_radioCDROM->setChecked(true);
   }
   // set enabled widgets
   slotClicked(m_buttonGroup->checkedId());
 
   return m_widget;
 }
 
 void FreeDBImporter::slotClicked(int id_) {
   QAbstractButton* button = m_buttonGroup->button(id_);
   if(!button) {
     return;
   }
 
   m_driveCombo->setEnabled(button == m_radioCDROM);
 }
 
 void FreeDBImporter::slotCancel() {
   m_cancelled = true;
 }
diff --git a/src/translators/tellicoimporter.cpp b/src/translators/tellicoimporter.cpp
index 40602469..edc46e92 100644
--- a/src/translators/tellicoimporter.cpp
+++ b/src/translators/tellicoimporter.cpp
@@ -1,353 +1,353 @@
 /***************************************************************************
     Copyright (C) 2008-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "tellicoimporter.h"
 #include "tellicoxmlhandler.h"
 #include "tellico_xml.h"
 #include "../collectionfactory.h"
 #include "../entry.h"
 #include "../field.h"
 #include "../images/imagefactory.h"
 #include "../images/image.h"
 #include "../utils/isbnvalidator.h"
 #include "../core/tellico_strings.h"
 #include "../utils/guiproxy.h"
 #include "../utils/tellico_utils.h"
 #include "../tellico_debug.h"
 
 #include <KLocalizedString>
 #include <KZip>
 
 #include <QBuffer>
 #include <QFile>
 #include <QTimer>
 #include <QApplication>
 #include <QPointer>
 
 using Tellico::Import::TellicoImporter;
 
 TellicoImporter::TellicoImporter(const QUrl& url_, bool loadAllImages_) : DataImporter(url_),
     m_loadAllImages(loadAllImages_), m_format(Unknown), m_modified(false),
     m_cancelled(false), m_hasImages(false), m_buffer(nullptr), m_zip(nullptr), m_imgDir(nullptr) {
 }
 
 TellicoImporter::TellicoImporter(const QString& text_) : DataImporter(text_),
     m_loadAllImages(true), m_format(Unknown), m_modified(false),
     m_cancelled(false), m_hasImages(false), m_buffer(nullptr), m_zip(nullptr), m_imgDir(nullptr) {
 }
 
 TellicoImporter::~TellicoImporter() {
   delete m_zip;
   m_zip = nullptr;
   delete m_buffer;
   m_buffer = nullptr;
 }
 
 Tellico::Data::CollPtr TellicoImporter::collection() {
   if(m_coll) {
     return m_coll;
   }
 
   QByteArray s; // read first 5 characters
   if(source() == URL) {
     if(!fileRef().open()) {
       return Data::CollPtr();
     }
     QIODevice* f = fileRef().file();
     char c;
     for(int i = 0; i < 5; ++i) {
       if(f->getChar(&c)) {
         s += c;
       }
     }
     f->reset();
   } else {
     if(data().size() < 5) {
       m_format = Error;
       return Data::CollPtr();
     }
     s = QByteArray(data().constData(), 6);
   }
 
   // hack for processEvents and deletion
   QPointer<TellicoImporter> thisPtr(this);
 
   // need to decide if the data is xml text, or a zip file
   // if the first 5 characters are <?xml then treat it like text
   if(s[0] == '<' && s[1] == '?' && s[2] == 'x' && s[3] == 'm' && s[4] == 'l') {
     m_format = XML;
     loadXMLData(source() == URL ? fileRef().file()->readAll() : data(), true);
   } else {
     m_format = Zip;
     loadZipData();
   }
   return thisPtr ? m_coll : Data::CollPtr();
 }
 
 void TellicoImporter::loadXMLData(const QByteArray& data_, bool loadImages_) {
   const bool showProgress = options() & ImportProgress;
 
   TellicoXMLHandler handler;
   handler.setLoadImages(loadImages_);
   handler.setShowImageLoadErrors(options() & ImportShowImageErrors);
 
   QXmlSimpleReader reader;
   reader.setContentHandler(&handler);
 
   QXmlInputSource source;
   source.setData(QByteArray()); // necessary
   bool success = reader.parse(&source, true);
 
   const int blockSize = data_.size()/100 + 1;
   int pos = 0;
   emit signalTotalSteps(this, data_.size());
 
   // hack to allow processEvents
   QPointer<TellicoImporter> thisPtr(this);
   while(thisPtr && success && !m_cancelled && pos < data_.size()) {
     uint size = qMin(blockSize, data_.size() - pos);
     QByteArray block = QByteArray::fromRawData(data_.data() + pos, size);
     source.setData(block);
     success = reader.parseContinue();
     pos += blockSize;
     if(thisPtr && showProgress) {
       emit signalProgress(this, pos);
       qApp->processEvents();
     }
   }
   if(!thisPtr) {
     return;
   }
 
   if(!success) {
     m_format = Error;
     QString error;
     if(!url().isEmpty()) {
       error = i18n(errorLoad).arg(url().fileName()) + QLatin1Char('\n');
     }
     error += handler.errorString();
     myDebug() << error;
     setStatusMessage(error);
     return;
   }
 
   if(!m_cancelled) {
     m_hasImages = handler.hasImages();
     m_coll = handler.collection();
   }
 }
 
 void TellicoImporter::loadZipData() {
   delete m_buffer;
   delete m_zip;
   if(source() == URL) {
     m_buffer = nullptr;
     m_zip = new KZip(fileRef().fileName());
   } else {
     QByteArray allData = data();
     m_buffer = new QBuffer(&allData);
     m_zip = new KZip(m_buffer);
   }
   if(!m_zip->open(QIODevice::ReadOnly)) {
     setStatusMessage(i18n(errorLoad, url().fileName()));
     m_format = Error;
     delete m_zip;
     m_zip = nullptr;
     delete m_buffer;
     m_buffer = nullptr;
     return;
   }
 
   const KArchiveDirectory* dir = m_zip->directory();
   if(!dir) {
     QString str = i18n(errorLoad, url().fileName()) + QLatin1Char('\n');
     str += i18n("The file is empty.");
     setStatusMessage(str);
     m_format = Error;
     delete m_zip;
     m_zip = nullptr;
     delete m_buffer;
     m_buffer = nullptr;
     return;
   }
 
   // main file was changed from bookcase.xml to tellico.xml as of version 0.13
   const KArchiveEntry* entry = dir->entry(QStringLiteral("tellico.xml"));
   if(!entry) {
     entry = dir->entry(QStringLiteral("bookcase.xml"));
   }
   if(!entry || !entry->isFile()) {
     QString str = i18n(errorLoad, url().fileName()) + QLatin1Char('\n');
     str += i18n("The file contains no collection data.");
     setStatusMessage(str);
     m_format = Error;
     delete m_zip;
     m_zip = nullptr;
     delete m_buffer;
     m_buffer = nullptr;
     return;
   }
 
   const QByteArray xmlData = static_cast<const KArchiveFile*>(entry)->data();
   // hack to account for processEvents and deletion
   QPointer<TellicoImporter> thisPtr(this);
   loadXMLData(xmlData, false);
   if(!thisPtr) {
     return;
   }
   if(!m_coll) {
     m_format = Error;
     delete m_zip;
     m_zip = nullptr;
     delete m_buffer;
     m_buffer = nullptr;
     return;
   }
 
   if(m_cancelled) {
     delete m_zip;
     m_zip = nullptr;
     delete m_buffer;
     m_buffer = nullptr;
     return;
   }
 
   const KArchiveEntry* imgDirEntry = dir->entry(QStringLiteral("images"));
   if(!imgDirEntry || !imgDirEntry->isDirectory()) {
     delete m_zip;
     m_zip = nullptr;
     delete m_buffer;
     m_buffer = nullptr;
     return;
   }
   m_imgDir = static_cast<const KArchiveDirectory*>(imgDirEntry);
   m_images.clear();
   m_images.add(m_imgDir->entries());
   m_hasImages = !m_images.isEmpty();
 
   // if all the images are not to be loaded, then we're done
   if(!m_loadAllImages) {
 //    myLog() << "delayed loading for " << m_images.count() << " images";
     return;
   }
 
   const QStringList images = m_imgDir->entries();
   const uint stepSize = qMax(s_stepSize, static_cast<uint>(images.count())/100);
 
   uint j = 0;
   for(QStringList::ConstIterator it = images.begin(); !m_cancelled && it != images.end(); ++it, ++j) {
     const KArchiveEntry* file = m_imgDir->entry(*it);
     if(file && file->isFile()) {
       ImageFactory::addImage(static_cast<const KArchiveFile*>(file)->data(),
                              (*it).section(QLatin1Char('.'), -1).toUpper(), (*it));
       m_images.remove(*it);
     }
     if(j%stepSize == 0) {
       qApp->processEvents();
     }
   }
 
   if(thisPtr && m_images.isEmpty()) {
     // give it some time
-    QTimer::singleShot(3000, this, SLOT(deleteLater()));
+    QTimer::singleShot(3000, this, &QObject::deleteLater);
   }
 }
 
 bool TellicoImporter::hasImages() const {
   return m_hasImages;
 }
 
 bool TellicoImporter::loadImage(const QString& id_) {
 //  myLog() << "id =  " << id_;
   if(m_format != Zip || !m_imgDir) {
     return false;
   }
   const KArchiveEntry* file = m_imgDir->entry(id_);
   if(!file || !file->isFile()) {
     return false;
   }
   QString newID = ImageFactory::addImage(static_cast<const KArchiveFile*>(file)->data(),
                                          id_.section(QLatin1Char('.'), -1).toUpper(), id_);
   m_images.remove(id_);
   if(m_images.isEmpty()) {
     // give it some time
-    QTimer::singleShot(3000, this, SLOT(deleteLater()));
+    QTimer::singleShot(3000, this, &QObject::deleteLater);
   }
   return !newID.isEmpty();
 }
 
 KZip* TellicoImporter::takeImages() {
   KZip* zip = m_zip;
   m_zip = nullptr;
   return zip;
 }
 
 void TellicoImporter::slotCancel() {
   m_cancelled = true;
   m_format = Cancel;
 }
 
 // static
 bool TellicoImporter::loadAllImages(const QUrl& url_) {
   // only local files are allowed
   if(url_.isEmpty() || !url_.isValid() || !url_.isLocalFile()) {
 //    myDebug() << "returning";
     return false;
   }
 
   // keep track of url for error reporting
   static QUrl u;
 
   KZip zip(url_.path());
   if(!zip.open(QIODevice::ReadOnly)) {
     if(u != url_) {
       GUI::Proxy::sorry(i18n(errorImageLoad, url_.fileName()));
     }
     u = url_;
     return false;
   }
 
   const KArchiveDirectory* dir = zip.directory();
   if(!dir) {
     if(u != url_) {
       GUI::Proxy::sorry(i18n(errorImageLoad, url_.fileName()));
     }
     u = url_;
     return false;
   }
 
   const KArchiveEntry* imgDirEntry = dir->entry(QStringLiteral("images"));
   if(!imgDirEntry || !imgDirEntry->isDirectory()) {
     return false;
   }
   const QStringList images = static_cast<const KArchiveDirectory*>(imgDirEntry)->entries();
   for(QStringList::ConstIterator it = images.begin(); it != images.end(); ++it) {
     const KArchiveEntry* file = static_cast<const KArchiveDirectory*>(imgDirEntry)->entry(*it);
     if(file && file->isFile()) {
       ImageFactory::addImage(static_cast<const KArchiveFile*>(file)->data(),
                              (*it).section(QLatin1Char('.'), -1).toUpper(), (*it));
     }
   }
   return true;
 }
diff --git a/src/viewstack.cpp b/src/viewstack.cpp
index 0f1e16b0..979fec35 100644
--- a/src/viewstack.cpp
+++ b/src/viewstack.cpp
@@ -1,156 +1,156 @@
 /***************************************************************************
     Copyright (C) 2002-2011 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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 <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "viewstack.h"
 #include "detailedlistview.h"
 #include "entryiconview.h"
 #include "config/tellico_config.h"
 
 #include <KLocalizedString>
 
 #include <QIcon>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QToolButton>
 #include <QStackedWidget>
 #include <QSlider>
 #include <QButtonGroup>
 
 using Tellico::ViewStack;
 
 ViewStack::ViewStack(QWidget* parent_) : QWidget(parent_)
     , m_listView(new DetailedListView(this))
     , m_iconView(new EntryIconView(this)) {
   QBoxLayout* lay = new QVBoxLayout();
   lay->setMargin(0);
   lay->setSpacing(0);
 
   QBoxLayout* hlay = new QHBoxLayout();
   lay->addLayout(hlay);
   hlay->setMargin(0);
   hlay->setSpacing(0);
 
   m_listButton = new QToolButton(this);
   m_listButton->setCheckable(true);
   m_listButton->setIcon(QIcon::fromTheme(QStringLiteral("view-list-details")));
-  connect(m_listButton, SIGNAL(clicked(bool)), SLOT(showListView()));
+  connect(m_listButton, &QAbstractButton::clicked, this, &ViewStack::showListView);
 
   m_iconButton = new QToolButton(this);
   m_iconButton->setCheckable(true);
   m_iconButton->setIcon(QIcon::fromTheme(QStringLiteral("view-list-icons")));
-  connect(m_iconButton, SIGNAL(clicked(bool)), SLOT(showIconView()));
+  connect(m_iconButton, &QAbstractButton::clicked, this, &ViewStack::showIconView);
 
   QButtonGroup* bg = new QButtonGroup(this);
   bg->addButton(m_listButton);
   bg->addButton(m_iconButton);
 
   hlay->addWidget(m_listButton);
   hlay->addWidget(m_iconButton);
   hlay->addStretch(10);
 
   m_decreaseIconSizeButton = new QToolButton(this);
   m_decreaseIconSizeButton->setIcon(QIcon::fromTheme(QStringLiteral("zoom-out")));
   m_decreaseIconSizeButton->setToolTip(i18n("Decrease the maximum icon size in the icon list view"));
   hlay->addWidget(m_decreaseIconSizeButton);
-  connect(m_decreaseIconSizeButton, SIGNAL(clicked(bool)), SLOT(slotDecreaseIconSizeButtonClicked()));
+  connect(m_decreaseIconSizeButton, &QAbstractButton::clicked, this, &ViewStack::slotDecreaseIconSizeButtonClicked);
 
   m_iconSizeSlider = new QSlider(Qt::Horizontal, this);
   m_iconSizeSlider->setMinimum(MIN_ENTRY_ICON_SIZE);
   m_iconSizeSlider->setMaximum(MAX_ENTRY_ICON_SIZE);
   m_iconSizeSlider->setSingleStep(SMALL_INCREMENT_ICON_SIZE);
   m_iconSizeSlider->setPageStep(LARGE_INCREMENT_ICON_SIZE);
   m_iconSizeSlider->setValue(Config::maxIconSize());
   m_iconSizeSlider->setTracking(true);
   m_iconSizeSlider->setToolTip(i18n("The current maximum icon size is %1.\nMove the slider to change it.", Config::maxIconSize()));
   hlay->addWidget(m_iconSizeSlider);
-  connect(m_iconSizeSlider, SIGNAL(valueChanged(int)), SLOT(slotIconSizeSliderChanged(int)));
+  connect(m_iconSizeSlider, &QAbstractSlider::valueChanged, this, &ViewStack::slotIconSizeSliderChanged);
 
   m_increaseIconSizeButton = new QToolButton(this);
   m_increaseIconSizeButton->setIcon(QIcon::fromTheme(QStringLiteral("zoom-in")));
   m_increaseIconSizeButton->setToolTip(i18n("Increase the maximum icon size in the icon list view"));
   hlay->addWidget(m_increaseIconSizeButton, 0);
-  connect(m_increaseIconSizeButton, SIGNAL(clicked(bool)), SLOT(slotIncreaseIconSizeButtonClicked()));
+  connect(m_increaseIconSizeButton, &QAbstractButton::clicked, this, &ViewStack::slotIncreaseIconSizeButtonClicked);
 
   setIconSizeInterfaceVisible(false);
 
   m_stack = new QStackedWidget(this);
   lay->addWidget(m_stack);
   m_stack->addWidget(m_listView);
   m_stack->addWidget(m_iconView);
 
   setLayout(lay);
 }
 
 int ViewStack::currentWidget() const {
   if(m_stack->currentWidget() == m_listView) {
     return Config::ListView;
   } else {
     return Config::IconView;
   }
 }
 
 void ViewStack::setCurrentWidget(int widget_) {
   switch(widget_) {
     case Config::ListView:
       m_listButton->setChecked(true);
       showListView();
       break;
     case Config::IconView:
       m_iconButton->setChecked(true);
       showIconView();
       break;
   }
 }
 
 void ViewStack::showListView() {
   setIconSizeInterfaceVisible(false);
   m_stack->setCurrentWidget(m_listView);
 }
 
 void ViewStack::showIconView() {
   m_stack->setCurrentWidget(m_iconView);
   setIconSizeInterfaceVisible(true);
 }
 
 void ViewStack::slotDecreaseIconSizeButtonClicked() {
   m_iconSizeSlider->setValue(m_iconSizeSlider->value() - LARGE_INCREMENT_ICON_SIZE);
 }
 
 void ViewStack::slotIncreaseIconSizeButtonClicked() {
   m_iconSizeSlider->setValue(m_iconSizeSlider->value() + LARGE_INCREMENT_ICON_SIZE);
 }
 
 void ViewStack::slotIconSizeSliderChanged(int size) {
   m_decreaseIconSizeButton->setEnabled(size > MIN_ENTRY_ICON_SIZE);
   m_increaseIconSizeButton->setEnabled(size < MAX_ENTRY_ICON_SIZE);
   m_iconSizeSlider->setToolTip(i18n("The current maximum icon size is %1.\nMove the slider to change it.", size));
   Config::setMaxIconSize(size);
   m_iconView->setMaxAllowedIconWidth(size);
 }
 
 void ViewStack::setIconSizeInterfaceVisible(bool visible) {
   m_decreaseIconSizeButton->setVisible(visible);
   m_increaseIconSizeButton->setVisible(visible);
   m_iconSizeSlider->setVisible(visible);
 }